def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        ret = OrderedDict()
        errors = OrderedDict()
        fields = [
            field for field in self.fields.values()
            if (not field.read_only) or (field.default is not empty)
        ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #2
0
    def loop_fields(self, data, errors):
        fields = self._writable_fields
        ret = OrderedDict()

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)

            # ---- start core code ----
            get_value_method = getattr(self, 'get_' + field.field_name, None)
            if get_value_method:
                primitive_value = get_value_method(field, data)
            else:
                primitive_value = field.get_value(data)
            # ---- end core code ----

            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        return ret
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        ret = OrderedDict()
        errors = OrderedDict()
        fields = [
            field for field in self.fields.values()
            if (not field.read_only) or (field.default is not empty)
        ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
    def to_internal_value(self, data):
        ret = super().to_internal_value(data)
        set_value(ret, ['type_'], data['type_'])
        if data['type_'] == 'campaign':
            set_value(ret, ['campaign'], data['campaign'])

        return ret
    def field_to_internal_value(self, field, data):
        ret = OrderedDict()
        errors = OrderedDict()

        validate_method = getattr(
            self,
            'validate_' +
            field.field_name,
            None)
        primitive_value = field.get_value(data)
        try:
            validated_value = field.run_validation(primitive_value)
            if validate_method is not None:
                validated_value = validate_method(validated_value)
        except ValidationError as exc:
            errors[field.field_name] = exc.detail
        except DjangoValidationError as exc:
            errors[field.field_name] = list(exc.messages)
        except SkipField:
            pass
        else:
            set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, Mapping):
            message = self.error_messages["invalid"].format(datatype=type(data).__name__)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [message]}, code="invalid")

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, "validate_" + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            self.error_list.update(errors)
            # Raise a CustomValidationErrors with the list of ValidationErrors
            raise CustomValidationErrors(error_list=errors)

        return ret
 def transform(self, data, request, obj, forwards):
     method_prefix = 'forwards_' if forwards else 'backwards_'
     kwargs = {
         'data': data,
         'request': request
     }
     if not forwards:
         kwargs['obj'] = obj
     if self.for_field:
         return getattr(self, method_prefix + 'field')(
             **kwargs
         )
     elif self.for_serializer:
         return getattr(self, method_prefix + 'serializer')(
             **kwargs
         )
     else:
         if forwards:
             value = self.field.get_value(data)
         else:
             value = self.field.get_attribute(obj)
         kwargs['data'] = data[self.field]
         transformed_value = getattr(self, method_prefix + 'specific_field')(
             obj=obj,
             data=value,
             request=request
         )
         if forwards:
             set_value(data, self.field.source_attrs, value)
         else:
             data[self.field.field_name] = transformed_value
         return data
Example #8
0
    def to_internal_value(self, data):
        if not isinstance(data, dict):
            message = self.error_messages["invalid"].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, "validate_" + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        return ret, errors
Example #9
0
    def to_internal_value(self, data):
        """
        Overrides the default deserialization to look up related objects that
        are needed to create/update the correct models.
        """
        out_data = {
            'program': self.root.instance,
            'course_code': self._get_course_code(data)
        }  # pylint: disable=no-member

        # handle run_modes if present
        if 'run_modes' in data:
            # NB this next block is based on `ModelSerializer.to_internal_value`
            # but has to be duplicated here because the superclass' method is
            # incompatible with nested writes.
            errors = {}
            try:
                validated_value = self.fields['run_modes'].run_validation(
                    data['run_modes'])
            except exceptions.ValidationError as exc:
                errors['run_modes'] = exc.detail
            else:
                fields.set_value(out_data,
                                 self.fields['run_modes'].source_attrs,
                                 validated_value)

            if errors:
                raise exceptions.ValidationError(errors)

        return out_data
