def get(self, request, format=None): """ --- parameters: - name: vnfId description: VNF ID type: string paramType: form serializer: AccountSerializer """ if self.request.query_params: vnfId = self.request.query_params.get('vnfId', None) if vnfId is not None: #find all the VNF running instances with the given VNF ID queryset = Account.objects.filter(productId=vnfId, productType=settings.VNF, status=settings.STATUS_RUNNING) serviceListing = list() try: for obj in queryset: if (obj.relatives) is not None: #find all the running services that use that VNF serviceListing.append(Account.objects.filter(status=settings.STATUS_RUNNING, productType=settings.NETWORK_SERVICE, instanceId=obj.relatives)[0]) #remove duplicates serviceListing= sorted(set(serviceListing)) serializer = AccountSerializer(serviceListing, many=True) print "vnfid: ", vnfId return Response(serializer.data) except Exception: print " [ERROR] Database malformed: the service does not exist." #raise return Response(status=status.HTTP_400_BAD_REQUEST) else: return Response(status=status.HTTP_400_BAD_REQUEST) serializer = AccountSerializer(Account.objects.filter(productType=settings.VNF, status=settings.STATUS_RUNNING), many=True) return Response(serializer.data)#, status=status.HTTP_400_BAD_REQUEST)
def user_list(request, pk=None): """ List all required messages, or create a new message. """ if request.method == 'GET': if pk: # If PrimaryKey (id) of the user is specified in the url users = Account.objects.filter( id=pk) # Select only that particular user else: users = Account.objects.all() # Else get all user list serializer = AccountSerializer(users, many=True, context={'request': request}) return JsonResponse(serializer.data, safe=False) # Return serialized data elif request.method == 'POST': data = JSONParser().parse( request ) # On POST, parse the request object to obtain the data in json serializer = AccountSerializer(data=data) # Seraialize the data if serializer.is_valid(): serializer.save() # Save it if valid return JsonResponse(serializer.data, status=201) # Return back the data on success return JsonResponse(serializer.errors, status=400) # Return back the errors if not valid
def post(self, request, ns_instance, new_status, format=None): """ --- response_serializer: AccountSerializer """ queryset = Account.objects.filter(productType=settings.NETWORK_SERVICE, instanceId=ns_instance) if queryset.exists(): jsonStatus='{"status":"' + new_status + '"}' service = queryset[0] serializer = AccountSerializer(service, data=json.loads(jsonStatus)) try: if serializer.is_valid(): #saves the new status serializer.save() print "status changed " #start/stop the SLA enforcement accordingly if (new_status == settings.STATUS_RUNNING): self.startEnforcement(service.agreementId) if (new_status == settings.STATUS_STOPPED): self.stopEnforcement(service.agreementId) #prepares and sends the message to the queue message = {} message['instanceId'] = ns_instance message['event'] = new_status #print (json.dumps(serializer.data)) send_msg(json.dumps(serializer.data)) #update the status of the participant VNFs vnf_list = service.relatives.replace(" ", "").split(",") print "VNF list: ", vnf_list for vnfInstance in vnf_list: time.sleep(1) print "VNF: ", vnfInstance vnfquery = Account.objects.filter(productType=settings.VNF, instanceId=vnfInstance) vnf = vnfquery[0] vnfserializer = AccountSerializer(vnf, many=False, data=json.loads(jsonStatus)) if vnfserializer.is_valid(): #print "VNF2: ", json.dumps(vnfserializer.data) vnfserializer.save() #start/stop the SLA enforcement accordingly if (new_status == settings.STATUS_RUNNING): self.startEnforcement(vnf.agreementId) if (new_status == settings.STATUS_STOPPED): self.stopEnforcement(vnf.agreementId) return Response(serializer.data, status=status.HTTP_201_CREATED) except ReferenceError: print " [ERROR] Could not update the messages queue" return Response(status=status.HTTP_408_REQUEST_TIMEOUT) except Exception as e: print " [ERROR] ", e return Response(status=status.HTTP_400_BAD_REQUEST) return Response(queryset, status=status.HTTP_404_NOT_FOUND)
def test_serialize(self): a_0 = ef.account() a_1 = ef.account() ci = ef.catalogue_item(name='names', created_by=a_0, maintained_by=a_1, spec=[{ 'name': 'name', 'type': 'STRING', 'is_nullable': False, 'is_enum': False, 'size': None, 'distribution': None, }], sample=[{ 'name': 'Jack' }], executor_type='ATHENA') assert CatalogueItemSerializer(ci).data == { '@type': 'catalogue_item', 'id': ci.id, 'created_by': AccountSerializer(a_0).data, 'updated_by': None, 'maintained_by': AccountSerializer(a_1).data, 'name': 'names', 'spec': [ { 'name': 'name', 'type': 'STRING', 'is_nullable': False, 'is_enum': False, 'size': None, 'distribution': None, }, ], 'sample': [{ 'name': 'Jack' }], 'executor_type': 'ATHENA', }
def account_list(request): if request.method == 'GET': account = Account.objects.all() account_serializer = AccountSerializer(account, many=True) return JSONResponse(account_serializer.data) elif request.method == 'POST': account_data = JSONParser().parse(request) account_serializer = AccountSerializer(data=account_data) if account_serializer.is_valid(): account_serializer.save() return JSONResponse(account_serializer.data, status=status.HTTP_201_CREATED) return JSONResponse(account_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_context_data(self, **kwargs): context_data = super(ImprestJVView, self).get_context_data(**kwargs) if 'form' in context_data: instance = context_data['form'].instance context_data['data'] = { 'jv': ImprestJVSerializer(instance).data, 'dr_ledgers': AccountSerializer(self.project_fy.dr_ledgers(), many=True).data, 'cr_ledgers': AccountSerializer(self.project_fy.cr_ledgers(), many=True).data, } return context_data
class InvoiceSerializer(serializers.ModelSerializer): location = LocationSerializer() invoice_type = InvoiceTypeSerializer() account = AccountSerializer() labor = LaborSerializer(many=True, required=False) services = ServiceSerializer(many=True, required=False) history = VehicleLogSerializer(many=True, required=False) class Meta: model = Invoice fields = ( "id", "invoice_number", "location", "invoice_type", "account", "receive_date", "complete_date", "year", "make", "model", "color", "vin", "stock_number", "po_number", "is_complete", "is_paid", "tax_rate", "labor", "services", "history", )
def get(self, request, format=None): """ --- parameters: - name: clientId description: Client ID type: string paramType: form serializer: AccountSerializer """ if self.request.query_params: clientId = self.request.query_params.get('clientId', None) if clientId: queryset = Account.objects.filter( status=settings.STATUS_RUNNING, productType=settings.NETWORK_SERVICE, clientId=clientId) else: return Response(status=status.HTTP_400_BAD_REQUEST) else: queryset = Account.objects.filter( status=settings.STATUS_RUNNING, productType=settings.NETWORK_SERVICE) serializer = AccountSerializer(queryset, many=True) return Response(serializer.data)
class ChatMessagesSerializer(serializers.ModelSerializer): thread = serializers.RelatedField(source='chatmessage', read_only=True) user = AccountSerializer() class Meta: model = ChatMessage fields = ['thread', 'user', 'message', 'timestamp']
class DashboardSerializer(serializers.ModelSerializer): owner = AccountSerializer(Account) class Meta: model = Dashboard fields = '__all__'
def get(self, request, vnf_instance, new_status, format=None): queryset = Account.objects.filter(productType=settings.VNF, instanceId=vnf_instance) if queryset.exists(): jsonStatus = '{"status":"' + new_status + '"}' for account in queryset: serializer = AccountSerializer(account, data=json.loads(jsonStatus)) try: if serializer.is_valid(): #saves the new status serializer.save() print "status changed " #prepares and sends the message to the queue message = {} message['instanceId'] = vnf_instance message['event'] = new_status #send_msg(json.dumps(serializer.data)) return Response(serializer.data, status=status.HTTP_201_CREATED) except ReferenceError: print " [ERROR] Could not update the messages queue" return Response(status=status.HTTP_408_REQUEST_TIMEOUT) except Exception: return Response(status=status.HTTP_400_BAD_REQUEST) return Response(queryset, status=status.HTTP_404_NOT_FOUND)
class UserSerializer(serializers.ModelSerializer): diary_list = UserDiarySerializer(many=True, read_only=True) account = AccountSerializer(many=True, read_only=True) class Meta: model = User fields = ('id', 'email', 'username', 'phone', 'account', 'diary_list')
def post(self, request, format=None): serializer = AccountSerializer(data=request.data) if serializer.is_valid(): try: if Account.objects.filter(productType=request.data['productType'], instanceId=request.data['instanceId']): print (" [ERROR] There is an entry already with that InstanceId (%s) for the same ProductType (%s)" % (request.data['instanceId'], request.data['productType'])) return Response(status=status.HTTP_400_BAD_REQUEST) serializer.save() #prepares and sends the message to the queue message = {} message['instanceId'] = request.data['instanceId'] message['event'] = request.data['status'] #send_msg(str(message)) send_msg(json.dumps(serializer.data)) #create the SLA agreements in the SLA module based on the already created templates templateId = request.data['productType']+request.data['productId']+request.data['flavour'] createAgreement(templateId, request.data['clientId'], request.data['agreementId']) #start the Agreement enforcement f = restclient.Factory(settings.SLA_URL) a_enforcement = f.enforcements() a_enforcement.start(request.data['agreementId']) except ReferenceError: print " [ERROR] Could not update the messages queue" return Response(status=status.HTTP_408_REQUEST_TIMEOUT) except Exception as e: print "DEBUG: ", e return Response(status=status.HTTP_400_BAD_REQUEST) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def accounts_delete(request): """ Function to manage the deletion of the accounts """ # Creating the default value account = None # If not declared in settings, configuring a default value # http://www.django-rest-framework.org/api-guide/exceptions/#exception-handling-in-rest-framework-views try: nfe = settings.NON_FIELD_ERRORS_KEY except AttributeError: nfe = 'non_field_errors' # Parsing data from the request and changing the creator field for the user who did the request data = JSONParser().parse(request) data['creator'] = request.user.pk # Check if all the data is valid to be used serializer = AccountSerializer(data=data) if serializer.is_valid(): # If valid, try to get the model instance to check if already exists try: account = Account.objects.get(id=serializer.validated_data['id']) # Check if the creator is who did the request if request.user.pk == account.creator.pk: account.delete() return Response({ 'status': 'ok', 'message': 'deleted' }) else: return Response( { 'errors': { nfe: 'No permissions', } }, status=status.HTTP_400_BAD_REQUEST, ) except Account.DoesNotExist: return Response( { 'errors': { nfe: 'Not exists', } }, status=status.HTTP_400_BAD_REQUEST, ) else: return Response( { 'errors': { 'data_validation_error': 'Error validating data', } }, status=status.HTTP_400_BAD_REQUEST, )
class ProjectSerializer(serializers.ModelSerializer): members = AccountSerializer(many=True, read_only=True, source='member') client = ClientSerializer(read_only=True) class Meta: model = Project fields = ('id', 'name', 'client', 'members') depth = 3
def put(self, request, pk, format=None): account = self.get_object(pk) serializer = AccountSerializer(account, data=request.data) print "request: ", request.data if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProjectCommentSerializer(serializers.ModelSerializer): project = serializers.SlugRelatedField(read_only=True, slug_field='title') user = AccountSerializer(Account) class Meta: model = ProjectComment fields = '__all__'
def test_account_getting(self): """Account should created""" # account = Account.objects.create_user('*****@*****.**', 'password') test_account = Account.objects.latest('created_at') self.assertEqual(test_account.email, self.account.email) serialized_account = AccountSerializer(test_account) self.assertEqual(serialized_account.data.get('email'), self.account.email) self.assertEqual(serialized_account.data.get('first_name'), self.account.first_name) self.assertEqual(serialized_account.data.get('is_active'), None)
def get(self, request, format=None): """ --- response_serializer: AccountSerializer """ accounts = Account.objects.all() serializer = AccountSerializer(accounts, many=True) return Response(serializer.data)
def setUp(self): self.account_data = { 'username': '******', 'email': '*****@*****.**', 'password': '******' } self.account = Account(**self.account_data) self.account.save() self.serializer = AccountSerializer(data=self.account_data)
def test_serialize(self): a = ef.account() assert AccountSerializer(a).data == { '@type': 'account', 'id': a.id, 'email': a.email, 'type': a.type, }
def post(self, request): if request.user.is_authenticated: serializer = AccountSerializer(data=request.data) if serializer.is_valid(): serializer.save(owner=request.user) return JsonResponse(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) return Response(status=status.HTTP_401_UNAUTHORIZED)
def test_validate_raises_max_backups_is_non_number(self): data = { 'username': '******', 'email': '*****@*****.**', 'password': '******', 'max_backups': 'f' } serializer = AccountSerializer(data=data) self.assertRaises(serializers.ValidationError, serializer.validate, *(data, ))
def search(request): data = {} search_term = request.GET['q'] tags = request.GET['type'].split(",") offset, limit = get_offset_limit(request=request) for tag in tags: addition = '&q=' + search_term + '&type=' + tag if tag == 'restaurant': restaurants = Restaurant.objects.filter( name__icontains=search_term)[offset:offset + limit + 1] next = pagination_maker(request=request, offset=offset, limit=limit, more=restaurants[limit:]) restaurant_list = [] for restaurant in restaurants[:limit]: restaurant_serializer = RestaurantSerializer(restaurant) restaurant_list.append(restaurant_serializer.data) data['restaurants'] = {'items': restaurant_list} data['restaurants']['next'] = next elif tag == 'user': accounts = Account.objects.filter( Q(first_name__icontains=search_term) | Q(last_name__icontains=search_term))[offset:offset + limit + 1] next = pagination_maker(request=request, offset=offset, limit=limit, more=accounts[limit:]) accounts_list = [] for account in accounts: account_serializer = AccountSerializer(account) accounts_list.append(account_serializer.data) data['users'] = {'items': accounts_list} data['users']['next'] = next return Response(data)
class ProjectSerializer(serializers.ModelSerializer): client = AccountSerializer(Account) client_dashboard = DashboardSerializer(Dashboard) freelancer_dashboard = DashboardSerializer(Dashboard) tags = TagSerializer(many=True) compensation = CompensationSerializer(Compensation) class Meta: model = Project fields = '__all__'
def get(self, request, userId, format=None): """ --- parameters: - name: userId description: User ID type: string paramType: form serializer: AccountSerializer """ queryset = Account.objects.filter(status=settings.STATUS_RUNNING, productType=settings.VNF, clientId=userId) serializer = AccountSerializer(queryset, many=True) return Response(serializer.data)
def post(self, request): data = request.data.copy() data['password'] = gen_password(len_to=10) serializer = AccountSerializer(data=data) if serializer.is_valid(): serializer.save() threading.Thread(target=self._send_credentials, kwargs=data).start() return Response({'detail': 'account has been created'}, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request: Request, *args: Any, **kwargs: Any): username = request.data.get('username', None) email = request.data.get('email', None) password = request.data.get('password', None) if not username or not password or not email: return Response(status=403) user = User.objects.create_user(username, email, password) user_profile = UserProfile.objects.create(user=user) django_login(request, user) return Response(AccountSerializer(user_profile).data)
def account_detail(request, pk): try: account = Account.objects.get(pk=pk) except Account.DoesNotExist: return HttpResponse(status=status.HTTP_400_BAD_REQUEST) if request.method == 'GET': account_serializer = AccountSerializer(account) return JSONResponse(account_serializer.data) elif request.method == 'PUT': account_data = JSONParser().parse(request) account_serializer = AccountSerializer(account, data=account_data) if account_serializer.is_valid(): account_serializer.save() return JSONResponse(account_serializer.data) return JSONResponse(account_serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': account.delete() return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def post(request): account = Account.get_by_pk(request.user.username) if account is None: return Response({'detail': 'account is not found'}, status=status.HTTP_404_NOT_FOUND) serializer = AccountSerializer(instance=account, data=request.data) if serializer.is_valid(): serializer.save() return Response({'detail': 'account has been edited'}, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)