class InventoryAccountRowSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
voucher_no = serializers.ReadOnlyField(source='creator.get_voucher_no')
income_quantity = serializers.SerializerMethodField()
income_rate = serializers.SerializerMethodField()
expense_quantity = serializers.SerializerMethodField()
current_balance = serializers.SerializerMethodField()
date = serializers.DateField(format=None)
class Meta:
model = JournalEntry
def get_income_quantity(self, obj):
if obj.creator.__class__.__name__ == 'SaleRow':
return ''
else:
default_unit = self.context.get('default_unit')
if obj.creator.unit.name != default_unit:
unit_conversion = UnitConversion.objects.get(
base_unit__name=default_unit,
unit_to_convert__name=obj.creator.unit.name)
multiple = unit_conversion.multiple
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return (obj.creator.quantity * multiple) / unit_multiple
else:
return obj.creator.quantity * multiple
else:
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return obj.creator.quantity / unit_multiple
else:
return obj.creator.quantity
def get_income_rate(self, obj):
if obj.creator.__class__.__name__ == 'SaleRow':
return ''
else:
default_unit = self.context.get('default_unit')
if obj.creator.unit.name != default_unit:
unit_conversion = UnitConversion.objects.get(
base_unit__name=default_unit,
unit_to_convert__name=obj.creator.unit.name)
multiple = unit_conversion.multiple
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return (obj.creator.rate * unit_multiple) / multiple
else:
return obj.creator.rate / multiple
else:
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return obj.creator.rate * unit_multiple
else:
return obj.creator.rate
def get_expense_quantity(self, obj):
if obj.creator.__class__.__name__ == 'PurchaseVoucherRow':
return ''
else:
default_unit = self.context.get('default_unit')
if obj.creator.unit.name != default_unit:
unit_conversion = UnitConversion.objects.get(
base_unit__name=default_unit,
unit_to_convert__name=obj.creator.unit.name)
multiple = unit_conversion.multiple
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return (obj.creator.quantity * multiple) / unit_multiple
else:
return obj.creator.quantity * multiple
else:
if self.context.get('unit_multiple'):
unit_multiple = self.context.get('unit_multiple')
return obj.creator.quantity / unit_multiple
else:
return obj.creator.quantity
def get_expense_rate(self, obj):
if obj.creator.__class__.__name__ == 'PurchaseVoucherRow':
return ''
return obj.creator.rate
def get_current_balance(self, obj):
return obj.transactions.filter(
account=obj.creator.item.account)[0].current_balance
class GameSerializer(serializers.Serializer):
url = serializers.ReadOnlyField(source="get_absolute_url")
class UserSerializer(serializers.ModelSerializer):
name = serializers.ReadOnlyField()
practice_names = serializers.SerializerMethodField()
active_practice_name = serializers.SerializerMethodField()
active_theme_name = serializers.SerializerMethodField()
active_rp_name = serializers.ReadOnlyField()
AFSL = AFSLSerializer(many=False, required=False, allow_null=True)
# multiple_rpgs = serializers.SerializerMethodField()
class Meta:
model = User
exclude = ["password", "date_joined", "last_login"]
def update(self, instance, validated_data):
'''
Modified to allow updating of AFSL number via the user serializer.
'''
AFSL_data = validated_data.pop('AFSL')
if AFSL_data:
if instance.AFSL:
if getattr(instance.AFSL,"AFSL_number","") != AFSL_data["AFSL_number"]:
# AFSL number has changed
validated_data = create_or_link_AFSL(AFSL_data, validated_data)
send_verification_email(instance, AFSL_data)
else:
# AFSL number has not changed, no action required.
pass
else:
# No AFSL currently linked, set up a new link and send email
validated_data = create_or_link_AFSL(AFSL_data, validated_data)
send_verification_email(instance, AFSL_data)
user = super().update(instance, validated_data)
return user
def get_practice_names(self, obj):
result = []
if obj.practices.all():
for practice in obj.practices.all():
print(practice)
result.append(practice.name);
return result
else:
return None
def get_active_practice_name(self,obj):
if obj.active_practice:
try:
practice = get_object_or_404(Practice, id=obj.active_practice.id)
return practice.name
except Exception as e:
print(e)
def get_active_theme_name(self,obj):
if obj.active_theme:
try:
theme = get_object_or_404(Theme, id=obj.active_theme.id)
return theme.name
except Exception as e:
print(e)
class Doc2RelateSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = Doc2Relate
fields = '__all__'
class TestSerializer(serializers.ModelSerializer):
missing = serializers.ReadOnlyField()
class MeetingtypeSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = Meetingtype
fields = '__all__'
class BiaoDanSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = BiaoDan
fields = '__all__'
class InterventionResultLinkVisitSerializer(serializers.ModelSerializer):
name = serializers.ReadOnlyField(source="cp_output.name")
class Meta:
model = InterventionResultLink
fields = ['id', 'name']
class EmployeeEmployeeRoleSerializer(serializers.HyperlinkedModelSerializer):
role = serializers.ReadOnlyField()
class Meta:
model = EmployeesEmployeeRoles
fields = ('employee_id', 'role_id', 'role')
class InterfaceNestedSerializer(InterfaceSerializer):
form_factor = serializers.ReadOnlyField(source='get_form_factor_display')
class Meta(InterfaceSerializer.Meta):
fields = ['id', 'device', 'name']
class TPMVisitLightSerializer(StatusPermissionsBasedRootSerializerMixin,
WritableNestedSerializerMixin,
serializers.ModelSerializer):
tpm_partner = SeparatedReadWriteField(read_field=TPMPartnerLightSerializer(
label=_('TPM Partner'), read_only=True), )
offices = SeparatedReadWriteField(read_field=OfficeSerializer(
read_only=True,
many=True,
label=_('Office(s) of UNICEF Focal Point(s)')), )
unicef_focal_points = SeparatedReadWriteField(
read_field=MinimalUserSerializer(read_only=True,
many=True,
label=_('UNICEF Focal Points')), )
tpm_partner_focal_points = SeparatedReadWriteField(
read_field=TPMPartnerStaffMemberSerializer(
read_only=True, many=True, label=_('TPM Focal Points')), )
status_date = serializers.ReadOnlyField(label=_('Status Date'))
implementing_partners = serializers.SerializerMethodField(
label=_('Implementing Partners'))
locations = serializers.SerializerMethodField(label=_('Locations'))
sections = serializers.SerializerMethodField(label=_('Sections'))
def get_implementing_partners(self, obj):
return MinimalPartnerOrganizationListSerializer(set(
map(lambda a: a.partner, obj.tpm_activities.all())),
many=True).data
def get_locations(self, obj):
return LocationLightSerializer(set(
itertools.chain(
*map(lambda a: a.locations.all(), obj.tpm_activities.all()))),
many=True).data
def get_sections(self, obj):
return SectorSerializer(set(
map(lambda a: a.section, obj.tpm_activities.all())),
many=True).data
class Meta(StatusPermissionsBasedRootSerializerMixin.Meta,
WritableNestedSerializerMixin.Meta):
model = TPMVisit
permission_class = TPMPermission
fields = [
'id',
'start_date',
'end_date',
'tpm_partner',
'implementing_partners',
'locations',
'sections',
'status',
'status_date',
'reference_number',
'offices',
'tpm_partner_focal_points',
'unicef_focal_points',
'date_created',
'date_of_assigned',
'date_of_tpm_accepted',
'date_of_tpm_rejected',
'date_of_tpm_reported',
'date_of_unicef_approved',
'date_of_tpm_report_rejected',
'date_of_cancelled',
]
extra_kwargs = {
'reference_number': {
'label': _('Reference Number'),
},
}
class UserPrivateSerializer(UserPublicSerializer):
token = serializers.ReadOnlyField(source='auth_token.key')
class Meta:
model = models.User
fields = UserPublicSerializer.Meta.fields + ('token',)
class UserPublicSerializer(serializers.ModelSerializer):
mode = serializers.ReadOnlyField()
class Meta:
model = models.User
fields = ('email', 'phone', 'birth', )
class PostSerializer(serializers.ModelSerializer):
owner = serializers.ReadOnlyField(source='user.username')
class Meta:
model = Post
fields = ('id', 'created_date', 'post_details', 'status',"owner")
class PageSerializer(DispatchModelSerializer, DispatchPublishableSerializer):
"""Serializes the Page model."""
id = serializers.ReadOnlyField(source='parent_id')
slug = serializers.SlugField(validators=[SlugValidator()])
featured_image = ImageAttachmentSerializer(required=False, allow_null=True)
featured_video = VideoAttachmentSerializer(required=False, allow_null=True)
content = ContentSerializer()
url = serializers.CharField(source='get_absolute_url', read_only=True)
current_version = serializers.IntegerField(read_only=True,
source='revision_id')
template = TemplateSerializer(required=False, source='get_template')
template_id = serializers.CharField(required=False, write_only=True)
template_data = JSONField(required=False)
updated_at = serializers.DateTimeField(read_only=True)
class Meta:
model = Page
fields = ('id', 'slug', 'url', 'title', 'featured_image',
'featured_video', 'snippet', 'content', 'published_at',
'updated_at', 'is_published', 'published_version',
'current_version', 'latest_version', 'preview_id',
'template', 'template_id', 'template_data', 'seo_keyword',
'seo_description')
authenticated_fields = ('template', 'preview_id')
def create(self, validated_data):
instance = Page()
return self.update(instance, validated_data)
def update(self, instance, validated_data):
# Update all the basic fields
instance.title = validated_data.get('title', instance.title)
instance.slug = validated_data.get('slug', instance.slug)
instance.snippet = validated_data.get('snippet', instance.snippet)
instance.seo_keyword = validated_data.get('seo_keyword',
instance.seo_keyword)
instance.seo_description = validated_data.get('seo_description',
instance.seo_description)
instance.template = validated_data.get('template_id',
instance.template)
instance.template_data = validated_data.get('template_data',
instance.template_data)
# Save instance before processing/saving content in order to save associations to correct ID
instance.save()
instance.content = validated_data.get('content', instance.content)
featured_image = validated_data.get('featured_image', False)
if featured_image != False:
instance.save_featured_image(featured_image)
featured_video = validated_data.get('featured_video', False)
if featured_video != False:
instance.save_featured_video(featured_video)
# Perform a final save (without revision), update content and featured image
instance.save(
update_fields=['content', 'featured_image', 'featured_video'],
revision=False)
return instance
class ItemRentalSerializer(serializers.HyperlinkedModelSerializer):
rental = serializers.ReadOnlyField()
class Meta:
model = ItemsRentals
fields = ('item_id', 'rental_id', 'rental')
class AccidentSerializer(serializers.ModelSerializer):
duty_manager_name_ch = serializers.ReadOnlyField()
type_parent_id = serializers.ReadOnlyField(source='type.ptype.id',
read_only=True)
type_parent_name = serializers.ReadOnlyField(source='type.ptype.name',
read_only=True)
type_id = serializers.ReadOnlyField(source='type.id', read_only=True)
type_name = serializers.ReadOnlyField(source='type.name', read_only=True)
status_name = serializers.ReadOnlyField(source='status.name',
read_only=True)
# duty_domains = AccidentDomainSerializer(many=True, read_only=True)
duty_dept_ids = serializers.ReadOnlyField()
duty_dept_names = serializers.ReadOnlyField()
duty_domain_ids = serializers.ReadOnlyField()
duty_domain_names = serializers.ReadOnlyField()
# log = AccidentLogSerializer(many=True,)
action = AccidentActionSerializer(many=True, read_only=True)
find_user_department = serializers.ReadOnlyField()
level_name = serializers.ReadOnlyField(source='get_level_display',
read_only=True)
time_length = serializers.ReadOnlyField()
basic_sla = serializers.ReadOnlyField()
detail_sla = serializers.ReadOnlyField()
# type_parent_id = serializers.SerializerMethodField()
class Meta:
model = Accident
fields = ('id', 'accidentid', 'title', 'status_name', 'is_accident',
'level', 'level_name', 'find_user_name',
'find_user_department', 'duty_manager_name',
'duty_manager_name_ch', 'duty_users', 'happened_time',
'finish_time', 'time_length', 'reason', 'process', 'comment',
'affect', 'is_online', 'is_online_str', 'health',
'is_available', 'type_id', 'type_name', 'type_parent_id',
'type_parent_name', 'is_punish', 'basicinfo_time',
'detailinfo_time', 'duty_dept_ids', 'duty_dept_names',
'duty_domain_ids', 'duty_domain_names', 'mantis_id',
'basic_sla', 'detail_sla', 'punish_users', 'punish_content',
'action')
class IndustriaSerializer(serializers.ModelSerializer):
prov = serializers.ReadOnlyField(source='provincia.Provincia')
mun = serializers.ReadOnlyField(source='municipio.Municipio')
codprov = serializers.ReadOnlyField(source='provincia.CodProvincia')
codmun = serializers.ReadOnlyField(source='municipio.CodCatastral')
codact = serializers.ReadOnlyField(source='producto.CodActividad')
actgen = serializers.ReadOnlyField(source='producto.Actividad')
prod = serializers.ReadOnlyField(source='producto.Producto')
codproducto = serializers.ReadOnlyField(source='producto.CodProducto')
procesados = serializers.ReadOnlyField(source='prodcts')
envasesProd = serializers.ReadOnlyField(source="envases")
marcs = serializers.ReadOnlyField(source="marcas")
class Meta:
model = Industria
fields = ('id', 'inscrito', 'procesados', 'envasesProd', 'marcs',
'matriculaRIA', 'provincia', 'municipio', 'declar_pac',
'Domicilio', 'CP', 'utmX', 'utmY', 'regSanit',
'regEmbotella', 'f_control', 'Estado', 'F_baja',
'expediente', 'ag_eco', 'tipProc', 'tipoCom', 'producto',
'codact', 'actgen', 'prod', 'codproducto', 'F_altaProducto',
'F_bajaProducto', 'productoCambiado', 'desc_product',
'f_ag_eco_prod', 'capacidad', 'form_pres', 'tam_emb',
'marcas_referencia', 'valor_produccion', 'prov', 'mun',
'codprov', 'codmun')
class MeetingUserSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
username = serializers.ReadOnlyField(source='user.truename')
class Meta:
model = MeetingUser
fields = '__all__'
class PriceEstimateSerializer(serializers.HyperlinkedModelSerializer):
scope = core_serializers.GenericRelatedField(
related_models=models.PriceEstimate.get_estimated_models(),
required=False)
scope_name = serializers.ReadOnlyField(source='scope.name')
scope_uuid = serializers.ReadOnlyField(source='scope.uuid')
class Meta:
model = models.PriceEstimate
fields = ('url', 'uuid', 'scope', 'scope_name', 'scope_uuid', 'limit',
'total', 'threshold')
read_only_fields = ('total', 'scope')
extra_kwargs = {
'url': {
'lookup_field': 'uuid'
},
}
def validate(self, attrs):
if 'limit' in attrs:
if isinstance(self.instance.scope, structure_models.Project):
self._validate_project_limit(self.instance.scope,
attrs['limit'])
if isinstance(self.instance.scope, structure_models.Customer):
self._validate_customer_limit(self.instance.scope,
attrs['limit'])
return attrs
def _validate_project_limit(self, project, limit):
customer = project.customer
customer_limit = self._get_customer_limit(customer)
if customer_limit == -1:
return
total_limit = self._get_total_limit(
customer.projects.exclude(uuid=project.uuid)) + limit
if total_limit > customer_limit:
message = _(
'Total price limits of projects exceeds organization price limit. '
'Total limit: %(total_limit)s, organization limit: %(customer_limit)s'
)
context = dict(total_limit=total_limit,
customer_limit=customer_limit)
raise serializers.ValidationError({'limit': message % context})
def _validate_customer_limit(self, customer, limit):
if limit == -1:
return
total_limit = self._get_total_limit(customer.projects.all())
if limit < total_limit:
message = _(
'Organization limit cannot be less than a sum of its projects limits: %d'
)
raise serializers.ValidationError({'limit': message % total_limit})
def _get_customer_limit(self, customer):
try:
estimate = models.PriceEstimate.objects.get(scope=customer)
return estimate.limit
except models.PriceEstimate.DoesNotExist:
return -1
def _get_total_limit(self, projects):
if not projects.exists():
return 0
estimates = models.PriceEstimate.objects.filter(
scope__in=projects).exclude(limit=-1)
return estimates.aggregate(Sum('limit'))['limit__sum'] or 0
class DirectorySerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = Directory
fields = '__all__'
class MissionSerializer(serializers.ModelSerializer):
owner = serializers.ReadOnlyField(source='owner.username')
class Meta:
model = Mission
fields = ('id', 'title', 'completed', 'owner')
class TestSerializer(serializers.ModelSerializer):
missing = serializers.ReadOnlyField()
class Meta:
model = RegularFieldsModel
fields = ('auto_field',)
class DataSerializer(serializers.ModelSerializer):
owner = serializers.ReadOnlyField(source='owner.username')
class Meta:
model = Data
fields = '__all__'
class Meta:
model = Recipe
date = serializers.DateField(read_only=True)
chef = serializers.ReadOnlyField()
fields = '__all__'
class DeviceSerializer(serializers.ModelSerializer):
owner = serializers.ReadOnlyField(source='owner.username', required=False)
class Meta:
model = Device
fields = '__all__'
class SnippetSerializer(serializers.ModelSerializer):
owner = serializers.ReadOnlyField(source='owner.username')
class Meta:
model = Snippet
fields = ('id', 'title', 'code', 'linenos', 'language', 'style', 'owner',)
class ArticleSerializer(DispatchModelSerializer,
DispatchPublishableSerializer):
"""Serializes the Article model."""
id = serializers.ReadOnlyField(source='parent_id')
slug = serializers.SlugField(validators=[SlugValidator()])
section = SectionSerializer(read_only=True)
section_id = serializers.IntegerField(write_only=True)
subsection = SubsectionSerializer(source='get_subsection', read_only=True)
subsection_id = serializers.IntegerField(write_only=True,
required=False,
allow_null=True)
featured_image = ImageAttachmentSerializer(required=False, allow_null=True)
featured_video = VideoAttachmentSerializer(required=False, allow_null=True)
content = ContentSerializer()
authors = AuthorSerializer(many=True, read_only=True)
author_ids = serializers.ListField(write_only=True,
child=serializers.JSONField(),
validators=[AuthorValidator])
authors_string = serializers.CharField(source='get_author_string',
read_only=True)
tags = TagSerializer(many=True, read_only=True)
tag_ids = serializers.ListField(write_only=True,
required=False,
child=serializers.IntegerField())
topic = TopicSerializer(read_only=True)
topic_id = serializers.IntegerField(write_only=True,
allow_null=True,
required=False)
url = serializers.CharField(source='get_absolute_url', read_only=True)
current_version = serializers.IntegerField(read_only=True,
source='revision_id')
template = TemplateSerializer(required=False, source='get_template')
template_id = serializers.CharField(required=False, write_only=True)
template_data = JSONField(required=False)
integrations = JSONField(required=False)
currently_breaking = serializers.BooleanField(
source='is_currently_breaking', read_only=True)
class Meta:
model = Article
fields = ('id', 'slug', 'url', 'headline', 'featured_image',
'featured_video', 'snippet', 'content', 'authors',
'author_ids', 'tags', 'tag_ids', 'topic', 'topic_id',
'authors_string', 'section', 'section_id', 'subsection',
'subsection_id', 'published_at', 'is_published',
'is_breaking', 'breaking_timeout', 'currently_breaking',
'published_version', 'current_version', 'latest_version',
'preview_id', 'importance', 'reading_time', 'template',
'template_id', 'template_data', 'seo_keyword',
'seo_description', 'integrations')
authenticated_fields = ('template', 'integrations', 'preview_id')
def create(self, validated_data):
instance = Article()
return self.update(instance, validated_data)
def update(self, instance, validated_data):
template = validated_data.get('template_id', instance.template)
template_data = validated_data.get('template_data',
instance.template_data)
tag_ids = validated_data.get('tag_ids', False)
tags = []
if tag_ids != False:
for tag_id in tag_ids:
try:
tags.append(Tag.objects.get(id=int(tag_id)))
except Tag.DoesNotExist:
pass
TemplateValidator(template, template_data, tags)
# Update basic fields
instance.headline = validated_data.get('headline', instance.headline)
instance.section_id = validated_data.get('section_id',
instance.section_id)
instance.slug = validated_data.get('slug', instance.slug)
instance.snippet = validated_data.get('snippet', instance.snippet)
instance.reading_time = validated_data.get('reading_time',
instance.reading_time)
instance.importance = validated_data.get('importance',
instance.importance)
instance.is_breaking = validated_data.get('is_breaking',
instance.is_breaking)
instance.breaking_timeout = validated_data.get(
'breaking_timeout', instance.breaking_timeout)
instance.seo_keyword = validated_data.get('seo_keyword',
instance.seo_keyword)
instance.seo_description = validated_data.get('seo_description',
instance.seo_description)
instance.integrations = validated_data.get('integrations',
instance.integrations)
instance.template = template
instance.template_data = template_data
instance.save()
instance.content = validated_data.get('content', instance.content)
featured_image = validated_data.get('featured_image', False)
if featured_image != False:
instance.save_featured_image(featured_image)
featured_video = validated_data.get('featured_video', False)
if featured_video != False:
instance.save_featured_video(featured_video)
authors = validated_data.get('author_ids')
if authors:
instance.save_authors(authors, is_publishable=True)
if tag_ids != False:
instance.save_tags(tag_ids)
topic_id = validated_data.get('topic_id', False)
if topic_id != False:
instance.save_topic(topic_id)
subsection_id = validated_data.get('subsection_id', None)
instance.save_subsection(subsection_id)
# Perform a final save (without revision), update content and featured image
instance.save(update_fields=[
'content', 'featured_image', 'featured_video', 'topic'
],
revision=False)
return instance
class BaseProjectSerializer(serializers.HyperlinkedModelSerializer):
"""
BaseProjectSerializer class.
"""
projectid = serializers.ReadOnlyField(source='id')
url = serializers.HyperlinkedIdentityField(view_name='project-detail',
lookup_field='pk')
owner = serializers.HyperlinkedRelatedField(
view_name='user-detail',
source='organization',
lookup_field='username',
queryset=User.objects.exclude(
username__iexact=settings.ANONYMOUS_DEFAULT_USERNAME))
created_by = serializers.HyperlinkedRelatedField(view_name='user-detail',
lookup_field='username',
read_only=True)
metadata = JsonField(required=False)
starred = serializers.SerializerMethodField()
users = serializers.SerializerMethodField()
forms = serializers.SerializerMethodField()
public = serializers.BooleanField(source='shared')
tags = TagListSerializer(read_only=True)
num_datasets = serializers.SerializerMethodField()
last_submission_date = serializers.SerializerMethodField()
teams = serializers.SerializerMethodField()
class Meta:
model = Project
fields = [
'url', 'projectid', 'owner', 'created_by', 'metadata', 'starred',
'users', 'forms', 'public', 'tags', 'num_datasets',
'last_submission_date', 'teams', 'name', 'date_created',
'date_modified', 'deleted_at'
]
def get_starred(self, obj):
"""
Return True if request user has starred this project.
"""
return is_starred(obj, self.context['request'])
def get_users(self, obj):
"""
Return a list of users and organizations that have access to the
project.
"""
owner_query_param_in_request = 'request' in self.context and\
"owner" in self.context['request'].GET
return get_users(obj, self.context, owner_query_param_in_request)
@check_obj
def get_forms(self, obj):
"""
Return list of xforms in the project.
"""
forms = cache.get('{}{}'.format(PROJ_BASE_FORMS_CACHE, obj.pk))
if forms:
return forms
xforms = get_project_xforms(obj)
request = self.context.get('request')
serializer = BaseProjectXFormSerializer(xforms,
context={'request': request},
many=True)
forms = list(serializer.data)
cache.set('{}{}'.format(PROJ_BASE_FORMS_CACHE, obj.pk), forms)
return forms
def get_num_datasets(self, obj): # pylint: disable=no-self-use
"""
Return the number of datasets attached to the project.
"""
return get_num_datasets(obj)
def get_last_submission_date(self, obj): # pylint: disable=no-self-use
"""
Return the most recent submission date to any of the projects datasets.
"""
return get_last_submission_date(obj)
def get_teams(self, obj): # pylint: disable=no-self-use
"""
Return the teams with access to the project.
"""
return get_teams(obj)
class ExamDetailSerializer(serializers.ModelSerializer):
"""Serializer Exam model database
Return Exam model serializer
For only examiner, for CreateUpdateRetrive APIView
View Nested Serializer for 'exam-detail'
Create and Update Exam instance and releted with Question model
Validate id of questions updated
- control that question id belong to updated exam instance
"""
exam_questions = QuestionSerializer(many=True)
examiner = serializers.ReadOnlyField(source='examiner.username')
test = serializers.HyperlinkedIdentityField(view_name='exam-test')
assesments = serializers.HyperlinkedIdentityField(
view_name='exam-assesment')
set_grades = serializers.HyperlinkedIdentityField(
view_name='exam-judge-results')
class Meta:
model = models.Exam
fields = ('url', 'id', 'examiner', 'title', 'topic', 'created_in',
'avaiable', 'test', 'answered', 'assesments', 'checking',
'set_grades', 'judged', 'archivized', 'archivized_in',
'exam_questions')
def create(self, validated_data):
questions_data = validated_data.pop('exam_questions')
exam = models.Exam.objects.create(**validated_data)
for question in questions_data:
models.Question.objects.create(exam=exam, **question_data)
return exam
def update(self, instance, validated_data):
questions_data = validated_data.pop('exam_questions')
instance.avaiable = validated_data.get('avaiable', instance.avaiable)
instance.title = validated_data.get('title', instance.title)
instance.topic = validated_data.get('topic', instance.topic)
instance.archivized = validated_data.get('archivized',
instance.archivized)
instance.save()
# Checking questions if some of them are deleted
questions_preview = [
x.id for x in models.Question.objects.filter(exam=instance)
]
questions_actuall = [
x.get('id') for x in questions_data if x.get('id') != None
]
for x in questions_preview:
if x not in questions_actuall:
models.Question.objects.get(id=x).delete()
# Adding new and updating questions
for question in questions_data:
nr = question.get('id', None)
if nr:
q = models.Question.objects.filter(id=nr, exam=instance)
if q.exists():
q = q.first()
q.question_text = question.get('question_text',
q.question_text)
q.max_points = question.get('max_points', q.question_text)
q.save()
else:
raise serializers.ValidationError(
'You cant edit/create question with this id.')
else:
models.Question.objects.create(exam=instance, **question)
return instance