class CommentSerializer(serializers.ModelSerializer):
author = serializers.StringRelatedField()
class Meta:
model = Comment
fields = ('id', 'url', 'content', 'author')
class GlobalUserSerializer(serializers.HyperlinkedModelSerializer):
names = serializers.StringRelatedField(many=True)
class Meta:
model = GlobalUser
fields = ['id', 'url', 'phone_number', 'spam', 'names']
class ProfileSerializer(serializers.ModelSerializer):
name = serializers.ReadOnlyField(source="user.username")
next_review_date = serializers.SerializerMethodField()
unlocked_levels = serializers.StringRelatedField(many=True, read_only=True)
reviews_within_hour_count = serializers.SerializerMethodField()
reviews_within_day_count = serializers.SerializerMethodField()
srs_counts = SrsCountSerializer(source="user", many=False, read_only=True)
# upcoming_reviews = DetailedUpcomingReviewCountSerializer(source='user', many=False, read_only=True)
upcoming_reviews = SimpleUpcomingReviewSerializer(
source="user", many=False, read_only=True
)
join_date = serializers.SerializerMethodField()
api_key_v2 = serializers.CharField(
max_length=40,
validators=[WanikaniApiKeyValidatorV2()],
allow_null=True,
)
class Meta:
model = Profile
fields = (
"id",
"name",
"api_key_v2",
"api_valid",
"level",
"follow_me",
"auto_advance_on_success",
"unlocked_levels",
"last_wanikani_sync_date",
"auto_expand_answer_on_success",
"auto_expand_answer_on_failure",
"on_vacation",
"vacation_date",
"reviews_within_day_count",
"reviews_within_hour_count",
"srs_counts",
"minimum_wk_srs_level_to_review",
"maximum_wk_srs_level_to_review",
"upcoming_reviews",
"next_review_date",
"join_date",
"auto_advance_on_success_delay_milliseconds",
"use_eijiro_pro_link",
"show_kanji_svg_stroke_order",
"show_kanji_svg_grid",
"kanji_svg_draw_speed",
"info_detail_level_on_success",
"info_detail_level_on_failure",
"order_reviews_by_level",
"burn_reviews",
)
read_only_fields = (
"id",
"name",
"api_valid",
"level",
"unlocked_levels",
"vacation_date",
"reviews_within_day_count",
"reviews_within_hour_count",
"srs_counts",
"next_review_date",
"last_wanikani_sync_date",
"join_date"
)
def get_join_date(self, obj):
"""
So this is a hack. By default the modelserializer expects a datefield, but a fewww users have datetimefields as their join_date,
due to an old version of the model. Eventually we should fix those users but for now this methodfield does the trick.
"""
return obj.join_date
def save(self, **kwargs):
return super().save(**kwargs)
def get_next_review_date(self, obj):
user = obj.user
if self.get_reviews_count(obj) == 0:
reviews = get_users_future_reviews(user)
if reviews:
next_review_date = reviews[0].next_review_date
return next_review_date
def get_reviews_count(self, obj):
return get_users_current_reviews(obj.user).count()
def get_reviews_within_hour_count(self, obj):
return get_users_future_reviews(
obj.user, time_limit=datetime.timedelta(hours=1)
).count()
def get_reviews_within_day_count(self, obj):
return get_users_future_reviews(
obj.user, time_limit=datetime.timedelta(hours=24)
).count()
class NickSerializer(serializers.ModelSerializer): variants = serializers.StringRelatedField(many=True) class Meta: model = Nick fields = ['name', 'abbreviation', 'is_primary_nick', 'variants']
class AccountSerializer(serializers.ModelSerializer):
direction = serializers.StringRelatedField(many=True)
class Meta:
model = Account
fields = '__all__'
class WorkoutReadSerializer(WorkoutSerializer):
author = serializers.StringRelatedField()
favorites = serializers.StringRelatedField(many=True)
class UserSerializer(serializers.ModelSerializer):
groups = serializers.StringRelatedField(many=True)
class Meta:
model = User
fields = ('url', 'username', 'first_name','last_name','email', 'groups')
class ApplicationAdminSerializer(AuditModelSerializer):
"""
Serializes RegistryApplication model fields for admin users
"""
status_set = ApplicationStatusSerializer(many=True, read_only=True)
current_status = ApplicationStatusSerializer(required=False)
cert_authority = serializers.ReadOnlyField(
source="primary_certificate.cert_auth.cert_auth_code")
qualifications = serializers.StringRelatedField(
source='subactivity.qualification_set', many=True, read_only=True)
subactivity = SubactivitySerializer()
class Meta:
model = RegistriesApplication
fields = ('create_user', 'create_date', 'update_user', 'update_date',
'application_guid', 'registration', 'file_no', 'over19_ind',
'cert_authority', 'registrar_notes', 'reason_denied',
'subactivity', 'qualifications', 'status_set',
'current_status')
def to_internal_value(self, data):
"""
Set fields to different serializers for create/update operations.
This method is called on POST/PUT/PATCH requests
"""
self.fields['subactivity'] = serializers.PrimaryKeyRelatedField(
queryset=SubactivityCode.objects.all())
return super(ApplicationAdminSerializer, self).to_internal_value(data)
def create(self, validated_data):
"""
Create an application as well as a default status record of "pending"
"""
try:
app = RegistriesApplication.objects.create(**validated_data)
except TypeError:
raise TypeError('A field may need to be made read only.')
# make a status record to go with the new application
# by default we set the ApplicationStatus to P(ending).
pending = ApplicationStatusCode.objects.get(
registries_application_status_code='P')
RegistriesApplicationStatus.objects.create(application=app,
status=pending)
return app
@transaction.atomic
def update(self, instance, validated_data):
"""
The update is wrapped inside a transaction since we're changing a few
records and creating one. We want to avoid a state where where a partial
change occurs, especially if it leaves an application without a current
status.
"""
# We pop the current status, as the update method on the base
# class cannot serialize nested fields.
validated_status = validated_data.pop('current_status', None)
if validated_status:
# Validated_status is an OrderedDict at this point.
validated_status_code = validated_status.get(
'status').registries_application_status_code
current_status = instance.current_status
if current_status:
current_status_code = current_status.status.registries_application_status_code
else:
logger.error(
'RegistryApplication {} does not have a current status'.
format(instance))
current_status_code = None
if validated_status_code != current_status_code:
if current_status:
# Expire existing status.
current_status.expired_date = timezone.now()
current_status.save()
new_status = ApplicationStatusCode.objects.get(
registries_application_status_code=validated_status_code)
# Create a new status.
RegistriesApplicationStatus.objects.create(
application=instance, status=new_status)
return super().update(instance, validated_data)
class ProductSerializer(serializers.ModelSerializer):
"""
A serializer to get a single product instance
"""
unit = serializers.SerializerMethodField()
colors = ProductInstanceNameSerializer(read_only=True, many=True)
styles = serializers.SerializerMethodField()
applications = serializers.SerializerMethodField()
materials = serializers.SerializerMethodField()
sizes = serializers.SerializerMethodField()
images = BaseHeaderImageSerializer(read_only=True, many=True)
variants = serializers.SerializerMethodField()
files = ProductFileSerializer(read_only=True, many=True)
origin_country = serializers.StringRelatedField(
source="supplier.origin_country", read_only=True
)
site_state = serializers.SerializerMethodField()
class Meta:
model = Product
fields = (
"id",
"unit",
"name",
"slug",
"short_description",
"description",
"available_in_special_sizes",
"absorption",
"sizes",
"colors",
"styles",
"applications",
"materials",
"images",
"variants",
"files",
"origin_country",
"site_state",
)
read_only_fields = fields
def get_unit(self, product):
"""
Return display name of unit type
"""
return product.get_unit_display()
def get_sizes(self, product):
"""
Order sizes based on width
"""
sizes = (
Size.objects.filter(product_options__product=product)
.distinct()
.order_by("width", "height", "depth", "circumference")
)
return SizeSerializer(sizes, read_only=True, many=True).data
def get_site_state(self, product):
site_state = ProductSiteState.on_site.get(product=product)
return ProductSiteStateSerializer(site_state, read_only=True).data
def get_styles(self, product):
styles = product.get_styles_display()
return ProductInstanceNameSerializer(styles, read_only=True, many=True).data
def get_applications(self, product):
applications = product.get_applications_display()
return ProductInstanceNameSerializer(
applications, read_only=True, many=True
).data
def get_materials(self, product):
materials = product.get_materials_display()
return ProductInstanceNameSerializer(materials, read_only=True, many=True).data
def get_variants(self, product):
product_variants = get_related_unique_variants(product=product)
return VariantSerializer(product_variants, read_only=True, many=True).data
class CarSerializer(serializers.ModelSerializer):
company = serializers.StringRelatedField()
class Meta:
model = Car
fields = ['id', 'name', 'company']
class ModelSerializer(serializers.ModelSerializer):
car = serializers.StringRelatedField()
class Meta:
model = Model
fields = ['id', 'name', 'car']
class QuestionSerializer(serializers.ModelSerializer):
asker = UserProfileSerializer(many=False)
categories = serializers.StringRelatedField(many=True, required=False)
answers = AnswerSerializer(many=True, read_only=True)
link = serializers.CharField(source='related_link', required=False)
replyTo = serializers.PrimaryKeyRelatedField(
queryset=Question.objects.all(), required=False)
class Meta:
model = Question
fields = ('id', 'text', 'questionType', 'date', 'asker', 'categories',
'option1', 'option2', 'option3', 'option4', 'option5',
'answers', 'link', 'replyTo')
read_only_fields = ('id', 'date')
def validate(self, data):
options = []
options.append(data['option1'].lower())
options.append(data['option2'].lower())
options.append(data['option3'].lower())
options.append(data['option4'].lower())
options.append(data['option5'].lower())
other = []
has_duplicates = False
for i in options:
if has_duplicates:
break
elif i is None or i == "":
pass
elif i in other:
has_duplicates = True
else:
other.append(i)
if has_duplicates:
print("This question has duplicates: " + str(has_duplicates))
raise serializers.ValidationError("Options must be unique")
return data
def to_representation(self, obj):
rep = super(serializers.ModelSerializer, self).to_representation(obj)
rep['options'] = to_array(rep)
answers = rep['answers']
request = self.context.get('request', None)
if request and request.user.is_authenticated():
rep['isUser'] = True
answer = Answer.objects.filter(question=rep['id'],
user=request.user.profile)
if answer is not None and answer.count() > 0:
serializer = AnswerSerializer(answer[0]).data
rep['usersAnswer'] = serializer
# for answer in answers:
# print("Answer user id: " + str(answer['user']))
# print("Request user id: " + str(request.user.profile.id))
# if answer['user'] == request.user.profile.id:
# rep['isAnswered'] = True
# rep['usersAnswer'] = answer
# break
# else:
# rep['isAnswered'] = False
else:
rep['isUser'] = False
answers = Answer.objects.filter(question=rep['id'])
if rep['questionType'] == 'RG':
rep['quick'] = answers.values('answer').aggregate(
Avg('answer')).get('answer__avg')
else:
rep['quick'] = {
'option1': answers.filter(answer=0).count(),
'option2': answers.filter(answer=1).count(),
'option3': answers.filter(answer=2).count(),
'option4': answers.filter(answer=3).count(),
'option5': answers.filter(answer=4).count()
}
return rep
def to_internal_value(self, data):
asker_id = data.get('asker', None)
if asker_id != None:
asker = UserProfile.objects.get(pk=asker_id)
data['asker'] = UserProfileSerializer(asker).data
data = to_columns(data)
categories = data.pop('categories', None)
data = super(serializers.ModelSerializer, self).to_internal_value(data)
if categories:
data['categories'] = categories
return data
def create(self, validated_data):
categories = validated_data.pop('categories', None)
asker = validated_data.pop('asker', None)
if asker != None:
asker = UserProfile.objects.get(pk=asker.pop('id'))
question = Question.objects.create(asker=asker, **validated_data)
question.save()
if categories:
for category in categories:
print("Creating category " + category)
catModel = Category.objects.create(category=category)
catModel.save()
print("Saving category")
catModel.question.add(question)
print("Added to the question")
return question
def update(self, instance, validated_data):
categories = validated_data.pop('categories', None)
instance.text = validated_data.get('text', instance.text)
instance.questionType = validated_data.get('questionType',
instance.questionType)
instance.option1 = validated_data.get('option1', instance.option1)
instance.option2 = validated_data.get('option2', instance.option2)
instance.option3 = validated_data.get('option3', instance.option3)
instance.option4 = validated_data.get('option4', instance.option4)
instance.option5 = validated_data.get('option5', instance.option5)
instance.save()
# for category in categories:
# catModel = Category.objects.create(category=category)
# catModel.save()
# catModel.question.add(instance)
return instance
class ItemSerializer(serializers.ModelSerializer):
keyword = serializers.StringRelatedField(many=True)
class Meta:
model = Item
fields = ('__all__')
class PostSerializer(serializers.ModelSerializer):
author = serializers.StringRelatedField()
class Meta:
model = Post
fields = ('id', 'url', 'title', 'content', 'author')
def setUp(self):
self.instance = MockObject(pk=1, name='foo')
self.field = serializers.StringRelatedField(many=True)
self.field.field_name = 'foo'
class UserSerializer(serializers.ModelSerializer):
staff_of = serializers.StringRelatedField()
class Meta:
model = User
fields = ['url', 'username', 'email']
class StockSerializer(serializers.HyperlinkedModelSerializer):
vendor = serializers.StringRelatedField(read_only=True)
class Meta:
model = Stock
fields = ('id', 'vendor', 'gastype', 'image', 'price')
class KeyDocSerializer(serializers.ModelSerializer):
creator = serializers.StringRelatedField()
class Meta:
model = KeyDoc
fields = ['creator', 'date_created', 'members_when_created']
class InstitutionDetailSerializer(serializers.ModelSerializer):
eter = serializers.StringRelatedField()
identifiers = InstitutionIdentifierSerializer(
many=True, read_only=True, source='institutionidentifier_set')
names = InstitutionNameSerializer(many=True,
read_only=True,
source='institutionname_set')
countries = InstitutionCountryDetailSerializer(
many=True, read_only=True, source='institutioncountry_set')
# nqf_levels = serializers.StringRelatedField(many=True, read_only=True, source='institutionnqflevel_set')
qf_ehea_levels = InstitutionQFEHEALevelSerializer(
many=True, read_only=True, source='institutionqfehealevel_set')
historical_relationships = serializers.SerializerMethodField()
hierarchical_relationships = serializers.SerializerMethodField()
historical_data = InstitutionHistoricalDataSerializer(
many=True, read_only=True, source='institutionhistoricaldata_set')
def get_hierarchical_relationships(self, obj):
includes = []
part_of = []
for relation in obj.relationship_parent.all():
includes.append(
InstitutionListSerializer(relation.institution_child,
context=self.context).data)
for relation in obj.relationship_child.all():
part_of.append(
InstitutionListSerializer(relation.institution_parent,
context=self.context).data)
return {'includes': includes, 'part_of': part_of}
def get_historical_relationships(self, obj):
relationships = []
for relation in obj.relationship_source.all():
relationships.append({
'institution':
InstitutionListSerializer(relation.institution_target,
context=self.context).data,
'relationship_type':
relation.relationship_type.type_to,
'relationship_date':
relation.relationship_date
})
for relation in obj.relationship_target.all():
relationships.append({
'institution':
InstitutionListSerializer(relation.institution_source,
context=self.context).data,
'relationship_type':
relation.relationship_type.type_from,
'relationship_date':
relation.relationship_date
})
return relationships
class Meta:
ref_name = 'Institution v1'
model = Institution
fields = ('id', 'eter', 'identifiers', 'website_link', 'names',
'countries', 'founding_date', 'closure_date',
'historical_relationships', 'hierarchical_relationships',
'qf_ehea_levels', 'historical_data')
class ProjectSerializer(FlexFieldsModelSerializer):
homepage = serializers.SerializerMethodField()
language = LanguageSerializer()
programming_language = ProgrammingLanguageSerializer()
repository = RepositorySerializer(source='*')
urls = ProjectURLsSerializer(source='*')
subproject_of = serializers.SerializerMethodField()
translation_of = serializers.SerializerMethodField()
default_branch = serializers.CharField(source='get_default_branch')
tags = serializers.StringRelatedField(many=True)
users = UserSerializer(many=True)
_links = ProjectLinksSerializer(source='*')
# TODO: adapt these fields with the proper names in the db and then remove
# them from here
created = serializers.DateTimeField(source='pub_date')
modified = serializers.DateTimeField(source='modified_date')
class Meta:
model = Project
fields = [
'id',
'name',
'slug',
'created',
'modified',
'language',
'programming_language',
'homepage',
'repository',
'default_version',
'default_branch',
'subproject_of',
'translation_of',
'users',
'urls',
'tags',
# NOTE: ``expandable_fields`` must not be included here. Otherwise,
# they will be tried to be rendered and fail
# 'users',
# 'active_versions',
'_links',
]
expandable_fields = {
'active_versions': (
VersionSerializer,
{
# NOTE: this has to be a Model method, can't be a
# ``SerializerMethodField`` as far as I know
'source': 'active_versions',
'many': True,
})
}
def get_homepage(self, obj):
# Overridden only to return ``None`` when the project_url is ``''``
return obj.project_url or None
def get_translation_of(self, obj):
if obj.main_language_project:
return self.__class__(obj.main_language_project).data
def get_subproject_of(self, obj):
try:
return self.__class__(obj.superprojects.first().parent).data
except Exception:
return None
class UserRequestSerializer(serializers.ModelSerializer):
requests = RequestSerializer(many=True)
submitter = serializers.StringRelatedField(
default=serializers.CurrentUserDefault())
class Meta:
model = UserRequest
fields = '__all__'
read_only_fields = ('id', 'submitter', 'created', 'state', 'modified')
extra_kwargs = {
'proposal': {
'error_messages': {
'null': 'Please provide a proposal.'
}
},
'group_id': {
'error_messages': {
'blank': 'Please provide a title.'
}
}
}
@transaction.atomic
def create(self, validated_data):
request_data = validated_data.pop('requests')
user_request = UserRequest.objects.create(**validated_data)
for r in request_data:
target_data = r.pop('target')
constraints_data = r.pop('constraints')
window_data = r.pop('windows')
molecule_data = r.pop('molecules')
location_data = r.pop('location')
request = Request.objects.create(user_request=user_request, **r)
Location.objects.create(request=request, **location_data)
Target.objects.create(request=request, **target_data)
Constraints.objects.create(request=request, **constraints_data)
for data in window_data:
Window.objects.create(request=request, **data)
for data in molecule_data:
Molecule.objects.create(request=request, **data)
debit_ipp_time(user_request)
logger.info('UserRequest created',
extra={
'tags': {
'user': user_request.submitter.username,
'tracking_num': user_request.id,
'group_id': user_request.group_id
}
})
return user_request
def validate(self, data):
# check that the user belongs to the supplied proposal
if data['proposal'] not in data['submitter'].proposal_set.all():
raise serializers.ValidationError(
_('You do not belong to the proposal you are trying to submit')
)
# validation on the operator matching the number of requests
if data['operator'] == 'SINGLE':
if len(data['requests']) > 1:
raise serializers.ValidationError(
_("'Single' type user requests must have exactly one child request."
))
elif len(data['requests']) == 1:
raise serializers.ValidationError(
_("'{}' type user requests must have more than one child request."
.format(data['operator'].title())))
try:
total_duration_dict = get_total_duration_dict(data)
for tak, duration in total_duration_dict.items():
time_allocation = TimeAllocation.objects.get(
semester=tak.semester,
telescope_class=tak.telescope_class,
proposal=data['proposal'],
)
time_available = 0
if data['observation_type'] == UserRequest.NORMAL:
time_available = time_allocation.std_allocation - time_allocation.std_time_used
elif data['observation_type'] == UserRequest.TOO:
time_available = time_allocation.too_allocation - time_allocation.too_time_used
if time_available <= 0.0:
raise serializers.ValidationError(
_("Proposal {} does not have any time left allocated in semester {} on {} telescopes"
).format(data['proposal'], tak.semester,
tak.telescope_class))
elif time_available * OVERHEAD_ALLOWANCE < (duration / 3600.0):
raise serializers.ValidationError(
_("Proposal {} does not have enough time allocated in semester {} on {} telescopes"
).format(data['proposal'], tak.semester,
tak.telescope_class))
# validate the ipp debitting that will take place later
validate_ipp(data, total_duration_dict)
except ObjectDoesNotExist:
raise serializers.ValidationError(
_("You do not have sufficient time allocated on the resource you're requesting for this proposal."
))
except TimeAllocationError as e:
raise serializers.ValidationError(repr(e))
return data
def validate_requests(self, value):
if not value:
raise serializers.ValidationError(
_('You must specify at least 1 request'))
return value
class AlbumSerializerWithStringRelatedField(serializers.ModelSerializer):
tracks = serializers.StringRelatedField(many=True)
class Meta:
model = Album
fields = ('album_name', 'artist', 'tracks')
class OrderItemSerializer(serializers.ModelSerializer):
drink = serializers.StringRelatedField()
class Meta:
model = models.OrderItem
fields = '__all__'
class AllFieldsSerializer(serializers.ModelSerializer):
field_decimal_uncoerced = serializers.DecimalField(
source='field_decimal',
max_digits=6,
decimal_places=3,
coerce_to_string=False
)
field_method_float = serializers.SerializerMethodField()
def get_field_method_float(self, obj) -> float:
return 1.3456
field_method_object = serializers.SerializerMethodField()
def get_field_method_object(self, obj) -> dict:
return {'key': 'value'}
field_regex = serializers.RegexField(r'^[a-zA-z0-9]{10}\-[a-z]')
# composite fields
field_list = serializers.ListField(
child=serializers.FloatField(), min_length=3, max_length=100,
)
field_list_serializer = serializers.ListField(
child=AuxSerializer(),
source='field_list_object',
)
# extra related fields
field_related_slug = serializers.SlugRelatedField(
read_only=True, source='field_foreign', slug_field='id'
)
field_related_string = serializers.StringRelatedField(
source='field_foreign'
)
field_related_hyperlink = serializers.HyperlinkedRelatedField(
read_only=True, source='field_foreign', view_name='aux-detail'
)
field_identity_hyperlink = serializers.HyperlinkedIdentityField(
read_only=True, view_name='allfields-detail'
)
# read only - model traversal
field_read_only_nav_uuid = serializers.ReadOnlyField(source='field_foreign.id')
field_read_only_nav_uuid_3steps = serializers.ReadOnlyField(
source='field_foreign.field_foreign.field_foreign.id',
allow_null=True, # force field output even if traversal fails
)
field_read_only_model_function_basic = serializers.ReadOnlyField(source='model_function_basic')
field_read_only_model_function_model = serializers.ReadOnlyField(source='model_function_model.id')
# override default writable bool field with readonly
field_bool_override = serializers.ReadOnlyField()
field_model_property_float = serializers.ReadOnlyField()
field_model_cached_property_float = serializers.ReadOnlyField()
field_dict_int = serializers.DictField(
child=serializers.IntegerField(),
source='field_json',
)
# there is a JSON model field for django>=3.1 that would be placed automatically. for <=3.1 we
# need to set the field explicitly. defined here for both cases to have consistent ordering.
field_json = serializers.JSONField()
class Meta:
fields = '__all__'
model = AllFields
class User_puntuationSerializer(serializers.ModelSerializer):
AccountSerializer = serializers.StringRelatedField(many=True)
class Meta:
model = User_puntuation
fields = '__all__'
class ExportOrderItemSerializer(serializers.ModelSerializer):
class Meta:
model = OrderItem
fields = ('product', 'quantity', 'cost')
product = serializers.StringRelatedField()
class VisitGetSerializer(serializers.ModelSerializer):
patient = serializers.StringRelatedField()
class Meta:
model = Visit
fields = '__all__'
class ProductParameterPriceSerializer(serializers.ModelSerializer):
class Meta:
model = ProductParameter
fields = ('parameter', 'value')
parameter = serializers.StringRelatedField()
class ProjectSerializer(serializers.ModelSerializer):
members = serializers.StringRelatedField(many=True)
class Meta:
model = Project
fields = '__all__'
class ProfilDurumSerializer(serializers.ModelSerializer):
user_profil = serializers.StringRelatedField(read_only=True)
class Meta:
model = ProfilDurum
fields = '__all__'
