コード例 #1
0
ファイル: serializers.py プロジェクト: yurkobb/shuup
class SavedAddressSerializer(serializers.ModelSerializer):
    role = EnumField(SavedAddressRole)
    status = EnumField(SavedAddressStatus)
    address = AddressSerializer()

    class Meta:
        model = SavedAddress
        exclude = ()
コード例 #2
0
ファイル: serializers.py プロジェクト: yurkobb/shuup
class OrderSerializer(serializers.ModelSerializer):
    payment_status = EnumField(PaymentStatus)
    shipping_status = EnumField(ShippingStatus)
    billing_address = AddressSerializer()
    shipping_address = AddressSerializer()
    lines = OrderLineSerializer(many=True)

    class Meta:
        model = Order
        exclude = ()
コード例 #3
0
ファイル: serializers.py プロジェクト: luisdomin5/turnout
class EventSerializer(EnumSupportSerializerMixin, serializers.ModelSerializer):
    action = serializers.PrimaryKeyRelatedField(queryset=Action.objects.all())
    event_type = EnumField(enum=enums.EventType)

    class Meta:
        model = Event
        fields = ["event_type", "action"]
コード例 #4
0
ファイル: serializers.py プロジェクト: yurkobb/shuup
class GDPRPersonContactSerializer(ContactSerializer):
    gender = EnumField(Gender)
    user = UserSerializer()
    log_entries = PersonContactLogEntrySerializer(many=True)
    company_memberships = GDPRCompanyContactSerializer(many=True)

    class Meta:
        model = PersonContact
        exclude = ("polymorphic_ctype", )
コード例 #5
0
ファイル: serializers.py プロジェクト: luisdomin5/turnout
class ActionSerializer(SubscriberSerializerMixin, EnumSupportSerializerMixin,
                       serializers.ModelSerializer):
    action = serializers.PrimaryKeyRelatedField(read_only=True, required=False)
    sms_opt_in_subscriber = serializers.BooleanField(required=False)
    initial_events = serializers.ListField(child=EnumField(
        enum=enums.EventType))

    def __init__(self, instance=None, data=empty, **kwargs) -> None:
        self.incomplete = kwargs.pop("incomplete", False)
        super().__init__(instance=instance, data=data, **kwargs)

    def create(self, validated_data: Dict[(str, Any)]) -> "Model":
        validated_data["action"] = Action.objects.create(
            visible_to_subscriber=self.request_subscriber(
            ).plan_has_data_access())
        return super().create(validated_data)

    @tracer.wrap()
    def run_validation(self, *args, **kwargs):
        return super().run_validation(*args, **kwargs)

    def get_field_names(self,
                        declared_fields: Mapping[(str, serializers.Field)],
                        info: "FieldInfo") -> List[str]:
        # There are 5 possible Meta attributes for fields in ActionSerializers,
        # "minimum_necessary_fields", "nationally_required_fields", "optional_fields",
        # "fields", and "exclude"
        minimum_necessary_fields = getattr(self.Meta,
                                           "minimum_necessary_fields", [])
        nationally_required_fields = getattr(self.Meta,
                                             "nationally_required_fields", [])
        optional_fields = getattr(self.Meta, "optional_fields", [])
        standard_fields = getattr(self.Meta, "fields", [])

        # Return a deduplicated list of all fields
        return list(
            set(minimum_necessary_fields + nationally_required_fields +
                optional_fields + standard_fields + ["initial_events"]))

    def get_fields(self) -> "collections.OrderedDict[str, serializers.Field]":
        initial_fields = super().get_fields()
        fields = collections.OrderedDict()
        for key, value in initial_fields.items():
            if key in getattr(self.Meta, "minimum_necessary_fields", []):
                value.required = True  # type: ignore[attr-defined]
            elif not self.incomplete and key in getattr(
                    self.Meta, "nationally_required_fields", []):
                value.required = True  # type: ignore[attr-defined]
            else:
                value.required = False  # type: ignore[attr-defined]
            fields[key] = value
        return fields
コード例 #6
0
class StatusSerializer(EnumSupportSerializerMixin, serializers.ModelSerializer):
    status = EnumField(enum=enums.TurnoutActionStatus, required=True)

    class Meta:
        model = Registration
        fields = ("status",)

    def validate_status(self, value):
        if not value == enums.TurnoutActionStatus.OVR_REFERRED:
            raise serializers.ValidationError(
                f"Registration status can only be {enums.TurnoutActionStatus.OVR_REFERRED.value}"
            )
        return value