Example #10
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        from rest_framework.fields import get_error_detail, set_value
        from collections import OrderedDict
        from django.core.exceptions import ValidationError as DjangoValidationError

        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='invalid')

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            primitive_value = field.get_value(data)

            try:

                # ManyRelatedField 取消写入数据验证, 防止每次都去查询数据库
                if isinstance(field, ManyRelatedField) and isinstance(
                        field.child_relation, PrimaryKeyRelatedField
                ) and primitive_value is not empty:
                    if not isinstance(primitive_value, (list, tuple)):
                        raise ValidationError()
                    validated_value = [int(i) for i in primitive_value]
                else:
                    validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #11
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise drf_fields.ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]})

        ret = OrderedDict()
        errors = OrderedDict()

        if data['_cls']:
            cls = get_document(data['_cls'])
            if not issubclass(cls, self.Meta.model):
                #not playing the 'pass anything in, and we'll construct it for you' game
                cls = self.Meta.model
        else:
            cls = self.Meta.model

        fields = self.chainmap[cls]

        fields = [
            field for name, field in fields.items() if not field.read_only
        ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except drf_fields.ValidationError as exc:
                errors[field.field_name] = exc.detail
            except drf_fields.DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                drf_fields.set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise drf_fields.ValidationError(errors)

        return ret
    def to_internal_value(self, data):
        ret = super(NestedModelSerializer, self).to_internal_value(data)

        # So, in the case that this object is nested, we really really need the id.
        if getattr(self, 'parent', None):
            child_model = self.Meta.model
            pk_field_name = child_model._meta.pk.name

            pk_field = self.fields[pk_field_name]

            primitive_value = pk_field.get_value(data)
            set_value(ret, pk_field.source_attrs, primitive_value)

            errors = OrderedDict()

        return ret
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise drf_fields.ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = OrderedDict()
        errors = OrderedDict()

        if data['_cls']:
            cls = get_document(data['_cls'])
            if not issubclass(cls, self.Meta.model):
                #not playing the 'pass anything in, and we'll construct it for you' game
                cls = self.Meta.model
        else:
            cls = self.Meta.model

        fields = self.chainmap[cls]

        fields = [field for name, field in fields.items() if not field.read_only]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except drf_fields.ValidationError as exc:
                errors[field.field_name] = exc.detail
            except drf_fields.DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                drf_fields.set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise drf_fields.ValidationError(errors)

        return ret
 def to_internal_value(self, data):
     """
     Dict of native values <- Dict of primitive datatypes.
     After calling super, we handle dynamic data which is not handled by super class
     """
     ret = super(DocumentSerializer, self).to_internal_value(data)
     [drf_fields.set_value(ret, [k], data[k]) for k in data if k not in ret]
     return ret
Example #15
0
 def to_internal_value(self, data):
     """
     Dict of native values <- Dict of primitive datatypes.
     After calling super, we handle dynamic data which is not handled by super class
     """
     ret = super(DocumentSerializer, self).to_internal_value(data)
     [drf_fields.set_value(ret, [k], data[k]) for k in data if k not in ret]
     return ret
Example #16
0
    def to_internal_value(self, data):
        """Verbatim copy of the original drf `to_internal_value()` method.

        This method replicates the implementation found on
        `restframework.serializers.Serializer.to_internal_value` method because the
        dynamic-rest package (which we are using, and which overrides the base
        implementation) adds some custom stuff on top of it which depends on the input
        data containing the instance's `id` property, which we are not requiring.

        A HarvestableResource's `id` is an implementation detail that is not exposed
        publicly. We rely on the instance's `unique_identifier` instead.

        """

        if not isinstance(data, typing.Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise exceptions.ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            }, code='invalid')

        ret = collections.OrderedDict()
        errors = collections.OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, f"validate_{field.field_name}", None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except exceptions.ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise exceptions.ValidationError(errors)

        return ret
Example #17
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='invalid')

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields
        for field in fields:

            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            field_name = field.field_name
            field_data = data.get(field_name)
            if field_name == 'address':
                primitive_value = json.loads(field_data)
            elif field_name == 'photo' and isinstance(field_data, str):
                continue
            elif field_name == 'owner' and field_data is None:
                primitive_value = User.objects.get(is_admin=True).id
            else:
                primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)
        return ret
    def to_internal_value(self, data):
        try:
            ret = super(NestedModelSerializer, self).to_internal_value(data)
        except AssertionError:
            raise ValidationError({self.__class__.__name__: "Cannot descend and create nested objects."})

        # So, in the case that this object is nested, we really really need the id.
        if getattr(self, 'parent', None):
            child_model = self.Meta.model
            pk_field_name = child_model._meta.pk.name

            pk_field = self.fields[pk_field_name]

            primitive_value = pk_field.get_value(data)
            set_value(ret, pk_field.source_attrs, primitive_value)

            errors = OrderedDict()

        return ret
