class TransferRecipientSerializer(serializers.Serializer): type = serializers.Serializer(required=True) name = serializers.Serializer(required=True) account_number = serializers.CharField(required=True) bank_code = serializers.CharField(required=True) description = serializers.CharField(required=False) currency = serializers.CharField(required=False) authorization_code = serializers.CharField(required=False) metadata = serializers.JSONField(required=False)
def test_instance_validator_serializer(): validator = InstanceValidator() serializer = serializers.Serializer() validator.set_context(serializer) assert validator.serializer == serializer assert validator.serializer.instance is None
def get_meta_serializer(self): default_serializer = serializers.Serializer(read_only=True) if isinstance(self.instance, Ticket): _type = self.instance.type else: _type = self.context['request'].query_params.get('type') if _type: action_serializer_classes_mapping = type_serializer_classes_mapping.get( _type) if action_serializer_classes_mapping: query_action = self.context['request'].query_params.get( 'action') action = query_action if query_action else self.context[ 'view'].action serializer_class = action_serializer_classes_mapping.get( action) if not serializer_class: serializer_class = action_serializer_classes_mapping.get( 'default') else: serializer_class = default_serializer else: serializer_class = default_serializer if not serializer_class: serializer_class = default_serializer if isinstance(serializer_class, type): serializer = serializer_class() else: serializer = serializer_class return serializer
def get_attrs_serializer(self): default_serializer = serializers.Serializer(read_only=True) if isinstance(self.instance, models.Application): _type = self.instance.type _category = self.instance.category else: _type = self.context['request'].query_params.get('type') _category = self.context['request'].query_params.get('category') if _type: serializer_class = type_serializer_classes_mapping.get(_type) elif _category: serializer_class = category_serializer_classes_mapping.get( _category) else: serializer_class = default_serializer if not serializer_class: serializer_class = default_serializer if isinstance(serializer_class, type): serializer = serializer_class() else: serializer = serializer_class return serializer
def test_instance_validator_serializer_instance(): validator = InstanceValidator() instance = object() serializer = serializers.Serializer(instance=instance) validator.set_context(serializer) assert validator.serializer == serializer assert validator.serializer.instance == serializer.instance
def api(request): print("req", request) queryset = Companies.objects.all() print("queryset", queryset) companies = Companies.objects.all().order_by('name') json = serializers.Serializer('json', companies) return HttpResponse(json)
def __call__(self, data, strict_mode=False): if self.VALIDATE_FIELD_NAME not in data: return data parameters_data = data[self.VALIDATE_FIELD_NAME] operation_type_pk = data.get(self.OPERATION_MODEL_TYPE_FIELD) if operation_type_pk is None: self.fail(f'{self.OPERATION_MODEL_TYPE_FIELD} field is required') parameters = self.parameter_model.objects.all_active( **{self.PARAMETER_MODEL_TYPE_FIELD: operation_type_pk}) parameters_serializer = serializers.Serializer(data=parameters_data) for param in parameters: parameters_serializer.fields[param.code] = self.get_field_by_param( param) if not parameters_serializer.is_valid(): self.fail(data=parameters_serializer.errors) if strict_mode: unexpected_data = set(parameters_serializer.initial_data) - set( parameters_serializer.data) # unexpected_data = {key: val for key, val in parameters_serializer.initial_data # if key not in parameters_serializer.data} if unexpected_data: self.fail(f'unexpected keywords {unexpected_data}') data[self.VALIDATE_FIELD_NAME] = parameters_serializer.data return data
def get_photo(request): # create data dictionary # picture = Picture.objects.get(pk=picture_id) all_picture = Picture.objects.filter(public=False)[:10] data = serializers.Serializer('json', all_picture) # dataJSON = MedicSerializer(all_picture, many=True) return render(request, 'portfolio/carouselv2.html', {'data': data})
def test_field_value_null(self): request = Request(self.factory.get('/', {'lang': 'en-US'})) mock_serializer = serializers.Serializer(context={'request': request}) field = self.field_class() self.addon.description_translations = {'en-US': None} field.bind('description', mock_serializer) result = field.to_representation(field.get_attribute(self.addon)) assert result is None
def test_is_field(): assert is_field(serializers.SlugField) assert is_field(serializers.SlugField()) assert not is_field(models.CharField) assert not is_field(models.CharField()) assert not is_field(serializers.Serializer) assert not is_field(serializers.Serializer())
def inline_serializer_from_fields(self, fields_dict, sub_serializer=True): attrs = { f_name: copy.deepcopy(field) for f_name, field in fields_dict.items() } serializer = type('Attributes', (serializers.Serializer, ), attrs)() if sub_serializer: serializer.bind(field_name='', parent=serializers.Serializer()) return serializer
class PetSerializer(serializers.Serializer): self = serializers.SerializerMethodField('create_self') id = serializers.CharField() images = serializers.Serializer(many=True) user_description = serializers.CharField() breed_by_user = serializers.CharField() created_at = serializers.DateTimeField() def create_self(self, pet): return urlresolvers.reverse('pets_view', kwargs=dict(id=str(pet.id)))
def list(self, request): serializer_data = datetime.now().second % 10 print(serializer_data) serializer = serializers.Serializer({"value":serializer_data}) stat = status.HTTP_200_OK print(serializer.data) if serializer_data%10 ==0: stat = status.HTTP_503_SERVICE_UNAVAILABLE return Response({ 'tags': serializer_data, }, status=stat)
def test_get_attribute_request_GET_lang(self): """ Pass a lang in the query string, expect to have a single string returned instead of an object. """ # Note that we don't go through the middlewares etc so the actual # language for the process isn't changed, we don't care as # _expect_single_string() method simply tests with the current # language, whatever it is. request = Request(self.factory.get('/', {'lang': 'lol'})) assert request.GET['lang'] == 'lol' mock_serializer = serializers.Serializer(context={'request': request}) field = self.field_class() self._test_expected_single_string(field, mock_serializer)
class LifeDataViewSet(GenericViewSet): queryset = LifeData.objects.all() serializer_class = LifeDataSerializer permission_classes = [] authentication_classes = [] lookup_field = "external_id" @swagger_auto_schema(method="post", request_body=serializers.Serializer(), responses={204: "Success"}) @action(detail=True, methods=["POST"]) def downvote(self, request, *args, **kwargs): if not validatecaptcha(request): raise CaptchaRequiredException external_id = kwargs["external_id"] try: LifeData.objects.filter(external_id=external_id).update( downvotes=F("downvotes") + 1) except: pass return Response(status=status.HTTP_204_NO_CONTENT) @swagger_auto_schema(method="post", request_body=serializers.Serializer(), responses={204: "Success"}) @action(detail=True, methods=["POST"]) def upvote(self, request, *args, **kwargs): if not validatecaptcha(request): raise CaptchaRequiredException external_id = kwargs["external_id"] try: LifeData.objects.filter(external_id=external_id).update( upvotes=F("upvotes") + 1) except: pass return Response(status=status.HTTP_204_NO_CONTENT)
def test_field_value_null(self): self.addon = addon_factory(slug='lol', name=None, description=None) request = Request(self.factory.get('/', {'lang': 'en-US'})) mock_serializer = serializers.Serializer(context={'request': request}) field = self.field_class() field.bind('name', mock_serializer) result = field.to_representation(field.get_attribute(self.addon)) assert result is None field.source = None field.bind('description', mock_serializer) result = field.to_representation(field.get_attribute(self.addon)) assert result is None
class PetCreationSerializer(serializers.Serializer): images = serializers.Serializer(many=True, required=False) # geo point (latitude, longitude) position = CoordinatesSerializer() phone_number = serializers.CharField() user_description = serializers.CharField(required=False) breed_by_user = serializers.CharField() def validate_images(self, attrs, field_name): if not field_name in attrs: return attrs for filename in attrs[field_name]: full_path = os.path.join(settings.MEDIA_ROOT, filename) if not os.path.exists(full_path): raise serializers.ValidationError( 'File "{0}" does not exist'.format(filename) ) return attrs
def test_get_attribute_request_GET_lang(self): """ Pass a lang in the query string, expect to have a single string returned instead of an object. """ # We don't go through the middlewares etc where the language for the # process would be set, so we have to manually activate the correct # locale. request = Request(self.factory.get('/', {'lang': 'es'})) assert request.GET['lang'] == 'es' mock_serializer = serializers.Serializer(context={'request': request}) with self.activate('es'): if self.addon.id: # Reload so the transformer loads the translation in the # correct locale. # (But only if it's in the database - the ES test doesn't save) self.addon = self.addon.reload() field = self.field_class() self._test_expected_single_locale(field, mock_serializer)
def get_meta_serializer(self): default_serializer = serializers.Serializer(read_only=True) if isinstance(self.instance, self.__class__.Meta.model): _type = self.instance.type else: _type = self.context['request'].query_params.get('type') if _type: serializer_class = self.storage_type_serializer_classes_mapping.get(_type) else: serializer_class = default_serializer if not serializer_class: serializer_class = default_serializer if isinstance(serializer_class, type): serializer = serializer_class() else: serializer = serializer_class return serializer
def get_serializer(self): assert hasattr(self.request, 'versioning_scheme') return serializers.Serializer()
def test_instance_validator_validation_serializer_error(): validator = InstanceValidator() validator.set_context(serializers.Serializer()) with pytest.raises(serializers.ValidationError): validator.raise_validation_error({'foo': 'bar'})
class CeleryTaskResultSerializer(ParamsSerializer): query_id = s.Serializer(label=_('任务查询ID'), required=False)
class LikeSerializer(serializers.Serializer): pk = serializers.Serializer() class Meta: fields = ('pk')
openapi.Schema( description="[min, max] values for land cover filter", type=openapi.TYPE_ARRAY, items=openapi.Items(type=openapi.TYPE_INTEGER)), 'fertility capability classification': openapi.Schema( description= "[min, max] values for fertility capability classification filter", type=openapi.TYPE_ARRAY, items=openapi.Items(type=openapi.TYPE_INTEGER)), }), responses={ status.HTTP_200_OK: serializers.Serializer({ "Bounds": {}, "Grid": { "FeatureCollection": "..." } }) }, ) @api_view(['POST']) def wider_area(request): """Get all or fitlered wider area. """ serializer_data, user = verify_auth_token(request) if not serializer_data or user["paymentLevels"] != "SECOND LEVEL" or user[ "memberOf"] != "61164207eaef91000adcfeab": return Response({"Error": "Unauthorized request"}, status=status.HTTP_403_FORBIDDEN) # NOTE: To be used for storing creds, the memberOf id I mean
def test_field_get_attribute_request_POST(self): request = Request(self.factory.post('/')) mock_serializer = serializers.Serializer() mock_serializer.context = {'request': request} field = self.field_class() self._test_expected_dict(field)
def setUp(self): self.expected_college = College(name="cbit", location="Hyderabad", acronym="cbit", contact="*****@*****.**") self.serialized_obj = serializers.Serializer(self.expected_college)
class PrinterViewSet(viewsets.ModelViewSet): queryset = Printer.objects.all() serializer_class = PrinterSerializer filter_backends = (django_filters.rest_framework.DjangoFilterBackend, ) filterset_fields = ( "name", "build_volume", "printer_type", "is_printing", "is_paused", "number_of_extruders", "has_heated_chamber", ) @swagger_auto_schema(request_body=GCODECommandSerializer) @action(detail=True, methods=["post"]) def gcode_command(self, request, pk=None): """ Endpoint that accepts the ID of the printer and list of commands NOTE: The commands aren't escaped, so be wary when using this endpoint """ serializer = GCODECommandSerializer(data=request.data) serializer.is_valid(raise_exception=True) execute_gcode_commands(printer_id=pk, **serializer.validated_data) return Response( data={ "printer_id": kwargs["printer_id"], "commands": kwargs["commands"] }, status=status.HTTP_200_OK, ) @swagger_auto_schema(request_body=DirectionSerializer) @action(detail=True, methods=["post"]) def move_axis(self, request, pk=None): """ Endpoint for moving around the tools of the printer, you can provide only one axis with one value or multiple as [x,z], [10,20] """ serializer = DirectionSerializer(data=request.data) serializer.is_valid(raise_exception=True) move_axis_printer(**serializer.validated_data, printer_id=kwargs["printer_id"]) return Response(data={**kwargs}, status=status.HTTP_200_OK) @swagger_auto_schema(request_body=JobSerializer) @action(detail=True, methods=["post"]) def start_job(self, request, pk=None): """ API endpoint for implicitly creating a one-file long queue, and therefore starting the print job # TODO this should send an exception if not ready to print NOTE: The print job won't start unless the printer is set as "ready to print" NOTE 2: If there is an existing queue, the file will be added to it """ serializer = JobSerializer(data=request.data) serializer.is_valid(raise_exception=True) printer_data = start_print_job(printer_id=pk, **serializer.validated_data) return Response( data={ "status": "The job has been started successfully", "socket_connection_info": { "ip": printer_data.ip_address, "port": printer_data.port_number, "endpoint": "/to/be/updated", }, }, status=status.HTTP_200_OK, ) # I'm passing an empty serializers so that the docs don't confuse people # Passing an empty serializer instance makes yasg generate an # empty data body, required with POST request @swagger_auto_schema(request_body=serializers.Serializer()) @action(detail=True, methods=["post"]) def pause_current_job(self, request, pk=None): """ API endpoint for pausing the current printing job. It can also be used to un-pause the job since it keeps the state """ pause_print_job(printer_id=pk) return Response( data={"status": "The job has been successfully paused"}, status=status.HTTP_200_OK, ) @swagger_auto_schema(request_body=serializers.Serializer()) @action(detail=True, methods=["post"]) def cancel_print_job(self, request, pk=None): """ API endpoint for canceling the printing job. """ cancel_print_job(**kwargs) return Response( data={"status": "The job has been canceled successfully"}, status=status.HTTP_200_OK, ) @swagger_auto_schema(request_body=PrinterTempSerializer) @action(detail=True, methods=["post"]) def set_temperature(self, request, pk=None): """ Endpoint for setting the temperature of either: tool, bed or the chamber """ data = self.PrinterTempSerializer(data=request.data) data.is_valid(raise_exception=True) set_printer_temperature(printer_id=kwargs["printer_id"], **data.validated_data) return Response( data={ "status": """ The temperature for the Bed has been successfully set to {temp} """.format(temp=data.validated_data["temperature"]) }, status=status.HTTP_200_OK, ) @swagger_auto_schema(request_body=serializers.Serializer()) @action(detail=True, methods=["post"]) def next_job(self, request, pk=None): """ API endpoint for letting the PrinterIO system know that it can safely issue next print job NOTE: this should be called by the frontend only when the user has been prompted that it is in fact safe to proceed """ call_next_job(printer_id=pk) return Response(data={"status": "Started next job successfully"}, status=status.HTTP_200_OK)
def test_get_attribute_request_GET(self): request = Request(self.factory.get('/')) mock_serializer = serializers.Serializer(context={'request': request}) field = self.field_class() self._test_expected_dict(field, mock_serializer)
def test_get_attribute_empty_context(self): mock_serializer = serializers.Serializer(context={}) field = self.field_class() self._test_expected_dict(field, mock_serializer)
def get_serializer(self, *args, **kwargs): # needed to avoid `'super' object has no attribute 'get_serializer'` # exception, raised in TokenAuthorizationMixin.get_serializer return serializers.Serializer(*args, **kwargs)