class OrderSerializer(AvailableOrderMethodsMixin, serializers.ModelSerializer): lines = OrderLineSerializer(many=True) billing_address = AddressSerializer(read_only=True) shipping_address = AddressSerializer(read_only=True) payments = PaymentSerializer(many=True, read_only=True) payment_data = JSONField(read_only=True) shipping_data = JSONField(read_only=True) extra_data = JSONField(read_only=True) codes = JSONField(source="_codes", read_only=True) class Meta: model = Order fields = "__all__" ref_name = "RestApiOrderSerializer" def get_fields(self): fields = super(OrderSerializer, self).get_fields() for name, field in fields.items(): if name in ("status", "key", "label", "currency", "prices_include_tax"): field.required = False if name == "order_date": field.default = lambda: now() if name == "status": field.default = OrderStatus.objects.get_default_initial() return fields
class HeavyPlanSerializer(LightPlanSerializer): data = JSONField(binary=False) previous_data = JSONField(binary=False) added_by = serializers.HyperlinkedRelatedField( view_name='user-detail', lookup_field='pk', many=False, read_only=True, ) modified_by = serializers.HyperlinkedRelatedField( view_name='user-detail', lookup_field='pk', many=False, read_only=True, ) locked_by = serializers.HyperlinkedRelatedField( view_name='user-detail', lookup_field='pk', many=False, read_only=True, ) published_by = serializers.HyperlinkedRelatedField( view_name='user-detail', lookup_field='pk', many=False, read_only=True, ) section_validity = LightSectionValiditySerializer(many=True, read_only=True) question_validity = LightQuestionValiditySerializer(many=True, read_only=True) class Meta: model = Plan fields = [ 'id', 'uuid', 'url', 'title', 'abbreviation', 'version', 'template', 'section_validity', 'question_validity', 'data', 'previous_data', 'generated_html', 'doi', 'added', 'added_by', 'modified', 'modified_by', 'locked', 'locked_by', 'published', 'published_by', ]
class PriceLog(models.Model): status = models.CharField(max_length=32, choices=PriceStatuses.STATUSES, default=PriceStatuses.ACTIVE) new_data = JSONField() old_data = JSONField(allow_null=True) price = models.ForeignKey(to=Price, related_name="logs", on_delete=models.DO_NOTHING) class Meta: verbose_name = "price log" verbose_name_plural = "prices logs"
class JobSerializer(serializers.ModelSerializer): """Serializer without hyperlinks for internal use""" algorithm_image = StringRelatedField() inputs = ComponentInterfaceValueSerializer(many=True) outputs = ComponentInterfaceValueSerializer(many=True) status = CharField(source="get_status_display", read_only=True) algorithm_title = CharField( source="algorithm_image.algorithm.title", read_only=True ) hanging_protocol = HangingProtocolSerializer( source="algorithm_image.algorithm.hanging_protocol", read_only=True ) view_content = JSONField( source="algorithm_image.algorithm.view_content", read_only=True ) class Meta: model = Job fields = [ "pk", "api_url", "algorithm_image", "inputs", "outputs", "status", "rendered_result_text", "algorithm_title", "started_at", "completed_at", "hanging_protocol", "view_content", ]
class AnnotationSerializer(FilterSerializerByAccountMixin, serializers.ModelSerializer): cargo_json = JSONField() id = serializers.IntegerField(required=False) class Meta: model = Annotation fields = [ 'id', 'author_user_id', 'document_id', 'audit_trail_id', 'document_page', 'type', 'created', 'geometry_tools_version', 'cargo_json', 'comments', 'local_id', 'shared' ] list_serializer_class = ReBindListSerializer comments = AnnotationCommentSerializer(many=True) def __init__(self, instance=None, **kwargs): super(AnnotationSerializer, self).__init__(instance, **kwargs) def create(self, validated_data): comments = validated_data.pop('comments', []) annotation = super(AnnotationSerializer, self).create(validated_data) self.sync_comments(annotation, comments) return annotation def update(self, instance, validated_data): comments = validated_data.pop('comments', []) if not self.context.get('readonly'): annotation = super(AnnotationSerializer, self).update(instance, validated_data) else: annotation = self.instance self.sync_comments(annotation, comments) return annotation def sync_comments(self, annotation, comments): existing_comments = { c.id: c for c in annotation.comments.filter( author_user=self.context['user']) } for comment in comments: if 'id' in comment: if comment['id'] in existing_comments: s = AnnotationCommentSerializer( instance=existing_comments[comment['id']], data=comment, context=self.context) else: raise ValidationError({ 'detail': "Can't update comment id=%d: it either not exists or belongs to other user" % comment['id'] }) else: s = AnnotationCommentSerializer(data=comment, context=self.context) s.is_valid(raise_exception=True) s.save(author_user=self.context['user'], annotation=annotation)
class Notification(BaseModel): user = models.ForeignKey(User, related_name='notifications', db_index=True) """ The receiving user of the notification. """ title = models.CharField(max_length=200) """ Title of the notification. """ message = models.TextField(blank=True, default='') """ Message of the notification. """ object_type = models.CharField(max_length=100, db_index=True) """ Type of the referring object. """ object_key = models.CharField(max_length=200, null=True, default=None) """ Related key to object. """ object_data = JSONField(allow_null=True, default=None) """ Extra data of object. """ is_read = models.BooleanField(default=False) """
class AuthenticatorWebAuthnChallengeResponse(ChallengeResponse): """WebAuthn Challenge response""" response = JSONField() component = CharField(default="ak-stage-authenticator-webauthn") request: HttpRequest user: User def validate_response(self, response: dict) -> dict: """Validate webauthn challenge response""" challenge = self.request.session["challenge"] try: registration: VerifiedRegistration = verify_registration_response( credential=RegistrationCredential.parse_raw(dumps(response)), expected_challenge=challenge, expected_rp_id=get_rp_id(self.request), expected_origin=get_origin(self.request), ) except InvalidRegistrationResponse as exc: LOGGER.warning("registration failed", exc=exc) raise ValidationError(f"Registration failed. Error: {exc}") credential_id_exists = WebAuthnDevice.objects.filter( credential_id=bytes_to_base64url( registration.credential_id)).first() if credential_id_exists: raise ValidationError("Credential ID already exists.") return registration
class SubscriptionSerializer(serializers.HyperlinkedModelSerializer): trial_end = serializers.DateField(required=False) start_date = serializers.DateField(required=False) ended_at = serializers.DateField(read_only=True) url = SubscriptionUrl(view_name='subscription-detail', source='*', queryset=Subscription.objects.all(), required=False) updateable_buckets = serializers.ReadOnlyField() meta = JSONField(required=False, encoder=DjangoJSONEncoder) class Meta: model = Subscription fields = ('id', 'url', 'plan', 'customer', 'trial_end', 'start_date', 'cancel_date', 'ended_at', 'state', 'reference', 'updateable_buckets', 'meta', 'description') read_only_fields = ('state', 'updateable_buckets') extra_kwargs = {'customer': {'lookup_url_kwarg': 'customer_pk'}} def validate(self, attrs): attrs = super(SubscriptionSerializer, self).validate(attrs) instance = Subscription(**attrs) instance.clean() return attrs
class MessageSerializer(ModelSerializer): message_text = JSONField() class Meta: model = Message fields = ('id', 'sender', 'message_text', 'time_sent') depth = 1
class ProviderSerializer(serializers.HyperlinkedModelSerializer): meta = JSONField(required=False) class Meta: model = Provider fields = ('id', 'url', 'name', 'company', 'invoice_series', 'flow', 'email', 'address_1', 'address_2', 'city', 'state', 'zip_code', 'country', 'extra', 'invoice_series', 'invoice_starting_number', 'proforma_series', 'proforma_starting_number', 'meta') def validate(self, data): data = super(ProviderSerializer, self).validate(data) flow = data.get('flow', None) if flow == Provider.FLOWS.PROFORMA: if not data.get('proforma_starting_number', None) and\ not data.get('proforma_series', None): errors = {'proforma_series': "This field is required as the " "chosen flow is proforma.", 'proforma_starting_number': "This field is required " "as the chosen flow is " "proforma."} raise serializers.ValidationError(errors) elif not data.get('proforma_series'): errors = {'proforma_series': "This field is required as the " "chosen flow is proforma."} raise serializers.ValidationError(errors) elif not data.get('proforma_starting_number', None): errors = {'proforma_starting_number': "This field is required " "as the chosen flow is " "proforma."} raise serializers.ValidationError(errors) return data
class UploadSerializer(serializers.Serializer): token = CharField() name = CharField() asset_type = EnumField(enum_type=AssetType) description = CharField(default="", required=False, allow_blank=True) attribution = CharField(default="", required=False, allow_blank=True) options = JSONField(default={}, required=False)
class UserSerializer(ModelSerializer): """User Serializer""" is_superuser = BooleanField(read_only=True) avatar = CharField(read_only=True) attributes = JSONField(validators=[is_dict], required=False) groups = ListSerializer(child=GroupSerializer(), read_only=True, source="ak_groups") uid = CharField(read_only=True) class Meta: model = User fields = [ "pk", "username", "name", "is_active", "last_login", "is_superuser", "groups", "email", "avatar", "attributes", "uid", ]
class HearingSerializer(serializers.ModelSerializer): labels = LabelSerializer(many=True, read_only=True) images = HearingImageSerializer.get_field_serializer(many=True, read_only=True) sections = serializers.SerializerMethodField() comments = HearingCommentSerializer.get_field_serializer(many=True, read_only=True) commenting = EnumField(enum_type=Commenting) geojson = JSONField() def get_sections(self, hearing): queryset = hearing.sections.all() if not hearing.closed: queryset = queryset.exclude(type__identifier=InitialSectionType.CLOSURE_INFO) serializer = SectionFieldSerializer(many=True, read_only=True) serializer.bind('sections', self) # this is needed to get context in the serializer return serializer.to_representation(queryset) class Meta: model = Hearing fields = [ 'abstract', 'title', 'id', 'borough', 'n_comments', 'commenting', 'published', 'labels', 'open_at', 'close_at', 'created_at', 'servicemap_url', 'images', 'sections', 'images', 'closed', 'comments', 'geojson' ]
class MappingDetailSerializer(MappingListSerializer): type = CharField(source='resource_type', read_only=True) uuid = CharField(source='id', read_only=True) extras = JSONField(required=False, allow_null=True) created_by = CharField(source='created_by.username', read_only=True) updated_by = CharField(source='created_by.username', read_only=True) parent_id = IntegerField(required=True) map_type = CharField(required=True) to_concept_url = CharField(required=True) from_concept_url = CharField(required=True) class Meta: model = Mapping fields = MappingListSerializer.Meta.fields + ( 'type', 'uuid', 'extras', 'created_at', 'updated_at', 'created_by', 'updated_by', 'parent_id') extra_kwargs = {'parent_id': {'write_only': True}} def create(self, validated_data): mapping = Mapping.persist_new(data=validated_data, user=self.context.get('request').user) self._errors.update(mapping.errors) return mapping def update(self, instance, validated_data): from core.concepts.models import Concept from core.sources.models import Source instance.extras = validated_data.get('extras', instance.extras) instance.external_id = validated_data.get('external_id', instance.external_id) instance.comment = validated_data.get( 'update_comment') or validated_data.get('comment') instance.retired = validated_data.get('retired', instance.retired) from_concept_url = validated_data.get('from_concept_url', None) to_concept_url = validated_data.get('to_concept_url', None) to_source_url = validated_data.get('to_source_url', None) if from_concept_url: instance.from_concept = Concept.from_uri_queryset( from_concept_url).first() if to_concept_url: instance.to_concept = Concept.from_uri_queryset( to_concept_url).first() if to_source_url: instance.to_source = Source.head_from_uri(to_source_url).first() instance.mnemonic = validated_data.get('mnemonic', instance.mnemonic) instance.map_type = validated_data.get('map_type', instance.map_type) instance.to_concept_code = validated_data.get('to_concept_code', instance.to_concept_code) instance.to_concept_name = validated_data.get('to_concept_name', instance.to_concept_name) errors = Mapping.persist_clone(instance, self.context.get('request').user) if errors: self._errors.update(errors) return instance
class SourceVersionExportSerializer(SourceVersionDetailSerializer): source = JSONField(source='snapshot') class Meta: model = Source fields = ( *SourceVersionDetailSerializer.Meta.fields, 'source' )
class HearingMapSerializer(serializers.ModelSerializer): geojson = JSONField() class Meta: model = Hearing fields = [ 'id', 'title', 'borough', 'open_at', 'close_at', 'closed', 'geojson' ]
class ActivitySerializer(serializers.ModelSerializer): # noqa: D101 actor = UserSerializer() target = JSONField(source="target.rendered_json", default=None) class Meta: model = ActivityLog fields = ("id", "actor", "target", "activity_type", "data", "created_at")
class EntityCreateMessageSerializer(serializers.Serializer): tags = serializers.ListField() action = serializers.CharField() type = serializers.CharField() key = serializers.CharField() version = serializers.CharField() payload = JSONField() created = serializers.CharField()
class GroupSerializer(ModelSerializer): """Group Serializer""" attributes = JSONField(validators=[is_dict], required=False) class Meta: model = Group fields = ["pk", "name", "is_superuser", "parent", "users", "attributes"]
class ToolSerializer(serializers.ModelSerializer): is_running = BooleanField() # this maps to Tool.is_running() owner = JSONField(source="_get_owner_info_as_dict") container_url = CharField(source="get_relative_container_url") relaunch_url = CharField() # this maps to Tool.relaunch_url class Meta: model = Tool exclude = ["id"]
class ClientConfigSerializer(serializers.ModelSerializer): config = JSONField(required=False) url = CharField(source='uri', read_only=True) resource_type = CharField(write_only=True, required=False) resource_id = IntegerField(write_only=True, required=False) class Meta: model = ClientConfig fields = ('id', 'name', 'type', 'is_default', 'config', 'url', 'resource_type', 'resource_id') def create(self, validated_data): user = self.context['request'].user from core.common.utils import get_content_type_from_resource_name resource_type = get_content_type_from_resource_name( validated_data.pop('resource_type', None)) instance = ClientConfig(**validated_data, created_by=user, updated_by=user, resource_type=resource_type) if not instance.type: instance.type = HOME_TYPE if instance.is_default is None: instance.is_default = False try: instance.full_clean() instance.save() if instance.id and instance.is_default: instance.siblings.filter(is_default=True).update( is_default=False) except ValidationError as ex: self._errors.update(ex.message_dict) return instance def update(self, instance, validated_data): user = self.context['request'].user instance.name = validated_data.get('name', instance.name) instance.config = validated_data.get('config', instance.config) instance.type = validated_data.get('type', instance.type) instance.is_default = bool( validated_data.get('is_default', instance.is_default)) instance.updated_by = user try: instance.full_clean() instance.save() if instance.id and instance.is_default: instance.siblings.filter(is_default=True).update( is_default=False) except ValidationError as ex: self._errors.update(ex.message_dict) return instance
class DetailedPlatformSerializer(ModelSerializer): title_count = IntegerField(read_only=True) interests = JSONField(read_only=True) has_data = BooleanField(read_only=True) class Meta: model = Platform fields = ('pk', 'ext_id', 'short_name', 'name', 'provider', 'url', 'title_count', 'interests', 'has_data')
class SourceCreateSerializer(SourceCreateOrUpdateSerializer): type = CharField(source='resource_type', read_only=True) uuid = CharField(source='id', read_only=True) id = CharField(required=True, validators=[RegexValidator(regex=NAMESPACE_REGEX)], source='mnemonic') short_code = CharField(source='mnemonic', read_only=True) name = CharField(required=True) full_name = CharField(required=False) description = CharField(required=False, allow_blank=True) source_type = CharField(required=False, allow_blank=True) custom_validation_schema = CharField(required=False, allow_blank=True, allow_null=True) public_access = ChoiceField(required=False, choices=ACCESS_TYPE_CHOICES) default_locale = CharField(required=False, allow_blank=True) supported_locales = ListField(required=False, allow_empty=True) website = CharField(required=False, allow_blank=True) url = CharField(read_only=True) canonical_url = CharField(required=False, allow_null=True, allow_blank=True) versions_url = CharField(read_only=True) concepts_url = CharField(read_only=True) mappings_url = CharField(read_only=True) owner = CharField(source='parent_resource', read_only=True) owner_type = CharField(source='parent_resource_type', read_only=True) owner_url = CharField(source='parent_url', read_only=True) versions = IntegerField(source='num_versions', read_only=True) created_on = DateTimeField(source='created_at', read_only=True) updated_on = DateTimeField(source='updated_at', read_only=True) created_by = CharField(source='owner', read_only=True) updated_by = CharField(read_only=True) extras = JSONField(required=False, allow_null=True) external_id = CharField(required=False, allow_blank=True) user_id = PrimaryKeyRelatedField(required=False, queryset=UserProfile.objects.all(), allow_null=True) organization_id = PrimaryKeyRelatedField( required=False, queryset=Organization.objects.all(), allow_null=True) version = CharField(default=HEAD) def create(self, validated_data): source = self.prepare_object(validated_data) user = self.context['request'].user errors = Source.persist_new(source, user) self._errors.update(errors) return source def create_version(self, validated_data): source = self.prepare_object(validated_data) user = self.context['request'].user errors = Source.persist_new_version(source, user) self._errors.update(errors) return source
class Transaction(models.Model): TYPES = (("S", "Stake"), ("C", "Coin"), ("D", "Data")) recipient = models.CharField(max_length=255) amount = models.DecimalField(null=True, decimal_places=2, max_digits=10) date = models.DateTimeField(auto_now_add=True) type = models.IntegerField(choices=TYPES, default=1) sender = models.CharField(max_length=255) signature = models.CharField(max_length=255) block_hash = models.CharField(max_length=255) data = JSONField(allow_null=True)
class SectionCommentSerializer(BaseCommentSerializer): """ Serializer for comment added to section. """ label = LabelSerializer(read_only=True) geojson = JSONField(required=False, allow_null=True) images = SectionImageSerializer(many=True, read_only=True) class Meta: model = SectionComment fields = ['section'] + COMMENT_FIELDS
class ToolSerializer(serializers.ModelSerializer): is_running = BooleanField() # this maps to Tool.is_running() owner = JSONField(source="_get_owner_info_as_dict") container_url = CharField(source="get_relative_container_url") relaunch_url = CharField() # this maps to Tool.relaunch_url detail_url = CharField() # this maps to Tool.detail_url dataset = DataSetSerializer() tool_definition = ToolDefinitionSerializer() class Meta: model = Tool exclude = ["id"]
class TitleCountSerializer(ModelSerializer): interests = JSONField(read_only=True) pub_type_name = SerializerMethodField() class Meta: model = Title fields = ('pk', 'name', 'pub_type', 'isbn', 'issn', 'eissn', 'doi', 'interests', 'pub_type_name') def get_pub_type_name(self, obj: Title): return obj.get_pub_type_display()
class AuthenticatorWebAuthnChallengeResponse(ChallengeResponse): """WebAuthn Challenge response""" response = JSONField() component = CharField(default="ak-stage-authenticator-webauthn") request: HttpRequest user: User def validate_response(self, response: dict) -> dict: """Validate webauthn challenge response""" challenge = self.request.session["challenge"] trusted_attestation_cert_required = True self_attestation_permitted = True none_attestation_permitted = True webauthn_registration_response = WebAuthnRegistrationResponse( get_rp_id(self.request), get_origin(self.request), response, challenge, trusted_attestation_cert_required=trusted_attestation_cert_required, self_attestation_permitted=self_attestation_permitted, none_attestation_permitted=none_attestation_permitted, uv_required=False, ) # User Verification try: webauthn_credential = webauthn_registration_response.verify() except RegistrationRejectedException as exc: LOGGER.warning("registration failed", exc=exc) raise ValidationError("Registration failed. Error: {}".format(exc)) # Step 17. # # Check that the credentialId is not yet registered to any other user. # If registration is requested for a credential that is already registered # to a different user, the Relying Party SHOULD fail this registration # ceremony, or it MAY decide to accept the registration, e.g. while deleting # the older registration. credential_id_exists = WebAuthnDevice.objects.filter( credential_id=webauthn_credential.credential_id).first() if credential_id_exists: raise ValidationError("Credential ID already exists.") webauthn_credential.credential_id = str( webauthn_credential.credential_id, "utf-8") webauthn_credential.public_key = str(webauthn_credential.public_key, "utf-8") return webauthn_credential
class XeroEntitySerializer(serializers.ModelSerializer): xero_data = JSONField(True) class Meta: model = XeroEntity fields = ('id', 'xero_id', 'xero_type', 'xero_data', 'xero_text', 'xero_code', 'other_id', 'other_name', 'total') extra_kwargs = { "id": { "read_only": False, "required": False, }, }
class ResultSerializer(serializers.ModelSerializer): class Meta: model = Result fields = ('resource_uri', 'name', 'status', 'last_update', 'data', 'log_url') resource_uri = HyperlinkedResultField(view_name='results-detail') log_url = SerializerMethodField(required=False) data = JSONField(required=False) def get_log_url(self, obj): request = self.context['request'] return obj.get_log_url(request)