Example #19
0
  def to_internal_value(self, data):
    if not isinstance(data, dict):
      message = self.error_messages['invalid'].format(
          datatype=type(data).__name__
      )
      raise ValidationError({
          api_settings.NON_FIELD_ERRORS_KEY: [message]
      })

    def append_error(field, key, error):
      if errors.get(field, None) is None:
        errors[field] = dict()
      errors[field][key] = error

    ret = OrderedDict()
    errors = OrderedDict()
    fields = self._writable_fields

    for field in fields:
      validate_method = getattr(self, 'validate_' + field.field_name, None)
      primitive_value = field.get_value(data)

      try:
        validated_value = field.run_validation(primitive_value)
        if validate_method is not None:
          validated_value = validate_method(validated_value)
      except ValidationError as exc:
        code = getattr(exc, 'code', None)
        if code is not None:
          append_error(field.field_name, code, ' '.join(exc.detail))
        else:
          errors[field.field_name] = ' '.join(exc.detail)
      except DjangoValidationError as exc:
        errors[field.field_name] = ' '.join(exc.messages)
      except serializers.SkipField:
        pass
      else:
        rest_fields.set_value(ret, field.source_attrs, validated_value)
      if errors:
        raise ValidationError(errors)

    return ret
Example #20
0
    def to_internal_value(self, data):
        """
                Dict of native values <- Dict of primitive datatypes.
                """
        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='invalid')

        data['attributes'] = []
        # resource_id = data['id']
        ret = OrderedDict()
        ret['type'] = self.resourceDefined
        errors = OrderedDict()
        fields = self._writable_fields

        for k, v in self.attr_map.items():
            data['attributes'].append({
                'value': data.get(k, None),
                'attributeDefined': v[0],
                'resourcetype': v[1]
            })
        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)
        if errors:
            raise ValidationError(errors)
        return ret
