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)