コード例 #7
0
    def get(self, request, **kwargs):
        last_span = models.Downtime.objects.order_by("-start").first()
        last_updated = cache.get("tweetdb:last_update")
        if last_updated:
            last_updated = datetime.datetime.fromtimestamp(last_updated)
            last_updated = DateTimeField().to_representation(last_updated)

        return Response(
            {
                "status": EnumField(models.Status, ints_as_names=True).to_representation(last_span.get_latest_status()),
                "last_span": serializers.DowntimeSerializer(last_span).data,
                "last_updated": last_updated,
            }
        )
コード例 #8
0
ファイル: serializers.py プロジェクト: yurkobb/shuup
class OrderLineSerializer(serializers.ModelSerializer):
    type = EnumField(OrderLineType)

    class Meta:
        model = OrderLine
        exclude = ()
コード例 #9
0
ファイル: serializers.py プロジェクト: yurkobb/shuup
class ContactLogEntrySerializer(serializers.ModelSerializer):
    kind = EnumField(LogEntryKind)

    class Meta:
        model = ContactGroupLogEntry
        exclude = ()
コード例 #10
0
class GatewayCallbackSerializer(serializers.Serializer):
    fax_id = serializers.UUIDField(required=True)
    status = EnumField(enum=enums.FaxStatus, required=True)
    message = serializers.CharField(required=True)
    timestamp = TimestampField(required=True)
コード例 #11
0
class ExternalRegistrationSerializer(
    EnumSupportSerializerMixin, serializers.ModelSerializer
):
    title = EnumField(required=False, enum=enums.PersonTitle)
    first_name = serializers.CharField(required=True, max_length=256)
    middle_name = serializers.CharField(required=False, max_length=256)
    last_name = serializers.CharField(required=True, max_length=256)
    suffix = serializers.CharField(required=False, max_length=256)

    date_of_birth = serializers.DateField(required=True, input_formats=["iso-8601"])

    email = serializers.EmailField(required=True, max_length=256)
    phone = PhoneNumberField(required=False)

    address1 = serializers.CharField(required=True, max_length=256)
    address2 = serializers.CharField(required=False, max_length=256)
    city = serializers.CharField(required=True, max_length=256)
    state = serializers.ChoiceField(
        choices=STATES,
        validators=[state_code_validator],
        required=True,
        source="state_id",
    )
    zipcode = serializers.CharField(validators=[zip_validator], required=True)

    sms_opt_in = RequiredBooleanField(
        required=True, validators=[must_be_true_validator]
    )
    sms_opt_in_subscriber = RequiredBooleanField(
        required=False, validators=[must_be_true_validator]
    )

    def validate(self, data):
        """
        To guarantee our ability to maintain backwards-compatibility, we reject
        extra fields -- we don't want someone to be passing, e.g., "previous_name"
        (which we would ignore), and then run into issues if we add a field with
        that name with different validation requirements than their assumptions.
        """
        if hasattr(self, "initial_data"):
            unknown_keys = set(self.initial_data.keys()) - set(self.fields.keys())
            if unknown_keys:
                raise ValidationError("Got unknown fields: {}".format(unknown_keys))

        if (
            data.get("state_id").lower() == "tn"
            and data.get("title") == enums.PersonTitle.MX
        ):
            raise ValidationError("Tennesee does not allow a title of Mx.")

        return data

    def create(self, validated_data):
        validated_data["action"] = Action.objects.create()
        validated_data["subscriber"] = self.request_subscriber(validated_data)
        validated_data["gender"] = self.guess_gender_from_title(validated_data)
        validated_data["status"] = enums.TurnoutActionStatus.INCOMPLETE
        return super().create(validated_data)

    def request_subscriber(self, data):
        return self.context.get("request").auth.subscriber

    def guess_gender_from_title(self, data):
        if data.get("title"):
            return data.get("title").guess_registration_gender()
        else:
            return None

    class Meta:
        model = Registration
        fields = (
            "title",
            "first_name",
            "middle_name",
            "last_name",
            "suffix",
            "date_of_birth",
            "email",
            "phone",
            "address1",
            "address2",
            "city",
            "state",
            "zipcode",
            "sms_opt_in",
            "sms_opt_in_subscriber",
            "subscriber",
            "gender",
            "status",
        )