class CompanyDetailedInfoSerializer(CompanyBasicInfoSerializer):
admins = serpy.MethodField()
roles = serpy.MethodField()
website = serpy.Field()
facebook = serpy.Field()
twitter = serpy.Field()
linkedin = serpy.Field()
id = serpy.Field()
city = serpy.MethodField()
city_raw = serpy.MethodField()
def get_admins(self, instance):
from django.contrib.postgres.aggregates.general import ArrayAgg
qs = Membership.objects.filter(company_id=instance.id).select_related(
'user', 'role')
qs = qs.annotate(arr=ArrayAgg('jobs'))
return MembershipBasicInfoSerializer(qs, many=True).data
def get_roles(self, instance):
return CompanyRolesSerializer(
instance.roles.filter(company__id=instance.id), many=True).data
def get_city(self, obj):
if obj.city:
return obj.city.pk
def get_city_raw(self, obj):
if obj.city:
return ", ".join([
obj.city.name,
obj.city.region.name if obj.city.region else 'NA',
obj.city.country.name
])
class JobHistorySerialiser(serpy.Serializer):
plant = BiogasPlantIDSerialiser()
fixers = serpy.MethodField()
accepted_but_did_not_visit = serpy.MethodField()
rejected_job = serpy.MethodField()
job_id = serpy.Field()
date_flagged = serpy.Field()
date_accepted = serpy.Field()
date_completed = serpy.Field()
completed = serpy.Field()
dispute_raised = serpy.Field()
job_status = serpy.Field() # Enum field
verification_of_engagement = serpy.Field()
fault_description = serpy.Field()
other = serpy.Field()
client_feedback_star = serpy.Field()
client_feedback_additional = serpy.Field()
overdue_for_acceptance = serpy.Field()
priority = serpy.Field()
fault_class = serpy.Field()
assistance = serpy.Field()
description_help_need = serpy.Field()
reason_abandoning_job = serpy.Field()
def get_fixers(self, obj):
return [{"id": ii.id} for ii in obj.fixers.all()]
def get_rejected_job(self, obj):
return [{"id": ii.id} for ii in obj.rejected_job.all()]
def get_accepted_but_did_not_visit(self, obj):
return [{"id": ii.id} for ii in obj.accepted_but_did_not_visit.all()]
class Image(ContextDictSerializer):
iid = serpy.MethodField(label="@id")
rtype = StaticField(label="@type", value="dctypes:Image")
format = StaticField(value="image/jpeg")
width = serpy.IntField(attr="width_i")
height = serpy.IntField(attr="height_i")
service = serpy.MethodField()
def get_iid(self, obj: SolrResult) -> str:
cfg = self.context.get('config')
req = self.context.get('request')
image_tmpl = cfg['templates']['image_id_tmpl']
# Images have the suffix "_image" in Solr.
identifier = re.sub(IMAGE_ID_SUB, "", obj.get("id"))
return get_identifier(req, identifier, image_tmpl) # type: ignore
def get_service(self, obj: SolrResult) -> Dict:
req = self.context.get('request')
cfg = self.context.get('config')
image_tmpl = cfg['templates']['image_id_tmpl']
identifier = re.sub(IMAGE_ID_SUB, "", obj.get("id"))
image_id = get_identifier(req, identifier, image_tmpl) # type: ignore
return {
"@context": "http://iiif.io/api/image/2/context.json",
"profile": "http://iiif.io/api/image/2/level1.json",
"@id": image_id
}
class Activity(ContextDictSerializer):
ctx = serpy.MethodField(label="@context")
id = serpy.MethodField()
# We only publish Create events (for now...)
type = StaticField(value="Create")
end_time = serpy.MethodField(label="endTime")
object = serpy.MethodField()
actor = StaticField(value=IIIF_ASTREAMS_ACTOR)
def get_ctx(
self, obj: SolrResult
) -> Optional[List]: # pylint: disable-msg=unused-argument
direct: bool = self.context.get('direct_request', False)
return IIIF_ASTREAMS_CONTEXT if direct else None
def get_id(self, obj: SolrResult) -> str:
req = self.context.get('request')
cfg = self.context.get('config')
activity_create_id_tmpl: str = cfg['templates'][
'activitystream_create_id_tmpl']
return get_identifier(req, obj.get('id'), activity_create_id_tmpl)
def get_end_time(self, obj: SolrResult) -> str:
return obj.get('accessioned_dt')
def get_object(self, obj: SolrResult) -> Dict:
req = self.context.get('request')
cfg = self.context.get('config')
manifest_tmpl: str = cfg['templates']['manifest_id_tmpl']
mfid = get_identifier(req, obj.get('id'), manifest_tmpl)
label: str = obj.get("full_shelfmark_s")
return {"id": mfid, "type": "Manifest", "name": label}
class PostCommentSerializer(ContextSerializer):
id = serpy.IntField()
author = serpy.MethodField('get_author')
post_id = serpy.IntField()
content = serpy.StrField()
points = serpy.IntField()
liked = serpy.MethodField('get_liked')
disliked = serpy.MethodField('get_disliked')
replies = serpy.MethodField('get_replies')
def get_author(self, obj):
return SimpleProfileSerializer(obj.profile).data
def get_liked(self, obj):
request = self.context.get('request')
if not isinstance(request.user, AnonymousUser):
return obj.interactions.filter(profile=request.user.profile, interaction=LIKE).count() > 0
return False
def get_disliked(self, obj):
request = self.context.get('request')
if not isinstance(request.user, AnonymousUser):
return obj.interactions.filter(profile=request.user.profile, interaction=DISLIKE).count() > 0
return False
def get_replies(self, obj):
query = PostComment.objects.filter(comment=obj).order_by('created')
return PostCommentSerializer(query, many=True, context=self.context).data
class AssetSerializer(serpy.Serializer):
slug = serpy.Field()
title = serpy.Field()
lang = serpy.Field()
asset_type = serpy.Field()
visibility = serpy.Field()
url = serpy.Field()
readme_url = serpy.Field()
difficulty = serpy.Field()
duration = serpy.Field()
status = serpy.Field()
graded = serpy.Field()
gitpod = serpy.Field()
preview = serpy.Field()
readme_url = serpy.Field()
translations = serpy.MethodField()
technologies = serpy.MethodField()
def get_translations(self,obj):
_s = map(lambda t: t.slug, obj.translations.all())
return _s
def get_technologies(self,obj):
_s = map(lambda t: t.slug, obj.technologies.all())
return _s
class QuoteSerializer(SearchableModelSerializer):
"""Serializer for quotes."""
text = serpy.Field(attr='text.html', required=True)
bite = serpy.MethodField()
html = serpy.Field()
truncated_html = serpy.MethodField()
attributee_string = serpy.Field()
has_multiple_attributees = serpy.BoolField()
attributee_html = serpy.Field()
date_html = serpy.Field()
serialized_images = serpy.Field()
primary_image = serpy.Field()
serialized_citations = serpy.Field()
def get_model(self, instance) -> str: # noqa
"""Return the model name of the instance."""
return 'quotes.quote'
def get_bite(self, instance: 'Quote') -> str:
"""Return the user-facing bite HTML."""
# "bite" is set to truncated text if it does not exist
# TODO: Add "truncated" field to model to distinguish true bites from auto bites
return (instance.bite.html if instance.bite else truncatechars_html(
instance.text, 100))
def get_truncated_html(self, instance: 'Quote') -> str:
"""Return truncated HTML content"""
if instance.bite is not None:
return truncatechars_html(instance.bite, 100)
else:
return truncatechars_html(instance.text, 100)
class UserMeSerializer(serpy.Serializer):
"""The serializer schema definition."""
# Use a Field subclass like IntField if you need more validation.
id = serpy.Field()
email = serpy.Field()
first_name = serpy.Field()
last_name = serpy.Field()
github = serpy.MethodField()
profile = ProfileSerializer(required=False)
roles = serpy.MethodField()
cohorts = serpy.MethodField()
date_joined = serpy.Field()
def get_github(self, obj):
github = CredentialsGithub.objects.filter(user=obj.id).first()
if github is None:
return None
return GithubSmallSerializer(github).data
def get_roles(self, obj):
roles = ProfileAcademy.objects.filter(user=obj.id)
return ProfileAcademySmallSerializer(roles, many=True).data
def get_cohorts(self, obj):
cohorts = CohortUser.objects.filter(user__id=obj.id)
return GETCohortUserSmallSerializer(cohorts, many=True).data
class CompanyBasicInfoSerializer(TBLightSerializer):
name = serpy.Field()
slug = serpy.Field()
size = serpy.Field()
verified = serpy.Field()
avatar = serpy.MethodField()
gravatar_id = serpy.MethodField()
city_raw = serpy.MethodField()
def get_avatar(self, instance):
request = self.context.get('request')
if request and instance.avatar:
avatar_url = instance.avatar.url
return request.build_absolute_uri(avatar_url)
def get_gravatar_id(self, obj):
return get_user_gravatar_id(obj.owner)
def get_city_raw(self, obj):
if obj.city:
return ", ".join([
obj.city.name,
obj.city.region.name if obj.city.region else 'NA',
obj.city.country.name
])
class Meta:
model = Company
fields = '__all__'
class BaseModelSerializer(serpy.Serializer):
id = serpy.IntField(label='id')
created_by = UserSerializer(label='createdBy')
created_on = serpy_fields.DateTimeField(label='createdOn')
last_modified_by = UserSerializer(label='lastModifiedBy')
last_modified_on = serpy_fields.DateTimeField(label='lastModifiedOn')
deleted_by = UserSerializer(label='deletedBy', required=False)
deleted_on = serpy_fields.DateTimeField(label='deletedOn', required=False)
is_deleted = serpy.BoolField(label='isDeleted')
created_by_id = serpy.MethodField('get_created_by_id', label='createdById')
last_modified_by_id = serpy.MethodField('get_last_modified_by_id',
label='lastModifiedById')
deleted_by_id = serpy.MethodField('get_deleted_by_id',
label='deletedById',
required=False)
def get_created_by_id(self, instance):
return getattr(instance, 'created_by_id')
def get_last_modified_by_id(self, instance):
return getattr(instance, 'last_modified_by_id')
def get_deleted_by_id(self, instance):
return getattr(instance, 'deleted_by_id')
class TaskListSerializer(ListVoteResourceSerializerMixin, ListWatchedResourceModelSerializer,
ListOwnerExtraInfoSerializerMixin, ListAssignedToExtraInfoSerializerMixin,
ListStatusExtraInfoSerializerMixin, ListBasicAttachmentsInfoSerializerMixin,
serializers.LightSerializer):
id = serpy.Field()
user_story = serpy.Field(attr="user_story_id")
ref = serpy.Field()
project = serpy.Field(attr="project_id")
milestone = serpy.Field(attr="milestone_id")
milestone_slug = serpy.MethodField("get_milestone_slug")
created_date = serpy.Field()
modified_date = serpy.Field()
finished_date = serpy.Field()
subject = serpy.Field()
us_order = serpy.Field()
taskboard_order = serpy.Field()
is_iocaine = serpy.Field()
external_reference = serpy.Field()
version = serpy.Field()
watchers = serpy.Field()
is_blocked = serpy.Field()
blocked_note = serpy.Field()
tags = serpy.Field()
is_closed = serpy.MethodField()
def get_milestone_slug(self, obj):
return obj.milestone.slug if obj.milestone else None
def get_is_closed(self, obj):
return obj.status is not None and obj.status.is_closed
class MilestoneListSerializer(ListWatchedResourceModelSerializer,
serializers.LightSerializer):
id = serpy.Field()
name = serpy.Field()
slug = serpy.Field()
owner = serpy.Field(attr="owner_id")
project = serpy.Field(attr="project_id")
estimated_start = serpy.Field()
estimated_finish = serpy.Field()
created_date = serpy.Field()
modified_date = serpy.Field()
closed = serpy.Field()
disponibility = serpy.Field()
order = serpy.Field()
watchers = serpy.Field()
user_stories = serpy.MethodField("get_user_stories")
total_points = serpy.MethodField()
closed_points = serpy.MethodField()
def get_user_stories(self, obj):
return UserStoryListSerializer(obj.user_stories.all(), many=True).data
def get_total_points(self, obj):
assert hasattr(obj, "total_points_attr"
), "instance must have a total_points_attr attribute"
return obj.total_points_attr
def get_closed_points(self, obj):
assert hasattr(obj, "closed_points_attr"
), "instance must have a closed_points_attr attribute"
return obj.closed_points_attr
class EntitySerializer(ModelSerializer):
"""Serializer for entities."""
name = serpy.Field()
unabbreviated_name = serpy.Field()
aliases = serpy.Field()
birth_date = serpy.MethodField('get_serialized_birth_date')
death_date = serpy.MethodField('get_serialized_death_date')
description = serpy.Field(attr='description.html', required=False)
serialized_images = serpy.Field()
categorizations = CategorizationSerializer(many=True,
attr='categorizations.all',
call=True)
def get_model(self, instance) -> str: # noqa
"""Return the model name of the instance."""
return f'entities.{instance.__class__.__name__.lower()}'
def get_serialized_birth_date(self, instance: 'Entity'):
"""Return the entity's birth date, serialized."""
return instance.birth_date.serialize() if instance.birth_date else None
def get_serialized_death_date(self, instance: 'Entity'):
"""Return the entity's death date, serialized."""
return instance.death_date.serialize() if instance.death_date else None
class BiosampleArtifactSerializer(ArtifactSerializer):
central_sample_id = serpy.StrField()
sample_type_collected = serpy.StrField()
sample_type_received = serpy.StrField(attr="sample_type_current")
swab_site = serpy.StrField(attr="sample_site")
# metadata
# Collection stuff
def serialize_collection_collection_date(self, biosample):
if biosample.created and biosample.created.collection_date:
return biosample.created.collection_date.isoformat()
def serialize_collection_received_date(self, biosample):
if biosample.created and biosample.created.received_date:
return biosample.created.received_date.isoformat()
def translate_adm1(self, biosample):
value = biosample.created.collection_location_adm1
countries = {
"UK-ENG": "England",
"UK-WLS": "Wales",
"UK-SCT": "Scotland",
"UK-NIR": "Northern_Ireland",
}
if value in countries:
return countries[value]
return value
collection_date = serpy.MethodField('serialize_collection_collection_date')
received_date = serpy.MethodField('serialize_collection_received_date')
submission_user = serpy.StrField(attr='created.submission_user.username')
submission_org = serpy.StrField(attr='created.submission_org.name')
submission_org_code = serpy.StrField(attr='created.submission_org.code')
submission_org_lab_or_name = serpy.MethodField('serialize_org_lab_or_name')
source_sex = serpy.StrField(attr="created.source_sex", required=False)
source_age = serpy.IntField(attr="created.source_age", required=False)
collected_by = None
adm0 = serpy.StrField(attr="created.collection_location_country")
adm1 = serpy.StrField(attr="created.collection_location_adm1")
adm1_trans = serpy.MethodField('translate_adm1')
adm2 = serpy.StrField(attr="created.collection_location_adm2")
adm2_private = None
supplement_coguk = serpy.MethodField('serialize_coguk_supp')
def serialize_org_lab_or_name(self, collection):
if collection.created.submission_org.gisaid_lab_name:
return collection.created.submission_org.gisaid_lab_name
else:
return collection.created.submission_org.name
def serialize_coguk_supp(self, biosample):
if hasattr(biosample.created, "coguk_supp"):
return COGUK_BiosourceSamplingProcessSupplementSerializer(
biosample.created.coguk_supp).data
class SimplePostSerializer(ContextSerializer):
id = serpy.IntField()
author = serpy.MethodField('get_author')
title = serpy.StrField()
content = serpy.StrField()
points = serpy.IntField()
liked = serpy.MethodField('get_liked')
disliked = serpy.MethodField('get_disliked')
def get_author(self, obj):
return SimpleProfileSerializer(obj.profile).data
def get_liked(self, obj):
request = self.context.get('request')
if not isinstance(request.user, AnonymousUser):
return obj.interactions.filter(profile=request.user.profile,
interaction=LIKE).count() > 0
return False
def get_disliked(self, obj):
request = self.context.get('request')
if not isinstance(request.user, AnonymousUser):
return obj.interactions.filter(profile=request.user.profile,
interaction=DISLIKE).count() > 0
return False
class BiogasPlantSerialiser(serpy.Serializer):
id = serpy.Field()
plant_id = serpy.Field()
biogas_plant_name = serpy.Field()
#constructing_technicians = serpy.Field()
contact = serpy.MethodField()
UIC = serpy.Field()
funding_source_notes = serpy.Field()
other_address_details = serpy.Field()
type_biogas = serpy.Field()
supplier = serpy.Field()
volume_biogas = serpy.Field()
location_estimated = serpy.Field()
location = serpy.MethodField()
QP_status = serpy.Field()
current_status = serpy.Field()
notes = serpy.Field()
def get_location(self, obj):
return to_serializable(obj.location)
def get_contact(self, obj):
return [{
"first_name": ii.first_name,
"surname": ii.surname,
"mobile": ii.mobile
} for ii in obj.contact.all()]
class RelationshipQuestionSerializer(serpy.Serializer):
id = serpy.Field()
questions_relations = serpy.MethodField()
when_answer = serpy.MethodField()
questions_redirect = serpy.MethodField()
def get_questions_relations(self, obj):
if obj.questions_relations is not None:
array_question_relation = {
'id_question_relation': obj.questions_relations.pk,
'page_question_relation': obj.questions_relations.pages,
'position_question_relation': obj.questions_relations.position,
}
return array_question_relation
def get_when_answer(self, obj):
if obj.when_answer is not None:
array_when_answer = {
'id_array_when': obj.when_answer.pk,
'name_when_answer': obj.when_answer.name_answer,
}
return array_when_answer
def get_questions_redirect(self, obj):
if obj.questions_redirect is not None:
array_question_redirect = {
'id_question_redirect': obj.questions_redirect.pk,
'page_question_redirect': obj.questions_redirect.pages,
'position_question_redirect': obj.questions_redirect.position,
}
return array_question_redirect
class AnswersOptionsSerializer(serpy.Serializer):
survey = serpy.MethodField('survey_main')
survey_question = QuestionSerializer()
ansewrs_options = serpy.MethodField()
def survey_main(self, obj):
if obj.survey_question is not None:
list_response = []
array = {
"id": obj.survey_question.survey_id,
"title": obj.survey_question.survey.title,
"descripcion": obj.survey_question.survey.descripcion
}
list_response.append(array)
return list_response
def get_ansewrs_options(self, obj):
if obj.ansewrs_options is not None:
list_response = []
for a in obj.ansewrs_options.all():
array = {
'id_answer': a.pk,
'name_Answerer': a.name_answer,
'position_answer': a.position,
}
list_response.append(array)
return list_response
class BaseAnnotation(ContextDictSerializer):
ctx = serpy.MethodField(
label="@context"
)
aid = serpy.MethodField(
label="id"
)
itype = StaticField(
label="type",
value="Annotation"
)
target = serpy.MethodField()
body = serpy.MethodField()
def get_aid(self, obj: SolrResult) -> str:
req = self.context.get('request')
cfg = self.context.get('config')
annotation_tmpl: str = cfg['templates']['annotation_id_tmpl']
# The substitution here is only needed for image annotations, but won't affect other annotations
annotation_id: str = re.sub(IMAGE_ID_SUB, "", obj.get("id"))
return get_identifier(req, annotation_id, annotation_tmpl)
@abstractmethod
def get_body(self, obj: SolrResult) -> Union[List[Dict], Dict]:
"""
Get the body of this annotation - either an Image or a representation of the text for a text annotation
:param obj:
:return:
"""
def get_ctx(self, obj: SolrResult) -> Optional[List]: # pylint: disable-msg=unused-argument
"""
If the resource is requested directly (instead of embedded in a manifest)
return the context object; otherwise it will inherit the context of the parent.
Note that the 'direct_request' context object is not passed down to children,
so it will only appear in a top-level object.
:param obj: Dictionary object to be serialized
:return: List containing the appropriate context objects.
"""
direct_request: bool = self.context.get('direct_request')
return IIIF_V3_CONTEXT if direct_request else None
def get_target(self, obj: SolrResult) -> str:
"""
This method may be overridden in subclasses to e.g. reference a specific region of the canvas
:param obj: A Solr Result object
:return: the uri for the canvas this annotation is attached to
"""
req = self.context.get('request')
cfg = self.context.get('config')
canvas_tmpl: str = cfg['templates']['canvas_id_tmpl']
identifier: str = re.sub(SURFACE_ID_SUB, "", obj['surface_id'])
return get_identifier(req, identifier, canvas_tmpl)
class Sequence(ContextDictSerializer):
ctx = serpy.MethodField(
label="@context"
)
sid = serpy.MethodField(
label="@id"
)
stype = StaticField(
label="@type",
value="sc:Sequence"
)
label = StaticField(
value="Default"
)
canvases = serpy.MethodField()
def get_ctx(self, obj: SolrResult) -> Optional[str]: # pylint: disable-msg=unused-argument
direct_request: bool = self.context.get('direct_request')
return IIIF_V2_CONTEXT if direct_request else None
def get_sid(self, obj: Dict) -> str:
req = self.context.get('request')
cfg = self.context.get('config')
obj_id = obj.get('id')
sequence_tmpl = cfg['templates']['sequence_id_tmpl']
return get_identifier(req, obj_id, sequence_tmpl)
def get_canvases(self, obj: SolrResult) -> Optional[Dict]:
req = self.context.get('request')
cfg = self.context.get('config')
obj_id = obj.get('id')
# Check if the canvases have annotations. We don't actually
# need to retrieve them, just get the number of hits.
has_annotations_res = SolrConnection.search(
"*:*",
fq=["type:annotationpage", f"object_id:{obj_id}"],
rows=0
)
has_annotations = has_annotations_res.hits > 0
manager: SolrManager = SolrManager(SolrConnection)
fq = ["type:surface", f"object_id:{obj_id}"]
sort = "sort_i asc"
fl = ["*,[child parentFilter=type:surface childFilter=type:image]"]
rows: int = 100
manager.search("*:*", fq=fq, fl=fl, sort=sort, rows=rows)
if manager.hits == 0:
return None
return Canvas(manager.results, context={'request': req,
'config': cfg,
'has_annotations': has_annotations}, many=True).data
class UserStoryListSerializer(ListVoteResourceSerializerMixin,
ListWatchedResourceModelSerializer,
OwnerExtraInfoMixin, AssigedToExtraInfoMixin,
StatusExtraInfoMixin,
serializers.LightSerializer):
id = serpy.Field()
ref = serpy.Field()
milestone = serpy.Field(attr="milestone_id")
milestone_slug = serpy.MethodField()
milestone_name = serpy.MethodField()
project = serpy.Field(attr="project_id")
is_closed = serpy.Field()
points = serpy.MethodField()
backlog_order = serpy.Field()
sprint_order = serpy.Field()
kanban_order = serpy.Field()
created_date = serpy.Field()
modified_date = serpy.Field()
finish_date = serpy.Field()
subject = serpy.Field()
client_requirement = serpy.Field()
team_requirement = serpy.Field()
generated_from_issue = serpy.Field(attr="generated_from_issue_id")
external_reference = serpy.Field()
tribe_gig = serpy.Field()
version = serpy.Field()
watchers = serpy.Field()
is_blocked = serpy.Field()
blocked_note = serpy.Field()
tags = serpy.Field()
total_points = serpy.Field("total_points_attr")
comment = serpy.MethodField("get_comment")
origin_issue = ListOriginIssueSerializer(attr="generated_from_issue")
def to_value(self, instance):
self._serialized_status = {}
return super().to_value(instance)
def get_milestone_slug(self, obj):
return obj.milestone.slug if obj.milestone else None
def get_milestone_name(self, obj):
return obj.milestone.name if obj.milestone else None
def get_points(self, obj):
if obj.role_points_attr is None:
return {}
return dict(ChainMap(*json.loads(obj.role_points_attr)))
def get_comment(self, obj):
return ""
class LineGroupSerializer(GenericSerializer):
lines = serpy.MethodField(display_none=False)
main_line = serpy.MethodField(display_none=False)
comments = CommentSerializer(many=True)
def get_lines(self, obj):
return LineSerializer(obj.lines, many=True, display_none=False).data
def get_main_line(self, obj):
if obj.HasField(str('main_line')):
return LineSerializer(obj.main_line).data
else:
return None
class JobMembersSerializer(TBLightSerializer):
role_name = serpy.MethodField()
role_slug = serpy.MethodField()
full_name = serpy.MethodField()
is_user_active = serpy.MethodField()
invited_by = serpy.MethodField()
view_all_jobs = serpy.MethodField()
is_admin = serpy.Field()
# is_owner = serpy.MethodField()
avatar = serpy.MethodField()
email = serpy.MethodField()
uuid = serpy.MethodField()
user = UserBasicInfoSerializer()
def get_view_all_jobs(self, obj):
return obj.role.inherit_permissions if obj.role else False
def get_invited_by(self, obj):
if obj.invited_by:
return UserBasicInfoSerializer(obj.invited_by).data
def get_role_name(self, obj):
return obj.role.name if obj.role else None
def get_role_slug(self, obj):
return obj.role.slug if obj.role else None
def get_full_name(self, obj):
return obj.user.get_full_name() if obj.user else None
def get_is_user_active(self, obj):
return obj.user.is_active if obj.user else False
def get_color(self, obj):
return obj.user.color if obj.user else None
def get_email(self, obj):
return obj.user.email
def get_avatar(self, obj):
return get_user_photo_url(obj.user)
def get_gravatar_id(self, obj):
return get_user_gravatar_id(obj.user)
def get_uuid(self, obj):
return obj.user.uuid
# def get_is_owner(self, obj):
# return (obj and obj.user_id and obj.company_id and obj.company.owner_id and
# obj.user_id == obj.company.owner_id)
class Meta:
model = get_model('company', 'Membership')
fields = ('role_slug', 'role_name', 'full_name', 'is_user_active',
'invited_by')
class CategorizationSerializer(serpy.Serializer):
"""Serializer for Entity-Category relationship."""
category = CategorySerializer()
start_date = serpy.MethodField('get_serialized_start_date')
end_date = serpy.MethodField('get_serialized_end_date')
def get_serialized_start_date(self, instance: 'Entity'):
"""Return the entity's birth date, serialized."""
return instance.date.serialize() if instance.date else None
def get_serialized_end_date(self, instance: 'Entity'):
"""Return the entity's death date, serialized."""
return instance.end_date.serialize() if instance.end_date else None
class CreditCardSerializers(serpy.Serializer):
"""
this class converts the data of the weedmatch user's credit card into json
"""
id = serpy.Field()
first_name = serpy.Field()
last_name = serpy.Field()
type_card = serpy.Field()
number_card = serpy.MethodField()
month = serpy.MethodField()
year = serpy.MethodField()
def get_number_card(self, obj):
"""
this method obtain the last fourth digits of credit card number
:param obj: credit card object
:type obj: Model CreditCard
:return: The last fourth digits of credit card number
"""
if not obj.number_card:
return ""
return obj.number_card[-4:]
def get_month(self, obj):
"""
This method obtain the month of expiration credit card
:param obj: credit card object.
:type obj: Model CreditCard.
:return: The month of expiration date
"""
if not obj.date_expiration:
return ""
month = str(obj.date_expiration)
return month[5:7]
def get_year(self, obj):
"""
This method obtain the year of expiration credit card
:param obj: credit card object.
:type obj: Model CreditCard.
:return: The year of expiration date
"""
if not obj.date_expiration:
return ""
month = str(obj.date_expiration)
return month[2:4]
class ImagePublicSerializer(serpy.Serializer):
id = serpy.Field()
like = serpy.Field()
image = serpy.MethodField()
comment = serpy.MethodField()
def get_image(self, obj):
if not obj.image:
return str(obj.image)
return settings.URL+settings.MEDIA_URL+str(obj.image)
def get_comment(self, obj):
if not obj.state:
return ""
return obj.state
class MembershipDetailedSerializer(MembershipSerializer):
abilities = serpy.MethodField()
jobs = serpy.MethodField()
def get_abilities(self, obj):
return obj.role.permissions
def get_jobs(self, obj):
if hasattr(obj, 'job_ids'):
return obj.job_ids
return obj.jobs.all().values_list('id', flat=True)
def get_company(self, obj):
return CompanyDetailedInfoSerializer(instance=obj.company,
context=self.context).data
class TaskSerializer(BaseProjectEntitySerializer, BaseModelSerializer):
project = ProjectSerializer(label='project', required=False)
project_id = serpy.MethodField('get_project_id',
label='projectId',
required=False)
priority = serpy.StrField(label='priority')
priority_full = serpy.MethodField('get_priority_full',
label='priorityFull')
def get_priority_full(self, instance):
return instance.get_priority_display()
def get_project_id(self, instance):
return getattr(instance, 'project_id')
class NetworkSerializer(GenericSerializer):
lines = serpy.MethodField(display_none=False)
links = LinkSerializer(attr='impact_uris')
codes = CodeSerializer(many=True, display_none=False)
def get_lines(self, obj):
return LineSerializer(obj.lines, many=True, display_none=False).data
class ContentTypeSerializer(BaseSerializer):
name = serpy.StrField()
is_first_party = serpy.BoolField()
client_type = serpy.StrField()
auth_call_back_urls = serpy.StrField(required=False)
web_origins = serpy.StrField(required=False)
client_secret = serpy.MethodField()
client_id = serpy.StrField(required=False)
description = serpy.StrField(required=False)
organization_id = serpy.StrField()
#tenant_id = serpy.StrField()
is_confidential = serpy.BoolField(required=False)
class Meta:
read_protected_fields = ('client_secret', )
write_protected_fields = (
'client_id',
'id',
'is_confidential',
'created_at',
'updated_at',
)
def get_client_secret(self, obj):
client_type = obj.get("client_type")
if client_type == 'spa':
return None
key = jwk.JWK.generate(kty='oct', size=256)
return json.loads(key.export()).get("k")