Example #21
0
    def to_internal_value(self, data):
        """
        In order to be able to handle passing tag_name in array,
        we need to overwrite this method to bypass run_validation for tags
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                if field.field_name != 'tags':
                    validated_value = field.run_validation(primitive_value)
                else:
                    validated_value = primitive_value

                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #22
0
    def to_internal_value(self, data):
        """
        In order to be able to handle passing tag_name in array,
        we need to overwrite this method to bypass run_validation for tags
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                if field.field_name != 'tags':
                    validated_value = field.run_validation(primitive_value)
                else:
                    validated_value = primitive_value

                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #23
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            }, code='invalid')

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            if field.field_name == 'company':
                continue

            validate_method = getattr(
                self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #24
0
    def to_internal_value(self, data):
        try:
            ret = super(NestedModelSerializer, self).to_internal_value(data)
        except AssertionError:
            raise ValidationError({
                self.__class__.__name__:
                "Cannot descend and create nested objects."
            })

        # So, in the case that this object is nested, we really really need the id.
        if getattr(self, 'parent', None):
            child_model = self.Meta.model
            pk_field_name = child_model._meta.pk.name

            pk_field = self.fields[pk_field_name]

            primitive_value = pk_field.get_value(data)
            set_value(ret, pk_field.source_attrs, primitive_value)

            errors = OrderedDict()

        return ret
Example #25
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        ret = OrderedDict()
        errors = OrderedDict()
        fields = [
            field for field in self.fields.values()
            if (not field.read_only) or (field.default is not empty)
            ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[unicode(field.label)] = exc.detail
            except DjangoValidationError as exc:
                errors[unicode(field.label)] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #26
0
    def to_internal_value_fields(self, data, fields=None):
        """
        This is basically a copy of the super.to_internal_value(), but we need the option to only use certain fields.
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__
            )
            raise ValidationError({
                api_settings.NON_FIELD_ERRORS_KEY: [message]
            })

        validated_values = OrderedDict()
        errors = OrderedDict()
        fields = fields or [
            field for field in self.fields.values()
            if (not field.read_only) or (field.default is not empty)
        ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(validated_values, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return validated_values
Example #27
0
    def to_internal_value_fields(self, data, fields=None):
        """
        This is basically a copy of the super.to_internal_value(), but we need the option to only use certain fields.
        """
        if not isinstance(data, dict):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]})

        validated_values = OrderedDict()
        errors = OrderedDict()
        fields = fields or [
            field for field in self.fields.values()
            if (not field.read_only) or (field.default is not empty)
        ]

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            primitive_value = field.get_value(data)
            try:
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = list(exc.messages)
            except SkipField:
                pass
            else:
                set_value(validated_values, field.source_attrs,
                          validated_value)

        if errors:
            raise ValidationError(errors)

        return validated_values
Example #28
0
        def to_internal_value(self, data):
            ret = OrderedDict()
            errors = OrderedDict()

            for field in tenant_specific_fields_definitions:
                validators = []
                for validator_instance in field.validators.all():
                    validator_function = import_from_string(
                        validator_instance.module_path)
                    validators.append(validator_function)

                validate_method = compose_list(validators)

                primitive_value = self.fields.get(field.name).get_value(data)
                try:
                    validated_value = self.fields.get(
                        field.name).run_validation(primitive_value)
                    if validate_method is not None:
                        validated_value = validate_method(validated_value)
                except serializers.ValidationError as exc:
                    errors[field.name] = exc.detail
                except DjangoValidationError as exc:
                    errors[field.name] = get_error_detail(exc)
                except SkipField:
                    pass
                else:
                    set_value(ret,
                              self.fields.get(field.name).source_attrs,
                              validated_value)

            if errors:
                raise serializers.ValidationError(errors)

            data.update(dict(ret))

            ret = super(TenantSpecificTableRowSerializer,
                        self).to_internal_value(data)

            return ret
Example #29
0
        def to_internal_value(self, data):
            """
            Dict of native values <- Dict of primitive datatypes.
            """
            if not isinstance(data, Mapping):
                message = self.error_messages['invalid'].format(
                    datatype=type(data).__name__
                )
                raise ValidationError({
                    api_settings.NON_FIELD_ERRORS_KEY: [message]
                }, code='invalid')

            ret = OrderedDict()
            errors = OrderedDict()
            fields = self._writable_fields

            for field in fields:
                validate_method = getattr(self,
                                          'validate_' + field.field_name,
                                          None)
                primitive_value = field.get_value(data)
                try:
                    validated_value = field.run_validation(primitive_value)
                    if validate_method is not None:
                        validated_value = validate_method(validated_value)
                except ValidationError as exc:
                    errors[field.field_name] = exc.detail
                except DjangoValidationError as exc:
                    errors[field.field_name] = get_error_detail(exc)
                except SkipField:
                    pass
                else:
                    set_value(ret, field.source_attrs, validated_value)

            if errors:
                raise ValidationError(errors)

            return ret
Example #30
0
    def ParseStrFilter(self, _str):
        ret = dict()
        str_filter = ''
        ar_obj = _str.split('=')
        str_field_name = ar_obj[0].split('[')[0]
        str_operator = None

        is_not = False
        is_or = False

        if str_field_name[0:4] == 'or__':
            is_or = True
            str_field_name = str_field_name[4:]

        if '[' in ar_obj[0]:
            str_operator = ar_obj[0].split('[')[1].split(']')[0]
            if str_operator == "not_in":
                is_not = True
                str_operator = "in"

        str_filter = str_field_name
        if str_operator != None:
            str_filter += "__" + str_operator
        value = ar_obj[1]

        fields = self._writable_fields
        for field in fields:
            if field.field_name == "str_field":
                set_value(ret, field.source_attrs, str_field_name)
            elif field.field_name == "str_value":
                set_value(ret, field.source_attrs, value)
            elif field.field_name == "str_operator":
                set_value(ret, field.source_attrs, str_operator)
            elif field.field_name == "is_not":
                set_value(ret, field.source_attrs, is_not)
            elif field.field_name == "is_or":
                set_value(ret, field.source_attrs, is_or)
        return ret
Example #31
0
    def to_internal_value(self, data):
        """
        Overrides the default deserialization to look up related objects that
        are needed to create/update the correct models.
        """
        out_data = {'program': self.root.instance, 'course_code': self._get_course_code(data)}  # pylint: disable=no-member

        # handle run_modes if present
        if 'run_modes' in data:
            # NB this next block is based on `ModelSerializer.to_internal_value`
            # but has to be duplicated here because the superclass' method is
            # incompatible with nested writes.
            errors = {}
            try:
                validated_value = self.fields['run_modes'].run_validation(data['run_modes'])
            except exceptions.ValidationError as exc:
                errors['run_modes'] = exc.detail
            else:
                fields.set_value(out_data, self.fields['run_modes'].source_attrs, validated_value)

            if errors:
                raise exceptions.ValidationError(errors)

        return out_data
Example #32
0
    def to_internal_value(self, data):
        logging.info("MedRecordSerializer: To to_internal_value")
        ret = OrderedDict()
        errors = OrderedDict()
        # operator_id required
        # if not 'operator_id' in data:
        operator_id = data.get('operator_id', None)
        if not operator_id:
            error = "Error: operator_id is required"
            logging.error(error)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        else:
            # operator_id must be in Staff list
            operator_id = data.get('operator_id', False)
            staff_q = Staff.objects.filter(mis_id=data['mis_id'], mis_staff_id=operator_id)
            if not staff_q.exists():
                error = "Error: operator_id must be in staff list"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
            data['operator_id'] = staff_q.first().id

        patient_address_src = data.get('patient_address_src', None)
        if patient_address_src:
            patient_address_src_qs = AddrDocType.objects.filter(name=patient_address_src)
            if patient_address_src_qs.exists():
                patient_address_src_obj = patient_address_src_qs.first()
                data['patient_address_src'] = patient_address_src_obj.id
            else:
                error = f"Bad patient_address_src: {data['patient_address_src']}"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        else:
            data['patient_address_src'] = 1     # Невідомо

        noresult = data.get('noresult', None)
        if noresult:
            noresult_qs = NoResult.objects.filter(name=noresult)
            if noresult_qs.exists():
                noresult_obj = noresult_qs.first()
                data['noresult'] = noresult_obj.id
            else:
                error = f"Bad noresult: {data['noresult']}"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        else:
            data['noresult'] = 1  # Результативний

        hospital = data.get('hospital', None)
        if hospital:
            data['is_hospital_record'] = True
        else:
            data['is_hospital_record'] = False

        if not self.instance:
            call_card_id = data.get('call_card_id', False)
            if not call_card_id:
                error = "Error: call_card_id is required!"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
            else:
                #call_card_id = data.get('call_card_id', False)
                call_card_qs = CallCard.objects.filter(call_card_id=call_card_id)
                if call_card_qs.exists():
                    call_card_obj = call_card_qs.first()
                    if int(call_card_obj.mis_id.id) != int(data['mis_id']):
                        error = f"CallCard [{data['call_card_id']}] doesnt belong to MIS [{data['mis_id']}]"
                        logging.error(error)
                        raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                    data['callcard'] = call_card_obj.id
                    if call_card_obj.crew_id:
                        data['crew'] = call_card_obj.crew_id.id
                    else:
                        error = f"MedRecord: No crew in related CallCard {call_card_obj.call_card_id}"
                        logging.error(error)
                        raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                else:
                    error = f"Bad call_card_id: {data['call_card_id']}"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})

        fields = self._writable_fields
        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = data.get(field.source_attrs[0], False)
            if primitive_value:
                try:
                    validated_value = field.run_validation(primitive_value)
                    if validate_method is not None:
                        validated_value = validate_method(validated_value)
                except ValidationError as exc:
                    errors[field.field_name] = exc.detail
                except DjangoValidationError as exc:
                    errors[field.field_name] = get_error_detail(exc)
                except SkipField:
                    pass
                else:
                    set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        #ret = super().to_internal_value(data=data)
        return ret
Example #33
0
    def to_internal_value(self, data):
        logging.info("CrewSerializer: To to_internal_value")
        ret = OrderedDict()
        errors = OrderedDict()
        mis_car_id = data.get('mis_car_id', False)
        if self.instance == None:
            if mis_car_id:
                mis_car_q = Cars.objects.filter(mis_id=data['mis_id'],
                                                mis_car_id=mis_car_id)
                if mis_car_q.exists():
                    data['car_id'] = mis_car_q.first().id
                else:
                    error = "CrewSerializer. Crew mis_car_id does not exist"
                    logging.error(error)
                    raise ValidationError(
                        {api_settings.NON_FIELD_ERRORS_KEY: [error]})
            else:
                crew_comment = data.get('crew_comment', None)
                if crew_comment:
                    data['car_id'] = None
                    logging.info(f'CrewSerializer: setting car_id to null')
                else:
                    error = "CrewSerializer. Crew mis_car_id or crew_comment required"
                    logging.error(error)
                    raise ValidationError(
                        {api_settings.NON_FIELD_ERRORS_KEY: [error]})

            mis_facility_id = data.get('mis_facility_id', False)
            if mis_facility_id:
                facility_q = Facility.objects.filter(
                    mis_id=data['mis_id'], mis_facility_id=mis_facility_id)
                if facility_q.exists():
                    data['facility_id'] = facility_q.first().id
                else:
                    error = "CrewSerializer. Crew mis_facility_id does not exist"
                    logging.error(error)
                    raise ValidationError(
                        {api_settings.NON_FIELD_ERRORS_KEY: [error]})
            else:
                if self.instance == None:
                    error = "CrewSerializer. Crew mis_facility_id required"
                    logging.error(error)
                    raise ValidationError(
                        {api_settings.NON_FIELD_ERRORS_KEY: [error]})

        crew_status = data.get('crew_status', False)
        if crew_status:
            if crew_status.isdigit():
                data['crew_status'] = crew_status
            else:
                q_qs = CrewStatus.objects.filter(crewstatus_name=crew_status)
                if q_qs.exists():
                    data['crew_status'] = q_qs.first().id
                else:
                    error = f"Error: crew_status is unknown: {crew_status}"
                    logging.error(error)
                    raise ValidationError(
                        {api_settings.NON_FIELD_ERRORS_KEY: error})
        else:
            if self.instance == None:
                data['crew_status'] = None

        if self.instance == None:
            ret = super().to_internal_value(data=data)
        else:
            fields = self._writable_fields
            for field in fields:
                validate_method = getattr(self, 'validate_' + field.field_name,
                                          None)
                primitive_value = data.get(field.source_attrs[0], False)
                if primitive_value:
                    try:
                        validated_value = field.run_validation(primitive_value)
                        if validate_method is not None:
                            validated_value = validate_method(validated_value)
                    except ValidationError as exc:
                        errors[field.field_name] = exc.detail
                    except DjangoValidationError as exc:
                        errors[field.field_name] = get_error_detail(exc)
                    except SkipField:
                        pass
                    else:
                        # print(f'Setting: {field.source_attrs}:{validated_value}')
                        set_value(ret, field.source_attrs, validated_value)

            if errors:
                raise ValidationError(errors)

        return ret
Example #34
0
 def to_representation(self, instance):
     ret = super().to_representation(instance)
     refresh = self.get_token(self.user)
     set_value(ret, ['refresh'], str(refresh))
     set_value(ret, ['access'], str(refresh.access_token))
     return ret
Example #35
0
    def to_internal_value(self, data):
        """
        Monkey patch the validate empty values function of the serializers fields. This way the validation that checks
        if fields are required also works on partial updates (PATCH) requests.
        """
        def custom_validate_empty_values(self, data):
            """
            The custom validate empty function that always checks for empty values, even on partial update.
            """
            if self.read_only:
                return (True, self.get_default())

            if data is empty:
                # The partial_update check is removed here.
                if self.required:
                    self.fail('required')
                return (True, self.get_default())

            if data is None:
                if not self.allow_null:
                    self.fail('null')
                return (True, None)

            return (False, data)

        if self.root.partial and 'id' not in data:
            for field in self.fields.values():
                # This is the actual monkey patching part.
                funcType = type(field.validate_empty_values)
                field.validate_empty_values = funcType(custom_validate_empty_values, field, field.__class__)

        if isinstance(data, dict) and 'id' in data:  # Set the instance so validators work properly
            try:
                self.instance = self.Meta.model.objects.get(pk=data.get('id'))
            except ObjectDoesNotExist:
                pass

            if not self.create_only and len(data) == 1:
                ret = OrderedDict()
                errors = OrderedDict()

                field = self.fields['id']
                validate_method = getattr(self, 'validate_id', None)

                primitive_value = field.get_value(data)
                try:
                    validated_value = field.run_validation(primitive_value)
                    if validate_method is not None:
                        validated_value = validate_method(validated_value)
                except ValidationError as exc:
                    errors[field.field_name] = exc.detail
                except DjangoValidationError as exc:
                    errors[field.field_name] = list(exc.messages)
                except SkipField:
                    pass
                else:
                    set_value(ret, field.source_attrs, validated_value)

                if errors:
                    raise ValidationError(errors)

                return ret

        model_cls = self.root.Meta.model
        instance = self.root.instance
        content_type = ContentType.objects.get_for_model(model_cls)

        generic_related_fields = [field.name for field in model_cls._meta.virtual_fields]

        if self.parent.field_name in generic_related_fields:
            data['content_type'] = content_type.pk

            if instance:
                data['object_id'] = instance.pk
            else:
                # Remove unique together validator because we are creating so it's always unique.
                self.validators = [validator for validator in self.validators if not isinstance(validator, UniqueTogetherValidator)]

        return super(RelatedSerializerMixin, self).to_internal_value(data)
 def to_internal_value(self, data):
     ret = super(DocumentSerializer, self).to_internal_value(data)
     [drf_fields.set_value(ret, [k], data[k]) for k in data if k not in ret]
     return ret
Example #37
0
 def to_internal_value(self, data):
     contacts = data.pop('contacts', None)
     ret = super().to_internal_value(data)
     set_value(ret, ['contacts'], contacts)
     return ret
Example #38
0
 def to_internal_value(self, data):
     ret = super(DocumentSerializer, self).to_internal_value(data)
     [drf_fields.set_value(ret, [k], data[k]) for k in data if k not in ret]
     return ret
Example #39
0
 def to_internal_value(self, data):
     ret = super().to_internal_value(data)
     if 'groups' in data:
         set_value(ret, ['groups'], data['groups'])
     return ret
Example #40
0
    def to_internal_value(self, data):
        """
        Dict of native values <- Dict of primitive datatypes.
        """
        if not isinstance(data, Mapping):
            message = self.error_messages['invalid'].format(
                datatype=type(data).__name__)
            raise ValidationError(
                {api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='invalid')

        ret = OrderedDict()
        errors = OrderedDict()
        fields = self._writable_fields

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name,
                                      None)
            primitive_value = field.get_value(data)

            if isinstance(primitive_value, str) and isinstance(
                    field, serializers.HyperlinkedRelatedField):
                # we need this because DRF HyperlinkedRelatedField is not fully compatible with Django 2.0+
                # when dealing with spaces in the URL (e.g. when we do lookup by name).
                # The issue has been reported and reopened, see the description here:
                # - https://github.com/encode/django-rest-framework/issues/4748
                # Once it is resolved there, we won't need this line anymore
                primitive_value = unquote(primitive_value)

            try:
                # For create only
                if not self.partial and hasattr(self, 'initial_data') and isinstance(primitive_value, dict) \
                        and 'url' in primitive_value:
                    model_class = field.Meta.model
                    pk = self._get_related_pk(primitive_value,
                                              model_class,
                                              related_field=field)
                    if pk:
                        obj = model_class.objects.filter(pk=pk, ).first()
                        serializer = self._get_serializer_for_field(
                            field,
                            instance=obj,
                        )
                        primitive_value = {
                            k: v
                            for k, v in serializer.data.items()
                        }
                        self.initial_data[field.field_name] = primitive_value
                validated_value = field.run_validation(primitive_value)
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
Example #41
0
    def to_internal_value(self, data):
        logging.info("CallCardSerializer: To to_internal_value")
        ret = OrderedDict()
        errors = OrderedDict()

        if not 'mis_id' in data:
            mis_obj = Mis.objects.get(mis_user=data['mis_user'])
            data['mis_id'] = mis_obj.id
            data['mis_user'] = mis_obj.mis_user.id
        data['start_datetime'] = data.get('start_datetime', timezone.now().isoformat())
        try:
            instance_start = datetime.fromisoformat(data['start_datetime'])
        except Exception as ex:
            logging.error(f"CallCardSerializer:: invalid start_datetime: {data['start_datetime']}")
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [ex]})

        data['call_station'] = data.get('call_station', "1")
        if data['start_datetime'] == "":
            error = "start_date_time may not be an empty string"
            logging.error(error)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})

        crew_id = data.get('crew_id', False)
        if crew_id:
            crew_q = Crew.objects.filter(mis_id=data['mis_id'],
                                         crew_id=data['crew_id'])
            if crew_q.exists():
                crew_obj = crew_q.first()
                if int(crew_obj.mis_id.id) != int(data['mis_id']):
                    error = f"Crew [{data['crew_id']}] doesnt belong to MIS [{data['mis_id']}]"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                data['crew_id'] = crew_obj.id
            else:
                error = f"Bad mis_id:crew_id: {data['mis_id']}: {data['crew_id']}"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})

        call_station = data.get('call_station', "1")
        if (type(call_station) == int) or call_station.isdigit():
            station_obj = CallStations.objects.get(id=call_station)
            if station_obj == None:
                error = f"Bad callStation: {call_station}"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
            data['call_station'] = station_obj.id
        else:
            station_obj = CallStations.objects.filter(station_name=call_station).first()
            if station_obj == None:
                error = f"Bad callStation: {call_station}"
                logging.error(error)
                raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
            data['call_station'] = station_obj.id
        call_priority = data.get('call_priority', False)
        if call_priority:
            if (type(call_priority) == int) or call_priority.isdigit():
                priority_obj = CallPriority.objects.get(id=call_priority)
                if priority_obj == None:
                    error = f"Bad call_priority: {call_priority}"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                data['call_priority'] = priority_obj.id
            else:
                priority_obj = CallPriority.objects.filter(priority_name=call_priority).first()
                if priority_obj == None:
                    error = f"Bad call_priority: {call_priority}"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                data['call_priority'] = priority_obj.id

        call_result = data.get('call_result', False)
        if call_result:
            if (type(call_result) == int) or call_result.isdigit():
                result_obj = CallResult.objects.get(id=call_result)
                if result_obj == None:
                    error = f"Bad call_result: {call_result}"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                data['call_result'] = result_obj.id
            else:
                result_obj = CallResult.objects.filter(result_name=call_result).first()
                if result_obj == None:
                    error = f"Bad call_result: {call_result}"
                    logging.error(error)
                    raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
                data['call_result'] = result_obj.id

        # Comments to CallCard only by Operator103
        c_c = data.get('call_comment', None)
        if c_c:
            if data['call_station'] != 2:
                data.pop('call_comment')
            else:
                c_c = str(c_c)
                if len(c_c) > 254:
                    logging.warning("Stripping call_comment")
                    data['call_comment'] = c_c[:254]
                else:
                    data['call_comment'] = c_c

        # end_datetime is required
        end_datetime = data.get('end_datetime', None)
        if not end_datetime:
            error = "Error: end_datetime is required"
            logging.error(error)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        # operator_id required
        operator_id = data.get('operator_id', None)
        if not operator_id:
            error = "Error: operator_id is required"
            logging.error(error)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        # operator_id must be in Staff list
        staff_qs = Staff.objects.filter(mis_id=data['mis_id'], mis_staff_id=operator_id)
        if not staff_qs.exists():
            error = "Error: operator_id must be in staff list"
            logging.error(error)
            raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: [error]})
        # Only Operator103 goes to CallCard
        operator_id_pk = staff_qs.first().id
        if data['call_station'] <= 2 | (not self.instance):
            data['operator_id'] = operator_id_pk
        else:
            data.pop('operator_id')

        # print(f'data[start_datetime]: {data["start_datetime"]}')
        fields = self._writable_fields
        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            primitive_value = data.get(field.source_attrs[0], False)
            if primitive_value:
                try:
                    validated_value = field.run_validation(primitive_value)
                    if validate_method is not None:
                        validated_value = validate_method(validated_value)
                except ValidationError as exc:
                    errors[field.field_name] = exc.detail
                except DjangoValidationError as exc:
                    errors[field.field_name] = get_error_detail(exc)
                except SkipField:
                    pass
                else:
                    set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        data['operator_id'] = operator_id_pk

        # Check if already Archive
        if self.instance and self.instance.call_station:
            if self.instance.call_station.station_name == "Архів":
                cc_slug = ret.get('call_card_id', None)
                logging.warning(f"CallCardSerializer:: The card# {cc_slug} is in Archive already. ")
                callrecord_start = datetime.fromisoformat(data['start_datetime'])
                logging.warning(f'callrecord_start : {callrecord_start.isoformat()}')
                logging.warning(f'callcard_end_time: {self.instance.end_datetime.isoformat()}')
                # logging.warning("CallCardSerializer:: puting call_station to Archive back")
                # ret['call_station'] = CallStations.objects.get(station_name="Архів")
                if callrecord_start < self.instance.end_datetime:
                    logging.warning("CallCardSerializer:: puting call_station to Archive back")
                    ret['call_station'] = CallStations.objects.get(station_name="Архів")

        #ret = super().to_internal_value(data=data)
        # print(f'ret [start_datetime]: {ret["start_datetime"]}')
        # print(ret)
        return ret