planetstack/genapi.py

   1 from rest_framework.decorators import api_view
   2 from rest_framework.response import Response
   3 from rest_framework.reverse import reverse
   4 from rest_framework import serializers
   5 from rest_framework import generics
   6 from rest_framework import status
   7 from rest_framework.generics import GenericAPIView
   8 from core.models import *
   9 from django.forms import widgets
  10 from rest_framework import filters
  11 from django.conf.urls import patterns, url
  12
  13 """
  14     Schema of the generator object:
  15         all: Set of all Model objects
  16         all_if(regex): Set of Model objects that match regex
  17
  18     Model object:
  19         plural: English plural of object name
  20         camel: CamelCase version of object name
  21         refs: list of references to other Model objects
  22         props: list of properties minus refs
  23
  24     TODO: Deal with subnets
  25 """
  26
  27 def get_REST_patterns():
  28     return patterns('',
  29         url(r'^plstackapi/$', api_root),
  30
  31         url(r'plstackapi/serviceattributes/$', ServiceAttributeList.as_view(), name='serviceattribute-list'),
  32         url(r'plstackapi/serviceattributes/(?P<pk>[a-zA-Z0-9\-]+)/$', ServiceAttributeDetail.as_view(), name ='serviceattribute-detail'),
  33
  34         url(r'plstackapi/images/$', ImageList.as_view(), name='image-list'),
  35         url(r'plstackapi/images/(?P<pk>[a-zA-Z0-9\-]+)/$', ImageDetail.as_view(), name ='image-detail'),
  36
  37         url(r'plstackapi/networkparameters/$', NetworkParameterList.as_view(), name='networkparameter-list'),
  38         url(r'plstackapi/networkparameters/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkParameterDetail.as_view(), name ='networkparameter-detail'),
  39
  40         url(r'plstackapi/sites/$', SiteList.as_view(), name='site-list'),
  41         url(r'plstackapi/sites/(?P<pk>[a-zA-Z0-9\-]+)/$', SiteDetail.as_view(), name ='site-detail'),
  42
  43         url(r'plstackapi/slice_roles/$', SliceRoleList.as_view(), name='slicerole-list'),
  44         url(r'plstackapi/slice_roles/(?P<pk>[a-zA-Z0-9\-]+)/$', SliceRoleDetail.as_view(), name ='slicerole-detail'),
  45
  46         url(r'plstackapi/tags/$', TagList.as_view(), name='tag-list'),
  47         url(r'plstackapi/tags/(?P<pk>[a-zA-Z0-9\-]+)/$', TagDetail.as_view(), name ='tag-detail'),
  48
  49         url(r'plstackapi/invoices/$', InvoiceList.as_view(), name='invoice-list'),
  50         url(r'plstackapi/invoices/(?P<pk>[a-zA-Z0-9\-]+)/$', InvoiceDetail.as_view(), name ='invoice-detail'),
  51
  52         url(r'plstackapi/slice_privileges/$', SlicePrivilegeList.as_view(), name='sliceprivilege-list'),
  53         url(r'plstackapi/slice_privileges/(?P<pk>[a-zA-Z0-9\-]+)/$', SlicePrivilegeDetail.as_view(), name ='sliceprivilege-detail'),
  54
  55         url(r'plstackapi/planetstackroles/$', PlanetStackRoleList.as_view(), name='planetstackrole-list'),
  56         url(r'plstackapi/planetstackroles/(?P<pk>[a-zA-Z0-9\-]+)/$', PlanetStackRoleDetail.as_view(), name ='planetstackrole-detail'),
  57
  58         url(r'plstackapi/networkslivers/$', NetworkSliverList.as_view(), name='networksliver-list'),
  59         url(r'plstackapi/networkslivers/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkSliverDetail.as_view(), name ='networksliver-detail'),
  60
  61         url(r'plstackapi/controllernetworks/$', ControllerNetworksList.as_view(), name='controllernetworks-list'),
  62         url(r'plstackapi/controllernetworks/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerNetworksDetail.as_view(), name ='controllernetworks-detail'),
  63
  64         url(r'plstackapi/flavors/$', FlavorList.as_view(), name='flavor-list'),
  65         url(r'plstackapi/flavors/(?P<pk>[a-zA-Z0-9\-]+)/$', FlavorDetail.as_view(), name ='flavor-detail'),
  66
  67         url(r'plstackapi/projects/$', ProjectList.as_view(), name='project-list'),
  68         url(r'plstackapi/projects/(?P<pk>[a-zA-Z0-9\-]+)/$', ProjectDetail.as_view(), name ='project-detail'),
  69
  70         url(r'plstackapi/slices/$', SliceList.as_view(), name='slice-list'),
  71         url(r'plstackapi/slices/(?P<pk>[a-zA-Z0-9\-]+)/$', SliceDetail.as_view(), name ='slice-detail'),
  72
  73         url(r'plstackapi/networks/$', NetworkList.as_view(), name='network-list'),
  74         url(r'plstackapi/networks/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkDetail.as_view(), name ='network-detail'),
  75
  76         url(r'plstackapi/services/$', ServiceList.as_view(), name='service-list'),
  77         url(r'plstackapi/services/(?P<pk>[a-zA-Z0-9\-]+)/$', ServiceDetail.as_view(), name ='service-detail'),
  78
  79         url(r'plstackapi/serviceclasses/$', ServiceClassList.as_view(), name='serviceclass-list'),
  80         url(r'plstackapi/serviceclasses/(?P<pk>[a-zA-Z0-9\-]+)/$', ServiceClassDetail.as_view(), name ='serviceclass-detail'),
  81
  82         url(r'plstackapi/payments/$', PaymentList.as_view(), name='payment-list'),
  83         url(r'plstackapi/payments/(?P<pk>[a-zA-Z0-9\-]+)/$', PaymentDetail.as_view(), name ='payment-detail'),
  84
  85         url(r'plstackapi/charges/$', ChargeList.as_view(), name='charge-list'),
  86         url(r'plstackapi/charges/(?P<pk>[a-zA-Z0-9\-]+)/$', ChargeDetail.as_view(), name ='charge-detail'),
  87
  88         url(r'plstackapi/roles/$', RoleList.as_view(), name='role-list'),
  89         url(r'plstackapi/roles/(?P<pk>[a-zA-Z0-9\-]+)/$', RoleDetail.as_view(), name ='role-detail'),
  90
  91         url(r'plstackapi/usableobjects/$', UsableObjectList.as_view(), name='usableobject-list'),
  92         url(r'plstackapi/usableobjects/(?P<pk>[a-zA-Z0-9\-]+)/$', UsableObjectDetail.as_view(), name ='usableobject-detail'),
  93
  94         url(r'plstackapi/site_roles/$', SiteRoleList.as_view(), name='siterole-list'),
  95         url(r'plstackapi/site_roles/(?P<pk>[a-zA-Z0-9\-]+)/$', SiteRoleDetail.as_view(), name ='siterole-detail'),
  96
  97         url(r'plstackapi/slicecredentials/$', SliceCredentialList.as_view(), name='slicecredential-list'),
  98         url(r'plstackapi/slicecredentials/(?P<pk>[a-zA-Z0-9\-]+)/$', SliceCredentialDetail.as_view(), name ='slicecredential-detail'),
  99
 100         url(r'plstackapi/slivers/$', SliverList.as_view(), name='sliver-list'),
 101         url(r'plstackapi/slivers/(?P<pk>[a-zA-Z0-9\-]+)/$', SliverDetail.as_view(), name ='sliver-detail'),
 102
 103         url(r'plstackapi/nodes/$', NodeList.as_view(), name='node-list'),
 104         url(r'plstackapi/nodes/(?P<pk>[a-zA-Z0-9\-]+)/$', NodeDetail.as_view(), name ='node-detail'),
 105
 106         url(r'plstackapi/dashboardviews/$', DashboardViewList.as_view(), name='dashboardview-list'),
 107         url(r'plstackapi/dashboardviews/(?P<pk>[a-zA-Z0-9\-]+)/$', DashboardViewDetail.as_view(), name ='dashboardview-detail'),
 108
 109         url(r'plstackapi/controllerimages/$', ControllerImagesList.as_view(), name='controllerimages-list'),
 110         url(r'plstackapi/controllerimages/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerImagesDetail.as_view(), name ='controllerimages-detail'),
 111
 112         url(r'plstackapi/reservedresources/$', ReservedResourceList.as_view(), name='reservedresource-list'),
 113         url(r'plstackapi/reservedresources/(?P<pk>[a-zA-Z0-9\-]+)/$', ReservedResourceDetail.as_view(), name ='reservedresource-detail'),
 114
 115         url(r'plstackapi/networkslices/$', NetworkSliceList.as_view(), name='networkslice-list'),
 116         url(r'plstackapi/networkslices/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkSliceDetail.as_view(), name ='networkslice-detail'),
 117
 118         url(r'plstackapi/userdashboardviews/$', UserDashboardViewList.as_view(), name='userdashboardview-list'),
 119         url(r'plstackapi/userdashboardviews/(?P<pk>[a-zA-Z0-9\-]+)/$', UserDashboardViewDetail.as_view(), name ='userdashboardview-detail'),
 120
 121         url(r'plstackapi/planetstackprivileges/$', PlanetStackPrivilegeList.as_view(), name='planetstackprivilege-list'),
 122         url(r'plstackapi/planetstackprivileges/(?P<pk>[a-zA-Z0-9\-]+)/$', PlanetStackPrivilegeDetail.as_view(), name ='planetstackprivilege-detail'),
 123
 124         url(r'plstackapi/users/$', UserList.as_view(), name='user-list'),
 125         url(r'plstackapi/users/(?P<pk>[a-zA-Z0-9\-]+)/$', UserDetail.as_view(), name ='user-detail'),
 126
 127         url(r'plstackapi/deployments/$', DeploymentList.as_view(), name='deployment-list'),
 128         url(r'plstackapi/deployments/(?P<pk>[a-zA-Z0-9\-]+)/$', DeploymentDetail.as_view(), name ='deployment-detail'),
 129         url(r'plstackapi/Controller/$', ControllerList.as_view(), name='controller-list'),
 130         url(r'plstackapi/Controller/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerDetail.as_view(), name ='controller-detail'),
 131
 132         url(r'plstackapi/reservations/$', ReservationList.as_view(), name='reservation-list'),
 133         url(r'plstackapi/reservations/(?P<pk>[a-zA-Z0-9\-]+)/$', ReservationDetail.as_view(), name ='reservation-detail'),
 134
 135         url(r'plstackapi/controllerslices/$', ControllerSlicesList.as_view(), name='controllerslices-list'),
 136         url(r'plstackapi/controllerslices/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerSlicesDetail.as_view(), name ='controllerslices-detail'),
 137
 138         url(r'plstackapi/siteprivileges/$', SitePrivilegeList.as_view(), name='siteprivilege-list'),
 139         url(r'plstackapi/siteprivileges/(?P<pk>[a-zA-Z0-9\-]+)/$', SitePrivilegeDetail.as_view(), name ='siteprivilege-detail'),
 140
 141         url(r'plstackapi/planetstacks/$', PlanetStackList.as_view(), name='planetstack-list'),
 142         url(r'plstackapi/planetstacks/(?P<pk>[a-zA-Z0-9\-]+)/$', PlanetStackDetail.as_view(), name ='planetstack-detail'),
 143
 144         url(r'plstackapi/controllerusers/$', ControllerUsersList.as_view(), name='controllerusers-list'),
 145         url(r'plstackapi/controllerusers/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerUsersDetail.as_view(), name ='controllerusers-detail'),
 146
 147         url(r'plstackapi/accounts/$', AccountList.as_view(), name='account-list'),
 148         url(r'plstackapi/accounts/(?P<pk>[a-zA-Z0-9\-]+)/$', AccountDetail.as_view(), name ='account-detail'),
 149
 150         url(r'plstackapi/networkparametertypes/$', NetworkParameterTypeList.as_view(), name='networkparametertype-list'),
 151         url(r'plstackapi/networkparametertypes/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkParameterTypeDetail.as_view(), name ='networkparametertype-detail'),
 152
 153         url(r'plstackapi/sitecredentials/$', SiteCredentialList.as_view(), name='sitecredential-list'),
 154         url(r'plstackapi/sitecredentials/(?P<pk>[a-zA-Z0-9\-]+)/$', SiteCredentialDetail.as_view(), name ='sitecredential-detail'),
 155
 156         url(r'plstackapi/controllerprivileges/$', ControllerPrivilegeList.as_view(), name='controllerprivilege-list'),
 157         url(r'plstackapi/controllerprivileges/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerPrivilegeDetail.as_view(), name ='controllerprivilege-detail'),
 158
 159         url(r'plstackapi/controllerroles/$', ControllerRoleList.as_view(), name='controllerrole-list'),
 160         url(r'plstackapi/controllerroles/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerRoleDetail.as_view(), name ='controllerrole-detail'),
 161
 162         url(r'plstackapi/usercredentials/$', UserCredentialList.as_view(), name='usercredential-list'),
 163         url(r'plstackapi/usercredentials/(?P<pk>[a-zA-Z0-9\-]+)/$', UserCredentialDetail.as_view(), name ='usercredential-detail'),
 164
 165         url(r'plstackapi/sitedeployments/$', SiteDeploymentsList.as_view(), name='sitedeployments-list'),
 166         url(r'plstackapi/sitedeployments/(?P<pk>[a-zA-Z0-9\-]+)/$', SiteDeploymentsDetail.as_view(), name ='sitedeployments-detail'),
 167         url(r'plstackapi/controllersites/$', ControllerSitesList.as_view(), name='sitedeployments-list'),
 168         url(r'plstackapi/controllersites/(?P<pk>[a-zA-Z0-9\-]+)/$', ControllerSitesDetail.as_view(), name ='sitedeployments-detail'),
 169
 170         url(r'plstackapi/slicetags/$', SliceTagList.as_view(), name='slicetag-list'),
 171         url(r'plstackapi/slicetags/(?P<pk>[a-zA-Z0-9\-]+)/$', SliceTagDetail.as_view(), name ='slicetag-detail'),
 172
 173         url(r'plstackapi/networktemplates/$', NetworkTemplateList.as_view(), name='networktemplate-list'),
 174         url(r'plstackapi/networktemplates/(?P<pk>[a-zA-Z0-9\-]+)/$', NetworkTemplateDetail.as_view(), name ='networktemplate-detail'),
 175
 176         url(r'plstackapi/routers/$', RouterList.as_view(), name='router-list'),
 177         url(r'plstackapi/routers/(?P<pk>[a-zA-Z0-9\-]+)/$', RouterDetail.as_view(), name ='router-detail'),
 178
 179         url(r'plstackapi/serviceresources/$', ServiceResourceList.as_view(), name='serviceresource-list'),
 180         url(r'plstackapi/serviceresources/(?P<pk>[a-zA-Z0-9\-]+)/$', ServiceResourceDetail.as_view(), name ='serviceresource-detail'),
 181
 182     )
 183
 184 @api_view(['GET'])
 185 def api_root(request, format=None):
 186     return Response({
 187         'serviceattributes': reverse('serviceattribute-list', request=request, format=format),
 188         'images': reverse('image-list', request=request, format=format),
 189         'networkparameters': reverse('networkparameter-list', request=request, format=format),
 190         'sites': reverse('site-list', request=request, format=format),
 191         'sliceroles': reverse('slicerole-list', request=request, format=format),
 192         'tags': reverse('tag-list', request=request, format=format),
 193         'invoices': reverse('invoice-list', request=request, format=format),
 194         'sliceprivileges': reverse('sliceprivilege-list', request=request, format=format),
 195         'planetstackroles': reverse('planetstackrole-list', request=request, format=format),
 196         'networkslivers': reverse('networksliver-list', request=request, format=format),
 197         'controllernetworkses': reverse('controllernetworks-list', request=request, format=format),
 198         'flavors': reverse('flavor-list', request=request, format=format),
 199         'projects': reverse('project-list', request=request, format=format),
 200         'slices': reverse('slice-list', request=request, format=format),
 201         'networks': reverse('network-list', request=request, format=format),
 202         'services': reverse('service-list', request=request, format=format),
 203         'serviceclasses': reverse('serviceclass-list', request=request, format=format),
 204         'payments': reverse('payment-list', request=request, format=format),
 205         'charges': reverse('charge-list', request=request, format=format),
 206         'roles': reverse('role-list', request=request, format=format),
 207         'usableobjects': reverse('usableobject-list', request=request, format=format),
 208         'siteroles': reverse('siterole-list', request=request, format=format),
 209         'slicecredentials': reverse('slicecredential-list', request=request, format=format),
 210         'slivers': reverse('sliver-list', request=request, format=format),
 211         'nodes': reverse('node-list', request=request, format=format),
 212         'dashboardviews': reverse('dashboardview-list', request=request, format=format),
 213         'controllerimageses': reverse('controllerimages-list', request=request, format=format),
 214         'reservedresources': reverse('reservedresource-list', request=request, format=format),
 215         'networkslices': reverse('networkslice-list', request=request, format=format),
 216         'userdashboardviews': reverse('userdashboardview-list', request=request, format=format),
 217         'planetstackprivileges': reverse('planetstackprivilege-list', request=request, format=format),
 218         'users': reverse('user-list', request=request, format=format),
 219         'deployments': reverse('deployment-list', request=request, format=format),
 220         'controllers': reverse('controller-list', request=request, format=format),
 221         'reservations': reverse('reservation-list', request=request, format=format),
 222         'controllersliceses': reverse('controllerslices-list', request=request, format=format),
 223         'siteprivileges': reverse('siteprivilege-list', request=request, format=format),
 224         'planetstacks': reverse('planetstack-list', request=request, format=format),
 225         'controlleruserses': reverse('controllerusers-list', request=request, format=format),
 226         'accounts': reverse('account-list', request=request, format=format),
 227         'networkparametertypes': reverse('networkparametertype-list', request=request, format=format),
 228         'sitecredentials': reverse('sitecredential-list', request=request, format=format),
 229         'controllerprivileges': reverse('controllerprivilege-list', request=request, format=format),
 230         'controllerroles': reverse('controllerrole-list', request=request, format=format),
 231         'usercredentials': reverse('usercredential-list', request=request, format=format),
 232         'sitedeploymentses': reverse('sitedeployments-list', request=request, format=format),
 233         'controllersiteses': reverse('controllersites-list', request=request, format=format),
 234         'slicetags': reverse('slicetag-list', request=request, format=format),
 235         'networktemplates': reverse('networktemplate-list', request=request, format=format),
 236         'routers': reverse('router-list', request=request, format=format),
 237         'serviceresources': reverse('serviceresource-list', request=request, format=format),
 238
 239     })
 240
 241 # Based on serializers.py
 242
 243
 244
 245 class ServiceAttributeSerializer(serializers.HyperlinkedModelSerializer):
 246     id = serializers.Field()
 247
 248     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 249     validators = serializers.SerializerMethodField("getValidators")
 250     def getHumanReadableName(self, obj):\r
 251         return str(obj)
 252     def getValidators(self, obj):
 253         try:
 254             return obj.getValidators()
 255         except:
 256             return None
 257     class Meta:
 258         model = ServiceAttribute
 259         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','value','service',)
 260
 261 class ServiceAttributeIdSerializer(serializers.ModelSerializer):
 262     id = serializers.Field()
 263
 264     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 265     validators = serializers.SerializerMethodField("getValidators")
 266     def getHumanReadableName(self, obj):\r
 267         return str(obj)\r
 268     def getValidators(self, obj):\r
 269         try:
 270             return obj.getValidators()
 271         except:
 272             return None\r
 273     class Meta:
 274         model = ServiceAttribute
 275         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','value','service',)
 276
 277
 278
 279
 280 class ImageSerializer(serializers.HyperlinkedModelSerializer):
 281     id = serializers.Field()
 282
 283     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 284     validators = serializers.SerializerMethodField("getValidators")
 285     def getHumanReadableName(self, obj):\r
 286         return str(obj)
 287     def getValidators(self, obj):
 288         try:
 289             return obj.getValidators()
 290         except:
 291             return None
 292     class Meta:
 293         model = Image
 294         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','disk_format','container_format','path',)
 295
 296 class ImageIdSerializer(serializers.ModelSerializer):
 297     id = serializers.Field()
 298
 299     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 300     validators = serializers.SerializerMethodField("getValidators")
 301     def getHumanReadableName(self, obj):\r
 302         return str(obj)\r
 303     def getValidators(self, obj):\r
 304         try:
 305             return obj.getValidators()
 306         except:
 307             return None\r
 308     class Meta:
 309         model = Image
 310         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','disk_format','container_format','path',)
 311
 312
 313
 314
 315 class NetworkParameterSerializer(serializers.HyperlinkedModelSerializer):
 316     id = serializers.Field()
 317
 318     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 319     validators = serializers.SerializerMethodField("getValidators")
 320     def getHumanReadableName(self, obj):\r
 321         return str(obj)
 322     def getValidators(self, obj):
 323         try:
 324             return obj.getValidators()
 325         except:
 326             return None
 327     class Meta:
 328         model = NetworkParameter
 329         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','parameter','value','content_type','object_id',)
 330
 331 class NetworkParameterIdSerializer(serializers.ModelSerializer):
 332     id = serializers.Field()
 333
 334     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 335     validators = serializers.SerializerMethodField("getValidators")
 336     def getHumanReadableName(self, obj):\r
 337         return str(obj)\r
 338     def getValidators(self, obj):\r
 339         try:
 340             return obj.getValidators()
 341         except:
 342             return None\r
 343     class Meta:
 344         model = NetworkParameter
 345         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','parameter','value','content_type','object_id',)
 346
 347
 348
 349
 350 class SiteSerializer(serializers.HyperlinkedModelSerializer):
 351     id = serializers.Field()
 352
 353     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 354     validators = serializers.SerializerMethodField("getValidators")
 355     def getHumanReadableName(self, obj):\r
 356         return str(obj)
 357     def getValidators(self, obj):
 358         try:
 359             return obj.getValidators()
 360         except:
 361             return None
 362     class Meta:
 363         model = Site
 364         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','site_url','enabled','location','longitude','latitude','login_base','is_public','abbreviated_name',)
 365
 366 class SiteIdSerializer(serializers.ModelSerializer):
 367     id = serializers.Field()
 368
 369     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 370     validators = serializers.SerializerMethodField("getValidators")
 371     def getHumanReadableName(self, obj):\r
 372         return str(obj)\r
 373     def getValidators(self, obj):\r
 374         try:
 375             return obj.getValidators()
 376         except:
 377             return None\r
 378     class Meta:
 379         model = Site
 380         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','site_url','enabled','location','longitude','latitude','login_base','is_public','abbreviated_name',)
 381
 382
 383
 384
 385 class SliceRoleSerializer(serializers.HyperlinkedModelSerializer):
 386     id = serializers.Field()
 387
 388     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 389     validators = serializers.SerializerMethodField("getValidators")
 390     def getHumanReadableName(self, obj):\r
 391         return str(obj)
 392     def getValidators(self, obj):
 393         try:
 394             return obj.getValidators()
 395         except:
 396             return None
 397     class Meta:
 398         model = SliceRole
 399         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
 400
 401 class SliceRoleIdSerializer(serializers.ModelSerializer):
 402     id = serializers.Field()
 403
 404     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 405     validators = serializers.SerializerMethodField("getValidators")
 406     def getHumanReadableName(self, obj):\r
 407         return str(obj)\r
 408     def getValidators(self, obj):\r
 409         try:
 410             return obj.getValidators()
 411         except:
 412             return None\r
 413     class Meta:
 414         model = SliceRole
 415         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
 416
 417
 418
 419
 420 class TagSerializer(serializers.HyperlinkedModelSerializer):
 421     id = serializers.Field()
 422
 423     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 424     validators = serializers.SerializerMethodField("getValidators")
 425     def getHumanReadableName(self, obj):\r
 426         return str(obj)
 427     def getValidators(self, obj):
 428         try:
 429             return obj.getValidators()
 430         except:
 431             return None
 432     class Meta:
 433         model = Tag
 434         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','service','name','value','content_type','object_id',)
 435
 436 class TagIdSerializer(serializers.ModelSerializer):
 437     id = serializers.Field()
 438
 439     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 440     validators = serializers.SerializerMethodField("getValidators")
 441     def getHumanReadableName(self, obj):\r
 442         return str(obj)\r
 443     def getValidators(self, obj):\r
 444         try:
 445             return obj.getValidators()
 446         except:
 447             return None\r
 448     class Meta:
 449         model = Tag
 450         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','service','name','value','content_type','object_id',)
 451
 452
 453
 454
 455 class InvoiceSerializer(serializers.HyperlinkedModelSerializer):
 456     id = serializers.Field()
 457
 458     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 459     validators = serializers.SerializerMethodField("getValidators")
 460     def getHumanReadableName(self, obj):\r
 461         return str(obj)
 462     def getValidators(self, obj):
 463         try:
 464             return obj.getValidators()
 465         except:
 466             return None
 467     class Meta:
 468         model = Invoice
 469         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','date','account',)
 470
 471 class InvoiceIdSerializer(serializers.ModelSerializer):
 472     id = serializers.Field()
 473
 474     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 475     validators = serializers.SerializerMethodField("getValidators")
 476     def getHumanReadableName(self, obj):\r
 477         return str(obj)\r
 478     def getValidators(self, obj):\r
 479         try:
 480             return obj.getValidators()
 481         except:
 482             return None\r
 483     class Meta:
 484         model = Invoice
 485         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','date','account',)
 486
 487
 488
 489
 490 class SlicePrivilegeSerializer(serializers.HyperlinkedModelSerializer):
 491     id = serializers.Field()
 492
 493     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 494     validators = serializers.SerializerMethodField("getValidators")
 495     def getHumanReadableName(self, obj):\r
 496         return str(obj)
 497     def getValidators(self, obj):
 498         try:
 499             return obj.getValidators()
 500         except:
 501             return None
 502     class Meta:
 503         model = SlicePrivilege
 504         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','slice','role',)
 505
 506 class SlicePrivilegeIdSerializer(serializers.ModelSerializer):
 507     id = serializers.Field()
 508
 509     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 510     validators = serializers.SerializerMethodField("getValidators")
 511     def getHumanReadableName(self, obj):\r
 512         return str(obj)\r
 513     def getValidators(self, obj):\r
 514         try:
 515             return obj.getValidators()
 516         except:
 517             return None\r
 518     class Meta:
 519         model = SlicePrivilege
 520         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','slice','role',)
 521
 522
 523
 524
 525 class PlanetStackRoleSerializer(serializers.HyperlinkedModelSerializer):
 526     id = serializers.Field()
 527
 528     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 529     validators = serializers.SerializerMethodField("getValidators")
 530     def getHumanReadableName(self, obj):\r
 531         return str(obj)
 532     def getValidators(self, obj):
 533         try:
 534             return obj.getValidators()
 535         except:
 536             return None
 537     class Meta:
 538         model = PlanetStackRole
 539         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
 540
 541 class PlanetStackRoleIdSerializer(serializers.ModelSerializer):
 542     id = serializers.Field()
 543
 544     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 545     validators = serializers.SerializerMethodField("getValidators")
 546     def getHumanReadableName(self, obj):\r
 547         return str(obj)\r
 548     def getValidators(self, obj):\r
 549         try:
 550             return obj.getValidators()
 551         except:
 552             return None\r
 553     class Meta:
 554         model = PlanetStackRole
 555         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
 556
 557
 558
 559
 560 class NetworkSliverSerializer(serializers.HyperlinkedModelSerializer):
 561     id = serializers.Field()
 562
 563     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 564     validators = serializers.SerializerMethodField("getValidators")
 565     def getHumanReadableName(self, obj):\r
 566         return str(obj)
 567     def getValidators(self, obj):
 568         try:
 569             return obj.getValidators()
 570         except:
 571             return None
 572     class Meta:
 573         model = NetworkSliver
 574         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','sliver','ip','port_id',)
 575
 576 class NetworkSliverIdSerializer(serializers.ModelSerializer):
 577     id = serializers.Field()
 578
 579     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 580     validators = serializers.SerializerMethodField("getValidators")
 581     def getHumanReadableName(self, obj):\r
 582         return str(obj)\r
 583     def getValidators(self, obj):\r
 584         try:
 585             return obj.getValidators()
 586         except:
 587             return None\r
 588     class Meta:
 589         model = NetworkSliver
 590         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','sliver','ip','port_id',)
 591
 592
 593
 594
 595 class ControllerNetworksSerializer(serializers.HyperlinkedModelSerializer):
 596     id = serializers.Field()
 597
 598     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 599     validators = serializers.SerializerMethodField("getValidators")
 600     def getHumanReadableName(self, obj):\r
 601         return str(obj)
 602     def getValidators(self, obj):
 603         try:
 604             return obj.getValidators()
 605         except:
 606             return None
 607     class Meta:
 608         model = ControllerNetworks
 609         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','deployment','net_id','router_id','subnet_id','subnet',)
 610
 611 class ControllerNetworksIdSerializer(serializers.ModelSerializer):
 612     id = serializers.Field()
 613
 614     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 615     validators = serializers.SerializerMethodField("getValidators")
 616     def getHumanReadableName(self, obj):\r
 617         return str(obj)\r
 618     def getValidators(self, obj):\r
 619         try:
 620             return obj.getValidators()
 621         except:
 622             return None\r
 623     class Meta:
 624         model = ControllerNetworks
 625         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','deployment','net_id','router_id','subnet_id','subnet',)
 626
 627
 628
 629
 630 class FlavorSerializer(serializers.HyperlinkedModelSerializer):
 631     id = serializers.Field()
 632
 633     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 634     validators = serializers.SerializerMethodField("getValidators")
 635     def getHumanReadableName(self, obj):\r
 636         return str(obj)
 637     def getValidators(self, obj):
 638         try:
 639             return obj.getValidators()
 640         except:
 641             return None
 642     class Meta:
 643         model = Flavor
 644         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','flavor','order','default',)
 645
 646 class FlavorIdSerializer(serializers.ModelSerializer):
 647     id = serializers.Field()
 648
 649     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 650     validators = serializers.SerializerMethodField("getValidators")
 651     def getHumanReadableName(self, obj):\r
 652         return str(obj)\r
 653     def getValidators(self, obj):\r
 654         try:
 655             return obj.getValidators()
 656         except:
 657             return None\r
 658     class Meta:
 659         model = Flavor
 660         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','flavor','order','default',)
 661
 662
 663
 664
 665 class ProjectSerializer(serializers.HyperlinkedModelSerializer):
 666     id = serializers.Field()
 667
 668     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 669     validators = serializers.SerializerMethodField("getValidators")
 670     def getHumanReadableName(self, obj):\r
 671         return str(obj)
 672     def getValidators(self, obj):
 673         try:
 674             return obj.getValidators()
 675         except:
 676             return None
 677     class Meta:
 678         model = Project
 679         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name',)
 680
 681 class ProjectIdSerializer(serializers.ModelSerializer):
 682     id = serializers.Field()
 683
 684     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 685     validators = serializers.SerializerMethodField("getValidators")
 686     def getHumanReadableName(self, obj):\r
 687         return str(obj)\r
 688     def getValidators(self, obj):\r
 689         try:
 690             return obj.getValidators()
 691         except:
 692             return None\r
 693     class Meta:
 694         model = Project
 695         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name',)
 696
 697
 698
 699
 700 class SliceSerializer(serializers.HyperlinkedModelSerializer):
 701     id = serializers.Field()
 702
 703
 704     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 705
 706
 707
 708     availableNetworks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 709
 710
 711
 712     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 713
 714
 715
 716     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 717
 718
 719     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 720     validators = serializers.SerializerMethodField("getValidators")
 721     def getHumanReadableName(self, obj):\r
 722         return str(obj)
 723     def getValidators(self, obj):
 724         try:
 725             return obj.getValidators()
 726         except:
 727             return None
 728     class Meta:
 729         model = Slice
 730         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','enabled','omf_friendly','description','slice_url','site','max_slivers','imagePreference','service','network','mountDataSets','serviceClass','creator','networks','availableNetworks','networks','networks',)
 731
 732 class SliceIdSerializer(serializers.ModelSerializer):
 733     id = serializers.Field()
 734
 735
 736     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 737
 738
 739
 740     availableNetworks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 741
 742
 743
 744     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 745
 746
 747
 748     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
 749
 750
 751     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 752     validators = serializers.SerializerMethodField("getValidators")
 753     def getHumanReadableName(self, obj):\r
 754         return str(obj)\r
 755     def getValidators(self, obj):\r
 756         try:
 757             return obj.getValidators()
 758         except:
 759             return None\r
 760     class Meta:
 761         model = Slice
 762         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','enabled','omf_friendly','description','slice_url','site','max_slivers','imagePreference','service','network','mountDataSets','serviceClass','creator','networks','availableNetworks','networks','networks',)
 763
 764
 765
 766
 767 class NetworkSerializer(serializers.HyperlinkedModelSerializer):
 768     id = serializers.Field()
 769
 770
 771     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 772
 773
 774
 775     availableRouters = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 776
 777
 778
 779     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 780
 781
 782
 783     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 784
 785
 786     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 787     validators = serializers.SerializerMethodField("getValidators")
 788     def getHumanReadableName(self, obj):\r
 789         return str(obj)
 790     def getValidators(self, obj):
 791         try:
 792             return obj.getValidators()
 793         except:
 794             return None
 795     class Meta:
 796         model = Network
 797         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','template','subnet','ports','labels','owner','guaranteedBandwidth','permitAllSlices','topologyParameters','controllerUrl','controllerParameters','network_id','router_id','subnet_id','routers','availableRouters','routers','routers',)
 798
 799 class NetworkIdSerializer(serializers.ModelSerializer):
 800     id = serializers.Field()
 801
 802
 803     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 804
 805
 806
 807     availableRouters = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 808
 809
 810
 811     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 812
 813
 814
 815     routers = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='router-detail')
 816
 817
 818     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 819     validators = serializers.SerializerMethodField("getValidators")
 820     def getHumanReadableName(self, obj):\r
 821         return str(obj)\r
 822     def getValidators(self, obj):\r
 823         try:
 824             return obj.getValidators()
 825         except:
 826             return None\r
 827     class Meta:
 828         model = Network
 829         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','template','subnet','ports','labels','owner','guaranteedBandwidth','permitAllSlices','topologyParameters','controllerUrl','controllerParameters','network_id','router_id','subnet_id','routers','availableRouters','routers','routers',)
 830
 831
 832
 833
 834 class ServiceSerializer(serializers.HyperlinkedModelSerializer):
 835     id = serializers.Field()
 836
 837     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 838     validators = serializers.SerializerMethodField("getValidators")
 839     def getHumanReadableName(self, obj):\r
 840         return str(obj)
 841     def getValidators(self, obj):
 842         try:
 843             return obj.getValidators()
 844         except:
 845             return None
 846     class Meta:
 847         model = Service
 848         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','description','enabled','name','versionNumber','published',)
 849
 850 class ServiceIdSerializer(serializers.ModelSerializer):
 851     id = serializers.Field()
 852
 853     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 854     validators = serializers.SerializerMethodField("getValidators")
 855     def getHumanReadableName(self, obj):\r
 856         return str(obj)\r
 857     def getValidators(self, obj):\r
 858         try:
 859             return obj.getValidators()
 860         except:
 861             return None\r
 862     class Meta:
 863         model = Service
 864         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','description','enabled','name','versionNumber','published',)
 865
 866
 867
 868
 869 class ServiceClassSerializer(serializers.HyperlinkedModelSerializer):
 870     id = serializers.Field()
 871
 872     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 873     validators = serializers.SerializerMethodField("getValidators")
 874     def getHumanReadableName(self, obj):\r
 875         return str(obj)
 876     def getValidators(self, obj):
 877         try:
 878             return obj.getValidators()
 879         except:
 880             return None
 881     class Meta:
 882         model = ServiceClass
 883         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','commitment','membershipFee','membershipFeeMonths','upgradeRequiresApproval',)
 884
 885 class ServiceClassIdSerializer(serializers.ModelSerializer):
 886     id = serializers.Field()
 887
 888     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 889     validators = serializers.SerializerMethodField("getValidators")
 890     def getHumanReadableName(self, obj):\r
 891         return str(obj)\r
 892     def getValidators(self, obj):\r
 893         try:
 894             return obj.getValidators()
 895         except:
 896             return None\r
 897     class Meta:
 898         model = ServiceClass
 899         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','commitment','membershipFee','membershipFeeMonths','upgradeRequiresApproval',)
 900
 901
 902
 903
 904 class PaymentSerializer(serializers.HyperlinkedModelSerializer):
 905     id = serializers.Field()
 906
 907     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 908     validators = serializers.SerializerMethodField("getValidators")
 909     def getHumanReadableName(self, obj):\r
 910         return str(obj)
 911     def getValidators(self, obj):
 912         try:
 913             return obj.getValidators()
 914         except:
 915             return None
 916     class Meta:
 917         model = Payment
 918         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','account','amount','date',)
 919
 920 class PaymentIdSerializer(serializers.ModelSerializer):
 921     id = serializers.Field()
 922
 923     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 924     validators = serializers.SerializerMethodField("getValidators")
 925     def getHumanReadableName(self, obj):\r
 926         return str(obj)\r
 927     def getValidators(self, obj):\r
 928         try:
 929             return obj.getValidators()
 930         except:
 931             return None\r
 932     class Meta:
 933         model = Payment
 934         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','account','amount','date',)
 935
 936
 937
 938
 939 class ChargeSerializer(serializers.HyperlinkedModelSerializer):
 940     id = serializers.Field()
 941
 942     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 943     validators = serializers.SerializerMethodField("getValidators")
 944     def getHumanReadableName(self, obj):\r
 945         return str(obj)
 946     def getValidators(self, obj):
 947         try:
 948             return obj.getValidators()
 949         except:
 950             return None
 951     class Meta:
 952         model = Charge
 953         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','account','slice','kind','state','date','object','amount','coreHours','invoice',)
 954
 955 class ChargeIdSerializer(serializers.ModelSerializer):
 956     id = serializers.Field()
 957
 958     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 959     validators = serializers.SerializerMethodField("getValidators")
 960     def getHumanReadableName(self, obj):\r
 961         return str(obj)\r
 962     def getValidators(self, obj):\r
 963         try:
 964             return obj.getValidators()
 965         except:
 966             return None\r
 967     class Meta:
 968         model = Charge
 969         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','account','slice','kind','state','date','object','amount','coreHours','invoice',)
 970
 971
 972
 973
 974 class RoleSerializer(serializers.HyperlinkedModelSerializer):
 975     id = serializers.Field()
 976
 977     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 978     validators = serializers.SerializerMethodField("getValidators")
 979     def getHumanReadableName(self, obj):\r
 980         return str(obj)
 981     def getValidators(self, obj):
 982         try:
 983             return obj.getValidators()
 984         except:
 985             return None
 986     class Meta:
 987         model = Role
 988         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role_type','role','description','content_type',)
 989
 990 class RoleIdSerializer(serializers.ModelSerializer):
 991     id = serializers.Field()
 992
 993     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
 994     validators = serializers.SerializerMethodField("getValidators")
 995     def getHumanReadableName(self, obj):\r
 996         return str(obj)\r
 997     def getValidators(self, obj):\r
 998         try:
 999             return obj.getValidators()
1000         except:
1001             return None\r
1002     class Meta:
1003         model = Role
1004         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role_type','role','description','content_type',)
1005
1006
1007
1008
1009 class UsableObjectSerializer(serializers.HyperlinkedModelSerializer):
1010     id = serializers.Field()
1011
1012     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1013     validators = serializers.SerializerMethodField("getValidators")
1014     def getHumanReadableName(self, obj):\r
1015         return str(obj)
1016     def getValidators(self, obj):
1017         try:
1018             return obj.getValidators()
1019         except:
1020             return None
1021     class Meta:
1022         model = UsableObject
1023         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name',)
1024
1025 class UsableObjectIdSerializer(serializers.ModelSerializer):
1026     id = serializers.Field()
1027
1028     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1029     validators = serializers.SerializerMethodField("getValidators")
1030     def getHumanReadableName(self, obj):\r
1031         return str(obj)\r
1032     def getValidators(self, obj):\r
1033         try:
1034             return obj.getValidators()
1035         except:
1036             return None\r
1037     class Meta:
1038         model = UsableObject
1039         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name',)
1040
1041
1042
1043
1044 class SiteRoleSerializer(serializers.HyperlinkedModelSerializer):
1045     id = serializers.Field()
1046
1047     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1048     validators = serializers.SerializerMethodField("getValidators")
1049     def getHumanReadableName(self, obj):\r
1050         return str(obj)
1051     def getValidators(self, obj):
1052         try:
1053             return obj.getValidators()
1054         except:
1055             return None
1056     class Meta:
1057         model = SiteRole
1058         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
1059
1060 class SiteRoleIdSerializer(serializers.ModelSerializer):
1061     id = serializers.Field()
1062
1063     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1064     validators = serializers.SerializerMethodField("getValidators")
1065     def getHumanReadableName(self, obj):\r
1066         return str(obj)\r
1067     def getValidators(self, obj):\r
1068         try:
1069             return obj.getValidators()
1070         except:
1071             return None\r
1072     class Meta:
1073         model = SiteRole
1074         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
1075
1076
1077
1078
1079 class SliceCredentialSerializer(serializers.HyperlinkedModelSerializer):
1080     id = serializers.Field()
1081
1082     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1083     validators = serializers.SerializerMethodField("getValidators")
1084     def getHumanReadableName(self, obj):\r
1085         return str(obj)
1086     def getValidators(self, obj):
1087         try:
1088             return obj.getValidators()
1089         except:
1090             return None
1091     class Meta:
1092         model = SliceCredential
1093         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','name','key_id','enc_value',)
1094
1095 class SliceCredentialIdSerializer(serializers.ModelSerializer):
1096     id = serializers.Field()
1097
1098     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1099     validators = serializers.SerializerMethodField("getValidators")
1100     def getHumanReadableName(self, obj):\r
1101         return str(obj)\r
1102     def getValidators(self, obj):\r
1103         try:
1104             return obj.getValidators()
1105         except:
1106             return None\r
1107     class Meta:
1108         model = SliceCredential
1109         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','name','key_id','enc_value',)
1110
1111
1112
1113
1114 class SliverSerializer(serializers.HyperlinkedModelSerializer):
1115     id = serializers.Field()
1116
1117
1118     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
1119
1120
1121
1122     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
1123
1124
1125     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1126     validators = serializers.SerializerMethodField("getValidators")
1127     def getHumanReadableName(self, obj):\r
1128         return str(obj)
1129     def getValidators(self, obj):
1130         try:
1131             return obj.getValidators()
1132         except:
1133             return None
1134     class Meta:
1135         model = Sliver
1136         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','instance_id','name','instance_name','ip','image','creator','slice','node','deploymentNetwork','numberCores','flavor','userData','networks','networks',)
1137
1138 class SliverIdSerializer(serializers.ModelSerializer):
1139     id = serializers.Field()
1140
1141
1142     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
1143
1144
1145
1146     networks = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='network-detail')
1147
1148
1149     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1150     validators = serializers.SerializerMethodField("getValidators")
1151     def getHumanReadableName(self, obj):\r
1152         return str(obj)\r
1153     def getValidators(self, obj):\r
1154         try:
1155             return obj.getValidators()
1156         except:
1157             return None\r
1158     class Meta:
1159         model = Sliver
1160         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','instance_id','name','instance_name','ip','image','creator','slice','node','deploymentNetwork','numberCores','flavor','userData','networks','networks',)
1161
1162
1163
1164
1165 class NodeSerializer(serializers.HyperlinkedModelSerializer):
1166     id = serializers.Field()
1167
1168     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1169     validators = serializers.SerializerMethodField("getValidators")
1170     def getHumanReadableName(self, obj):\r
1171         return str(obj)
1172     def getValidators(self, obj):
1173         try:
1174             return obj.getValidators()
1175         except:
1176             return None
1177     class Meta:
1178         model = Node
1179         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','site','deployment',)
1180
1181 class NodeIdSerializer(serializers.ModelSerializer):
1182     id = serializers.Field()
1183
1184     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1185     validators = serializers.SerializerMethodField("getValidators")
1186     def getHumanReadableName(self, obj):\r
1187         return str(obj)\r
1188     def getValidators(self, obj):\r
1189         try:
1190             return obj.getValidators()
1191         except:
1192             return None\r
1193     class Meta:
1194         model = Node
1195         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','site','deployment',)
1196
1197
1198
1199
1200 class DashboardViewSerializer(serializers.HyperlinkedModelSerializer):
1201     id = serializers.Field()
1202
1203     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1204     validators = serializers.SerializerMethodField("getValidators")
1205     def getHumanReadableName(self, obj):\r
1206         return str(obj)
1207     def getValidators(self, obj):
1208         try:
1209             return obj.getValidators()
1210         except:
1211             return None
1212     class Meta:
1213         model = DashboardView
1214         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','url',)
1215
1216 class DashboardViewIdSerializer(serializers.ModelSerializer):
1217     id = serializers.Field()
1218
1219     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1220     validators = serializers.SerializerMethodField("getValidators")
1221     def getHumanReadableName(self, obj):\r
1222         return str(obj)\r
1223     def getValidators(self, obj):\r
1224         try:
1225             return obj.getValidators()
1226         except:
1227             return None\r
1228     class Meta:
1229         model = DashboardView
1230         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','url',)
1231
1232
1233
1234
1235 class ControllerImagesSerializer(serializers.HyperlinkedModelSerializer):
1236     id = serializers.Field()
1237
1238     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1239     validators = serializers.SerializerMethodField("getValidators")
1240     def getHumanReadableName(self, obj):\r
1241         return str(obj)
1242     def getValidators(self, obj):
1243         try:
1244             return obj.getValidators()
1245         except:
1246             return None
1247     class Meta:
1248         model = ControllerImages
1249         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','image','deployment','glance_image_id',)
1250
1251 class ControllerImagesIdSerializer(serializers.ModelSerializer):
1252     id = serializers.Field()
1253
1254     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1255     validators = serializers.SerializerMethodField("getValidators")
1256     def getHumanReadableName(self, obj):\r
1257         return str(obj)\r
1258     def getValidators(self, obj):\r
1259         try:
1260             return obj.getValidators()
1261         except:
1262             return None\r
1263     class Meta:
1264         model = ControllerImages
1265         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','image','deployment','glance_image_id',)
1266
1267
1268
1269
1270 class ReservedResourceSerializer(serializers.HyperlinkedModelSerializer):
1271     id = serializers.Field()
1272
1273     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1274     validators = serializers.SerializerMethodField("getValidators")
1275     def getHumanReadableName(self, obj):\r
1276         return str(obj)
1277     def getValidators(self, obj):
1278         try:
1279             return obj.getValidators()
1280         except:
1281             return None
1282     class Meta:
1283         model = ReservedResource
1284         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','sliver','resource','quantity','reservationSet',)
1285
1286 class ReservedResourceIdSerializer(serializers.ModelSerializer):
1287     id = serializers.Field()
1288
1289     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1290     validators = serializers.SerializerMethodField("getValidators")
1291     def getHumanReadableName(self, obj):\r
1292         return str(obj)\r
1293     def getValidators(self, obj):\r
1294         try:
1295             return obj.getValidators()
1296         except:
1297             return None\r
1298     class Meta:
1299         model = ReservedResource
1300         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','sliver','resource','quantity','reservationSet',)
1301
1302
1303
1304
1305 class NetworkSliceSerializer(serializers.HyperlinkedModelSerializer):
1306     id = serializers.Field()
1307
1308     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1309     validators = serializers.SerializerMethodField("getValidators")
1310     def getHumanReadableName(self, obj):\r
1311         return str(obj)
1312     def getValidators(self, obj):
1313         try:
1314             return obj.getValidators()
1315         except:
1316             return None
1317     class Meta:
1318         model = NetworkSlice
1319         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','slice',)
1320
1321 class NetworkSliceIdSerializer(serializers.ModelSerializer):
1322     id = serializers.Field()
1323
1324     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1325     validators = serializers.SerializerMethodField("getValidators")
1326     def getHumanReadableName(self, obj):\r
1327         return str(obj)\r
1328     def getValidators(self, obj):\r
1329         try:
1330             return obj.getValidators()
1331         except:
1332             return None\r
1333     class Meta:
1334         model = NetworkSlice
1335         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','network','slice',)
1336
1337
1338
1339
1340 class UserDashboardViewSerializer(serializers.HyperlinkedModelSerializer):
1341     id = serializers.Field()
1342
1343     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1344     validators = serializers.SerializerMethodField("getValidators")
1345     def getHumanReadableName(self, obj):\r
1346         return str(obj)
1347     def getValidators(self, obj):
1348         try:
1349             return obj.getValidators()
1350         except:
1351             return None
1352     class Meta:
1353         model = UserDashboardView
1354         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','dashboardView','order',)
1355
1356 class UserDashboardViewIdSerializer(serializers.ModelSerializer):
1357     id = serializers.Field()
1358
1359     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1360     validators = serializers.SerializerMethodField("getValidators")
1361     def getHumanReadableName(self, obj):\r
1362         return str(obj)\r
1363     def getValidators(self, obj):\r
1364         try:
1365             return obj.getValidators()
1366         except:
1367             return None
1368     class Meta:
1369         model = UserDashboardView
1370         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','dashboardView','order',)
1371
1372
1373
1374
1375 class PlanetStackPrivilegeSerializer(serializers.HyperlinkedModelSerializer):
1376     id = serializers.Field()
1377
1378     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1379     validators = serializers.SerializerMethodField("getValidators")
1380     def getHumanReadableName(self, obj):
1381         return str(obj)
1382     def getValidators(self, obj):
1383         try:
1384             return obj.getValidators()
1385         except:
1386             return None
1387     class Meta:
1388         model = PlanetStackPrivilege
1389         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','planetstack','role',)
1390
1391 class PlanetStackPrivilegeIdSerializer(serializers.ModelSerializer):
1392     id = serializers.Field()
1393
1394     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1395     validators = serializers.SerializerMethodField("getValidators")
1396     def getHumanReadableName(self, obj):
1397         return str(obj)
1398     def getValidators(self, obj):
1399         try:
1400             return obj.getValidators()
1401         except:
1402             return None
1403     class Meta:
1404         model = PlanetStackPrivilege
1405         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','planetstack','role',)
1406
1407
1408
1409
1410 class UserSerializer(serializers.HyperlinkedModelSerializer):
1411     id = serializers.Field()
1412
1413     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1414     validators = serializers.SerializerMethodField("getValidators")
1415     def getHumanReadableName(self, obj):
1416         return str(obj)
1417     def getValidators(self, obj):
1418         try:
1419             return obj.getValidators()
1420         except:
1421             return None
1422     class Meta:
1423         model = User
1424         fields = ('humanReadableName', 'validators', 'id','password','last_login','email','username','firstname','lastname','phone','user_url','site','public_key','is_active','is_admin','is_staff','is_readonly','created','updated','enacted','backend_status','deleted','timezone',)
1425
1426 class UserIdSerializer(serializers.ModelSerializer):
1427     id = serializers.Field()
1428
1429     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1430     validators = serializers.SerializerMethodField("getValidators")
1431     def getHumanReadableName(self, obj):
1432         return str(obj)
1433     def getValidators(self, obj):
1434         try:
1435             return obj.getValidators()
1436         except:
1437             return None
1438     class Meta:
1439         model = User
1440         fields = ('humanReadableName', 'validators', 'id','password','last_login','email','username','firstname','lastname','phone','user_url','site','public_key','is_active','is_admin','is_staff','is_readonly','created','updated','enacted','backend_status','deleted','timezone',)
1441
1442
1443
1444
1445 class DeploymentSerializer(serializers.HyperlinkedModelSerializer):
1446     id = serializers.Field()
1447
1448
1449     sites = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='site-detail')
1450
1451
1452
1453     sites = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='site-detail')
1454
1455
1456
1457     flavors = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='flavor-detail')
1458
1459
1460
1461     flavors = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='flavor-detail')
1462
1463
1464     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1465     validators = serializers.SerializerMethodField("getValidators")
1466     def getHumanReadableName(self, obj):
1467         return str(obj)
1468     def getValidators(self, obj):
1469         try:
1470             return obj.getValidators()
1471         except:
1472             return None
1473     class Meta:
1474         model = Deployment
1475         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','accessControl','sites','sites','flavors','flavors',)
1476
1477
1478 class ControllerSerializer(serializers.HyperlinkedModelSerializer):
1479     id = serializers.Field()
1480     site_deployments = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='sitedeployment-detail')
1481     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1482     validators = serializers.SerializerMethodField("getValidators")
1483     def getHumanReadableName(self, obj):
1484         return str(obj)
1485     def getValidators(self, obj):
1486         try:
1487             return obj.getValidators()
1488         except:
1489             return None
1490     class Meta:
1491         model = Controller
1492         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','admin_user','admin_password','admin_tenant','auth_url','backend_type','availability_zone','accessControl',)
1493
1494
1495 class DeploymentIdSerializer(serializers.ModelSerializer):
1496     id = serializers.Field()
1497
1498
1499     sites = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='site-detail')
1500
1501
1502
1503     sites = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='site-detail')
1504
1505
1506
1507     flavors = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='flavor-detail')
1508
1509
1510
1511     flavors = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='flavor-detail')
1512
1513
1514     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1515     validators = serializers.SerializerMethodField("getValidators")
1516     def getHumanReadableName(self, obj):\r
1517         return str(obj)\r
1518     def getValidators(self, obj):\r
1519         try:
1520             return obj.getValidators()
1521         except:
1522             return None\r
1523     class Meta:
1524         model = Deployment
1525         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','admin_user','admin_password','admin_tenant','auth_url','backend_type','availability_zone','accessControl','sites','sites','flavors','flavors',)
1526
1527
1528 class ControllerSerializer(serializers.HyperlinkedModelSerializer):
1529     id = serializers.Field()
1530     site_deployments = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='sitedeployment-detail')
1531     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1532     validators = serializers.SerializerMethodField("getValidators")
1533     def getHumanReadableName(self, obj):
1534         return str(obj)
1535     def getValidators(self, obj):
1536         try:
1537             return obj.getValidators()
1538         except:
1539             return None
1540     class Meta:
1541         model = Controller
1542         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','admin_user','admin_password','admin_tenant','auth_url','backend_type')
1543
1544
1545 class ControllerIdSerializer(serializers.ModelSerializer):
1546     id = serializers.Field()
1547     sites = serializers.HyperlinkedRelatedField(many=True, read_only=True, view_name='site-detail')
1548     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1549     validators = serializers.SerializerMethodField("getValidators")
1550     def getHumanReadableName(self, obj):
1551         return str(obj)
1552     def getValidators(self, obj):
1553         try:
1554             return obj.getValidators()
1555         except:
1556             return None
1557     class Meta:
1558         model = Controller
1559         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','admin_user','admin_password','admin_tenant','auth_url','backend_type')
1560
1561
1562 class ReservationSerializer(serializers.HyperlinkedModelSerializer):
1563     id = serializers.Field()
1564
1565     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1566     validators = serializers.SerializerMethodField("getValidators")
1567     def getHumanReadableName(self, obj):\r
1568         return str(obj)
1569     def getValidators(self, obj):
1570         try:
1571             return obj.getValidators()
1572         except:
1573             return None
1574     class Meta:
1575         model = Reservation
1576         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','startTime','slice','duration',)
1577
1578 class ReservationIdSerializer(serializers.ModelSerializer):
1579     id = serializers.Field()
1580
1581     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1582     validators = serializers.SerializerMethodField("getValidators")
1583     def getHumanReadableName(self, obj):\r
1584         return str(obj)\r
1585     def getValidators(self, obj):\r
1586         try:
1587             return obj.getValidators()
1588         except:
1589             return None\r
1590     class Meta:
1591         model = Reservation
1592         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','startTime','slice','duration',)
1593
1594
1595
1596
1597 class ControllerSlicesSerializer(serializers.HyperlinkedModelSerializer):
1598     id = serializers.Field()
1599
1600     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1601     validators = serializers.SerializerMethodField("getValidators")
1602     def getHumanReadableName(self, obj):\r
1603         return str(obj)
1604     def getValidators(self, obj):
1605         try:
1606             return obj.getValidators()
1607         except:
1608             return None
1609     class Meta:
1610         model = ControllerSlices
1611         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','deployment','tenant_id','network_id','router_id','subnet_id',)
1612
1613 class ControllerSlicesIdSerializer(serializers.ModelSerializer):
1614     id = serializers.Field()
1615
1616     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1617     validators = serializers.SerializerMethodField("getValidators")
1618     def getHumanReadableName(self, obj):\r
1619         return str(obj)\r
1620     def getValidators(self, obj):\r
1621         try:
1622             return obj.getValidators()
1623         except:
1624             return None\r
1625     class Meta:
1626         model = ControllerSlices
1627         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','deployment','tenant_id','network_id','router_id','subnet_id',)
1628
1629
1630
1631
1632 class SitePrivilegeSerializer(serializers.HyperlinkedModelSerializer):
1633     id = serializers.Field()
1634
1635     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1636     validators = serializers.SerializerMethodField("getValidators")
1637     def getHumanReadableName(self, obj):\r
1638         return str(obj)
1639     def getValidators(self, obj):
1640         try:
1641             return obj.getValidators()
1642         except:
1643             return None
1644     class Meta:
1645         model = SitePrivilege
1646         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','site','role',)
1647
1648 class SitePrivilegeIdSerializer(serializers.ModelSerializer):
1649     id = serializers.Field()
1650
1651     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1652     validators = serializers.SerializerMethodField("getValidators")
1653     def getHumanReadableName(self, obj):\r
1654         return str(obj)\r
1655     def getValidators(self, obj):\r
1656         try:
1657             return obj.getValidators()
1658         except:
1659             return None\r
1660     class Meta:
1661         model = SitePrivilege
1662         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','site','role',)
1663
1664
1665
1666
1667 class PlanetStackSerializer(serializers.HyperlinkedModelSerializer):
1668     id = serializers.Field()
1669
1670     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1671     validators = serializers.SerializerMethodField("getValidators")
1672     def getHumanReadableName(self, obj):\r
1673         return str(obj)
1674     def getValidators(self, obj):
1675         try:
1676             return obj.getValidators()
1677         except:
1678             return None
1679     class Meta:
1680         model = PlanetStack
1681         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','description',)
1682
1683 class PlanetStackIdSerializer(serializers.ModelSerializer):
1684     id = serializers.Field()
1685
1686     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1687     validators = serializers.SerializerMethodField("getValidators")
1688     def getHumanReadableName(self, obj):\r
1689         return str(obj)\r
1690     def getValidators(self, obj):\r
1691         try:
1692             return obj.getValidators()
1693         except:
1694             return None\r
1695     class Meta:
1696         model = PlanetStack
1697         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','description',)
1698
1699
1700
1701
1702 class ControllerUsersSerializer(serializers.HyperlinkedModelSerializer):
1703     id = serializers.Field()
1704
1705     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1706     validators = serializers.SerializerMethodField("getValidators")
1707     def getHumanReadableName(self, obj):\r
1708         return str(obj)
1709     def getValidators(self, obj):
1710         try:
1711             return obj.getValidators()
1712         except:
1713             return None
1714     class Meta:
1715         model = ControllerUsers
1716         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','deployment','kuser_id',)
1717
1718 class ControllerUsersIdSerializer(serializers.ModelSerializer):
1719     id = serializers.Field()
1720
1721     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1722     validators = serializers.SerializerMethodField("getValidators")
1723     def getHumanReadableName(self, obj):\r
1724         return str(obj)\r
1725     def getValidators(self, obj):\r
1726         try:
1727             return obj.getValidators()
1728         except:
1729             return None\r
1730     class Meta:
1731         model = ControllerUsers
1732         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','deployment','kuser_id',)
1733
1734
1735
1736
1737 class AccountSerializer(serializers.HyperlinkedModelSerializer):
1738     id = serializers.Field()
1739
1740     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1741     validators = serializers.SerializerMethodField("getValidators")
1742     def getHumanReadableName(self, obj):\r
1743         return str(obj)
1744     def getValidators(self, obj):
1745         try:
1746             return obj.getValidators()
1747         except:
1748             return None
1749     class Meta:
1750         model = Account
1751         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site',)
1752
1753 class AccountIdSerializer(serializers.ModelSerializer):
1754     id = serializers.Field()
1755
1756     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1757     validators = serializers.SerializerMethodField("getValidators")
1758     def getHumanReadableName(self, obj):\r
1759         return str(obj)\r
1760     def getValidators(self, obj):\r
1761         try:
1762             return obj.getValidators()
1763         except:
1764             return None\r
1765     class Meta:
1766         model = Account
1767         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site',)
1768
1769
1770
1771
1772 class NetworkParameterTypeSerializer(serializers.HyperlinkedModelSerializer):
1773     id = serializers.Field()
1774
1775     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1776     validators = serializers.SerializerMethodField("getValidators")
1777     def getHumanReadableName(self, obj):\r
1778         return str(obj)
1779     def getValidators(self, obj):
1780         try:
1781             return obj.getValidators()
1782         except:
1783             return None
1784     class Meta:
1785         model = NetworkParameterType
1786         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description',)
1787
1788 class NetworkParameterTypeIdSerializer(serializers.ModelSerializer):
1789     id = serializers.Field()
1790
1791     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1792     validators = serializers.SerializerMethodField("getValidators")
1793     def getHumanReadableName(self, obj):\r
1794         return str(obj)\r
1795     def getValidators(self, obj):\r
1796         try:
1797             return obj.getValidators()
1798         except:
1799             return None\r
1800     class Meta:
1801         model = NetworkParameterType
1802         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description',)
1803
1804
1805
1806
1807 class SiteCredentialSerializer(serializers.HyperlinkedModelSerializer):
1808     id = serializers.Field()
1809
1810     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1811     validators = serializers.SerializerMethodField("getValidators")
1812     def getHumanReadableName(self, obj):\r
1813         return str(obj)
1814     def getValidators(self, obj):
1815         try:
1816             return obj.getValidators()
1817         except:
1818             return None
1819     class Meta:
1820         model = SiteCredential
1821         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site','name','key_id','enc_value',)
1822
1823 class SiteCredentialIdSerializer(serializers.ModelSerializer):
1824     id = serializers.Field()
1825
1826     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1827     validators = serializers.SerializerMethodField("getValidators")
1828     def getHumanReadableName(self, obj):\r
1829         return str(obj)\r
1830     def getValidators(self, obj):\r
1831         try:
1832             return obj.getValidators()
1833         except:
1834             return None\r
1835     class Meta:
1836         model = SiteCredential
1837         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site','name','key_id','enc_value',)
1838
1839
1840
1841
1842 class ControllerPrivilegeSerializer(serializers.HyperlinkedModelSerializer):
1843     id = serializers.Field()
1844
1845     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1846     validators = serializers.SerializerMethodField("getValidators")
1847     def getHumanReadableName(self, obj):\r
1848         return str(obj)
1849     def getValidators(self, obj):
1850         try:
1851             return obj.getValidators()
1852         except:
1853             return None
1854     class Meta:
1855         model = ControllerPrivilege
1856         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','deployment','role',)
1857
1858 class ControllerPrivilegeIdSerializer(serializers.ModelSerializer):
1859     id = serializers.Field()
1860
1861     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1862     validators = serializers.SerializerMethodField("getValidators")
1863     def getHumanReadableName(self, obj):\r
1864         return str(obj)\r
1865     def getValidators(self, obj):\r
1866         try:
1867             return obj.getValidators()
1868         except:
1869             return None\r
1870     class Meta:
1871         model = ControllerPrivilege
1872         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','deployment','role',)
1873
1874
1875
1876
1877 class ControllerRoleSerializer(serializers.HyperlinkedModelSerializer):
1878     id = serializers.Field()
1879
1880     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1881     validators = serializers.SerializerMethodField("getValidators")
1882     def getHumanReadableName(self, obj):\r
1883         return str(obj)
1884     def getValidators(self, obj):
1885         try:
1886             return obj.getValidators()
1887         except:
1888             return None
1889     class Meta:
1890         model = ControllerRole
1891         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
1892
1893 class ControllerRoleIdSerializer(serializers.ModelSerializer):
1894     id = serializers.Field()
1895
1896     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1897     validators = serializers.SerializerMethodField("getValidators")
1898     def getHumanReadableName(self, obj):\r
1899         return str(obj)\r
1900     def getValidators(self, obj):\r
1901         try:
1902             return obj.getValidators()
1903         except:
1904             return None\r
1905     class Meta:
1906         model = ControllerRole
1907         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','role',)
1908
1909
1910
1911
1912 class UserCredentialSerializer(serializers.HyperlinkedModelSerializer):
1913     id = serializers.Field()
1914
1915     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1916     validators = serializers.SerializerMethodField("getValidators")
1917     def getHumanReadableName(self, obj):\r
1918         return str(obj)
1919     def getValidators(self, obj):
1920         try:
1921             return obj.getValidators()
1922         except:
1923             return None
1924     class Meta:
1925         model = UserCredential
1926         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','name','key_id','enc_value',)
1927
1928 class UserCredentialIdSerializer(serializers.ModelSerializer):
1929     id = serializers.Field()
1930
1931     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1932     validators = serializers.SerializerMethodField("getValidators")
1933     def getHumanReadableName(self, obj):\r
1934         return str(obj)\r
1935     def getValidators(self, obj):\r
1936         try:
1937             return obj.getValidators()
1938         except:
1939             return None\r
1940     class Meta:
1941         model = UserCredential
1942         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','user','name','key_id','enc_value',)
1943
1944
1945
1946
1947 class SiteDeploymentsSerializer(serializers.HyperlinkedModelSerializer):
1948     id = serializers.Field()
1949
1950     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1951     validators = serializers.SerializerMethodField("getValidators")
1952     def getHumanReadableName(self, obj):\r
1953         return str(obj)
1954     def getValidators(self, obj):
1955         try:
1956             return obj.getValidators()
1957         except:
1958             return None
1959     class Meta:
1960         model = SiteDeployments
1961         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site','deployment','tenant_id',)
1962
1963 class SiteDeploymentsIdSerializer(serializers.ModelSerializer):
1964     id = serializers.Field()
1965
1966     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1967     validators = serializers.SerializerMethodField("getValidators")
1968     def getHumanReadableName(self, obj):\r
1969         return str(obj)\r
1970     def getValidators(self, obj):\r
1971         try:
1972             return obj.getValidators()
1973         except:
1974             return None\r
1975     class Meta:
1976         model = SiteDeployments
1977         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site','deployment')
1978
1979
1980 class ControllerSitesSerializer(serializers.HyperlinkedModelSerializer):
1981     id = serializers.Field()
1982
1983     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
1984     validators = serializers.SerializerMethodField("getValidators")
1985     def getHumanReadableName(self, obj):
1986         return str(obj)
1987     def getValidators(self, obj):
1988         try:
1989             return obj.getValidators()
1990         except:
1991             return None
1992     class Meta:
1993         model = ControllerSites
1994         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site_deployment','controller','tenant_id',)
1995
1996 class ControllerSitesIdSerializer(serializers.ModelSerializer):
1997     id = serializers.Field()
1998
1999     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2000     validators = serializers.SerializerMethodField("getValidators")
2001     def getHumanReadableName(self, obj):
2002         return str(obj)
2003     def getValidators(self, obj):
2004         try:
2005             return obj.getValidators()
2006         except:
2007             return None
2008     class Meta:
2009         model = ControllerSites
2010         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','site_deployment','controller','tenant_id',)
2011
2012
2013 class SliceTagSerializer(serializers.HyperlinkedModelSerializer):
2014     id = serializers.Field()
2015
2016     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2017     validators = serializers.SerializerMethodField("getValidators")
2018     def getHumanReadableName(self, obj):\r
2019         return str(obj)
2020     def getValidators(self, obj):
2021         try:
2022             return obj.getValidators()
2023         except:
2024             return None
2025     class Meta:
2026         model = SliceTag
2027         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','name','value',)
2028
2029 class SliceTagIdSerializer(serializers.ModelSerializer):
2030     id = serializers.Field()
2031
2032     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2033     validators = serializers.SerializerMethodField("getValidators")
2034     def getHumanReadableName(self, obj):\r
2035         return str(obj)\r
2036     def getValidators(self, obj):\r
2037         try:
2038             return obj.getValidators()
2039         except:
2040             return None\r
2041     class Meta:
2042         model = SliceTag
2043         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','slice','name','value',)
2044
2045
2046
2047
2048 class NetworkTemplateSerializer(serializers.HyperlinkedModelSerializer):
2049     id = serializers.Field()
2050
2051     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2052     validators = serializers.SerializerMethodField("getValidators")
2053     def getHumanReadableName(self, obj):\r
2054         return str(obj)
2055     def getValidators(self, obj):
2056         try:
2057             return obj.getValidators()
2058         except:
2059             return None
2060     class Meta:
2061         model = NetworkTemplate
2062         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','guaranteedBandwidth','visibility','translation','sharedNetworkName','sharedNetworkId','topologyKind','controllerKind',)
2063
2064 class NetworkTemplateIdSerializer(serializers.ModelSerializer):
2065     id = serializers.Field()
2066
2067     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2068     validators = serializers.SerializerMethodField("getValidators")
2069     def getHumanReadableName(self, obj):\r
2070         return str(obj)\r
2071     def getValidators(self, obj):\r
2072         try:
2073             return obj.getValidators()
2074         except:
2075             return None\r
2076     class Meta:
2077         model = NetworkTemplate
2078         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','description','guaranteedBandwidth','visibility','translation','sharedNetworkName','sharedNetworkId','topologyKind','controllerKind',)
2079
2080
2081
2082
2083 class RouterSerializer(serializers.HyperlinkedModelSerializer):
2084     id = serializers.Field()
2085
2086     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2087     validators = serializers.SerializerMethodField("getValidators")
2088     def getHumanReadableName(self, obj):\r
2089         return str(obj)
2090     def getValidators(self, obj):
2091         try:
2092             return obj.getValidators()
2093         except:
2094             return None
2095     class Meta:
2096         model = Router
2097         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','owner',)
2098
2099 class RouterIdSerializer(serializers.ModelSerializer):
2100     id = serializers.Field()
2101
2102     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2103     validators = serializers.SerializerMethodField("getValidators")
2104     def getHumanReadableName(self, obj):\r
2105         return str(obj)\r
2106     def getValidators(self, obj):\r
2107         try:
2108             return obj.getValidators()
2109         except:
2110             return None\r
2111     class Meta:
2112         model = Router
2113         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','name','owner',)
2114
2115
2116
2117
2118 class ServiceResourceSerializer(serializers.HyperlinkedModelSerializer):
2119     id = serializers.Field()
2120
2121     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2122     validators = serializers.SerializerMethodField("getValidators")
2123     def getHumanReadableName(self, obj):\r
2124         return str(obj)
2125     def getValidators(self, obj):
2126         try:
2127             return obj.getValidators()
2128         except:
2129             return None
2130     class Meta:
2131         model = ServiceResource
2132         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','serviceClass','name','maxUnitsDeployment','maxUnitsNode','maxDuration','bucketInRate','bucketMaxSize','cost','calendarReservable',)
2133
2134 class ServiceResourceIdSerializer(serializers.ModelSerializer):
2135     id = serializers.Field()
2136
2137     humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
2138     validators = serializers.SerializerMethodField("getValidators")
2139     def getHumanReadableName(self, obj):\r
2140         return str(obj)\r
2141     def getValidators(self, obj):\r
2142         try:
2143             return obj.getValidators()
2144         except:
2145             return None\r
2146     class Meta:
2147         model = ServiceResource
2148         fields = ('humanReadableName', 'validators', 'id','created','updated','enacted','backend_status','deleted','serviceClass','name','maxUnitsDeployment','maxUnitsNode','maxDuration','bucketInRate','bucketMaxSize','cost','calendarReservable',)
2149
2150
2151
2152
2153 serializerLookUp = {
2154
2155                  ServiceAttribute: ServiceAttributeSerializer,
2156
2157                  Image: ImageSerializer,
2158
2159                  NetworkParameter: NetworkParameterSerializer,
2160
2161                  Site: SiteSerializer,
2162
2163                  SliceRole: SliceRoleSerializer,
2164
2165                  Tag: TagSerializer,
2166
2167                  Invoice: InvoiceSerializer,
2168
2169                  SlicePrivilege: SlicePrivilegeSerializer,
2170
2171                  PlanetStackRole: PlanetStackRoleSerializer,
2172
2173                  NetworkSliver: NetworkSliverSerializer,
2174
2175                  ControllerNetworks: ControllerNetworksSerializer,
2176
2177                  Flavor: FlavorSerializer,
2178
2179                  Project: ProjectSerializer,
2180
2181                  Slice: SliceSerializer,
2182
2183                  Network: NetworkSerializer,
2184
2185                  Service: ServiceSerializer,
2186
2187                  ServiceClass: ServiceClassSerializer,
2188
2189                  Payment: PaymentSerializer,
2190
2191                  Charge: ChargeSerializer,
2192
2193                  Role: RoleSerializer,
2194
2195                  UsableObject: UsableObjectSerializer,
2196
2197                  SiteRole: SiteRoleSerializer,
2198
2199                  SliceCredential: SliceCredentialSerializer,
2200
2201                  Sliver: SliverSerializer,
2202
2203                  Node: NodeSerializer,
2204
2205                  DashboardView: DashboardViewSerializer,
2206
2207                  ControllerImages: ControllerImagesSerializer,
2208
2209                  ReservedResource: ReservedResourceSerializer,
2210
2211                  NetworkSlice: NetworkSliceSerializer,
2212
2213                  UserDashboardView: UserDashboardViewSerializer,
2214
2215                  PlanetStackPrivilege: PlanetStackPrivilegeSerializer,
2216
2217                  User: UserSerializer,
2218
2219                  Deployment: DeploymentSerializer,
2220
2221                  Reservation: ReservationSerializer,
2222
2223                  ControllerSlices: ControllerSlicesSerializer,
2224
2225                  SitePrivilege: SitePrivilegeSerializer,
2226
2227                  PlanetStack: PlanetStackSerializer,
2228
2229                  ControllerUsers: ControllerUsersSerializer,
2230
2231                  Account: AccountSerializer,
2232
2233                  NetworkParameterType: NetworkParameterTypeSerializer,
2234
2235                  SiteCredential: SiteCredentialSerializer,
2236
2237                  ControllerPrivilege: ControllerPrivilegeSerializer,
2238
2239                  ControllerRole: ControllerRoleSerializer,
2240
2241                  UserCredential: UserCredentialSerializer,
2242
2243                  SiteDeployments: SiteDeploymentsSerializer,
2244
2245                  SliceTag: SliceTagSerializer,
2246
2247                  NetworkTemplate: NetworkTemplateSerializer,
2248
2249                  Router: RouterSerializer,
2250
2251                  ServiceResource: ServiceResourceSerializer,
2252
2253                  None: None,
2254                 }
2255
2256 class PlanetStackRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView):
2257
2258     # To handle fine-grained field permissions, we have to check can_update
2259     # the object has been updated but before it has been saved.
2260
2261     def update(self, request, *args, **kwargs):\r
2262         partial = kwargs.pop('partial', False)\r
2263         self.object = self.get_object_or_none()\r
2264 \r
2265         serializer = self.get_serializer(self.object, data=request.DATA,\r
2266                                          files=request.FILES, partial=partial)\r
2267 \r
2268         if not serializer.is_valid():\r
2269             response = {"error": "validation",\r
2270                         "specific_error": "not serializer.is_valid()",\r
2271                         "reasons": serializer.errors}\r
2272             return Response(response, status=status.HTTP_400_BAD_REQUEST)\r
2273 \r
2274         try:\r
2275             self.pre_save(serializer.object)\r
2276         except ValidationError as err:\r
2277             # full_clean on model instance may be called in pre_save,\r
2278             # so we have to handle eventual errors.\r
2279             response = {"error": "validation",\r
2280                          "specific_error": "ValidationError in pre_save",\r
2281                          "reasons": err.message_dict}\r
2282             return Response(response, status=status.HTTP_400_BAD_REQUEST)\r
2283 \r
2284         if serializer.object is not None:\r
2285             if not serializer.object.can_update(request.user):\r
2286                 return Response(status=status.HTTP_400_BAD_REQUEST)\r
2287 \r
2288         if self.object is None:\r
2289             self.object = serializer.save(force_insert=True)\r
2290             self.post_save(self.object, created=True)\r
2291             return Response(serializer.data, status=status.HTTP_201_CREATED)\r
2292 \r
2293         self.object = serializer.save(force_update=True)\r
2294         self.post_save(self.object, created=False)\r
2295         return Response(serializer.data, status=status.HTTP_200_OK)
2296
2297     def destroy(self, request, *args, **kwargs):
2298         obj = self.get_object()
2299         if obj.can_update(request.user):
2300             return super(generics.RetrieveUpdateDestroyAPIView, self).destroy(request, *args, **kwargs)
2301         else:
2302             return Response(status=status.HTTP_400_BAD_REQUEST)
2303
2304
2305 # Based on core/views/*.py
2306
2307
2308 class ServiceAttributeList(generics.ListCreateAPIView):
2309     queryset = ServiceAttribute.objects.select_related().all()
2310     serializer_class = ServiceAttributeSerializer
2311     id_serializer_class = ServiceAttributeIdSerializer
2312     filter_backends = (filters.DjangoFilterBackend,)
2313     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','value','service',)
2314
2315     def get_serializer_class(self):
2316         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2317         if (no_hyperlinks):
2318             return self.id_serializer_class
2319         else:
2320             return self.serializer_class
2321
2322     def get_queryset(self):
2323         return ServiceAttribute.select_by_user(self.request.user)
2324
2325     def create(self, request, *args, **kwargs):
2326         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2327         if not (serializer.is_valid()):
2328             response = {"error": "validation",
2329                         "specific_error": "not serializer.is_valid()",\r
2330                         "reasons": serializer.errors}\r
2331             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2332         obj = serializer.object
2333         obj.caller = request.user
2334         if obj.can_update(request.user):
2335             return super(ServiceAttributeList, self).create(request, *args, **kwargs)
2336         else:
2337             raise Exception("failed obj.can_update")
2338
2339         ret = super(ServiceAttributeList, self).create(request, *args, **kwargs)
2340         if (ret.status_code%100 != 200):
2341             raise Exception(ret.data)
2342
2343         return ret
2344
2345
2346 class ServiceAttributeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2347     queryset = ServiceAttribute.objects.select_related().all()
2348     serializer_class = ServiceAttributeSerializer
2349     id_serializer_class = ServiceAttributeIdSerializer
2350
2351     def get_serializer_class(self):
2352         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2353         if (no_hyperlinks):
2354             return self.id_serializer_class
2355         else:
2356             return self.serializer_class
2357
2358     def get_queryset(self):
2359         return ServiceAttribute.select_by_user(self.request.user)
2360
2361     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2362
2363     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2364
2365
2366
2367 class ImageList(generics.ListCreateAPIView):
2368     queryset = Image.objects.select_related().all()
2369     serializer_class = ImageSerializer
2370     id_serializer_class = ImageIdSerializer
2371     filter_backends = (filters.DjangoFilterBackend,)
2372     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','disk_format','container_format','path',)
2373
2374     def get_serializer_class(self):
2375         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2376         if (no_hyperlinks):
2377             return self.id_serializer_class
2378         else:
2379             return self.serializer_class
2380
2381     def get_queryset(self):
2382         return Image.select_by_user(self.request.user)
2383
2384     def create(self, request, *args, **kwargs):
2385         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2386         if not (serializer.is_valid()):
2387             response = {"error": "validation",
2388                         "specific_error": "not serializer.is_valid()",\r
2389                         "reasons": serializer.errors}\r
2390             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2391         obj = serializer.object
2392         obj.caller = request.user
2393         if obj.can_update(request.user):
2394             return super(ImageList, self).create(request, *args, **kwargs)
2395         else:
2396             raise Exception("failed obj.can_update")
2397
2398         ret = super(ImageList, self).create(request, *args, **kwargs)
2399         if (ret.status_code%100 != 200):
2400             raise Exception(ret.data)
2401
2402         return ret
2403
2404
2405 class ImageDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2406     queryset = Image.objects.select_related().all()
2407     serializer_class = ImageSerializer
2408     id_serializer_class = ImageIdSerializer
2409
2410     def get_serializer_class(self):
2411         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2412         if (no_hyperlinks):
2413             return self.id_serializer_class
2414         else:
2415             return self.serializer_class
2416
2417     def get_queryset(self):
2418         return Image.select_by_user(self.request.user)
2419
2420     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2421
2422     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2423
2424
2425
2426 class NetworkParameterList(generics.ListCreateAPIView):
2427     queryset = NetworkParameter.objects.select_related().all()
2428     serializer_class = NetworkParameterSerializer
2429     id_serializer_class = NetworkParameterIdSerializer
2430     filter_backends = (filters.DjangoFilterBackend,)
2431     filter_fields = ('id','created','updated','enacted','backend_status','deleted','parameter','value','content_type','object_id',)
2432
2433     def get_serializer_class(self):
2434         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2435         if (no_hyperlinks):
2436             return self.id_serializer_class
2437         else:
2438             return self.serializer_class
2439
2440     def get_queryset(self):
2441         return NetworkParameter.select_by_user(self.request.user)
2442
2443     def create(self, request, *args, **kwargs):
2444         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2445         if not (serializer.is_valid()):
2446             response = {"error": "validation",
2447                         "specific_error": "not serializer.is_valid()",\r
2448                         "reasons": serializer.errors}\r
2449             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2450         obj = serializer.object
2451         obj.caller = request.user
2452         if obj.can_update(request.user):
2453             return super(NetworkParameterList, self).create(request, *args, **kwargs)
2454         else:
2455             raise Exception("failed obj.can_update")
2456
2457         ret = super(NetworkParameterList, self).create(request, *args, **kwargs)
2458         if (ret.status_code%100 != 200):
2459             raise Exception(ret.data)
2460
2461         return ret
2462
2463
2464 class NetworkParameterDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2465     queryset = NetworkParameter.objects.select_related().all()
2466     serializer_class = NetworkParameterSerializer
2467     id_serializer_class = NetworkParameterIdSerializer
2468
2469     def get_serializer_class(self):
2470         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2471         if (no_hyperlinks):
2472             return self.id_serializer_class
2473         else:
2474             return self.serializer_class
2475
2476     def get_queryset(self):
2477         return NetworkParameter.select_by_user(self.request.user)
2478
2479     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2480
2481     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2482
2483
2484
2485 class SiteList(generics.ListCreateAPIView):
2486     queryset = Site.objects.select_related().all()
2487     serializer_class = SiteSerializer
2488     id_serializer_class = SiteIdSerializer
2489     filter_backends = (filters.DjangoFilterBackend,)
2490     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','site_url','enabled','location','longitude','latitude','login_base','is_public','abbreviated_name',)
2491
2492     def get_serializer_class(self):
2493         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2494         if (no_hyperlinks):
2495             return self.id_serializer_class
2496         else:
2497             return self.serializer_class
2498
2499     def get_queryset(self):
2500         return Site.select_by_user(self.request.user)
2501
2502     def create(self, request, *args, **kwargs):
2503         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2504         if not (serializer.is_valid()):
2505             response = {"error": "validation",
2506                         "specific_error": "not serializer.is_valid()",\r
2507                         "reasons": serializer.errors}\r
2508             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2509         obj = serializer.object
2510         obj.caller = request.user
2511         if obj.can_update(request.user):
2512             return super(SiteList, self).create(request, *args, **kwargs)
2513         else:
2514             raise Exception("failed obj.can_update")
2515
2516         ret = super(SiteList, self).create(request, *args, **kwargs)
2517         if (ret.status_code%100 != 200):
2518             raise Exception(ret.data)
2519
2520         return ret
2521
2522
2523 class SiteDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2524     queryset = Site.objects.select_related().all()
2525     serializer_class = SiteSerializer
2526     id_serializer_class = SiteIdSerializer
2527
2528     def get_serializer_class(self):
2529         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2530         if (no_hyperlinks):
2531             return self.id_serializer_class
2532         else:
2533             return self.serializer_class
2534
2535     def get_queryset(self):
2536         return Site.select_by_user(self.request.user)
2537
2538     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2539
2540     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2541
2542
2543
2544 class SliceRoleList(generics.ListCreateAPIView):
2545     queryset = SliceRole.objects.select_related().all()
2546     serializer_class = SliceRoleSerializer
2547     id_serializer_class = SliceRoleIdSerializer
2548     filter_backends = (filters.DjangoFilterBackend,)
2549     filter_fields = ('id','created','updated','enacted','backend_status','deleted','role',)
2550
2551     def get_serializer_class(self):
2552         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2553         if (no_hyperlinks):
2554             return self.id_serializer_class
2555         else:
2556             return self.serializer_class
2557
2558     def get_queryset(self):
2559         return SliceRole.select_by_user(self.request.user)
2560
2561     def create(self, request, *args, **kwargs):
2562         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2563         if not (serializer.is_valid()):
2564             response = {"error": "validation",
2565                         "specific_error": "not serializer.is_valid()",\r
2566                         "reasons": serializer.errors}\r
2567             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2568         obj = serializer.object
2569         obj.caller = request.user
2570         if obj.can_update(request.user):
2571             return super(SliceRoleList, self).create(request, *args, **kwargs)
2572         else:
2573             raise Exception("failed obj.can_update")
2574
2575         ret = super(SliceRoleList, self).create(request, *args, **kwargs)
2576         if (ret.status_code%100 != 200):
2577             raise Exception(ret.data)
2578
2579         return ret
2580
2581
2582 class SliceRoleDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2583     queryset = SliceRole.objects.select_related().all()
2584     serializer_class = SliceRoleSerializer
2585     id_serializer_class = SliceRoleIdSerializer
2586
2587     def get_serializer_class(self):
2588         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2589         if (no_hyperlinks):
2590             return self.id_serializer_class
2591         else:
2592             return self.serializer_class
2593
2594     def get_queryset(self):
2595         return SliceRole.select_by_user(self.request.user)
2596
2597     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2598
2599     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2600
2601
2602
2603 class TagList(generics.ListCreateAPIView):
2604     queryset = Tag.objects.select_related().all()
2605     serializer_class = TagSerializer
2606     id_serializer_class = TagIdSerializer
2607     filter_backends = (filters.DjangoFilterBackend,)
2608     filter_fields = ('id','created','updated','enacted','backend_status','deleted','service','name','value','content_type','object_id',)
2609
2610     def get_serializer_class(self):
2611         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2612         if (no_hyperlinks):
2613             return self.id_serializer_class
2614         else:
2615             return self.serializer_class
2616
2617     def get_queryset(self):
2618         return Tag.select_by_user(self.request.user)
2619
2620     def create(self, request, *args, **kwargs):
2621         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2622         if not (serializer.is_valid()):
2623             response = {"error": "validation",
2624                         "specific_error": "not serializer.is_valid()",\r
2625                         "reasons": serializer.errors}\r
2626             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2627         obj = serializer.object
2628         obj.caller = request.user
2629         if obj.can_update(request.user):
2630             return super(TagList, self).create(request, *args, **kwargs)
2631         else:
2632             raise Exception("failed obj.can_update")
2633
2634         ret = super(TagList, self).create(request, *args, **kwargs)
2635         if (ret.status_code%100 != 200):
2636             raise Exception(ret.data)
2637
2638         return ret
2639
2640
2641 class TagDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2642     queryset = Tag.objects.select_related().all()
2643     serializer_class = TagSerializer
2644     id_serializer_class = TagIdSerializer
2645
2646     def get_serializer_class(self):
2647         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2648         if (no_hyperlinks):
2649             return self.id_serializer_class
2650         else:
2651             return self.serializer_class
2652
2653     def get_queryset(self):
2654         return Tag.select_by_user(self.request.user)
2655
2656     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2657
2658     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2659
2660
2661
2662 class InvoiceList(generics.ListCreateAPIView):
2663     queryset = Invoice.objects.select_related().all()
2664     serializer_class = InvoiceSerializer
2665     id_serializer_class = InvoiceIdSerializer
2666     filter_backends = (filters.DjangoFilterBackend,)
2667     filter_fields = ('id','created','updated','enacted','backend_status','deleted','date','account',)
2668
2669     def get_serializer_class(self):
2670         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2671         if (no_hyperlinks):
2672             return self.id_serializer_class
2673         else:
2674             return self.serializer_class
2675
2676     def get_queryset(self):
2677         return Invoice.select_by_user(self.request.user)
2678
2679     def create(self, request, *args, **kwargs):
2680         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2681         if not (serializer.is_valid()):
2682             response = {"error": "validation",
2683                         "specific_error": "not serializer.is_valid()",\r
2684                         "reasons": serializer.errors}\r
2685             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2686         obj = serializer.object
2687         obj.caller = request.user
2688         if obj.can_update(request.user):
2689             return super(InvoiceList, self).create(request, *args, **kwargs)
2690         else:
2691             raise Exception("failed obj.can_update")
2692
2693         ret = super(InvoiceList, self).create(request, *args, **kwargs)
2694         if (ret.status_code%100 != 200):
2695             raise Exception(ret.data)
2696
2697         return ret
2698
2699
2700 class InvoiceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2701     queryset = Invoice.objects.select_related().all()
2702     serializer_class = InvoiceSerializer
2703     id_serializer_class = InvoiceIdSerializer
2704
2705     def get_serializer_class(self):
2706         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2707         if (no_hyperlinks):
2708             return self.id_serializer_class
2709         else:
2710             return self.serializer_class
2711
2712     def get_queryset(self):
2713         return Invoice.select_by_user(self.request.user)
2714
2715     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2716
2717     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2718
2719
2720
2721 class SlicePrivilegeList(generics.ListCreateAPIView):
2722     queryset = SlicePrivilege.objects.select_related().all()
2723     serializer_class = SlicePrivilegeSerializer
2724     id_serializer_class = SlicePrivilegeIdSerializer
2725     filter_backends = (filters.DjangoFilterBackend,)
2726     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','slice','role',)
2727
2728     def get_serializer_class(self):
2729         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2730         if (no_hyperlinks):
2731             return self.id_serializer_class
2732         else:
2733             return self.serializer_class
2734
2735     def get_queryset(self):
2736         return SlicePrivilege.select_by_user(self.request.user)
2737
2738     def create(self, request, *args, **kwargs):
2739         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2740         if not (serializer.is_valid()):
2741             response = {"error": "validation",
2742                         "specific_error": "not serializer.is_valid()",\r
2743                         "reasons": serializer.errors}\r
2744             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2745         obj = serializer.object
2746         obj.caller = request.user
2747         if obj.can_update(request.user):
2748             return super(SlicePrivilegeList, self).create(request, *args, **kwargs)
2749         else:
2750             raise Exception("failed obj.can_update")
2751
2752         ret = super(SlicePrivilegeList, self).create(request, *args, **kwargs)
2753         if (ret.status_code%100 != 200):
2754             raise Exception(ret.data)
2755
2756         return ret
2757
2758
2759 class SlicePrivilegeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2760     queryset = SlicePrivilege.objects.select_related().all()
2761     serializer_class = SlicePrivilegeSerializer
2762     id_serializer_class = SlicePrivilegeIdSerializer
2763
2764     def get_serializer_class(self):
2765         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2766         if (no_hyperlinks):
2767             return self.id_serializer_class
2768         else:
2769             return self.serializer_class
2770
2771     def get_queryset(self):
2772         return SlicePrivilege.select_by_user(self.request.user)
2773
2774     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2775
2776     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2777
2778
2779
2780 class PlanetStackRoleList(generics.ListCreateAPIView):
2781     queryset = PlanetStackRole.objects.select_related().all()
2782     serializer_class = PlanetStackRoleSerializer
2783     id_serializer_class = PlanetStackRoleIdSerializer
2784     filter_backends = (filters.DjangoFilterBackend,)
2785     filter_fields = ('id','created','updated','enacted','backend_status','deleted','role',)
2786
2787     def get_serializer_class(self):
2788         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2789         if (no_hyperlinks):
2790             return self.id_serializer_class
2791         else:
2792             return self.serializer_class
2793
2794     def get_queryset(self):
2795         return PlanetStackRole.select_by_user(self.request.user)
2796
2797     def create(self, request, *args, **kwargs):
2798         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2799         if not (serializer.is_valid()):
2800             response = {"error": "validation",
2801                         "specific_error": "not serializer.is_valid()",\r
2802                         "reasons": serializer.errors}\r
2803             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2804         obj = serializer.object
2805         obj.caller = request.user
2806         if obj.can_update(request.user):
2807             return super(PlanetStackRoleList, self).create(request, *args, **kwargs)
2808         else:
2809             raise Exception("failed obj.can_update")
2810
2811         ret = super(PlanetStackRoleList, self).create(request, *args, **kwargs)
2812         if (ret.status_code%100 != 200):
2813             raise Exception(ret.data)
2814
2815         return ret
2816
2817
2818 class PlanetStackRoleDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2819     queryset = PlanetStackRole.objects.select_related().all()
2820     serializer_class = PlanetStackRoleSerializer
2821     id_serializer_class = PlanetStackRoleIdSerializer
2822
2823     def get_serializer_class(self):
2824         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2825         if (no_hyperlinks):
2826             return self.id_serializer_class
2827         else:
2828             return self.serializer_class
2829
2830     def get_queryset(self):
2831         return PlanetStackRole.select_by_user(self.request.user)
2832
2833     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2834
2835     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2836
2837
2838
2839 class NetworkSliverList(generics.ListCreateAPIView):
2840     queryset = NetworkSliver.objects.select_related().all()
2841     serializer_class = NetworkSliverSerializer
2842     id_serializer_class = NetworkSliverIdSerializer
2843     filter_backends = (filters.DjangoFilterBackend,)
2844     filter_fields = ('id','created','updated','enacted','backend_status','deleted','network','sliver','ip','port_id',)
2845
2846     def get_serializer_class(self):
2847         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2848         if (no_hyperlinks):
2849             return self.id_serializer_class
2850         else:
2851             return self.serializer_class
2852
2853     def get_queryset(self):
2854         return NetworkSliver.select_by_user(self.request.user)
2855
2856     def create(self, request, *args, **kwargs):
2857         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2858         if not (serializer.is_valid()):
2859             response = {"error": "validation",
2860                         "specific_error": "not serializer.is_valid()",\r
2861                         "reasons": serializer.errors}\r
2862             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2863         obj = serializer.object
2864         obj.caller = request.user
2865         if obj.can_update(request.user):
2866             return super(NetworkSliverList, self).create(request, *args, **kwargs)
2867         else:
2868             raise Exception("failed obj.can_update")
2869
2870         ret = super(NetworkSliverList, self).create(request, *args, **kwargs)
2871         if (ret.status_code%100 != 200):
2872             raise Exception(ret.data)
2873
2874         return ret
2875
2876
2877 class NetworkSliverDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2878     queryset = NetworkSliver.objects.select_related().all()
2879     serializer_class = NetworkSliverSerializer
2880     id_serializer_class = NetworkSliverIdSerializer
2881
2882     def get_serializer_class(self):
2883         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2884         if (no_hyperlinks):
2885             return self.id_serializer_class
2886         else:
2887             return self.serializer_class
2888
2889     def get_queryset(self):
2890         return NetworkSliver.select_by_user(self.request.user)
2891
2892     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2893
2894     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2895
2896
2897
2898 class ControllerNetworksList(generics.ListCreateAPIView):
2899     queryset = ControllerNetworks.objects.select_related().all()
2900     serializer_class = ControllerNetworksSerializer
2901     id_serializer_class = ControllerNetworksIdSerializer
2902     filter_backends = (filters.DjangoFilterBackend,)
2903     filter_fields = ('id','created','updated','enacted','backend_status','deleted','network','deployment','net_id','router_id','subnet_id','subnet',)
2904
2905     def get_serializer_class(self):
2906         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2907         if (no_hyperlinks):
2908             return self.id_serializer_class
2909         else:
2910             return self.serializer_class
2911
2912     def get_queryset(self):
2913         return ControllerNetworks.select_by_user(self.request.user)
2914
2915     def create(self, request, *args, **kwargs):
2916         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2917         if not (serializer.is_valid()):
2918             response = {"error": "validation",
2919                         "specific_error": "not serializer.is_valid()",\r
2920                         "reasons": serializer.errors}\r
2921             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2922         obj = serializer.object
2923         obj.caller = request.user
2924         if obj.can_update(request.user):
2925             return super(ControllerNetworksList, self).create(request, *args, **kwargs)
2926         else:
2927             raise Exception("failed obj.can_update")
2928
2929         ret = super(ControllerNetworksList, self).create(request, *args, **kwargs)
2930         if (ret.status_code%100 != 200):
2931             raise Exception(ret.data)
2932
2933         return ret
2934
2935
2936 class ControllerNetworksDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2937     queryset = ControllerNetworks.objects.select_related().all()
2938     serializer_class = ControllerNetworksSerializer
2939     id_serializer_class = ControllerNetworksIdSerializer
2940
2941     def get_serializer_class(self):
2942         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2943         if (no_hyperlinks):
2944             return self.id_serializer_class
2945         else:
2946             return self.serializer_class
2947
2948     def get_queryset(self):
2949         return ControllerNetworks.select_by_user(self.request.user)
2950
2951     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2952
2953     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
2954
2955
2956
2957 class FlavorList(generics.ListCreateAPIView):
2958     queryset = Flavor.objects.select_related().all()
2959     serializer_class = FlavorSerializer
2960     id_serializer_class = FlavorIdSerializer
2961     filter_backends = (filters.DjangoFilterBackend,)
2962     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','description','flavor','order','default',)
2963
2964     def get_serializer_class(self):
2965         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
2966         if (no_hyperlinks):
2967             return self.id_serializer_class
2968         else:
2969             return self.serializer_class
2970
2971     def get_queryset(self):
2972         return Flavor.select_by_user(self.request.user)
2973
2974     def create(self, request, *args, **kwargs):
2975         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
2976         if not (serializer.is_valid()):
2977             response = {"error": "validation",
2978                         "specific_error": "not serializer.is_valid()",\r
2979                         "reasons": serializer.errors}\r
2980             return Response(response, status=status.HTTP_400_BAD_REQUEST)
2981         obj = serializer.object
2982         obj.caller = request.user
2983         if obj.can_update(request.user):
2984             return super(FlavorList, self).create(request, *args, **kwargs)
2985         else:
2986             raise Exception("failed obj.can_update")
2987
2988         ret = super(FlavorList, self).create(request, *args, **kwargs)
2989         if (ret.status_code%100 != 200):
2990             raise Exception(ret.data)
2991
2992         return ret
2993
2994
2995 class FlavorDetail(PlanetStackRetrieveUpdateDestroyAPIView):
2996     queryset = Flavor.objects.select_related().all()
2997     serializer_class = FlavorSerializer
2998     id_serializer_class = FlavorIdSerializer
2999
3000     def get_serializer_class(self):
3001         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3002         if (no_hyperlinks):
3003             return self.id_serializer_class
3004         else:
3005             return self.serializer_class
3006
3007     def get_queryset(self):
3008         return Flavor.select_by_user(self.request.user)
3009
3010     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3011
3012     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3013
3014
3015
3016 class ProjectList(generics.ListCreateAPIView):
3017     queryset = Project.objects.select_related().all()
3018     serializer_class = ProjectSerializer
3019     id_serializer_class = ProjectIdSerializer
3020     filter_backends = (filters.DjangoFilterBackend,)
3021     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name',)
3022
3023     def get_serializer_class(self):
3024         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3025         if (no_hyperlinks):
3026             return self.id_serializer_class
3027         else:
3028             return self.serializer_class
3029
3030     def get_queryset(self):
3031         return Project.select_by_user(self.request.user)
3032
3033     def create(self, request, *args, **kwargs):
3034         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3035         if not (serializer.is_valid()):
3036             response = {"error": "validation",
3037                         "specific_error": "not serializer.is_valid()",\r
3038                         "reasons": serializer.errors}\r
3039             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3040         obj = serializer.object
3041         obj.caller = request.user
3042         if obj.can_update(request.user):
3043             return super(ProjectList, self).create(request, *args, **kwargs)
3044         else:
3045             raise Exception("failed obj.can_update")
3046
3047         ret = super(ProjectList, self).create(request, *args, **kwargs)
3048         if (ret.status_code%100 != 200):
3049             raise Exception(ret.data)
3050
3051         return ret
3052
3053
3054 class ProjectDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3055     queryset = Project.objects.select_related().all()
3056     serializer_class = ProjectSerializer
3057     id_serializer_class = ProjectIdSerializer
3058
3059     def get_serializer_class(self):
3060         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3061         if (no_hyperlinks):
3062             return self.id_serializer_class
3063         else:
3064             return self.serializer_class
3065
3066     def get_queryset(self):
3067         return Project.select_by_user(self.request.user)
3068
3069     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3070
3071     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3072
3073
3074
3075 class SliceList(generics.ListCreateAPIView):
3076     queryset = Slice.objects.select_related().all()
3077     serializer_class = SliceSerializer
3078     id_serializer_class = SliceIdSerializer
3079     filter_backends = (filters.DjangoFilterBackend,)
3080     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','enabled','omf_friendly','description','slice_url','site','max_slivers','imagePreference','service','network','mountDataSets','serviceClass','creator','networks','availableNetworks','networks','networks',)
3081
3082     def get_serializer_class(self):
3083         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3084         if (no_hyperlinks):
3085             return self.id_serializer_class
3086         else:
3087             return self.serializer_class
3088
3089     def get_queryset(self):
3090         return Slice.select_by_user(self.request.user)
3091
3092     def create(self, request, *args, **kwargs):
3093         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3094         if not (serializer.is_valid()):
3095             response = {"error": "validation",
3096                         "specific_error": "not serializer.is_valid()",\r
3097                         "reasons": serializer.errors}\r
3098             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3099         obj = serializer.object
3100         obj.caller = request.user
3101         if obj.can_update(request.user):
3102             return super(SliceList, self).create(request, *args, **kwargs)
3103         else:
3104             raise Exception("failed obj.can_update")
3105
3106         ret = super(SliceList, self).create(request, *args, **kwargs)
3107         if (ret.status_code%100 != 200):
3108             raise Exception(ret.data)
3109
3110         return ret
3111
3112
3113 class SliceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3114     queryset = Slice.objects.select_related().all()
3115     serializer_class = SliceSerializer
3116     id_serializer_class = SliceIdSerializer
3117
3118     def get_serializer_class(self):
3119         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3120         if (no_hyperlinks):
3121             return self.id_serializer_class
3122         else:
3123             return self.serializer_class
3124
3125     def get_queryset(self):
3126         return Slice.select_by_user(self.request.user)
3127
3128     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3129
3130     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3131
3132
3133
3134 class NetworkList(generics.ListCreateAPIView):
3135     queryset = Network.objects.select_related().all()
3136     serializer_class = NetworkSerializer
3137     id_serializer_class = NetworkIdSerializer
3138     filter_backends = (filters.DjangoFilterBackend,)
3139     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','template','subnet','ports','labels','owner','guaranteedBandwidth','permitAllSlices','topologyParameters','controllerUrl','controllerParameters','network_id','router_id','subnet_id','routers','availableRouters','routers','routers',)
3140
3141     def get_serializer_class(self):
3142         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3143         if (no_hyperlinks):
3144             return self.id_serializer_class
3145         else:
3146             return self.serializer_class
3147
3148     def get_queryset(self):
3149         return Network.select_by_user(self.request.user)
3150
3151     def create(self, request, *args, **kwargs):
3152         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3153         if not (serializer.is_valid()):
3154             response = {"error": "validation",
3155                         "specific_error": "not serializer.is_valid()",\r
3156                         "reasons": serializer.errors}\r
3157             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3158         obj = serializer.object
3159         obj.caller = request.user
3160         if obj.can_update(request.user):
3161             return super(NetworkList, self).create(request, *args, **kwargs)
3162         else:
3163             raise Exception("failed obj.can_update")
3164
3165         ret = super(NetworkList, self).create(request, *args, **kwargs)
3166         if (ret.status_code%100 != 200):
3167             raise Exception(ret.data)
3168
3169         return ret
3170
3171
3172 class NetworkDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3173     queryset = Network.objects.select_related().all()
3174     serializer_class = NetworkSerializer
3175     id_serializer_class = NetworkIdSerializer
3176
3177     def get_serializer_class(self):
3178         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3179         if (no_hyperlinks):
3180             return self.id_serializer_class
3181         else:
3182             return self.serializer_class
3183
3184     def get_queryset(self):
3185         return Network.select_by_user(self.request.user)
3186
3187     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3188
3189     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3190
3191
3192
3193 class ServiceList(generics.ListCreateAPIView):
3194     queryset = Service.objects.select_related().all()
3195     serializer_class = ServiceSerializer
3196     id_serializer_class = ServiceIdSerializer
3197     filter_backends = (filters.DjangoFilterBackend,)
3198     filter_fields = ('id','created','updated','enacted','backend_status','deleted','description','enabled','name','versionNumber','published',)
3199
3200     def get_serializer_class(self):
3201         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3202         if (no_hyperlinks):
3203             return self.id_serializer_class
3204         else:
3205             return self.serializer_class
3206
3207     def get_queryset(self):
3208         return Service.select_by_user(self.request.user)
3209
3210     def create(self, request, *args, **kwargs):
3211         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3212         if not (serializer.is_valid()):
3213             response = {"error": "validation",
3214                         "specific_error": "not serializer.is_valid()",\r
3215                         "reasons": serializer.errors}\r
3216             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3217         obj = serializer.object
3218         obj.caller = request.user
3219         if obj.can_update(request.user):
3220             return super(ServiceList, self).create(request, *args, **kwargs)
3221         else:
3222             raise Exception("failed obj.can_update")
3223
3224         ret = super(ServiceList, self).create(request, *args, **kwargs)
3225         if (ret.status_code%100 != 200):
3226             raise Exception(ret.data)
3227
3228         return ret
3229
3230
3231 class ServiceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3232     queryset = Service.objects.select_related().all()
3233     serializer_class = ServiceSerializer
3234     id_serializer_class = ServiceIdSerializer
3235
3236     def get_serializer_class(self):
3237         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3238         if (no_hyperlinks):
3239             return self.id_serializer_class
3240         else:
3241             return self.serializer_class
3242
3243     def get_queryset(self):
3244         return Service.select_by_user(self.request.user)
3245
3246     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3247
3248     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3249
3250
3251
3252 class ServiceClassList(generics.ListCreateAPIView):
3253     queryset = ServiceClass.objects.select_related().all()
3254     serializer_class = ServiceClassSerializer
3255     id_serializer_class = ServiceClassIdSerializer
3256     filter_backends = (filters.DjangoFilterBackend,)
3257     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','description','commitment','membershipFee','membershipFeeMonths','upgradeRequiresApproval',)
3258
3259     def get_serializer_class(self):
3260         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3261         if (no_hyperlinks):
3262             return self.id_serializer_class
3263         else:
3264             return self.serializer_class
3265
3266     def get_queryset(self):
3267         return ServiceClass.select_by_user(self.request.user)
3268
3269     def create(self, request, *args, **kwargs):
3270         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3271         if not (serializer.is_valid()):
3272             response = {"error": "validation",
3273                         "specific_error": "not serializer.is_valid()",\r
3274                         "reasons": serializer.errors}\r
3275             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3276         obj = serializer.object
3277         obj.caller = request.user
3278         if obj.can_update(request.user):
3279             return super(ServiceClassList, self).create(request, *args, **kwargs)
3280         else:
3281             raise Exception("failed obj.can_update")
3282
3283         ret = super(ServiceClassList, self).create(request, *args, **kwargs)
3284         if (ret.status_code%100 != 200):
3285             raise Exception(ret.data)
3286
3287         return ret
3288
3289
3290 class ServiceClassDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3291     queryset = ServiceClass.objects.select_related().all()
3292     serializer_class = ServiceClassSerializer
3293     id_serializer_class = ServiceClassIdSerializer
3294
3295     def get_serializer_class(self):
3296         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3297         if (no_hyperlinks):
3298             return self.id_serializer_class
3299         else:
3300             return self.serializer_class
3301
3302     def get_queryset(self):
3303         return ServiceClass.select_by_user(self.request.user)
3304
3305     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3306
3307     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3308
3309
3310
3311 class PaymentList(generics.ListCreateAPIView):
3312     queryset = Payment.objects.select_related().all()
3313     serializer_class = PaymentSerializer
3314     id_serializer_class = PaymentIdSerializer
3315     filter_backends = (filters.DjangoFilterBackend,)
3316     filter_fields = ('id','created','updated','enacted','backend_status','deleted','account','amount','date',)
3317
3318     def get_serializer_class(self):
3319         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3320         if (no_hyperlinks):
3321             return self.id_serializer_class
3322         else:
3323             return self.serializer_class
3324
3325     def get_queryset(self):
3326         return Payment.select_by_user(self.request.user)
3327
3328     def create(self, request, *args, **kwargs):
3329         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3330         if not (serializer.is_valid()):
3331             response = {"error": "validation",
3332                         "specific_error": "not serializer.is_valid()",\r
3333                         "reasons": serializer.errors}\r
3334             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3335         obj = serializer.object
3336         obj.caller = request.user
3337         if obj.can_update(request.user):
3338             return super(PaymentList, self).create(request, *args, **kwargs)
3339         else:
3340             raise Exception("failed obj.can_update")
3341
3342         ret = super(PaymentList, self).create(request, *args, **kwargs)
3343         if (ret.status_code%100 != 200):
3344             raise Exception(ret.data)
3345
3346         return ret
3347
3348
3349 class PaymentDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3350     queryset = Payment.objects.select_related().all()
3351     serializer_class = PaymentSerializer
3352     id_serializer_class = PaymentIdSerializer
3353
3354     def get_serializer_class(self):
3355         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3356         if (no_hyperlinks):
3357             return self.id_serializer_class
3358         else:
3359             return self.serializer_class
3360
3361     def get_queryset(self):
3362         return Payment.select_by_user(self.request.user)
3363
3364     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3365
3366     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3367
3368
3369
3370 class ChargeList(generics.ListCreateAPIView):
3371     queryset = Charge.objects.select_related().all()
3372     serializer_class = ChargeSerializer
3373     id_serializer_class = ChargeIdSerializer
3374     filter_backends = (filters.DjangoFilterBackend,)
3375     filter_fields = ('id','created','updated','enacted','backend_status','deleted','account','slice','kind','state','date','object','amount','coreHours','invoice',)
3376
3377     def get_serializer_class(self):
3378         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3379         if (no_hyperlinks):
3380             return self.id_serializer_class
3381         else:
3382             return self.serializer_class
3383
3384     def get_queryset(self):
3385         return Charge.select_by_user(self.request.user)
3386
3387     def create(self, request, *args, **kwargs):
3388         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3389         if not (serializer.is_valid()):
3390             response = {"error": "validation",
3391                         "specific_error": "not serializer.is_valid()",\r
3392                         "reasons": serializer.errors}\r
3393             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3394         obj = serializer.object
3395         obj.caller = request.user
3396         if obj.can_update(request.user):
3397             return super(ChargeList, self).create(request, *args, **kwargs)
3398         else:
3399             raise Exception("failed obj.can_update")
3400
3401         ret = super(ChargeList, self).create(request, *args, **kwargs)
3402         if (ret.status_code%100 != 200):
3403             raise Exception(ret.data)
3404
3405         return ret
3406
3407
3408 class ChargeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3409     queryset = Charge.objects.select_related().all()
3410     serializer_class = ChargeSerializer
3411     id_serializer_class = ChargeIdSerializer
3412
3413     def get_serializer_class(self):
3414         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3415         if (no_hyperlinks):
3416             return self.id_serializer_class
3417         else:
3418             return self.serializer_class
3419
3420     def get_queryset(self):
3421         return Charge.select_by_user(self.request.user)
3422
3423     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3424
3425     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3426
3427
3428
3429 class RoleList(generics.ListCreateAPIView):
3430     queryset = Role.objects.select_related().all()
3431     serializer_class = RoleSerializer
3432     id_serializer_class = RoleIdSerializer
3433     filter_backends = (filters.DjangoFilterBackend,)
3434     filter_fields = ('id','created','updated','enacted','backend_status','deleted','role_type','role','description','content_type',)
3435
3436     def get_serializer_class(self):
3437         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3438         if (no_hyperlinks):
3439             return self.id_serializer_class
3440         else:
3441             return self.serializer_class
3442
3443     def get_queryset(self):
3444         return Role.select_by_user(self.request.user)
3445
3446     def create(self, request, *args, **kwargs):
3447         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3448         if not (serializer.is_valid()):
3449             response = {"error": "validation",
3450                         "specific_error": "not serializer.is_valid()",\r
3451                         "reasons": serializer.errors}\r
3452             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3453         obj = serializer.object
3454         obj.caller = request.user
3455         if obj.can_update(request.user):
3456             return super(RoleList, self).create(request, *args, **kwargs)
3457         else:
3458             raise Exception("failed obj.can_update")
3459
3460         ret = super(RoleList, self).create(request, *args, **kwargs)
3461         if (ret.status_code%100 != 200):
3462             raise Exception(ret.data)
3463
3464         return ret
3465
3466
3467 class RoleDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3468     queryset = Role.objects.select_related().all()
3469     serializer_class = RoleSerializer
3470     id_serializer_class = RoleIdSerializer
3471
3472     def get_serializer_class(self):
3473         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3474         if (no_hyperlinks):
3475             return self.id_serializer_class
3476         else:
3477             return self.serializer_class
3478
3479     def get_queryset(self):
3480         return Role.select_by_user(self.request.user)
3481
3482     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3483
3484     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3485
3486
3487
3488 class UsableObjectList(generics.ListCreateAPIView):
3489     queryset = UsableObject.objects.select_related().all()
3490     serializer_class = UsableObjectSerializer
3491     id_serializer_class = UsableObjectIdSerializer
3492     filter_backends = (filters.DjangoFilterBackend,)
3493     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name',)
3494
3495     def get_serializer_class(self):
3496         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3497         if (no_hyperlinks):
3498             return self.id_serializer_class
3499         else:
3500             return self.serializer_class
3501
3502     def get_queryset(self):
3503         return UsableObject.select_by_user(self.request.user)
3504
3505     def create(self, request, *args, **kwargs):
3506         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3507         if not (serializer.is_valid()):
3508             response = {"error": "validation",
3509                         "specific_error": "not serializer.is_valid()",\r
3510                         "reasons": serializer.errors}\r
3511             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3512         obj = serializer.object
3513         obj.caller = request.user
3514         if obj.can_update(request.user):
3515             return super(UsableObjectList, self).create(request, *args, **kwargs)
3516         else:
3517             raise Exception("failed obj.can_update")
3518
3519         ret = super(UsableObjectList, self).create(request, *args, **kwargs)
3520         if (ret.status_code%100 != 200):
3521             raise Exception(ret.data)
3522
3523         return ret
3524
3525
3526 class UsableObjectDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3527     queryset = UsableObject.objects.select_related().all()
3528     serializer_class = UsableObjectSerializer
3529     id_serializer_class = UsableObjectIdSerializer
3530
3531     def get_serializer_class(self):
3532         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3533         if (no_hyperlinks):
3534             return self.id_serializer_class
3535         else:
3536             return self.serializer_class
3537
3538     def get_queryset(self):
3539         return UsableObject.select_by_user(self.request.user)
3540
3541     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3542
3543     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3544
3545
3546
3547 class SiteRoleList(generics.ListCreateAPIView):
3548     queryset = SiteRole.objects.select_related().all()
3549     serializer_class = SiteRoleSerializer
3550     id_serializer_class = SiteRoleIdSerializer
3551     filter_backends = (filters.DjangoFilterBackend,)
3552     filter_fields = ('id','created','updated','enacted','backend_status','deleted','role',)
3553
3554     def get_serializer_class(self):
3555         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3556         if (no_hyperlinks):
3557             return self.id_serializer_class
3558         else:
3559             return self.serializer_class
3560
3561     def get_queryset(self):
3562         return SiteRole.select_by_user(self.request.user)
3563
3564     def create(self, request, *args, **kwargs):
3565         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3566         if not (serializer.is_valid()):
3567             response = {"error": "validation",
3568                         "specific_error": "not serializer.is_valid()",\r
3569                         "reasons": serializer.errors}\r
3570             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3571         obj = serializer.object
3572         obj.caller = request.user
3573         if obj.can_update(request.user):
3574             return super(SiteRoleList, self).create(request, *args, **kwargs)
3575         else:
3576             raise Exception("failed obj.can_update")
3577
3578         ret = super(SiteRoleList, self).create(request, *args, **kwargs)
3579         if (ret.status_code%100 != 200):
3580             raise Exception(ret.data)
3581
3582         return ret
3583
3584
3585 class SiteRoleDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3586     queryset = SiteRole.objects.select_related().all()
3587     serializer_class = SiteRoleSerializer
3588     id_serializer_class = SiteRoleIdSerializer
3589
3590     def get_serializer_class(self):
3591         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3592         if (no_hyperlinks):
3593             return self.id_serializer_class
3594         else:
3595             return self.serializer_class
3596
3597     def get_queryset(self):
3598         return SiteRole.select_by_user(self.request.user)
3599
3600     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3601
3602     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3603
3604
3605
3606 class SliceCredentialList(generics.ListCreateAPIView):
3607     queryset = SliceCredential.objects.select_related().all()
3608     serializer_class = SliceCredentialSerializer
3609     id_serializer_class = SliceCredentialIdSerializer
3610     filter_backends = (filters.DjangoFilterBackend,)
3611     filter_fields = ('id','created','updated','enacted','backend_status','deleted','slice','name','key_id','enc_value',)
3612
3613     def get_serializer_class(self):
3614         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3615         if (no_hyperlinks):
3616             return self.id_serializer_class
3617         else:
3618             return self.serializer_class
3619
3620     def get_queryset(self):
3621         return SliceCredential.select_by_user(self.request.user)
3622
3623     def create(self, request, *args, **kwargs):
3624         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3625         if not (serializer.is_valid()):
3626             response = {"error": "validation",
3627                         "specific_error": "not serializer.is_valid()",\r
3628                         "reasons": serializer.errors}\r
3629             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3630         obj = serializer.object
3631         obj.caller = request.user
3632         if obj.can_update(request.user):
3633             return super(SliceCredentialList, self).create(request, *args, **kwargs)
3634         else:
3635             raise Exception("failed obj.can_update")
3636
3637         ret = super(SliceCredentialList, self).create(request, *args, **kwargs)
3638         if (ret.status_code%100 != 200):
3639             raise Exception(ret.data)
3640
3641         return ret
3642
3643
3644 class SliceCredentialDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3645     queryset = SliceCredential.objects.select_related().all()
3646     serializer_class = SliceCredentialSerializer
3647     id_serializer_class = SliceCredentialIdSerializer
3648
3649     def get_serializer_class(self):
3650         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3651         if (no_hyperlinks):
3652             return self.id_serializer_class
3653         else:
3654             return self.serializer_class
3655
3656     def get_queryset(self):
3657         return SliceCredential.select_by_user(self.request.user)
3658
3659     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3660
3661     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3662
3663
3664
3665 class SliverList(generics.ListCreateAPIView):
3666     queryset = Sliver.objects.select_related().all()
3667     serializer_class = SliverSerializer
3668     id_serializer_class = SliverIdSerializer
3669     filter_backends = (filters.DjangoFilterBackend,)
3670     filter_fields = ('id','created','updated','enacted','backend_status','deleted','instance_id','name','instance_name','ip','image','creator','slice','node','deploymentNetwork','numberCores','flavor','userData','networks','networks',)
3671
3672     def get_serializer_class(self):
3673         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3674         if (no_hyperlinks):
3675             return self.id_serializer_class
3676         else:
3677             return self.serializer_class
3678
3679     def get_queryset(self):
3680         return Sliver.select_by_user(self.request.user)
3681
3682     def create(self, request, *args, **kwargs):
3683         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3684         if not (serializer.is_valid()):
3685             response = {"error": "validation",
3686                         "specific_error": "not serializer.is_valid()",\r
3687                         "reasons": serializer.errors}\r
3688             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3689         obj = serializer.object
3690         obj.caller = request.user
3691         if obj.can_update(request.user):
3692             return super(SliverList, self).create(request, *args, **kwargs)
3693         else:
3694             raise Exception("failed obj.can_update")
3695
3696         ret = super(SliverList, self).create(request, *args, **kwargs)
3697         if (ret.status_code%100 != 200):
3698             raise Exception(ret.data)
3699
3700         return ret
3701
3702
3703 class SliverDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3704     queryset = Sliver.objects.select_related().all()
3705     serializer_class = SliverSerializer
3706     id_serializer_class = SliverIdSerializer
3707
3708     def get_serializer_class(self):
3709         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3710         if (no_hyperlinks):
3711             return self.id_serializer_class
3712         else:
3713             return self.serializer_class
3714
3715     def get_queryset(self):
3716         return Sliver.select_by_user(self.request.user)
3717
3718     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3719
3720     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3721
3722
3723
3724 class NodeList(generics.ListCreateAPIView):
3725     queryset = Node.objects.select_related().all()
3726     serializer_class = NodeSerializer
3727     id_serializer_class = NodeIdSerializer
3728     filter_backends = (filters.DjangoFilterBackend,)
3729     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','site','deployment',)
3730
3731     def get_serializer_class(self):
3732         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3733         if (no_hyperlinks):
3734             return self.id_serializer_class
3735         else:
3736             return self.serializer_class
3737
3738     def get_queryset(self):
3739         return Node.select_by_user(self.request.user)
3740
3741     def create(self, request, *args, **kwargs):
3742         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3743         if not (serializer.is_valid()):
3744             response = {"error": "validation",
3745                         "specific_error": "not serializer.is_valid()",\r
3746                         "reasons": serializer.errors}\r
3747             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3748         obj = serializer.object
3749         obj.caller = request.user
3750         if obj.can_update(request.user):
3751             return super(NodeList, self).create(request, *args, **kwargs)
3752         else:
3753             raise Exception("failed obj.can_update")
3754
3755         ret = super(NodeList, self).create(request, *args, **kwargs)
3756         if (ret.status_code%100 != 200):
3757             raise Exception(ret.data)
3758
3759         return ret
3760
3761
3762 class NodeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3763     queryset = Node.objects.select_related().all()
3764     serializer_class = NodeSerializer
3765     id_serializer_class = NodeIdSerializer
3766
3767     def get_serializer_class(self):
3768         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3769         if (no_hyperlinks):
3770             return self.id_serializer_class
3771         else:
3772             return self.serializer_class
3773
3774     def get_queryset(self):
3775         return Node.select_by_user(self.request.user)
3776
3777     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3778
3779     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3780
3781
3782
3783 class DashboardViewList(generics.ListCreateAPIView):
3784     queryset = DashboardView.objects.select_related().all()
3785     serializer_class = DashboardViewSerializer
3786     id_serializer_class = DashboardViewIdSerializer
3787     filter_backends = (filters.DjangoFilterBackend,)
3788     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','url',)
3789
3790     def get_serializer_class(self):
3791         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3792         if (no_hyperlinks):
3793             return self.id_serializer_class
3794         else:
3795             return self.serializer_class
3796
3797     def get_queryset(self):
3798         return DashboardView.select_by_user(self.request.user)
3799
3800     def create(self, request, *args, **kwargs):
3801         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3802         if not (serializer.is_valid()):
3803             response = {"error": "validation",
3804                         "specific_error": "not serializer.is_valid()",\r
3805                         "reasons": serializer.errors}\r
3806             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3807         obj = serializer.object
3808         obj.caller = request.user
3809         if obj.can_update(request.user):
3810             return super(DashboardViewList, self).create(request, *args, **kwargs)
3811         else:
3812             raise Exception("failed obj.can_update")
3813
3814         ret = super(DashboardViewList, self).create(request, *args, **kwargs)
3815         if (ret.status_code%100 != 200):
3816             raise Exception(ret.data)
3817
3818         return ret
3819
3820
3821 class DashboardViewDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3822     queryset = DashboardView.objects.select_related().all()
3823     serializer_class = DashboardViewSerializer
3824     id_serializer_class = DashboardViewIdSerializer
3825
3826     def get_serializer_class(self):
3827         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3828         if (no_hyperlinks):
3829             return self.id_serializer_class
3830         else:
3831             return self.serializer_class
3832
3833     def get_queryset(self):
3834         return DashboardView.select_by_user(self.request.user)
3835
3836     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3837
3838     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3839
3840
3841
3842 class ControllerImagesList(generics.ListCreateAPIView):
3843     queryset = ControllerImages.objects.select_related().all()
3844     serializer_class = ControllerImagesSerializer
3845     id_serializer_class = ControllerImagesIdSerializer
3846     filter_backends = (filters.DjangoFilterBackend,)
3847     filter_fields = ('id','created','updated','enacted','backend_status','deleted','image','deployment','glance_image_id',)
3848
3849     def get_serializer_class(self):
3850         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3851         if (no_hyperlinks):
3852             return self.id_serializer_class
3853         else:
3854             return self.serializer_class
3855
3856     def get_queryset(self):
3857         return ControllerImages.select_by_user(self.request.user)
3858
3859     def create(self, request, *args, **kwargs):
3860         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3861         if not (serializer.is_valid()):
3862             response = {"error": "validation",
3863                         "specific_error": "not serializer.is_valid()",\r
3864                         "reasons": serializer.errors}\r
3865             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3866         obj = serializer.object
3867         obj.caller = request.user
3868         if obj.can_update(request.user):
3869             return super(ControllerImagesList, self).create(request, *args, **kwargs)
3870         else:
3871             raise Exception("failed obj.can_update")
3872
3873         ret = super(ControllerImagesList, self).create(request, *args, **kwargs)
3874         if (ret.status_code%100 != 200):
3875             raise Exception(ret.data)
3876
3877         return ret
3878
3879
3880 class ControllerImagesDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3881     queryset = ControllerImages.objects.select_related().all()
3882     serializer_class = ControllerImagesSerializer
3883     id_serializer_class = ControllerImagesIdSerializer
3884
3885     def get_serializer_class(self):
3886         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3887         if (no_hyperlinks):
3888             return self.id_serializer_class
3889         else:
3890             return self.serializer_class
3891
3892     def get_queryset(self):
3893         return ControllerImages.select_by_user(self.request.user)
3894
3895     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3896
3897     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3898
3899
3900
3901 class ReservedResourceList(generics.ListCreateAPIView):
3902     queryset = ReservedResource.objects.select_related().all()
3903     serializer_class = ReservedResourceSerializer
3904     id_serializer_class = ReservedResourceIdSerializer
3905     filter_backends = (filters.DjangoFilterBackend,)
3906     filter_fields = ('id','created','updated','enacted','backend_status','deleted','sliver','resource','quantity','reservationSet',)
3907
3908     def get_serializer_class(self):
3909         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3910         if (no_hyperlinks):
3911             return self.id_serializer_class
3912         else:
3913             return self.serializer_class
3914
3915     def get_queryset(self):
3916         return ReservedResource.select_by_user(self.request.user)
3917
3918     def create(self, request, *args, **kwargs):
3919         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3920         if not (serializer.is_valid()):
3921             response = {"error": "validation",
3922                         "specific_error": "not serializer.is_valid()",\r
3923                         "reasons": serializer.errors}\r
3924             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3925         obj = serializer.object
3926         obj.caller = request.user
3927         if obj.can_update(request.user):
3928             return super(ReservedResourceList, self).create(request, *args, **kwargs)
3929         else:
3930             raise Exception("failed obj.can_update")
3931
3932         ret = super(ReservedResourceList, self).create(request, *args, **kwargs)
3933         if (ret.status_code%100 != 200):
3934             raise Exception(ret.data)
3935
3936         return ret
3937
3938
3939 class ReservedResourceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3940     queryset = ReservedResource.objects.select_related().all()
3941     serializer_class = ReservedResourceSerializer
3942     id_serializer_class = ReservedResourceIdSerializer
3943
3944     def get_serializer_class(self):
3945         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3946         if (no_hyperlinks):
3947             return self.id_serializer_class
3948         else:
3949             return self.serializer_class
3950
3951     def get_queryset(self):
3952         return ReservedResource.select_by_user(self.request.user)
3953
3954     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3955
3956     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
3957
3958
3959
3960 class NetworkSliceList(generics.ListCreateAPIView):
3961     queryset = NetworkSlice.objects.select_related().all()
3962     serializer_class = NetworkSliceSerializer
3963     id_serializer_class = NetworkSliceIdSerializer
3964     filter_backends = (filters.DjangoFilterBackend,)
3965     filter_fields = ('id','created','updated','enacted','backend_status','deleted','network','slice',)
3966
3967     def get_serializer_class(self):
3968         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
3969         if (no_hyperlinks):
3970             return self.id_serializer_class
3971         else:
3972             return self.serializer_class
3973
3974     def get_queryset(self):
3975         return NetworkSlice.select_by_user(self.request.user)
3976
3977     def create(self, request, *args, **kwargs):
3978         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
3979         if not (serializer.is_valid()):
3980             response = {"error": "validation",
3981                         "specific_error": "not serializer.is_valid()",\r
3982                         "reasons": serializer.errors}\r
3983             return Response(response, status=status.HTTP_400_BAD_REQUEST)
3984         obj = serializer.object
3985         obj.caller = request.user
3986         if obj.can_update(request.user):
3987             return super(NetworkSliceList, self).create(request, *args, **kwargs)
3988         else:
3989             raise Exception("failed obj.can_update")
3990
3991         ret = super(NetworkSliceList, self).create(request, *args, **kwargs)
3992         if (ret.status_code%100 != 200):
3993             raise Exception(ret.data)
3994
3995         return ret
3996
3997
3998 class NetworkSliceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
3999     queryset = NetworkSlice.objects.select_related().all()
4000     serializer_class = NetworkSliceSerializer
4001     id_serializer_class = NetworkSliceIdSerializer
4002
4003     def get_serializer_class(self):
4004         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4005         if (no_hyperlinks):
4006             return self.id_serializer_class
4007         else:
4008             return self.serializer_class
4009
4010     def get_queryset(self):
4011         return NetworkSlice.select_by_user(self.request.user)
4012
4013     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4014
4015     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4016
4017
4018
4019 class UserDashboardViewList(generics.ListCreateAPIView):
4020     queryset = UserDashboardView.objects.select_related().all()
4021     serializer_class = UserDashboardViewSerializer
4022     id_serializer_class = UserDashboardViewIdSerializer
4023     filter_backends = (filters.DjangoFilterBackend,)
4024     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','dashboardView','order',)
4025
4026     def get_serializer_class(self):
4027         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4028         if (no_hyperlinks):
4029             return self.id_serializer_class
4030         else:
4031             return self.serializer_class
4032
4033     def get_queryset(self):
4034         return UserDashboardView.select_by_user(self.request.user)
4035
4036     def create(self, request, *args, **kwargs):
4037         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4038         if not (serializer.is_valid()):
4039             response = {"error": "validation",
4040                         "specific_error": "not serializer.is_valid()",\r
4041                         "reasons": serializer.errors}\r
4042             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4043         obj = serializer.object
4044         obj.caller = request.user
4045         if obj.can_update(request.user):
4046             return super(UserDashboardViewList, self).create(request, *args, **kwargs)
4047         else:
4048             raise Exception("failed obj.can_update")
4049
4050         ret = super(UserDashboardViewList, self).create(request, *args, **kwargs)
4051         if (ret.status_code%100 != 200):
4052             raise Exception(ret.data)
4053
4054         return ret
4055
4056
4057 class UserDashboardViewDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4058     queryset = UserDashboardView.objects.select_related().all()
4059     serializer_class = UserDashboardViewSerializer
4060     id_serializer_class = UserDashboardViewIdSerializer
4061
4062     def get_serializer_class(self):
4063         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4064         if (no_hyperlinks):
4065             return self.id_serializer_class
4066         else:
4067             return self.serializer_class
4068
4069     def get_queryset(self):
4070         return UserDashboardView.select_by_user(self.request.user)
4071
4072     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4073
4074     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4075
4076
4077
4078 class PlanetStackPrivilegeList(generics.ListCreateAPIView):
4079     queryset = PlanetStackPrivilege.objects.select_related().all()
4080     serializer_class = PlanetStackPrivilegeSerializer
4081     id_serializer_class = PlanetStackPrivilegeIdSerializer
4082     filter_backends = (filters.DjangoFilterBackend,)
4083     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','planetstack','role',)
4084
4085     def get_serializer_class(self):
4086         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4087         if (no_hyperlinks):
4088             return self.id_serializer_class
4089         else:
4090             return self.serializer_class
4091
4092     def get_queryset(self):
4093         return PlanetStackPrivilege.select_by_user(self.request.user)
4094
4095     def create(self, request, *args, **kwargs):
4096         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4097         if not (serializer.is_valid()):
4098             response = {"error": "validation",
4099                         "specific_error": "not serializer.is_valid()",\r
4100                         "reasons": serializer.errors}\r
4101             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4102         obj = serializer.object
4103         obj.caller = request.user
4104         if obj.can_update(request.user):
4105             return super(PlanetStackPrivilegeList, self).create(request, *args, **kwargs)
4106         else:
4107             raise Exception("failed obj.can_update")
4108
4109         ret = super(PlanetStackPrivilegeList, self).create(request, *args, **kwargs)
4110         if (ret.status_code%100 != 200):
4111             raise Exception(ret.data)
4112
4113         return ret
4114
4115
4116 class PlanetStackPrivilegeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4117     queryset = PlanetStackPrivilege.objects.select_related().all()
4118     serializer_class = PlanetStackPrivilegeSerializer
4119     id_serializer_class = PlanetStackPrivilegeIdSerializer
4120
4121     def get_serializer_class(self):
4122         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4123         if (no_hyperlinks):
4124             return self.id_serializer_class
4125         else:
4126             return self.serializer_class
4127
4128     def get_queryset(self):
4129         return PlanetStackPrivilege.select_by_user(self.request.user)
4130
4131     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4132
4133     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4134
4135
4136
4137 class UserList(generics.ListCreateAPIView):
4138     queryset = User.objects.select_related().all()
4139     serializer_class = UserSerializer
4140     id_serializer_class = UserIdSerializer
4141     filter_backends = (filters.DjangoFilterBackend,)
4142     filter_fields = ('id','password','last_login','email','username','firstname','lastname','phone','user_url','site','public_key','is_active','is_admin','is_staff','is_readonly','created','updated','enacted','backend_status','deleted','timezone',)
4143
4144     def get_serializer_class(self):
4145         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4146         if (no_hyperlinks):
4147             return self.id_serializer_class
4148         else:
4149             return self.serializer_class
4150
4151     def get_queryset(self):
4152         return User.select_by_user(self.request.user)
4153
4154     def create(self, request, *args, **kwargs):
4155         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4156         if not (serializer.is_valid()):
4157             response = {"error": "validation",
4158                         "specific_error": "not serializer.is_valid()",\r
4159                         "reasons": serializer.errors}\r
4160             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4161         obj = serializer.object
4162         obj.caller = request.user
4163         if obj.can_update(request.user):
4164             return super(UserList, self).create(request, *args, **kwargs)
4165         else:
4166             raise Exception("failed obj.can_update")
4167
4168         ret = super(UserList, self).create(request, *args, **kwargs)
4169         if (ret.status_code%100 != 200):
4170             raise Exception(ret.data)
4171
4172         return ret
4173
4174
4175 class UserDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4176     queryset = User.objects.select_related().all()
4177     serializer_class = UserSerializer
4178     id_serializer_class = UserIdSerializer
4179
4180     def get_serializer_class(self):
4181         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4182         if (no_hyperlinks):
4183             return self.id_serializer_class
4184         else:
4185             return self.serializer_class
4186
4187     def get_queryset(self):
4188         return User.select_by_user(self.request.user)
4189
4190     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4191
4192     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4193
4194
4195
4196 class DeploymentList(generics.ListCreateAPIView):
4197     queryset = Deployment.objects.select_related().all()
4198     serializer_class = DeploymentSerializer
4199     id_serializer_class = DeploymentIdSerializer
4200     filter_backends = (filters.DjangoFilterBackend,)
4201     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','accessControl','sites','sites','flavors','flavors',)
4202
4203     def get_serializer_class(self):
4204         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4205         if (no_hyperlinks):
4206             return self.id_serializer_class
4207         else:
4208             return self.serializer_class
4209
4210     def get_queryset(self):
4211         return Deployment.select_by_user(self.request.user)
4212
4213     def create(self, request, *args, **kwargs):
4214         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4215         if not (serializer.is_valid()):
4216             response = {"error": "validation",
4217                         "specific_error": "not serializer.is_valid()",\r
4218                         "reasons": serializer.errors}\r
4219             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4220         obj = serializer.object
4221         obj.caller = request.user
4222         if obj.can_update(request.user):
4223             return super(DeploymentList, self).create(request, *args, **kwargs)
4224         else:
4225             raise Exception("failed obj.can_update")
4226
4227         ret = super(DeploymentList, self).create(request, *args, **kwargs)
4228         if (ret.status_code%100 != 200):
4229             raise Exception(ret.data)
4230
4231         return ret
4232
4233
4234 class DeploymentDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4235     queryset = Deployment.objects.select_related().all()
4236     serializer_class = DeploymentSerializer
4237     id_serializer_class = DeploymentIdSerializer
4238
4239     def get_serializer_class(self):
4240         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4241         if (no_hyperlinks):
4242             return self.id_serializer_class
4243         else:
4244             return self.serializer_class
4245
4246     def get_queryset(self):
4247         return Deployment.select_by_user(self.request.user)
4248
4249     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4250
4251     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4252
4253 class ControllerList(generics.ListCreateAPIView):
4254     queryset = Controller.objects.select_related().all()
4255     serializer_class = ControllerSerializer
4256     id_serializer_class = ControllerIdSerializer
4257     filter_backends = (filters.DjangoFilterBackend,)
4258     filter_fields = ('id','created','updated','enacted','backend_status','deleted','site_deployment','admin_user','admin_password','admin_tenant','auth_url','backend_type')
4259
4260     def get_serializer_class(self):
4261         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4262         if (no_hyperlinks):
4263             return self.id_serializer_class
4264         else:
4265             return self.serializer_class
4266
4267     def get_queryset(self):
4268         return Controller.select_by_user(self.request.user)
4269
4270     def create(self, request, *args, **kwargs):
4271         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4272         if not (serializer.is_valid()):
4273             response = {"error": "validation",
4274                         "specific_error": "not serializer.is_valid()",
4275                         "reasons": serializer.errors}
4276             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4277         obj = serializer.object
4278         obj.caller = request.user
4279         if obj.can_update(request.user):
4280             return super(ControllerList, self).create(request, *args, **kwargs)
4281         else:
4282             raise Exception("failed obj.can_update")
4283
4284         ret = super(ControllerList, self).create(request, *args, **kwargs)
4285         if (ret.status_code%100 != 200):
4286             raise Exception(ret.data)
4287
4288         return ret
4289
4290 class ControllerDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4291     queryset = Controller.objects.select_related().all()
4292     serializer_class = ControllerSerializer
4293     id_serializer_class = ControllerIdSerializer
4294
4295     def get_serializer_class(self):
4296         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4297         if (no_hyperlinks):
4298             return self.id_serializer_class
4299         else:
4300             return self.serializer_class
4301
4302     def get_queryset(self):
4303         return Controller.select_by_user(self.request.user)
4304
4305 class ReservationList(generics.ListCreateAPIView):
4306     queryset = Reservation.objects.select_related().all()
4307     serializer_class = ReservationSerializer
4308     id_serializer_class = ReservationIdSerializer
4309     filter_backends = (filters.DjangoFilterBackend,)
4310     filter_fields = ('id','created','updated','enacted','backend_status','deleted','startTime','slice','duration',)
4311
4312     def get_serializer_class(self):
4313         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4314         if (no_hyperlinks):
4315             return self.id_serializer_class
4316         else:
4317             return self.serializer_class
4318
4319     def get_queryset(self):
4320         return Reservation.select_by_user(self.request.user)
4321
4322     def create(self, request, *args, **kwargs):
4323         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4324         if not (serializer.is_valid()):
4325             response = {"error": "validation",
4326                         "specific_error": "not serializer.is_valid()",\r
4327                         "reasons": serializer.errors}\r
4328             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4329         obj = serializer.object
4330         obj.caller = request.user
4331         if obj.can_update(request.user):
4332             return super(ReservationList, self).create(request, *args, **kwargs)
4333         else:
4334             raise Exception("failed obj.can_update")
4335
4336         ret = super(ReservationList, self).create(request, *args, **kwargs)
4337         if (ret.status_code%100 != 200):
4338             raise Exception(ret.data)
4339
4340         return ret
4341
4342
4343 class ReservationDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4344     queryset = Reservation.objects.select_related().all()
4345     serializer_class = ReservationSerializer
4346     id_serializer_class = ReservationIdSerializer
4347
4348     def get_serializer_class(self):
4349         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4350         if (no_hyperlinks):
4351             return self.id_serializer_class
4352         else:
4353             return self.serializer_class
4354
4355     def get_queryset(self):
4356         return Reservation.select_by_user(self.request.user)
4357
4358     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4359
4360     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4361
4362
4363
4364 class ControllerSlicesList(generics.ListCreateAPIView):
4365     queryset = ControllerSlices.objects.select_related().all()
4366     serializer_class = ControllerSlicesSerializer
4367     id_serializer_class = ControllerSlicesIdSerializer
4368     filter_backends = (filters.DjangoFilterBackend,)
4369     filter_fields = ('id','created','updated','enacted','backend_status','deleted','slice','deployment','tenant_id','network_id','router_id','subnet_id',)
4370
4371     def get_serializer_class(self):
4372         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4373         if (no_hyperlinks):
4374             return self.id_serializer_class
4375         else:
4376             return self.serializer_class
4377
4378     def get_queryset(self):
4379         return ControllerSlices.select_by_user(self.request.user)
4380
4381     def create(self, request, *args, **kwargs):
4382         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4383         if not (serializer.is_valid()):
4384             response = {"error": "validation",
4385                         "specific_error": "not serializer.is_valid()",\r
4386                         "reasons": serializer.errors}\r
4387             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4388         obj = serializer.object
4389         obj.caller = request.user
4390         if obj.can_update(request.user):
4391             return super(ControllerSlicesList, self).create(request, *args, **kwargs)
4392         else:
4393             raise Exception("failed obj.can_update")
4394
4395         ret = super(ControllerSlicesList, self).create(request, *args, **kwargs)
4396         if (ret.status_code%100 != 200):
4397             raise Exception(ret.data)
4398
4399         return ret
4400
4401
4402 class ControllerSlicesDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4403     queryset = ControllerSlices.objects.select_related().all()
4404     serializer_class = ControllerSlicesSerializer
4405     id_serializer_class = ControllerSlicesIdSerializer
4406
4407     def get_serializer_class(self):
4408         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4409         if (no_hyperlinks):
4410             return self.id_serializer_class
4411         else:
4412             return self.serializer_class
4413
4414     def get_queryset(self):
4415         return ControllerSlices.select_by_user(self.request.user)
4416
4417     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4418
4419     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4420
4421
4422
4423 class SitePrivilegeList(generics.ListCreateAPIView):
4424     queryset = SitePrivilege.objects.select_related().all()
4425     serializer_class = SitePrivilegeSerializer
4426     id_serializer_class = SitePrivilegeIdSerializer
4427     filter_backends = (filters.DjangoFilterBackend,)
4428     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','site','role',)
4429
4430     def get_serializer_class(self):
4431         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4432         if (no_hyperlinks):
4433             return self.id_serializer_class
4434         else:
4435             return self.serializer_class
4436
4437     def get_queryset(self):
4438         return SitePrivilege.select_by_user(self.request.user)
4439
4440     def create(self, request, *args, **kwargs):
4441         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4442         if not (serializer.is_valid()):
4443             response = {"error": "validation",
4444                         "specific_error": "not serializer.is_valid()",\r
4445                         "reasons": serializer.errors}\r
4446             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4447         obj = serializer.object
4448         obj.caller = request.user
4449         if obj.can_update(request.user):
4450             return super(SitePrivilegeList, self).create(request, *args, **kwargs)
4451         else:
4452             raise Exception("failed obj.can_update")
4453
4454         ret = super(SitePrivilegeList, self).create(request, *args, **kwargs)
4455         if (ret.status_code%100 != 200):
4456             raise Exception(ret.data)
4457
4458         return ret
4459
4460
4461 class SitePrivilegeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4462     queryset = SitePrivilege.objects.select_related().all()
4463     serializer_class = SitePrivilegeSerializer
4464     id_serializer_class = SitePrivilegeIdSerializer
4465
4466     def get_serializer_class(self):
4467         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4468         if (no_hyperlinks):
4469             return self.id_serializer_class
4470         else:
4471             return self.serializer_class
4472
4473     def get_queryset(self):
4474         return SitePrivilege.select_by_user(self.request.user)
4475
4476     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4477
4478     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4479
4480
4481
4482 class PlanetStackList(generics.ListCreateAPIView):
4483     queryset = PlanetStack.objects.select_related().all()
4484     serializer_class = PlanetStackSerializer
4485     id_serializer_class = PlanetStackIdSerializer
4486     filter_backends = (filters.DjangoFilterBackend,)
4487     filter_fields = ('id','created','updated','enacted','backend_status','deleted','description',)
4488
4489     def get_serializer_class(self):
4490         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4491         if (no_hyperlinks):
4492             return self.id_serializer_class
4493         else:
4494             return self.serializer_class
4495
4496     def get_queryset(self):
4497         return PlanetStack.select_by_user(self.request.user)
4498
4499     def create(self, request, *args, **kwargs):
4500         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4501         if not (serializer.is_valid()):
4502             response = {"error": "validation",
4503                         "specific_error": "not serializer.is_valid()",\r
4504                         "reasons": serializer.errors}\r
4505             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4506         obj = serializer.object
4507         obj.caller = request.user
4508         if obj.can_update(request.user):
4509             return super(PlanetStackList, self).create(request, *args, **kwargs)
4510         else:
4511             raise Exception("failed obj.can_update")
4512
4513         ret = super(PlanetStackList, self).create(request, *args, **kwargs)
4514         if (ret.status_code%100 != 200):
4515             raise Exception(ret.data)
4516
4517         return ret
4518
4519
4520 class PlanetStackDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4521     queryset = PlanetStack.objects.select_related().all()
4522     serializer_class = PlanetStackSerializer
4523     id_serializer_class = PlanetStackIdSerializer
4524
4525     def get_serializer_class(self):
4526         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4527         if (no_hyperlinks):
4528             return self.id_serializer_class
4529         else:
4530             return self.serializer_class
4531
4532     def get_queryset(self):
4533         return PlanetStack.select_by_user(self.request.user)
4534
4535     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4536
4537     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4538
4539
4540
4541 class ControllerUsersList(generics.ListCreateAPIView):
4542     queryset = ControllerUsers.objects.select_related().all()
4543     serializer_class = ControllerUsersSerializer
4544     id_serializer_class = ControllerUsersIdSerializer
4545     filter_backends = (filters.DjangoFilterBackend,)
4546     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','deployment','kuser_id',)
4547
4548     def get_serializer_class(self):
4549         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4550         if (no_hyperlinks):
4551             return self.id_serializer_class
4552         else:
4553             return self.serializer_class
4554
4555     def get_queryset(self):
4556         return ControllerUsers.select_by_user(self.request.user)
4557
4558     def create(self, request, *args, **kwargs):
4559         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4560         if not (serializer.is_valid()):
4561             response = {"error": "validation",
4562                         "specific_error": "not serializer.is_valid()",\r
4563                         "reasons": serializer.errors}\r
4564             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4565         obj = serializer.object
4566         obj.caller = request.user
4567         if obj.can_update(request.user):
4568             return super(ControllerUsersList, self).create(request, *args, **kwargs)
4569         else:
4570             raise Exception("failed obj.can_update")
4571
4572         ret = super(ControllerUsersList, self).create(request, *args, **kwargs)
4573         if (ret.status_code%100 != 200):
4574             raise Exception(ret.data)
4575
4576         return ret
4577
4578
4579 class ControllerUsersDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4580     queryset = ControllerUsers.objects.select_related().all()
4581     serializer_class = ControllerUsersSerializer
4582     id_serializer_class = ControllerUsersIdSerializer
4583
4584     def get_serializer_class(self):
4585         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4586         if (no_hyperlinks):
4587             return self.id_serializer_class
4588         else:
4589             return self.serializer_class
4590
4591     def get_queryset(self):
4592         return ControllerUsers.select_by_user(self.request.user)
4593
4594     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4595
4596     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4597
4598
4599
4600 class AccountList(generics.ListCreateAPIView):
4601     queryset = Account.objects.select_related().all()
4602     serializer_class = AccountSerializer
4603     id_serializer_class = AccountIdSerializer
4604     filter_backends = (filters.DjangoFilterBackend,)
4605     filter_fields = ('id','created','updated','enacted','backend_status','deleted','site',)
4606
4607     def get_serializer_class(self):
4608         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4609         if (no_hyperlinks):
4610             return self.id_serializer_class
4611         else:
4612             return self.serializer_class
4613
4614     def get_queryset(self):
4615         return Account.select_by_user(self.request.user)
4616
4617     def create(self, request, *args, **kwargs):
4618         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4619         if not (serializer.is_valid()):
4620             response = {"error": "validation",
4621                         "specific_error": "not serializer.is_valid()",\r
4622                         "reasons": serializer.errors}\r
4623             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4624         obj = serializer.object
4625         obj.caller = request.user
4626         if obj.can_update(request.user):
4627             return super(AccountList, self).create(request, *args, **kwargs)
4628         else:
4629             raise Exception("failed obj.can_update")
4630
4631         ret = super(AccountList, self).create(request, *args, **kwargs)
4632         if (ret.status_code%100 != 200):
4633             raise Exception(ret.data)
4634
4635         return ret
4636
4637
4638 class AccountDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4639     queryset = Account.objects.select_related().all()
4640     serializer_class = AccountSerializer
4641     id_serializer_class = AccountIdSerializer
4642
4643     def get_serializer_class(self):
4644         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4645         if (no_hyperlinks):
4646             return self.id_serializer_class
4647         else:
4648             return self.serializer_class
4649
4650     def get_queryset(self):
4651         return Account.select_by_user(self.request.user)
4652
4653     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4654
4655     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4656
4657
4658
4659 class NetworkParameterTypeList(generics.ListCreateAPIView):
4660     queryset = NetworkParameterType.objects.select_related().all()
4661     serializer_class = NetworkParameterTypeSerializer
4662     id_serializer_class = NetworkParameterTypeIdSerializer
4663     filter_backends = (filters.DjangoFilterBackend,)
4664     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','description',)
4665
4666     def get_serializer_class(self):
4667         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4668         if (no_hyperlinks):
4669             return self.id_serializer_class
4670         else:
4671             return self.serializer_class
4672
4673     def get_queryset(self):
4674         return NetworkParameterType.select_by_user(self.request.user)
4675
4676     def create(self, request, *args, **kwargs):
4677         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4678         if not (serializer.is_valid()):
4679             response = {"error": "validation",
4680                         "specific_error": "not serializer.is_valid()",\r
4681                         "reasons": serializer.errors}\r
4682             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4683         obj = serializer.object
4684         obj.caller = request.user
4685         if obj.can_update(request.user):
4686             return super(NetworkParameterTypeList, self).create(request, *args, **kwargs)
4687         else:
4688             raise Exception("failed obj.can_update")
4689
4690         ret = super(NetworkParameterTypeList, self).create(request, *args, **kwargs)
4691         if (ret.status_code%100 != 200):
4692             raise Exception(ret.data)
4693
4694         return ret
4695
4696
4697 class NetworkParameterTypeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4698     queryset = NetworkParameterType.objects.select_related().all()
4699     serializer_class = NetworkParameterTypeSerializer
4700     id_serializer_class = NetworkParameterTypeIdSerializer
4701
4702     def get_serializer_class(self):
4703         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4704         if (no_hyperlinks):
4705             return self.id_serializer_class
4706         else:
4707             return self.serializer_class
4708
4709     def get_queryset(self):
4710         return NetworkParameterType.select_by_user(self.request.user)
4711
4712     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4713
4714     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4715
4716
4717
4718 class SiteCredentialList(generics.ListCreateAPIView):
4719     queryset = SiteCredential.objects.select_related().all()
4720     serializer_class = SiteCredentialSerializer
4721     id_serializer_class = SiteCredentialIdSerializer
4722     filter_backends = (filters.DjangoFilterBackend,)
4723     filter_fields = ('id','created','updated','enacted','backend_status','deleted','site','name','key_id','enc_value',)
4724
4725     def get_serializer_class(self):
4726         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4727         if (no_hyperlinks):
4728             return self.id_serializer_class
4729         else:
4730             return self.serializer_class
4731
4732     def get_queryset(self):
4733         return SiteCredential.select_by_user(self.request.user)
4734
4735     def create(self, request, *args, **kwargs):
4736         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4737         if not (serializer.is_valid()):
4738             response = {"error": "validation",
4739                         "specific_error": "not serializer.is_valid()",\r
4740                         "reasons": serializer.errors}\r
4741             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4742         obj = serializer.object
4743         obj.caller = request.user
4744         if obj.can_update(request.user):
4745             return super(SiteCredentialList, self).create(request, *args, **kwargs)
4746         else:
4747             raise Exception("failed obj.can_update")
4748
4749         ret = super(SiteCredentialList, self).create(request, *args, **kwargs)
4750         if (ret.status_code%100 != 200):
4751             raise Exception(ret.data)
4752
4753         return ret
4754
4755
4756 class SiteCredentialDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4757     queryset = SiteCredential.objects.select_related().all()
4758     serializer_class = SiteCredentialSerializer
4759     id_serializer_class = SiteCredentialIdSerializer
4760
4761     def get_serializer_class(self):
4762         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4763         if (no_hyperlinks):
4764             return self.id_serializer_class
4765         else:
4766             return self.serializer_class
4767
4768     def get_queryset(self):
4769         return SiteCredential.select_by_user(self.request.user)
4770
4771     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4772
4773     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4774
4775
4776
4777 class ControllerPrivilegeList(generics.ListCreateAPIView):
4778     queryset = ControllerPrivilege.objects.select_related().all()
4779     serializer_class = ControllerPrivilegeSerializer
4780     id_serializer_class = ControllerPrivilegeIdSerializer
4781     filter_backends = (filters.DjangoFilterBackend,)
4782     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','deployment','role',)
4783
4784     def get_serializer_class(self):
4785         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4786         if (no_hyperlinks):
4787             return self.id_serializer_class
4788         else:
4789             return self.serializer_class
4790
4791     def get_queryset(self):
4792         return ControllerPrivilege.select_by_user(self.request.user)
4793
4794     def create(self, request, *args, **kwargs):
4795         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4796         if not (serializer.is_valid()):
4797             response = {"error": "validation",
4798                         "specific_error": "not serializer.is_valid()",\r
4799                         "reasons": serializer.errors}\r
4800             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4801         obj = serializer.object
4802         obj.caller = request.user
4803         if obj.can_update(request.user):
4804             return super(ControllerPrivilegeList, self).create(request, *args, **kwargs)
4805         else:
4806             raise Exception("failed obj.can_update")
4807
4808         ret = super(ControllerPrivilegeList, self).create(request, *args, **kwargs)
4809         if (ret.status_code%100 != 200):
4810             raise Exception(ret.data)
4811
4812         return ret
4813
4814
4815 class ControllerPrivilegeDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4816     queryset = ControllerPrivilege.objects.select_related().all()
4817     serializer_class = ControllerPrivilegeSerializer
4818     id_serializer_class = ControllerPrivilegeIdSerializer
4819
4820     def get_serializer_class(self):
4821         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4822         if (no_hyperlinks):
4823             return self.id_serializer_class
4824         else:
4825             return self.serializer_class
4826
4827     def get_queryset(self):
4828         return ControllerPrivilege.select_by_user(self.request.user)
4829
4830     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4831
4832     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4833
4834
4835
4836 class ControllerRoleList(generics.ListCreateAPIView):
4837     queryset = ControllerRole.objects.select_related().all()
4838     serializer_class = ControllerRoleSerializer
4839     id_serializer_class = ControllerRoleIdSerializer
4840     filter_backends = (filters.DjangoFilterBackend,)
4841     filter_fields = ('id','created','updated','enacted','backend_status','deleted','role',)
4842
4843     def get_serializer_class(self):
4844         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4845         if (no_hyperlinks):
4846             return self.id_serializer_class
4847         else:
4848             return self.serializer_class
4849
4850     def get_queryset(self):
4851         return ControllerRole.select_by_user(self.request.user)
4852
4853     def create(self, request, *args, **kwargs):
4854         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4855         if not (serializer.is_valid()):
4856             response = {"error": "validation",
4857                         "specific_error": "not serializer.is_valid()",\r
4858                         "reasons": serializer.errors}\r
4859             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4860         obj = serializer.object
4861         obj.caller = request.user
4862         if obj.can_update(request.user):
4863             return super(ControllerRoleList, self).create(request, *args, **kwargs)
4864         else:
4865             raise Exception("failed obj.can_update")
4866
4867         ret = super(ControllerRoleList, self).create(request, *args, **kwargs)
4868         if (ret.status_code%100 != 200):
4869             raise Exception(ret.data)
4870
4871         return ret
4872
4873
4874 class ControllerRoleDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4875     queryset = ControllerRole.objects.select_related().all()
4876     serializer_class = ControllerRoleSerializer
4877     id_serializer_class = ControllerRoleIdSerializer
4878
4879     def get_serializer_class(self):
4880         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4881         if (no_hyperlinks):
4882             return self.id_serializer_class
4883         else:
4884             return self.serializer_class
4885
4886     def get_queryset(self):
4887         return ControllerRole.select_by_user(self.request.user)
4888
4889     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4890
4891     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4892
4893
4894
4895 class UserCredentialList(generics.ListCreateAPIView):
4896     queryset = UserCredential.objects.select_related().all()
4897     serializer_class = UserCredentialSerializer
4898     id_serializer_class = UserCredentialIdSerializer
4899     filter_backends = (filters.DjangoFilterBackend,)
4900     filter_fields = ('id','created','updated','enacted','backend_status','deleted','user','name','key_id','enc_value',)
4901
4902     def get_serializer_class(self):
4903         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4904         if (no_hyperlinks):
4905             return self.id_serializer_class
4906         else:
4907             return self.serializer_class
4908
4909     def get_queryset(self):
4910         return UserCredential.select_by_user(self.request.user)
4911
4912     def create(self, request, *args, **kwargs):
4913         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4914         if not (serializer.is_valid()):
4915             response = {"error": "validation",
4916                         "specific_error": "not serializer.is_valid()",\r
4917                         "reasons": serializer.errors}\r
4918             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4919         obj = serializer.object
4920         obj.caller = request.user
4921         if obj.can_update(request.user):
4922             return super(UserCredentialList, self).create(request, *args, **kwargs)
4923         else:
4924             raise Exception("failed obj.can_update")
4925
4926         ret = super(UserCredentialList, self).create(request, *args, **kwargs)
4927         if (ret.status_code%100 != 200):
4928             raise Exception(ret.data)
4929
4930         return ret
4931
4932
4933 class UserCredentialDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4934     queryset = UserCredential.objects.select_related().all()
4935     serializer_class = UserCredentialSerializer
4936     id_serializer_class = UserCredentialIdSerializer
4937
4938     def get_serializer_class(self):
4939         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4940         if (no_hyperlinks):
4941             return self.id_serializer_class
4942         else:
4943             return self.serializer_class
4944
4945     def get_queryset(self):
4946         return UserCredential.select_by_user(self.request.user)
4947
4948     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4949
4950     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
4951
4952
4953
4954 class SiteDeploymentsList(generics.ListCreateAPIView):
4955     queryset = SiteDeployments.objects.select_related().all()
4956     serializer_class = SiteDeploymentsSerializer
4957     id_serializer_class = SiteDeploymentsIdSerializer
4958     filter_backends = (filters.DjangoFilterBackend,)
4959     filter_fields = ('id','created','updated','enacted','backend_status','deleted','site','deployment')
4960
4961     def get_serializer_class(self):
4962         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4963         if (no_hyperlinks):
4964             return self.id_serializer_class
4965         else:
4966             return self.serializer_class
4967
4968     def get_queryset(self):
4969         return SiteDeployments.select_by_user(self.request.user)
4970
4971     def create(self, request, *args, **kwargs):
4972         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
4973         if not (serializer.is_valid()):
4974             response = {"error": "validation",
4975                         "specific_error": "not serializer.is_valid()",\r
4976                         "reasons": serializer.errors}\r
4977             return Response(response, status=status.HTTP_400_BAD_REQUEST)
4978         obj = serializer.object
4979         obj.caller = request.user
4980         if obj.can_update(request.user):
4981             return super(SiteDeploymentsList, self).create(request, *args, **kwargs)
4982         else:
4983             raise Exception("failed obj.can_update")
4984
4985         ret = super(SiteDeploymentsList, self).create(request, *args, **kwargs)
4986         if (ret.status_code%100 != 200):
4987             raise Exception(ret.data)
4988
4989         return ret
4990
4991
4992 class SiteDeploymentsDetail(PlanetStackRetrieveUpdateDestroyAPIView):
4993     queryset = SiteDeployments.objects.select_related().all()
4994     serializer_class = SiteDeploymentsSerializer
4995     id_serializer_class = SiteDeploymentsIdSerializer
4996
4997     def get_serializer_class(self):
4998         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
4999         if (no_hyperlinks):
5000             return self.id_serializer_class
5001         else:
5002             return self.serializer_class
5003
5004     def get_queryset(self):
5005         return SiteDeployments.select_by_user(self.request.user)
5006
5007     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5008
5009     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5010
5011 class ControllerSitesList(generics.ListCreateAPIView):
5012     queryset = ControllerSites.objects.select_related().all()
5013     serializer_class = ControllerSitesSerializer
5014     id_serializer_class = ControllerSiteIdSerializer
5015     filter_backends = (filters.DjangoFilterBackend,)
5016     filter_fields = ('id','created','updated','enacted','backend_status','deleted','site_deployment','controller','tenant_id',)
5017
5018     def get_serializer_class(self):
5019         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5020         if (no_hyperlinks):
5021             return self.id_serializer_class
5022         else:
5023             return self.serializer_class
5024
5025     def get_queryset(self):
5026         return ControllerSites.select_by_user(self.request.user)
5027
5028     def create(self, request, *args, **kwargs):
5029         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
5030         if not (serializer.is_valid()):
5031             response = {"error": "validation",
5032                         "specific_error": "not serializer.is_valid()",
5033                         "reasons": serializer.errors}
5034             return Response(response, status=status.HTTP_400_BAD_REQUEST)
5035         obj = serializer.object
5036         obj.caller = request.user
5037         if obj.can_update(request.user):
5038             return super(ControllerSitesList, self).create(request, *args, **kwargs)
5039         else:
5040             raise Exception("failed obj.can_update")
5041
5042         ret = super(ControllerSitesList, self).create(request, *args, **kwargs)
5043         if (ret.status_code%100 != 200):
5044             raise Exception(ret.data)
5045
5046         return ret
5047
5048 class ControllerSitesDetail(PlanetStackRetrieveUpdateDestroyAPIView):
5049     queryset = ControllerSites.objects.select_related().all()
5050     serializer_class = ControllerSitesSerializer
5051     id_serializer_class = ControllerSitesIdSerializer
5052
5053     def get_serializer_class(self):
5054         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5055         if (no_hyperlinks):
5056             return self.id_serializer_class
5057         else:
5058             return self.serializer_class
5059
5060     def get_queryset(self):
5061         return ControllerSites.select_by_user(self.request.user)
5062
5063 class SliceTagList(generics.ListCreateAPIView):
5064     queryset = SliceTag.objects.select_related().all()
5065     serializer_class = SliceTagSerializer
5066     id_serializer_class = SliceTagIdSerializer
5067     filter_backends = (filters.DjangoFilterBackend,)
5068     filter_fields = ('id','created','updated','enacted','backend_status','deleted','slice','name','value',)
5069
5070     def get_serializer_class(self):
5071         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5072         if (no_hyperlinks):
5073             return self.id_serializer_class
5074         else:
5075             return self.serializer_class
5076
5077     def get_queryset(self):
5078         return SliceTag.select_by_user(self.request.user)
5079
5080     def create(self, request, *args, **kwargs):
5081         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
5082         if not (serializer.is_valid()):
5083             response = {"error": "validation",
5084                         "specific_error": "not serializer.is_valid()",\r
5085                         "reasons": serializer.errors}\r
5086             return Response(response, status=status.HTTP_400_BAD_REQUEST)
5087         obj = serializer.object
5088         obj.caller = request.user
5089         if obj.can_update(request.user):
5090             return super(SliceTagList, self).create(request, *args, **kwargs)
5091         else:
5092             raise Exception("failed obj.can_update")
5093
5094         ret = super(SliceTagList, self).create(request, *args, **kwargs)
5095         if (ret.status_code%100 != 200):
5096             raise Exception(ret.data)
5097
5098         return ret
5099
5100
5101 class SliceTagDetail(PlanetStackRetrieveUpdateDestroyAPIView):
5102     queryset = SliceTag.objects.select_related().all()
5103     serializer_class = SliceTagSerializer
5104     id_serializer_class = SliceTagIdSerializer
5105
5106     def get_serializer_class(self):
5107         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5108         if (no_hyperlinks):
5109             return self.id_serializer_class
5110         else:
5111             return self.serializer_class
5112
5113     def get_queryset(self):
5114         return SliceTag.select_by_user(self.request.user)
5115
5116     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5117
5118     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5119
5120
5121
5122 class NetworkTemplateList(generics.ListCreateAPIView):
5123     queryset = NetworkTemplate.objects.select_related().all()
5124     serializer_class = NetworkTemplateSerializer
5125     id_serializer_class = NetworkTemplateIdSerializer
5126     filter_backends = (filters.DjangoFilterBackend,)
5127     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','description','guaranteedBandwidth','visibility','translation','sharedNetworkName','sharedNetworkId','topologyKind','controllerKind',)
5128
5129     def get_serializer_class(self):
5130         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5131         if (no_hyperlinks):
5132             return self.id_serializer_class
5133         else:
5134             return self.serializer_class
5135
5136     def get_queryset(self):
5137         return NetworkTemplate.select_by_user(self.request.user)
5138
5139     def create(self, request, *args, **kwargs):
5140         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
5141         if not (serializer.is_valid()):
5142             response = {"error": "validation",
5143                         "specific_error": "not serializer.is_valid()",\r
5144                         "reasons": serializer.errors}\r
5145             return Response(response, status=status.HTTP_400_BAD_REQUEST)
5146         obj = serializer.object
5147         obj.caller = request.user
5148         if obj.can_update(request.user):
5149             return super(NetworkTemplateList, self).create(request, *args, **kwargs)
5150         else:
5151             raise Exception("failed obj.can_update")
5152
5153         ret = super(NetworkTemplateList, self).create(request, *args, **kwargs)
5154         if (ret.status_code%100 != 200):
5155             raise Exception(ret.data)
5156
5157         return ret
5158
5159
5160 class NetworkTemplateDetail(PlanetStackRetrieveUpdateDestroyAPIView):
5161     queryset = NetworkTemplate.objects.select_related().all()
5162     serializer_class = NetworkTemplateSerializer
5163     id_serializer_class = NetworkTemplateIdSerializer
5164
5165     def get_serializer_class(self):
5166         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5167         if (no_hyperlinks):
5168             return self.id_serializer_class
5169         else:
5170             return self.serializer_class
5171
5172     def get_queryset(self):
5173         return NetworkTemplate.select_by_user(self.request.user)
5174
5175     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5176
5177     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5178
5179
5180
5181 class RouterList(generics.ListCreateAPIView):
5182     queryset = Router.objects.select_related().all()
5183     serializer_class = RouterSerializer
5184     id_serializer_class = RouterIdSerializer
5185     filter_backends = (filters.DjangoFilterBackend,)
5186     filter_fields = ('id','created','updated','enacted','backend_status','deleted','name','owner',)
5187
5188     def get_serializer_class(self):
5189         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5190         if (no_hyperlinks):
5191             return self.id_serializer_class
5192         else:
5193             return self.serializer_class
5194
5195     def get_queryset(self):
5196         return Router.select_by_user(self.request.user)
5197
5198     def create(self, request, *args, **kwargs):
5199         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
5200         if not (serializer.is_valid()):
5201             response = {"error": "validation",
5202                         "specific_error": "not serializer.is_valid()",\r
5203                         "reasons": serializer.errors}\r
5204             return Response(response, status=status.HTTP_400_BAD_REQUEST)
5205         obj = serializer.object
5206         obj.caller = request.user
5207         if obj.can_update(request.user):
5208             return super(RouterList, self).create(request, *args, **kwargs)
5209         else:
5210             raise Exception("failed obj.can_update")
5211
5212         ret = super(RouterList, self).create(request, *args, **kwargs)
5213         if (ret.status_code%100 != 200):
5214             raise Exception(ret.data)
5215
5216         return ret
5217
5218
5219 class RouterDetail(PlanetStackRetrieveUpdateDestroyAPIView):
5220     queryset = Router.objects.select_related().all()
5221     serializer_class = RouterSerializer
5222     id_serializer_class = RouterIdSerializer
5223
5224     def get_serializer_class(self):
5225         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5226         if (no_hyperlinks):
5227             return self.id_serializer_class
5228         else:
5229             return self.serializer_class
5230
5231     def get_queryset(self):
5232         return Router.select_by_user(self.request.user)
5233
5234     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5235
5236     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5237
5238
5239
5240 class ServiceResourceList(generics.ListCreateAPIView):
5241     queryset = ServiceResource.objects.select_related().all()
5242     serializer_class = ServiceResourceSerializer
5243     id_serializer_class = ServiceResourceIdSerializer
5244     filter_backends = (filters.DjangoFilterBackend,)
5245     filter_fields = ('id','created','updated','enacted','backend_status','deleted','serviceClass','name','maxUnitsDeployment','maxUnitsNode','maxDuration','bucketInRate','bucketMaxSize','cost','calendarReservable',)
5246
5247     def get_serializer_class(self):
5248         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5249         if (no_hyperlinks):
5250             return self.id_serializer_class
5251         else:
5252             return self.serializer_class
5253
5254     def get_queryset(self):
5255         return ServiceResource.select_by_user(self.request.user)
5256
5257     def create(self, request, *args, **kwargs):
5258         serializer = self.get_serializer(data=request.DATA, files=request.FILES)
5259         if not (serializer.is_valid()):
5260             response = {"error": "validation",
5261                         "specific_error": "not serializer.is_valid()",\r
5262                         "reasons": serializer.errors}\r
5263             return Response(response, status=status.HTTP_400_BAD_REQUEST)
5264         obj = serializer.object
5265         obj.caller = request.user
5266         if obj.can_update(request.user):
5267             return super(ServiceResourceList, self).create(request, *args, **kwargs)
5268         else:
5269             raise Exception("failed obj.can_update")
5270
5271         ret = super(ServiceResourceList, self).create(request, *args, **kwargs)
5272         if (ret.status_code%100 != 200):
5273             raise Exception(ret.data)
5274
5275         return ret
5276
5277
5278 class ServiceResourceDetail(PlanetStackRetrieveUpdateDestroyAPIView):
5279     queryset = ServiceResource.objects.select_related().all()
5280     serializer_class = ServiceResourceSerializer
5281     id_serializer_class = ServiceResourceIdSerializer
5282
5283     def get_serializer_class(self):
5284         no_hyperlinks = self.request.QUERY_PARAMS.get('no_hyperlinks', False)
5285         if (no_hyperlinks):
5286             return self.id_serializer_class
5287         else:
5288             return self.serializer_class
5289
5290     def get_queryset(self):
5291         return ServiceResource.select_by_user(self.request.user)
5292
5293     # update() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5294
5295     # destroy() is handled by PlanetStackRetrieveUpdateDestroyAPIView
5296
5297
5298