class PostSerializer(serializers.ModelSerializer):
'''serializer for Post model'''
#read only fields
communities_list = serializers.ListField(source="get_communities_as_list",
read_only=True)
owner = serializers.DictField(source="get_owner_info", read_only=True)
date = serializers.CharField(source="get_date_posted", read_only=True)
uuid = serializers.CharField(source="get_uuid_as_string", read_only=True)
liked = serializers.SerializerMethodField()
reported = serializers.SerializerMethodField()
#write only fields
user_id = serializers.IntegerField(write_only=True)
add_communities = serializers.ListField(allow_null=True,
default=None, write_only=True)
remove_communities = serializers.ListField(write_only=True,
allow_null=True,
default=None)
class Meta:
model = Post
fields = ['communities_list', 'owner', 'date', 'uuid', 'liked',
'reported', 'user_id', 'add_communities', 'remove_communities',
'title', 'text', 'likes', 'reports']
def get_liked(self, obj):
if self.context:
session_sub = self.context['session_sub']
if str(obj.uuid) in session_sub.liked_posts_as_list:
return True
else:
return False
else:
return None
def get_reported(self, obj):
if self.context:
session_sub = self.context['session_sub']
if str(obj.uuid) in session_sub.reported_posts_as_list:
return True
else:
return False
else:
return None
def create(self, validated_data):
#remove_communities, add_communities and user_id are fields
#that are not in Post model itself therefore they can't go into
#Post.objects.create() method so we will take them away from
#validated_data
del validated_data['remove_communities']
#communities are added to the model through the taggit api at the end
communities = validated_data.pop('add_communities')
#try to get user from user_id to then get the corresponding
#Sub model that will be the post owner
try:
#user_id cannot be supplied by the front end, it should always
#be provided by the corresponding views that serves to create and
#update posts
usr_id = validated_data.pop('user_id')
user = User.objects.get(id=usr_id)
sub = Sub.objects.get(user=user)
except User.DoesNotExist as e:
raise Exception(e)
except Sub.DoesNotExist as e:
raise Exception(e)
else:
validated_data['owner'] = sub
new_post = Post.objects.create(**validated_data)
if communities:
for com in communities:
new_post.communities.add(com)
return new_post
def update(self, instance, validated_data):
#user_id cannot be supplied by the front end, it shouold always be
#provided by the corresponding views that serves to
#update and create a post
usr_id = validated_data.pop('user_id')
if usr_id == instance.owner.user.id:
new_title = validated_data.get('title')
new_text = validated_data.get('text')
new_likes = validated_data.get('likes')
new_reports = validated_data.get('reports')
if new_title != instance.title:
instance.title = new_title
if new_text != instance.text:
instance.text = new_text
if new_likes != instance.likes and new_likes != None:
instance.likes = new_likes
if new_reports != instance.reports and new_reports != None:
instance.reports = new_reports
if validated_data.get('remove_communities'):
for com in validated_data.get('remove_communities'):
instance.communities.remove(com)
instance.save()
return instance
else:
message = "user_id cannot change"
raise Exception(message)
class LearnerDetailsSerializer(serializers.ModelSerializer):
"""
{
"username": "******",
"name": "Maxi Fernandez",
"country": "UY",
"is_active": true,
"year_of_birth": 1985,
"level_of_education": "b",
"gender": "m",
"date_joined": "2018-05-06T14:01:58Z",
"bio": null,
"profile_image": {
"image_url_full": "http://*****:*****@appsembler.com",
"courses": [
{
"course_name": "Something",
"course_code": "A193",
"course_id": "A193+2016Q4+something",
"date_enrolled": "2018-05-06T14:01:58Z",
"progress_data": {
"course_completed": "2018-05-06T14:01:58Z", // empty if not completed
"course_progress": 0.59, // percentage
"course_progress_history": [
{
"period": "April 2018",
"value": 0.28,
},
...
]
}
}
...
]
}
"""
name = serializers.CharField(source='profile.name', default=None,)
country = SerializeableCountryField(
source='profile.country',
required=False, allow_blank=True)
year_of_birth = serializers.IntegerField(source='profile.year_of_birth',)
gender = serializers.CharField(source='profile.gender',)
level_of_education = serializers.CharField(
source='profile.level_of_education',
allow_blank=True, required=False,)
bio = serializers.CharField(source='profile.bio', required=False)
# We may want to exclude this unless we want to show
# profile images in Figures
profile_image = serializers.SerializerMethodField()
language_proficiencies = serializers.SerializerMethodField()
# Would like to make this work without using the SerializerMethodField
# courses = LearnerCourseDetailsSerializezr(many=True)
courses = serializers.SerializerMethodField()
class Meta:
model = get_user_model()
editable = False
fields = (
'id', 'username', 'name', 'email', 'country', 'is_active',
'year_of_birth', 'level_of_education', 'gender', 'date_joined',
'bio', 'courses', 'language_proficiencies', 'profile_image',
)
read_only_fields = fields
def get_language_proficiencies(self, user):
if hasattr(user, 'profiles') and user.profile.language:
return [user.profile.language]
else:
return []
def get_courses(self, user):
"""
This method is a hack until I figure out customizing DRF fields and/or
related serializers to explicitly link models not linked via FK
"""
course_enrollments = figures.sites.get_course_enrollments_for_site(
self.context.get('site')).filter(user=user)
return LearnerCourseDetailsSerializer(course_enrollments, many=True).data
def get_profile_image(self, user):
if hasattr(user, 'profile'):
return AccountLegacyProfileSerializer.get_profile_image(
user.profile, user, None)
else:
return None
class PropertyCustomSearchSerializer(serializers.ModelSerializer):
class Meta:
model = ds.Property
fields = (ds.Property.SHORT_SUMMARY_FIELDS +
('nycha', 'subsidyprograms', 'subsidyj51', 'subsidy421a',
'unitsrentstabilized', 'latestsaleprice'))
subsidyprograms = serializers.SerializerMethodField()
subsidyj51 = serializers.SerializerMethodField()
subsidy421a = serializers.SerializerMethodField()
nycha = serializers.SerializerMethodField()
unitsrentstabilized = serializers.SerializerMethodField()
latestsaleprice = serializers.SerializerMethodField()
def get_nycha(self, obj):
try:
return obj.propertyannotation.nycha
except Exception as e:
return None
def get_subsidy421a(self, obj):
try:
return obj.propertyannotation.subsidy421a
except Exception as e:
return None
def get_subsidyj51(self, obj):
try:
return obj.propertyannotation.subsidyj51
except Exception as e:
return None
def get_subsidyprograms(self, obj):
try:
return obj.propertyannotation.subsidyprograms
except Exception as e:
return None
def get_unitsrentstabilized(self, obj):
try:
return obj.propertyannotation.unitsrentstabilized
except Exception as e:
return None
def get_latestsaleprice(self, obj):
try:
return obj.propertyannotation.latestsaleprice
except Exception as e:
return None
def to_representation(self, obj):
rep = super(serializers.ModelSerializer, self).to_representation(obj)
def get_context_field(dataset_prefix, date_label=None):
# uses singular dataset_prefix
for field in self.context['fields']:
if date_label:
if dataset_prefix in field and date_label in field:
return field
else:
if dataset_prefix in field:
return field
return None
for model_name in settings.ANNOTATED_DATASETS:
dataset_class = getattr(ds, model_name)
if hasattr(
dataset_class, 'REQUIRES_AUTHENTICATION'
) and dataset_class.REQUIRES_AUTHENTICATION and not is_authenticated(
self.context['request']):
continue
dataset_prefix = dataset_class.__name__.lower()
try:
serializer_count_key = model_name.lower() + 's__count'
filter_search_str = f'filter_([0-9])+_{serializer_count_key}'
if hasattr(obj, serializer_count_key):
# annotated from api_helpers.py #prefetch_annotated_datasets
try:
filter_counts = [
elem for elem in dir(obj)
if bool(re.search(filter_search_str, elem))
]
rep[get_context_field(dataset_prefix)] = getattr(
obj, filter_counts[0])
for filter_count in filter_counts[1:]:
rep[get_context_field(dataset_prefix)] += getattr(
obj, filter_count)
except IndexError:
rep[get_context_field(dataset_prefix)] = getattr(
obj, serializer_count_key)
except ds.PropertyAnnotation.DoesNotExist:
logger.warning('No property annotation for {}'.format(obj.bbl))
return rep
class GeneralCourseDataSerializer(serializers.Serializer):
"""
Returns data in the format::
[
{
"course_id": "A101+SomethingSomething",
"course_name": "This is the course name",
"course_code": "A101",
"course_mode": "Something",
"org": "MyOrganization",
"start_date": "2017-07-15T16:59:51.740702Z", // can be empty
"end_date": "2017-07-15T16:59:51.740702Z", // can be empty
"self_paced": false,
"staff": [
{
"username": "******",
"fullname": "Matej Grozdanovic",
"user_id": 123,
"role": "instructor"
},
{
"username": "******",
"fullname": "Bubba Brown",
"user_id": 42,
"role": "staff"
}
],
"metrics": {
"learners_enrolled": 123,
"average_progress": 0.39, // percentage
"average_completion_time": "some_time_in_standardised_format",
"users_completed": 493, // total number of users that have
// completed the course since the
// course was created
}
},
...
]
"""
site = None
course_id = serializers.CharField(source='id', read_only=True)
course_name = serializers.CharField(
source='display_name_with_default_escaped', read_only=True)
course_code = serializers.CharField(
source='display_number_with_default', read_only=True)
org = serializers.CharField(
source='display_org_with_default', read_only=True)
start_date = serializers.DateTimeField(
source='start', read_only=True, default=None)
end_date = serializers.DateTimeField(
source='end', read_only=True, default=None)
self_paced = serializers.BooleanField(read_only=True)
staff = serializers.SerializerMethodField()
metrics = serializers.SerializerMethodField()
def to_representation(self, instance):
"""
This is a hack to get the site for this course
We do this because the figures.metrics calls we are making require the
site object as a parameter
"""
self.site = figures.sites.get_site_for_course(instance)
ret = super(GeneralCourseDataSerializer, self).to_representation(instance)
return ret
# def get_site(self, obj):
# return figures.sites.get_site_for_course(str(obj.id))
def get_staff(self, obj):
qs = CourseAccessRole.objects.filter(course_id=obj.id)
if qs:
return [CourseAccessRoleForGCDSerializer(data).data for data in qs]
else:
return []
def get_metrics(self, obj):
qs = CourseDailyMetrics.objects.filter(course_id=str(obj.id))
if qs:
return CourseDailyMetricsSerializer(qs.order_by('-date_for')[0]).data
else:
return None
class GeneralUserDataSerializer(serializers.Serializer):
"""
Example from API docs:
{
"username": "******",
"country": "UY",
"is_active": true,
"year_of_birth": 1985,
"level_of_education": "b",
"gender": "m",
"date_joined": "2018-05-06T14:01:58Z",
"language_proficiencies": [],
"courses": [
{
"course_name": "Something",
"course_id": "A193+2016Q4+something",
}
...
]
},
Changes from spec:
courses list:
- uses 'id' instead of 'course_id'
- includes additional fields, org and number, as we are reusing the
CourseIndexSerializer
"""
id = serializers.IntegerField(read_only=True)
username = serializers.CharField(read_only=True)
email = serializers.CharField(read_only=True)
fullname = serializers.CharField(
source='profile.name', default=None, read_only=True)
country = SerializeableCountryField(
source='profile.country',
required=False,
read_only=True,
allow_blank=True)
is_active = serializers.BooleanField(read_only=True)
year_of_birth = serializers.IntegerField(
source='profile.year_of_birth', read_only=True)
gender = serializers.CharField(source='profile.gender', read_only=True)
date_joined = serializers.DateTimeField(format="%Y-%m-%d", read_only=True)
level_of_education = serializers.CharField(
source='profile.level_of_education',
allow_blank=True,
required=False,
read_only=True)
language_proficiencies = serializers.SerializerMethodField()
courses = serializers.SerializerMethodField()
def get_language_proficiencies(self, user):
if hasattr(user, 'profiles') and user.profile.language:
return [user.profile.language]
else:
return []
def get_courses(self, user):
course_ids = CourseEnrollment.objects.filter(
user=user).values_list('course_id', flat=True).distinct()
course_overviews = CourseOverview.objects.filter(
id__in=[as_course_key(course_id) for course_id in course_ids])
return [CourseOverviewSerializer(data).data for data in course_overviews]
class IndexCategorySerializer(serializers.ModelSerializer):
'''
首页类别广告：
一级类，一级类里面有：
商品商标（多个）
大类下的二级类（多个）
所有商品（多个）
广告商品（单个）
'''
# 商品商标（多个）
brands = CategoryBrandSerializer(many=True) # GoodsCategory.brands
# 大类下的二级类
sub_cat = GoodsCategorySerializer2(many=True) # GoodsCategory.sub_cat
# 所有商品，SerializerMethodField自定义model没有的字段
goods = serializers.SerializerMethodField(
) # 这只能取出第三级分类下的商品，取不出一级类、二级类下的所有商品
def get_goods(self, obj):
'''
取出一二三级分类的商品：
获取到serializer（get_serializer），对queryset进行系列化。many=True是固定的：
serializer = self.get_serializer(queryset, many=True) # 实例
return Response(serializer.data) 实例的数据
:param obj: serializer的实例
:return: Goods数据
'''
all_goods = Goods.objects.filter(
Q(category_id=obj.id) | Q(category__parent_category_id=obj.id)
| Q(category__parent_category__parent_category_id=obj.id))
# 得到goods实例：获取到GoodsSerializer，对all_goods进行序列化。嵌套serializer要加context
goods_serializer = GoodsSerializer(
all_goods, many=True, context={'request': self.context['request']})
# 得到goods数据,返回给goods
return goods_serializer.data
# 广告商品，只有一个图
ad_goods = serializers.SerializerMethodField()
def get_ad_goods(self, obj):
'''
广告的商品
:param obj: GoodsCategory实例
:return: 实例的数据
'''
goods_json = {} # 返回json给前端
# 商品广告当前的一级类的广告的商品
ad_goods = IndexAd.objects.filter(category_id=obj.id, )
if ad_goods:
good_ins = ad_goods[0].goods # 取到商品。因为ad_goods是list,所以要加[0]
# 广告商品只有一个分类和一个商品：many=False
# 在serializer里面调用serializer的话，就要添加一个参数context（上下文有request，则返回域名）,嵌套serializer必须加
goods_json = GoodsSerializer(good_ins,
many=False,
context={
'request': self.context['request']
}).data
# # 只返回id和image
# goods_id = goods_json['id']
# goods_image = goods_json['goods_front_image']
# goods_list = [goods_id,goods_image]
# goods_json = goods_list
return goods_json
class Meta:
model = GoodsCategory
fields = '__all__'
class CommentSerializer(_ContentSerializer):
"""
A serializer for comment data.
N.B. This should not be used with a comment_client Comment object that has
not had retrieve() called, because of the interaction between DRF's attempts
at introspection and Comment's __getattr__.
"""
thread_id = serializers.CharField()
parent_id = serializers.CharField(required=False, allow_null=True)
endorsed = serializers.BooleanField(required=False)
endorsed_by = serializers.SerializerMethodField()
endorsed_by_label = serializers.SerializerMethodField()
endorsed_at = serializers.SerializerMethodField()
child_count = serializers.IntegerField(read_only=True)
children = serializers.SerializerMethodField(required=False)
non_updatable_fields = NON_UPDATABLE_COMMENT_FIELDS
def __init__(self, *args, **kwargs):
remove_fields = kwargs.pop('remove_fields', None)
super(CommentSerializer, self).__init__(*args, **kwargs)
if remove_fields:
# for multiple fields in a list
for field_name in remove_fields:
self.fields.pop(field_name)
def get_endorsed_by(self, obj):
"""
Returns the username of the endorsing user, if the information is
available and would not identify the author of an anonymous thread.
"""
endorsement = obj.get("endorsement")
if endorsement:
endorser_id = int(endorsement["user_id"])
# Avoid revealing the identity of an anonymous non-staff question
# author who has endorsed a comment in the thread
if not (self._is_anonymous(self.context["thread"])
and not self._is_user_privileged(endorser_id)):
return DjangoUser.objects.get(id=endorser_id).username
return None
def get_endorsed_by_label(self, obj):
"""
Returns the role label (i.e. "Staff" or "Community TA") for the
endorsing user
"""
endorsement = obj.get("endorsement")
if endorsement:
return self._get_user_label(int(endorsement["user_id"]))
else:
return None
def get_endorsed_at(self, obj):
"""
Returns the timestamp for the endorsement, if available.
"""
endorsement = obj.get("endorsement")
return endorsement["time"] if endorsement else None
def get_children(self, obj):
return [
CommentSerializer(child, context=self.context).data
for child in obj.get("children", [])
]
def to_representation(self, data):
data = super(CommentSerializer, self).to_representation(data)
# Django Rest Framework v3 no longer includes None values
# in the representation. To maintain the previous behavior,
# we do this manually instead.
if 'parent_id' not in data:
data["parent_id"] = None
return data
def validate(self, attrs):
"""
Ensure that parent_id identifies a comment that is actually in the
thread identified by thread_id and does not violate the configured
maximum depth.
"""
parent = None
parent_id = attrs.get("parent_id")
if parent_id:
try:
parent = Comment(id=parent_id).retrieve()
except CommentClientRequestError:
pass
if not (parent and parent["thread_id"] == attrs["thread_id"]):
raise ValidationError(
"parent_id does not identify a comment in the thread identified by thread_id."
)
if is_comment_too_deep(parent):
raise ValidationError(
{"parent_id": ["Comment level is too deep."]})
return attrs
def create(self, validated_data):
comment = Comment(course_id=self.context["thread"]["course_id"],
user_id=self.context["cc_requester"]["id"],
**validated_data)
comment.save()
return comment
def update(self, instance, validated_data):
for key, val in validated_data.items():
instance[key] = val
# TODO: The comments service doesn't populate the endorsement
# field on comment creation, so we only provide
# endorsement_user_id on update
if key == "endorsed":
instance["endorsement_user_id"] = self.context["cc_requester"][
"id"]
instance.save()
return instance
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 APKeySerializer(serializers.Serializer):
ap_key = serializers.SerializerMethodField()
def get_ap_key(self, obj):
str = pack.encode(obj)
return str
class VersionURLsSerializer(serializers.Serializer):
documentation = serializers.SerializerMethodField()
vcs = serializers.URLField(source='vcs_url')
def get_documentation(self, obj):
return obj.project.get_docs_url(version_slug=obj.slug, )
class ProjectLinksSerializer(BaseLinksSerializer):
_self = serializers.SerializerMethodField()
versions = serializers.SerializerMethodField()
builds = serializers.SerializerMethodField()
environmentvariables = serializers.SerializerMethodField()
redirects = serializers.SerializerMethodField()
subprojects = serializers.SerializerMethodField()
superproject = serializers.SerializerMethodField()
translations = serializers.SerializerMethodField()
def get__self(self, obj):
path = reverse('projects-detail', kwargs={'project_slug': obj.slug})
return self._absolute_url(path)
def get_versions(self, obj):
path = reverse(
'projects-versions-list',
kwargs={
'parent_lookup_project__slug': obj.slug,
},
)
return self._absolute_url(path)
def get_environmentvariables(self, obj):
path = reverse(
'projects-environmentvariables-list',
kwargs={
'parent_lookup_project__slug': obj.slug,
},
)
return self._absolute_url(path)
def get_redirects(self, obj):
path = reverse(
'projects-redirects-list',
kwargs={
'parent_lookup_project__slug': obj.slug,
},
)
return self._absolute_url(path)
def get_builds(self, obj):
path = reverse(
'projects-builds-list',
kwargs={
'parent_lookup_project__slug': obj.slug,
},
)
return self._absolute_url(path)
def get_subprojects(self, obj):
path = reverse(
'projects-subprojects-list',
kwargs={
'parent_lookup_parent__slug': obj.slug,
},
)
return self._absolute_url(path)
def get_superproject(self, obj):
path = reverse(
'projects-superproject',
kwargs={
'project_slug': obj.slug,
},
)
return self._absolute_url(path)
def get_translations(self, obj):
path = reverse(
'projects-translations-list',
kwargs={
'parent_lookup_main_language_project__slug': obj.slug,
},
)
return self._absolute_url(path)
class BuildStateSerializer(serializers.Serializer):
code = serializers.CharField(source='state')
name = serializers.SerializerMethodField()
def get_name(self, obj):
return obj.state.title()
class MetaDataSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
xform = XFormRelatedField(queryset=XForm.objects.all(), required=False)
project = ProjectRelatedField(queryset=Project.objects.all(),
required=False)
instance = InstanceRelatedField(queryset=Instance.objects.all(),
required=False)
data_value = serializers.CharField(max_length=255, required=True)
data_type = serializers.ChoiceField(choices=METADATA_TYPES)
data_file = serializers.FileField(required=False)
data_file_type = serializers.CharField(max_length=255,
required=False,
allow_blank=True)
media_url = serializers.SerializerMethodField()
date_created = serializers.ReadOnlyField()
_xform_field = None
_project_field = None
class Meta:
model = MetaData
fields = ('id', 'xform', 'project', 'instance', 'data_value',
'data_type', 'data_file', 'data_file_type', 'media_url',
'file_hash', 'url', 'date_created')
def get_media_url(self, obj):
if obj.data_type in [DOC_TYPE, MEDIA_TYPE] and\
getattr(obj, "data_file") and getattr(obj.data_file, "url"):
return obj.data_file.url
elif obj.data_type in [MEDIA_TYPE] and obj.is_linked_dataset:
kwargs = {
'kwargs': {
'pk': obj.content_object.pk,
'username': obj.content_object.user.username,
'metadata': obj.pk
},
'request': self.context.get('request'),
'format': 'csv'
}
return reverse('xform-media', **kwargs)
def validate(self, attrs):
"""
Validate url if we are adding a media uri instead of a media file
"""
value = attrs.get('data_value')
data_type = attrs.get('data_type')
data_file = attrs.get('data_file')
if not ('project' in attrs or 'xform' in attrs or 'instance' in attrs):
raise serializers.ValidationError({
'missing_field':
_(u"`xform` or `project` or `instance`"
"field is required.")
})
if data_type == 'media' and data_file is None:
try:
URLValidator()(value)
except ValidationError:
parts = value.split()
if len(parts) < 3:
raise serializers.ValidationError({
'data_value':
_(u"Expecting 'xform [xform id] [media name]' "
"or 'dataview [dataview id] [media name]' "
"or a valid URL.")
})
obj = get_linked_object(parts)
if obj:
xform = obj.xform if isinstance(obj, DataView) else obj
request = self.context['request']
user_has_role = ManagerRole.user_has_role
has_perm = user_has_role(request.user, xform) or \
user_has_role(request.user, obj.project)
if not has_perm:
raise serializers.ValidationError({
'data_value':
_(u"User has no permission to "
"the dataview.")
})
else:
raise serializers.ValidationError(
{'data_value': _(u"Invalid url '%s'." % value)})
if data_type == XFORM_META_PERMS:
perms = value.split('|')
if len(perms) != 2 or not set(perms).issubset(set(ROLES.keys())):
raise serializers.ValidationError(
_(u"Format 'role'|'role' or Invalid role"))
return attrs
def get_content_object(self, validated_data):
if validated_data:
return (validated_data.get('xform')
or validated_data.get('project')
or validated_data.get('instance'))
def create(self, validated_data):
data_type = validated_data.get('data_type')
data_file = validated_data.get('data_file')
content_object = self.get_content_object(validated_data)
data_value = data_file.name \
if data_file else validated_data.get('data_value')
data_file_type = data_file.content_type if data_file else None
# not exactly sure what changed in the requests.FILES for django 1.7
# csv files uploaded in windows do not have the text/csv content_type
# this works around that
if data_type == MEDIA_TYPE and data_file \
and data_file.name.lower().endswith('.csv') \
and data_file_type != CSV_CONTENT_TYPE:
data_file_type = CSV_CONTENT_TYPE
content_type = ContentType.objects.get_for_model(content_object)
try:
if data_type == XFORM_META_PERMS:
metadata = \
MetaData.xform_meta_permission(content_object,
data_value=data_value)
update_role_by_meta_xform_perms(content_object)
else:
metadata = MetaData.objects.create(
content_type=content_type,
data_type=data_type,
data_value=data_value,
data_file=data_file,
data_file_type=data_file_type,
object_id=content_object.id)
return metadata
except IntegrityError:
raise serializers.ValidationError(_(UNIQUE_TOGETHER_ERROR))
def update(self, instance, validated_data):
instance = super(MetaDataSerializer,
self).update(instance, validated_data)
if instance.data_type == XFORM_META_PERMS:
update_role_by_meta_xform_perms(instance.content_object)
return instance
class DataWorkspaceSerializer(AssessmentFieldsMixin, BarrierSerializerBase):
status_history = serializers.SerializerMethodField()
team_count = serializers.SerializerMethodField()
class Meta(BarrierSerializerBase.Meta):
fields = (
"admin_areas",
"all_sectors",
"archived",
"archived_by",
"archived_explanation",
"archived_on",
"archived_reason",
"categories",
"caused_by_trading_bloc",
"code",
"commercial_value",
"commercial_value_explanation",
"commodities",
"companies",
"country",
"created_by",
"created_on",
"economic_assessment_eligibility",
"economic_assessment_eligibility_summary",
"economic_assessment_explanation",
"economic_assessment_rating",
"economic_assessments",
"end_date",
"government_organisations",
"id",
"import_market_size",
"is_summary_sensitive",
"modified_by",
"modified_on",
"other_source",
"priority",
"priority_summary",
"product",
"public_barrier",
"public_eligibility",
"public_eligibility_summary",
"resolvability_assessments",
"sectors",
"sectors_affected",
"source",
"status",
"status_date",
"status_history",
"status_summary",
"strategic_assessments",
"sub_status",
"sub_status_other",
"summary",
"tags",
"team_count",
"term",
"title",
"trade_category",
"trade_direction",
"trading_bloc",
"unarchived_by",
"unarchived_on",
"unarchived_reason",
"valuation_assessment_explanation",
"valuation_assessment_rating",
"value_to_economy",
"wto_profile",
)
def get_status_history(self, obj):
history_items = CachedHistoryItem.objects.filter(
barrier=obj,
model="barrier",
field="status",
)
status_lookup = dict(BarrierStatus.choices)
return [
{
"date": item.date.isoformat(),
"status": {
"id": item.new_record.status,
"name": status_lookup.get(item.new_record.status, "Unknown"),
}
} for item in history_items
]
def get_team_count(self, obj):
return TeamMember.objects.filter(barrier=obj).count()
class ImageSerializer(serializers.Serializer):
""" A single image. Used in search results."""
title = serializers.CharField(required=False)
id = serializers.CharField(
required=True,
help_text="The unique identifier for the image.",
source='identifier'
)
creator = serializers.CharField(required=False, allow_blank=True)
creator_url = serializers.URLField(required=False)
tags = TagSerializer(
required=False,
many=True,
help_text="Tags with detailed metadata, such as accuracy."
)
url = serializers.URLField()
thumbnail = serializers.URLField(required=False, allow_blank=True)
source = serializers.CharField(required=False, source='provider')
license = serializers.SerializerMethodField()
license_version = serializers.CharField(required=False)
license_url = serializers.SerializerMethodField()
foreign_landing_url = serializers.URLField(required=False)
detail_url = serializers.HyperlinkedIdentityField(
read_only=True,
view_name='image-detail',
lookup_field='identifier',
help_text="A direct link to the detail view of this image."
)
related_url = serializers.HyperlinkedIdentityField(
view_name='related-images',
lookup_field='identifier',
read_only=True,
help_text="A link to an endpoint that provides similar images."
)
fields_matched = serializers.ListField(
required=False,
help_text="List the fields that matched the query for this result."
)
height = serializers.IntegerField(
required=False,
help_text="The height of the image in pixels. Not always available."
)
width = serializers.IntegerField(
required=False,
help_text="The width of the image in pixels. Not always available."
)
attribution = serializers.CharField(
required=False,
help_text="The Creative Commons attribution of the work. Use this to "
"give credit to creators to their works and fulfill "
"legal attribution requirements."
)
def get_license(self, obj):
return obj.license.lower()
def get_license_url(self, obj):
if hasattr(obj, 'meta_data'):
return license_helpers.get_license_url(
obj.license, obj.license_version, obj.meta_data
)
elif hasattr(obj, 'license_url') and obj.license_url is not None:
return obj.license_url
else:
return license_helpers.get_license_url(
obj.license, obj.license_version, None
)
def validate_url(self, value):
return _add_protocol(value)
def validate_creator_url(self, value):
return _add_protocol(value)
def validate_foreign_landing_url(self, value):
return _add_protocol(value)
class ProfileSerializer(serializers.ModelSerializer):
email = serializers.CharField(source='user.email', read_only=True)
skills = serializers.PrimaryKeyRelatedField(many=True, read_only=False, queryset=Skill.objects.all())
#skills = SkillSerializer(many = True,required= False, read_only=True)
#values = ValueSerializer(many = True,required = False)
#following = UserCompactSerializer(many=True, required = False, read_only = True)
following_count = serializers.SerializerMethodField()
followers = UserCompactSerializer(many = True, required=False)
followers_count = serializers.SerializerMethodField()
avatar = serializers.ImageField(source='user.avatar.avatar', read_only = True)
me_following = serializers.SerializerMethodField()
def get_following_count(self, profile):
return profile.following.filter(profile__deactivated_at__isnull=True).count()
def get_followers_count(self, profile):
return User.objects.filter(profile__following__id__contains=profile.user.id).count()
def get_me_following(self, profile):
if(self.context.get('request').user.profile.following.filter(id=profile.id).exists()):
return True
else:
return False
""" def update(self, instance, validated_data):
skills_data = []
values_data = []
askills_data = []
print("@@@@@@@@@@@@@",validated_data.keys())
if('skills' in validated_data.keys()):
skills_data = validated_data.pop('skills')
print("***************",skills_data)
if('values' in validated_data.keys()):
values_data = validated_data.pop('values')
print("################",values_data)
instance = super().update(instance, validated_data)
if(len(skills_data)>0):
instance.skills.set([])
for skill_data in skills_data:
nskills = Skill.objects.filter(id=skill_data.id)
if(nskills.exists()):
nskill = nskills.first()
instance.skills.add(nskill)
if(len(askills_data)>0):
instance.askills.set([])
for askill_data in askills_data:
naskills = Skill.objects.filter(id=askill_data.id)
if(naskills.exists()):
naskill = naskills.first()
instance.askills.add(naskill)
if(len(values_data)>0):
instance.values.set([])
for value_data in values_data:
nvalues = Value.objects.filter(id=value_data.id)
if(nvalues.exists()):
nvalue = nvalues.first()
instance.values.add(nvalue)
return instance """
""" def update(self, instance, validated_data):
skills = validated_data.pop('skills', [])
instance = super().update(instance, validated_data)
for skill_data in skills:
skill = Skill.objects.get(title=skill_data.get('title'))
instance.skills.add(skill)
values = validated_data.pop('values', [])
instance = super().update(instance, validated_data)
for value_data in values:
value = Value.objects.get(title=value_data.get('title'))
instance.values.add(value)
return instance """
class Meta:
model = Profile
fields = ['askills','me_following','id','firstname','lastname','email','gender','birthdate','bio','phone','city','languages','skills','values','q1','q2','q3','pic','highested','designation','tandcversion','avatar','completed_at','followers', 'following', 'followers_count', 'following_count','institution','state', 'company']
class FileSerializer(serializers.ModelSerializer):
"""
Serialiser for geokey.contributions.models.MediaFile instances
"""
creator = UserSerializer(fields=('id', 'display_name'))
isowner = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
file_type = serializers.SerializerMethodField()
thumbnail_url = serializers.SerializerMethodField()
class Meta:
model = MediaFile
fields = ('id', 'name', 'description', 'created_at', 'creator',
'isowner', 'url', 'thumbnail_url', 'file_type')
def get_file_type(self, obj):
"""
Returns the type of the MediaFile
Parameter
---------
obj : geokey.contributions.models.MediaFile
The instance that is serialised
Returns
-------
str
The type of the, e.g. 'ImageFile'
"""
return obj.type_name
def get_isowner(self, obj):
"""
Returns `True` if the user provided in the serializer context is the
creator of this file
Parameter
---------
obj : geokey.contributions.models.MediaFile
The instance that is serialised
Returns
-------
Boolean
indicating if user created the file
"""
if not self.context.get('user').is_anonymous():
return obj.creator == self.context.get('user')
else:
return False
def get_url(self, obj):
"""
Return the url to access this file based on its file type
Parameter
---------
obj : geokey.contributions.models.MediaFile
The instance that is serialised
Returns
-------
str
The URL to embed the file on client side
"""
if isinstance(obj, ImageFile):
return obj.image.url
elif isinstance(obj, VideoFile):
return obj.youtube_link
elif isinstance(obj, AudioFile):
return obj.audio.url
def _get_thumb(self, image, size=(300, 300)):
"""
Returns the thumbnail of the media file base on the size privoded
Parameter
---------
image : Image
The image to be thumbnailed
size : tuple
width and height of the thumbnail, defaults to 300 by 300
Returns
-------
Image
The thumbnail
"""
thumbnailer = get_thumbnailer(image)
thumb = thumbnailer.get_thumbnail({'crop': True, 'size': size})
return thumb
def get_thumbnail_url(self, obj):
"""
Creates and returns a thumbnail for the MediaFile object
Parameter
---------
obj : geokey.contributions.models.MediaFile
The instance that is serialised
Returns
-------
str
The url to embed thumbnails on client side
"""
if isinstance(obj, ImageFile):
# Some of the imported image files in the original community maps
# seem to be broken. The error thrown when the image can not be
# read is caught here.
try:
return self._get_thumb(obj.image).url
except (IOError, InvalidImageFormatError):
return ''
elif isinstance(obj, VideoFile):
if obj.thumbnail:
# thumbnail has been downloaded, return the link
return self._get_thumb(obj.thumbnail).url
request = requests.get('http://img.youtube.com/vi/%s/0.jpg' %
obj.youtube_id,
stream=True)
if request.status_code != requests.codes.ok:
# Image not found, return placeholder thumbnail
return '/static/img/play.png'
lf = tempfile.NamedTemporaryFile()
# Read the streamed image in sections
for block in request.iter_content(1024 * 8):
# If no more file then stop
if not block:
break
# Write image block to temporary file
lf.write(block)
file_name = obj.youtube_id + '.jpg'
obj.thumbnail.save(file_name, files.File(lf))
from PIL import Image
w, h = Image.open(obj.thumbnail).size
thumb = self._get_thumb(obj.thumbnail, size=(h, h))
obj.thumbnail.save(file_name, thumb)
return self._get_thumb(obj.thumbnail).url
elif isinstance(obj, AudioFile):
return '/static/img/play.png'
class RackSerializer(AdminLinkMixin, RackBaseSerializer):
rack_admin_url = serializers.SerializerMethodField('admin_link')
class Meta(RackBaseSerializer.Meta):
fields = RackBaseSerializer.Meta.fields + ('rack_admin_url',)
class ThreadSerializer(_ContentSerializer):
"""
A serializer for thread data.
N.B. This should not be used with a comment_client Thread object that has
not had retrieve() called, because of the interaction between DRF's attempts
at introspection and Thread's __getattr__.
"""
course_id = serializers.CharField()
topic_id = serializers.CharField(source="commentable_id",
validators=[validate_not_blank])
group_id = serializers.IntegerField(required=False, allow_null=True)
group_name = serializers.SerializerMethodField()
type = serializers.ChoiceField(source="thread_type",
choices=[
(val, val)
for val in ["discussion", "question"]
])
title = serializers.CharField(validators=[validate_not_blank])
pinned = serializers.SerializerMethodField(read_only=True)
closed = serializers.BooleanField(read_only=True)
following = serializers.SerializerMethodField()
comment_count = serializers.SerializerMethodField(read_only=True)
unread_comment_count = serializers.SerializerMethodField(read_only=True)
comment_list_url = serializers.SerializerMethodField()
endorsed_comment_list_url = serializers.SerializerMethodField()
non_endorsed_comment_list_url = serializers.SerializerMethodField()
read = serializers.BooleanField(required=False)
has_endorsed = serializers.BooleanField(source="endorsed", read_only=True)
response_count = serializers.IntegerField(source="resp_total",
read_only=True,
required=False)
non_updatable_fields = NON_UPDATABLE_THREAD_FIELDS
def __init__(self, *args, **kwargs):
super(ThreadSerializer, self).__init__(*args, **kwargs)
# Compensate for the fact that some threads in the comments service do
# not have the pinned field set
if self.instance and self.instance.get("pinned") is None:
self.instance["pinned"] = False
def get_pinned(self, obj):
"""
Compensate for the fact that some threads in the comments service do
not have the pinned field set.
"""
return bool(obj["pinned"])
def get_group_name(self, obj):
"""
Returns the name of the group identified by the thread's group_id.
"""
return self.context["group_ids_to_names"].get(obj["group_id"])
def get_following(self, obj):
"""
Returns a boolean indicating whether the requester is following the
thread.
"""
return obj["id"] in self.context["cc_requester"][
"subscribed_thread_ids"]
def get_comment_list_url(self, obj, endorsed=None):
"""
Returns the URL to retrieve the thread's comments, optionally including
the endorsed query parameter.
"""
if ((obj["thread_type"] == "question" and endorsed is None) or
(obj["thread_type"] == "discussion" and endorsed is not None)):
return None
path = reverse("comment-list")
query_dict = {"thread_id": obj["id"]}
if endorsed is not None:
query_dict["endorsed"] = endorsed
return self.context["request"].build_absolute_uri(
urlunparse(("", "", path, "", urlencode(query_dict), "")))
def get_endorsed_comment_list_url(self, obj):
"""
Returns the URL to retrieve the thread's endorsed comments.
"""
return self.get_comment_list_url(obj, endorsed=True)
def get_non_endorsed_comment_list_url(self, obj):
"""
Returns the URL to retrieve the thread's non-endorsed comments.
"""
return self.get_comment_list_url(obj, endorsed=False)
def get_comment_count(self, obj):
"""
Increments comment count to include post and returns total count of
contributions (i.e. post + responses + comments) for the thread
"""
return obj["comments_count"] + 1
def get_unread_comment_count(self, obj):
"""
Returns the number of unread comments. If the thread has never been read,
this additionally includes 1 for the post itself, in addition to its responses and
comments.
"""
if not obj["read"] and obj["comments_count"] == obj[
"unread_comments_count"]:
return obj["unread_comments_count"] + 1
return obj["unread_comments_count"]
def create(self, validated_data):
thread = Thread(user_id=self.context["cc_requester"]["id"],
**validated_data)
thread.save()
return thread
def update(self, instance, validated_data):
for key, val in validated_data.items():
instance[key] = val
instance.save()
return instance
class AssetSnapshotSerializer(serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(
lookup_field='uid', view_name='assetsnapshot-detail')
uid = serializers.ReadOnlyField()
xml = serializers.SerializerMethodField()
enketopreviewlink = serializers.SerializerMethodField()
details = WritableJSONField(required=False)
asset = RelativePrefixHyperlinkedRelatedField(
queryset=Asset.objects.all(), view_name='asset-detail',
lookup_field='uid',
required=False,
allow_null=True,
style={'base_template': 'input.html'} # Render as a simple text box
)
owner = RelativePrefixHyperlinkedRelatedField(
view_name='user-detail',
lookup_field='username',
read_only=True
)
asset_version_id = serializers.ReadOnlyField()
date_created = serializers.DateTimeField(read_only=True)
source = WritableJSONField(required=False)
def get_xml(self, obj):
''' There's too much magic in HyperlinkedIdentityField. When format is
unspecified by the request, HyperlinkedIdentityField.to_representation()
refuses to append format to the url. We want to *unconditionally*
include the xml format suffix. '''
return reverse(
viewname='assetsnapshot-detail', format='xml',
kwargs={'uid': obj.uid},
request=self.context.get('request', None)
)
def get_enketopreviewlink(self, obj):
return reverse(
viewname='assetsnapshot-preview',
kwargs={'uid': obj.uid},
request=self.context.get('request', None)
)
def create(self, validated_data):
''' Create a snapshot of an asset, either by copying an existing
asset's content or by accepting the source directly in the request.
Transform the source into XML that's then exposed to Enketo
(and the www). '''
asset = validated_data.get('asset', None)
source = validated_data.get('source', None)
# Force owner to be the requesting user
# NB: validated_data is not used when linking to an existing asset
# without specifying source; in that case, the snapshot owner is the
# asset's owner, even if a different user makes the request
validated_data['owner'] = self.context['request'].user
# TODO: Move to a validator?
if asset and source:
if not self.context['request'].user.has_perm('view_asset', asset):
# The client is not allowed to snapshot this asset
raise exceptions.PermissionDenied
validated_data['source'] = source
snapshot = AssetSnapshot.objects.create(**validated_data)
elif asset:
# The client provided an existing asset; read source from it
if not self.context['request'].user.has_perm('view_asset', asset):
# The client is not allowed to snapshot this asset
raise exceptions.PermissionDenied
# asset.snapshot pulls , by default, a snapshot for the latest
# version.
snapshot = asset.snapshot
elif source:
# The client provided source directly; no need to copy anything
# For tidiness, pop off unused fields. `None` avoids KeyError
validated_data.pop('asset', None)
validated_data.pop('asset_version', None)
snapshot = AssetSnapshot.objects.create(**validated_data)
else:
raise serializers.ValidationError('Specify an asset and/or a source')
if not snapshot.xml:
raise serializers.ValidationError(snapshot.details)
return snapshot
class Meta:
model = AssetSnapshot
lookup_field = 'uid'
fields = ('url',
'uid',
'owner',
'date_created',
'xml',
'enketopreviewlink',
'asset',
'asset_version_id',
'details',
'source',
)
class _ContentSerializer(serializers.Serializer):
"""
A base class for thread and comment serializers.
"""
id = serializers.CharField(read_only=True) # pylint: disable=invalid-name
author = serializers.SerializerMethodField()
author_label = serializers.SerializerMethodField()
created_at = serializers.CharField(read_only=True)
updated_at = serializers.CharField(read_only=True)
raw_body = serializers.CharField(source="body",
validators=[validate_not_blank])
rendered_body = serializers.SerializerMethodField()
abuse_flagged = serializers.SerializerMethodField()
voted = serializers.SerializerMethodField()
vote_count = serializers.SerializerMethodField()
editable_fields = serializers.SerializerMethodField()
non_updatable_fields = set()
def __init__(self, *args, **kwargs):
super(_ContentSerializer, self).__init__(*args, **kwargs)
for field in self.non_updatable_fields:
setattr(self, "validate_{}".format(field),
self._validate_non_updatable)
def _validate_non_updatable(self, value):
"""Ensure that a field is not edited in an update operation."""
if self.instance:
raise ValidationError("This field is not allowed in an update.")
return value
def _is_user_privileged(self, user_id):
"""
Returns a boolean indicating whether the given user_id identifies a
privileged user.
"""
return user_id in self.context[
"staff_user_ids"] or user_id in self.context["ta_user_ids"]
def _is_anonymous(self, obj):
"""
Returns a boolean indicating whether the content should be anonymous to
the requester.
"""
return (obj["anonymous"] or obj["anonymous_to_peers"]
and not self.context["is_requester_privileged"])
def get_author(self, obj):
"""
Returns the author's username, or None if the content is anonymous.
"""
return None if self._is_anonymous(obj) else obj["username"]
def _get_user_label(self, user_id):
"""
Returns the role label (i.e. "Staff" or "Community TA") for the user
with the given id.
"""
return (
"Staff" if user_id in self.context["staff_user_ids"] else
"Community TA" if user_id in self.context["ta_user_ids"] else None)
def get_author_label(self, obj):
"""
Returns the role label for the content author.
"""
if self._is_anonymous(obj) or obj["user_id"] is None:
return None
else:
user_id = int(obj["user_id"])
return self._get_user_label(user_id)
def get_rendered_body(self, obj):
"""
Returns the rendered body content.
"""
return render_body(obj["body"])
def get_abuse_flagged(self, obj):
"""
Returns a boolean indicating whether the requester has flagged the
content as abusive.
"""
return self.context["cc_requester"]["id"] in obj.get(
"abuse_flaggers", [])
def get_voted(self, obj):
"""
Returns a boolean indicating whether the requester has voted for the
content.
"""
return obj["id"] in self.context["cc_requester"]["upvoted_ids"]
def get_vote_count(self, obj):
"""
Returns the number of votes for the content.
"""
return obj.get("votes", {}).get("up_count", 0)
def get_editable_fields(self, obj):
"""
Return the list of the fields the requester can edit
"""
return sorted(get_editable_fields(obj, self.context))
class AssetSerializer(serializers.HyperlinkedModelSerializer):
owner = RelativePrefixHyperlinkedRelatedField(
view_name='user-detail', lookup_field='username', read_only=True)
owner__username = serializers.ReadOnlyField(source='owner.username')
url = serializers.HyperlinkedIdentityField(
lookup_field='uid', view_name='asset-detail')
asset_type = serializers.ChoiceField(choices=ASSET_TYPES)
settings = WritableJSONField(required=False, allow_blank=True)
content = WritableJSONField(required=False)
report_styles = WritableJSONField(required=False)
xls_link = serializers.SerializerMethodField()
summary = serializers.ReadOnlyField()
koboform_link = serializers.SerializerMethodField()
xform_link = serializers.SerializerMethodField()
version_count = serializers.SerializerMethodField()
downloads = serializers.SerializerMethodField()
embeds = serializers.SerializerMethodField()
parent = RelativePrefixHyperlinkedRelatedField(
lookup_field='uid',
queryset=Collection.objects.all(),
view_name='collection-detail',
required=False,
allow_null=True
)
ancestors = AncestorCollectionsSerializer(
many=True, read_only=True, source='get_ancestors_or_none')
permissions = ObjectPermissionSerializer(many=True, read_only=True)
tag_string = serializers.CharField(required=False, allow_blank=True)
version_id = serializers.CharField(read_only=True)
has_deployment = serializers.ReadOnlyField()
deployed_version_id = serializers.SerializerMethodField()
deployed_versions = serializers.SerializerMethodField()
deployment__identifier = serializers.SerializerMethodField()
deployment__active = serializers.SerializerMethodField()
deployment__links = serializers.SerializerMethodField()
deployment__data_download_links = serializers.SerializerMethodField()
deployment__submission_count = serializers.SerializerMethodField()
class Meta:
model = Asset
lookup_field = 'uid'
fields = ('url',
'owner',
'owner__username',
'parent',
'ancestors',
'settings',
'asset_type',
'date_created',
'summary',
'date_modified',
'version_id',
'version_count',
'has_deployment',
'deployed_version_id',
'deployed_versions',
'deployment__identifier',
'deployment__links',
'deployment__active',
'deployment__data_download_links',
'deployment__submission_count',
'report_styles',
'content',
'downloads',
'embeds',
'koboform_link',
'xform_link',
'tag_string',
'uid',
'kind',
'xls_link',
'name',
'permissions',
'settings',)
extra_kwargs = {
'parent': {
'lookup_field': 'uid',
},
'uid': {
'read_only': True,
},
}
def update(self, asset, validated_data):
asset_content = asset.content
_req_data = self.context['request'].data
_has_translations = 'translations' in _req_data
_has_content = 'content' in _req_data
if _has_translations and not _has_content:
translations_list = json.loads(_req_data['translations'])
try:
asset.update_translation_list(translations_list)
except ValueError as err:
raise serializers.ValidationError(err.message)
validated_data['content'] = asset_content
return super(AssetSerializer, self).update(asset, validated_data)
def get_fields(self, *args, **kwargs):
fields = super(AssetSerializer, self).get_fields(*args, **kwargs)
user = self.context['request'].user
# Check if the user is anonymous. The
# django.contrib.auth.models.AnonymousUser object doesn't work for
# queries.
if user.is_anonymous():
user = get_anonymous_user()
if 'parent' in fields:
# TODO: remove this restriction?
fields['parent'].queryset = fields['parent'].queryset.filter(
owner=user)
# Honor requests to exclude fields
# TODO: Actually exclude fields from tha database query! DRF grabs
# all columns, even ones that are never named in `fields`
excludes = self.context['request'].GET.get('exclude', '')
for exclude in excludes.split(','):
exclude = exclude.strip()
if exclude in fields:
fields.pop(exclude)
return fields
def get_version_count(self, obj):
return obj.asset_versions.count()
def get_xls_link(self, obj):
return reverse('asset-xls', args=(obj.uid,), request=self.context.get('request', None))
def get_xform_link(self, obj):
return reverse('asset-xform', args=(obj.uid,), request=self.context.get('request', None))
def get_embeds(self, obj):
request = self.context.get('request', None)
def _reverse_lookup_format(fmt):
url = reverse('asset-%s' % fmt,
args=(obj.uid,),
request=request)
return {'format': fmt,
'url': url, }
base_url = reverse('asset-detail',
args=(obj.uid,),
request=request)
return [
_reverse_lookup_format('xls'),
_reverse_lookup_format('xform'),
]
def get_downloads(self, obj):
def _reverse_lookup_format(fmt):
request = self.context.get('request', None)
obj_url = reverse('asset-detail', args=(obj.uid,), request=request)
# The trailing slash must be removed prior to appending the format
# extension
url = '%s.%s' % (obj_url.rstrip('/'), fmt)
return {'format': fmt,
'url': url, }
return [
_reverse_lookup_format('xls'),
_reverse_lookup_format('xml'),
]
def get_koboform_link(self, obj):
return reverse('asset-koboform', args=(obj.uid,), request=self.context
.get('request', None))
def get_deployed_version_id(self, obj):
if not obj.has_deployment:
return
if obj.asset_versions.filter(deployed=True).exists():
if isinstance(obj.deployment.version_id, int):
# this can be removed once the 'replace_deployment_ids'
# migration has been run
v_id = obj.deployment.version_id
try:
return obj.asset_versions.get(_reversion_version_id=v_id).uid
except ObjectDoesNotExist, e:
return obj.asset_versions.filter(deployed=True).first().uid
else:
return obj.deployment.version_id
class CourseDetailsSerializer(serializers.ModelSerializer):
"""
Initial implementation uses serializer emthods to retrieve some data
Need to ask edX team why CourseEnrollment doesn't have a foreign key
relationship to CourseOverview
"""
site = None
course_id = serializers.CharField(source='id', read_only=True)
course_name = serializers.CharField(
source='display_name_with_default_escaped', read_only=True)
course_code = serializers.CharField(
source='display_number_with_default', read_only=True)
org = serializers.CharField(
source='display_org_with_default', read_only=True)
start_date = serializers.DateTimeField(
source='start', read_only=True, default=None)
end_date = serializers.DateTimeField(
source='end', read_only=True, default=None)
self_paced = serializers.BooleanField(read_only=True)
staff = serializers.SerializerMethodField()
learners_enrolled = serializers.SerializerMethodField()
average_progress = serializers.SerializerMethodField()
average_days_to_complete = serializers.SerializerMethodField()
users_completed = serializers.SerializerMethodField()
# TODO: Consider if we want to add a hyperlink field to the learner details endpoint
class Meta:
model = CourseOverview
fields = ['course_id', 'course_name', 'course_code', 'org', 'start_date',
'end_date', 'self_paced', 'staff', 'learners_enrolled',
'average_progress', 'average_days_to_complete', 'users_completed', ]
read_only_fields = fields
def to_representation(self, instance):
"""
This is a hack to get the site for this course
We do this because the figures.metrics calls we are making require the
site object as a parameter
"""
self.site = figures.sites.get_site_for_course(instance)
ret = super(CourseDetailsSerializer, self).to_representation(instance)
return ret
def get_staff(self, course_overview):
qs = CourseAccessRole.objects.filter(course_id=course_overview.id)
if qs:
return [CourseAccessRoleForGCDSerializer(data).data for data in qs]
else:
return []
def get_learners_enrolled(self, course_overview):
"""
Would be nice to have the course_enrollment and course_overview models
linked
"""
return get_course_history_metric(
site=self.site,
course_id=course_overview.id,
func=get_course_enrolled_users_for_time_period,
date_for=datetime.datetime.utcnow(),
months_back=HISTORY_MONTHS_BACK,
)
def get_average_progress(self, course_overview):
"""
"""
return get_course_history_metric(
site=self.site,
course_id=course_overview.id,
func=get_course_average_progress_for_time_period,
date_for=datetime.datetime.utcnow(),
months_back=HISTORY_MONTHS_BACK,
)
def get_average_days_to_complete(self, course_overview):
"""
"""
return get_course_history_metric(
site=self.site,
course_id=course_overview.id,
func=get_course_average_days_to_complete_for_time_period,
date_for=datetime.datetime.utcnow(),
months_back=HISTORY_MONTHS_BACK,
)
def get_users_completed(self, course_overview):
"""
"""
return get_course_history_metric(
site=self.site,
course_id=course_overview.id,
func=get_course_num_learners_completed_for_time_period,
date_for=datetime.datetime.utcnow(),
months_back=HISTORY_MONTHS_BACK,
)
class CurrentUserSerializer(serializers.ModelSerializer):
email = serializers.EmailField()
server_time = serializers.SerializerMethodField()
projects_url = serializers.SerializerMethodField()
support = serializers.SerializerMethodField()
gravatar = serializers.SerializerMethodField()
languages = serializers.SerializerMethodField()
extra_details = WritableJSONField(source='extra_details.data')
current_password = serializers.CharField(write_only=True, required=False)
new_password = serializers.CharField(write_only=True, required=False)
git_rev = serializers.SerializerMethodField()
class Meta:
model = User
fields = (
'username',
'first_name',
'last_name',
'email',
'server_time',
'projects_url',
'support',
'is_superuser',
'gravatar',
'is_staff',
'last_login',
'languages',
'extra_details',
'current_password',
'new_password',
'git_rev',
)
def get_server_time(self, obj):
return datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
def get_projects_url(self, obj):
return '/'.join((settings.KOBOCAT_URL, obj.username))
def get_support(self, obj):
return {
'email': settings.KOBO_SUPPORT_EMAIL,
'url': settings.KOBO_SUPPORT_URL,
}
def get_gravatar(self, obj):
return gravatar_url(obj.email)
def get_languages(self, obj):
return settings.LANGUAGES
def get_git_rev(self, obj):
request = self.context.get('request', False)
if settings.EXPOSE_GIT_REV or (request and request.user.is_superuser):
return settings.GIT_REV
else:
return False
def to_representation(self, obj):
if obj.is_anonymous():
return {'message': 'user is not logged in'}
rep = super(CurrentUserSerializer, self).to_representation(obj)
if settings.UPCOMING_DOWNTIME:
# setting is in the format:
# [dateutil.parser.parse('6pm edt').isoformat(), countdown_msg]
rep['upcoming_downtime'] = settings.UPCOMING_DOWNTIME
# TODO: Find a better location for SECTORS and COUNTRIES
# as the functionality develops. (possibly in tags?)
rep['available_sectors'] = SECTORS
rep['available_countries'] = COUNTRIES
rep['all_languages'] = LANGUAGES
if not rep['extra_details']:
rep['extra_details'] = {}
# `require_auth` needs to be read from KC every time
if settings.KOBOCAT_URL and settings.KOBOCAT_INTERNAL_URL:
rep['extra_details']['require_auth'] = get_kc_profile_data(
obj.pk).get('require_auth', False)
return rep
def update(self, instance, validated_data):
# "The `.update()` method does not support writable dotted-source
# fields by default." --DRF
extra_details = validated_data.pop('extra_details', False)
if extra_details:
extra_details_obj, created = ExtraUserDetail.objects.get_or_create(
user=instance)
# `require_auth` needs to be written back to KC
if settings.KOBOCAT_URL and settings.KOBOCAT_INTERNAL_URL and \
'require_auth' in extra_details['data']:
set_kc_require_auth(
instance.pk, extra_details['data']['require_auth'])
extra_details_obj.data.update(extra_details['data'])
extra_details_obj.save()
current_password = validated_data.pop('current_password', False)
new_password = validated_data.pop('new_password', False)
if all((current_password, new_password)):
with transaction.atomic():
if instance.check_password(current_password):
instance.set_password(new_password)
instance.save()
else:
raise serializers.ValidationError({
'current_password': '******'
})
elif any((current_password, new_password)):
raise serializers.ValidationError(
'current_password and new_password must both be sent ' \
'together; one or the other cannot be sent individually.'
)
return super(CurrentUserSerializer, self).update(
instance, validated_data)
class LearnerCourseDetailsSerializer(serializers.ModelSerializer):
"""
{
"course_name": "Something",
"course_code": "A193",
"course_id": "A193+2016Q4+something",
"date_enrolled": "2018-05-06T14:01:58Z",
"progress_data": {
"course_completed": "2018-05-06T14:01:58Z", // empty if not completed
"course_progress": 0.59, // percentage
"course_progress_history": [
{
"period": "April 2018",
"value": 0.28,
},
...
]
}
}
"""
if RELEASE_LINE == 'ginkgo':
course_name = serializers.CharField(source='course_overview.display_name')
course_code = serializers.CharField(source='course_overview.number')
course_id = serializers.CharField()
else:
course_name = serializers.CharField(source='course.display_name')
course_code = serializers.CharField(source='course.number')
course_id = serializers.CharField(source='course.id')
date_enrolled = serializers.DateTimeField(source='created', format="%Y-%m-%d")
progress_data = serializers.SerializerMethodField()
enrollment_id = serializers.IntegerField(source='id')
class Meta:
model = CourseEnrollment
fields = (
'course_name', 'course_code', 'course_id', 'date_enrolled',
'progress_data', 'enrollment_id',
)
read_only_fields = fields
def get_progress_data(self, course_enrollment):
"""
TODO: Add this to metrics, then we'll need to store per-user progress data
For initial implementation, we get the
TODO: We will cache course grades, so we'll refactor this method to use
the cache, so we'll likely change the call to LearnerCourseGrades
"""
cert = GeneratedCertificate.objects.filter(
user=course_enrollment.user,
course_id=course_enrollment.course_id,
)
if cert:
course_completed = cert[0].created_date
else:
course_completed = False
# Default values if we can't retrieve progress data
progress_percent = 0.0
course_progress_details = None
try:
obj = LearnerCourseGradeMetrics.objects.most_recent_for_learner_course(
user=course_enrollment.user,
course_id=str(course_enrollment.course_id))
if obj:
progress_percent = obj.progress_percent
course_progress_details = obj.progress_details
except Exception as e: # pylint: disable=broad-except
# TODO: Use more specific database-related exception
error_data = dict(
msg='Exception trying to get learner course metrics',
username=course_enrollment.user.username,
course_id=str(course_enrollment.course_id),
exception=str(e)
)
log_error(
error_data=error_data,
error_type=PipelineError.UNSPECIFIED_DATA,
)
# Empty list initially, then will fill after we implement capturing
# learner specific progress
course_progress_history = []
data = dict(
course_completed=course_completed,
course_progress=progress_percent,
course_progress_details=course_progress_details,
course_progress_history=course_progress_history,
)
return data
class CollectionSerializer(serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(
lookup_field='uid', view_name='collection-detail')
owner = RelativePrefixHyperlinkedRelatedField(
view_name='user-detail',
lookup_field='username',
read_only=True
)
parent = RelativePrefixHyperlinkedRelatedField(
lookup_field='uid',
required=False,
view_name='collection-detail',
queryset=Collection.objects.all()
)
owner__username = serializers.ReadOnlyField(source='owner.username')
# ancestors are ordered from farthest to nearest
ancestors = AncestorCollectionsSerializer(
many=True, read_only=True, source='get_ancestors_or_none')
children = serializers.SerializerMethodField()
permissions = ObjectPermissionSerializer(many=True, read_only=True)
downloads = serializers.SerializerMethodField()
tag_string = serializers.CharField(required=False)
access_type = serializers.SerializerMethodField()
class Meta:
model = Collection
fields = ('name',
'uid',
'kind',
'url',
'parent',
'owner',
'owner__username',
'downloads',
'date_created',
'date_modified',
'ancestors',
'children',
'permissions',
'access_type',
'discoverable_when_public',
'tag_string',)
lookup_field = 'uid'
extra_kwargs = {
'assets': {
'lookup_field': 'uid',
},
'uid': {
'read_only': True,
},
}
def _get_tag_names(self, obj):
return obj.tags.names()
def get_children(self, obj):
paginator = LimitOffsetPagination()
paginator.default_limit = 10
queryset = CollectionChildrenQuerySet(obj).select_related(
'owner', 'parent'
).prefetch_related(
'permissions',
'permissions__permission',
'permissions__user',
'permissions__content_object',
).all()
page = paginator.paginate_queryset(
queryset=queryset,
request=self.context.get('request', None)
)
serializer = CollectionChildrenSerializer(
page, read_only=True, many=True, context=self.context)
return OrderedDict([
('count', paginator.count),
('next', paginator.get_next_link()),
('previous', paginator.get_previous_link()),
('results', serializer.data)
])
def get_downloads(self, obj):
request = self.context.get('request', None)
obj_url = reverse(
'collection-detail', args=(obj.uid,), request=request)
return [
{'format': 'zip', 'url': '%s?format=zip' % obj_url},
]
def get_access_type(self, obj):
try:
request = self.context['request']
except KeyError:
return None
if request.user == obj.owner:
return 'owned'
# `obj.permissions.filter(...).exists()` would be cleaner, but it'd
# cost a query. This ugly loop takes advantage of having already called
# `prefetch_related()`
for permission in obj.permissions.all():
if not permission.deny and permission.user == request.user:
return 'shared'
for subscription in obj.usercollectionsubscription_set.all():
# `usercollectionsubscription_set__user` is not prefetched
if subscription.user_id == request.user.pk:
return 'subscribed'
if obj.discoverable_when_public:
return 'public'
if request.user.is_superuser:
return 'superuser'
raise Exception(u'{} has unexpected access to {}'.format(
request.user.username, obj.uid))
class PropertyShortAnnotatedSerializer(serializers.ModelSerializer):
class Meta:
model = ds.Property
fields = (ds.Property.SHORT_SUMMARY_FIELDS +
('nycha', 'subsidyprograms', 'subsidyj51', 'subsidy421a',
'unitsrentstabilized', 'latestsaleprice'))
subsidyprograms = serializers.SerializerMethodField()
subsidyj51 = serializers.SerializerMethodField()
subsidy421a = serializers.SerializerMethodField()
nycha = serializers.SerializerMethodField()
unitsrentstabilized = serializers.SerializerMethodField()
latestsaleprice = serializers.SerializerMethodField()
def get_nycha(self, obj):
try:
return obj.propertyannotation.nycha
except Exception as e:
return None
def get_subsidy421a(self, obj):
try:
return obj.propertyannotation.subsidy421a
except Exception as e:
return None
def get_subsidyj51(self, obj):
try:
return obj.propertyannotation.subsidyj51
except Exception as e:
return None
def get_subsidyprograms(self, obj):
try:
return obj.propertyannotation.subsidyprograms
except Exception as e:
return None
def get_unitsrentstabilized(self, obj):
try:
return obj.propertyannotation.unitsrentstabilized
except Exception as e:
return None
def get_latestsaleprice(self, obj):
try:
return obj.propertyannotation.latestsaleprice
except Exception as e:
return None
def to_representation(self, obj):
rep = super(serializers.ModelSerializer, self).to_representation(obj)
params = self.context['request'].query_params
def get_context_field(dataset_prefix, date_label=None):
# uses singular dataset_prefix
for field in self.context['fields']:
if date_label:
if dataset_prefix in field and date_label in field:
return field
else:
if dataset_prefix in field:
return field
return None
for model_name in settings.ANNOTATED_DATASETS:
dataset_class = getattr(ds, model_name) # results in query
if not hasattr(dataset_class, 'QUERY_DATE_KEY'):
continue
dataset = next(x for x in self.context['datasets']
if x.model_name == model_name)
if hasattr(
dataset_class, 'REQUIRES_AUTHENTICATION'
) and dataset_class.REQUIRES_AUTHENTICATION and not is_authenticated(
self.context['request']):
continue
dataset_prefix = dataset_class.__name__.lower()
try:
if hasattr(obj, dataset_prefix + 's'):
# annotated from advanced search
rep[get_context_field(dataset_prefix)] = getattr(
obj, dataset_prefix + 's')
elif 'annotation__start' in params and params[
'annotation__start'] == 'recent':
rep[get_context_field(dataset_prefix, 'recent')] = getattr(
obj.propertyannotation, dataset_prefix + 's_last30')
elif 'annotation__start' in params and params[
'annotation__start'] == 'lastyear':
rep[get_context_field(dataset_prefix,
'lastyear')] = getattr(
obj.propertyannotation,
dataset_prefix + 's_lastyear')
elif 'annotation__start' in params and params[
'annotation__start'] == 'last3years':
rep[get_context_field(dataset_prefix,
'last3years')] = getattr(
obj.propertyannotation,
dataset_prefix + 's_last3years')
elif 'annotation__start' in params and params[
'annotation__start'] == 'full':
rep[get_context_field(dataset_prefix, 'recent')] = getattr(
obj.propertyannotation, dataset_prefix + 's_last30')
rep[get_context_field(dataset_prefix,
'lastyear')] = getattr(
obj.propertyannotation,
dataset_prefix + 's_lastyear')
rep[get_context_field(dataset_prefix,
'last3years')] = getattr(
obj.propertyannotation,
dataset_prefix + 's_last3years')
elif 'annotation__start' in params:
if dataset_class == ds.AcrisRealMaster:
rep[get_context_field(dataset_prefix)] = getattr(
obj, 'acrisreallegal_set'
).filter(
documentid__doctype__in=ds.AcrisRealMaster.
SALE_DOC_TYPES
).filter(
**{
'documentid__' + dataset_class.QUERY_DATE_KEY + '__gte':
get_annotation_start(
params, dataset, dataset_class.
QUERY_DATE_KEY, dataset_class),
'documentid__' + dataset_class.QUERY_DATE_KEY + '__lte':
get_annotation_end(
params, dataset, dataset_class.
QUERY_DATE_KEY, dataset_class)
}).count()
else:
rep[get_context_field(dataset_prefix)] = getattr(
obj, dataset_prefix + '_set').filter(
**{
dataset_class.QUERY_DATE_KEY + '__gte':
get_annotation_start(
params, dataset, dataset_class.
QUERY_DATE_KEY, dataset_class),
dataset_class.QUERY_DATE_KEY + '__lte':
get_annotation_end(
params, dataset, dataset_class.
QUERY_DATE_KEY, dataset_class)
}).count()
else:
# defaults to recent if no annotation start
rep[get_context_field(dataset_prefix)] = getattr(
obj.propertyannotation, dataset_prefix + 's_last30')
except ds.PropertyAnnotation.DoesNotExist:
logger.warning('No property annotation for {}'.format(obj.bbl))
return rep
class UibeJzgXqSerializer(serializers.ModelSerializer):
create_time = serializers.DateField(format='%Y%m%d')
# lxrq = serializers.DateField(format='%Y-%m-%d')
# kyxxtjsj = serializers.SerializerMethodField()
# ekwltjsj = serializers.SerializerMethodField()
# lxrq = serializers.StringRelatedField(format='%Y-%m-%d')
wlsysc = serializers.SerializerMethodField()
wlsyll = serializers.SerializerMethodField()
class Meta:
model = pm.UibeJzg
fields = [
'id',
'zgh',
'xm',
'xb',
'csrq',
'xw',
'xl',
'lxrq',
'zzmm',
'jsjzs',
'jszgz',
'gqpxzs',
'qtzs',
'yjfx',
'zxxmsl',
'hxxmsl',
'cgjlsl',
'yjbgsl',
'zzcgsl',
'lwcgsl',
'bmdm',
'bm',
'rylb',
'gwzj',
'zcxxdm',
'zcxx',
'zcbdrq',
'xngw',
'zxsf',
'jl',
'yjskcxsrc',
'yjskcskjc',
'yjskcxss',
'yjskcskms',
'bkkcxsrc',
'bkkcskjc',
'bkkcxss',
'bkkcskms',
'tsjycs',
'ekxf',
'wlsyll',
'wlsysc',
'create_time',
]
# def get_kyxxtjsj(self, obj):
# lxrq = time.strftime("%Y-%m-%d", obj.lxrq)
# create_time = time.strftime("%Y-%m-%d", obj.create_time)
# return lxrq + "-" + create_time
#
# def get_ekwltjsj(self, obj):
# create_time = obj.create_time
# tjsj = time.strftime("%Y%m", create_time)
# return tjsj
def get_wlsysc(self, obj):
sysc = ("%.2f" % float(obj.wlsysc))
return sysc
def get_wlsyll(self, obj):
syll = ("%.2f" % float(obj.wlsyll))
return syll
class PropertySummarySerializer(serializers.ModelSerializer):
class Meta:
model = ds.Property
fields = ('bbl', 'zipcode', 'council', 'cd', 'stateassembly',
'statesenate', 'borough', 'yearbuilt', 'unitsres',
'unitstotal', 'bldgclass', 'zonedist1', 'numbldgs',
'numfloors', 'address', 'latitude', 'longitude', 'ownertype',
'ownername', 'taxlien', 'taxliens', 'buildings',
'rsunits_percent_lost', 'nycha', 'hpdregistrations',
'subsidyprograms', 'rentstabilizationrecord',
'unitsrentstabilized', 'subsidyj51', 'subsidy421a',
'conhrecord', 'zonedist1', 'zonedist2', 'zonedist3',
'zonedist4', 'overlay1', 'overlay2', 'spdist1', 'spdist2',
'spdist3', 'builtfar', 'residfar', 'commfar', 'facilfar',
'original_address', 'legalclassa', 'legalclassb',
'managementprogram', 'aepstatus', 'aepstartdate',
'aepdischargedate')
hpdregistrations = HPDRegistrationSerializer(source='hpdregistration_set',
many=True,
read_only=True)
buildings = BuildingSummarySerializer(source='building_set',
many=True,
read_only=True)
rentstabilizationrecord = RentStabilizationRecordSerializer(many=False,
read_only=True)
taxliens = TaxLienSerializer(source='taxlien_set',
many=True,
read_only=True)
taxlien = serializers.SerializerMethodField()
conhrecord = serializers.SerializerMethodField()
subsidyprograms = serializers.SerializerMethodField()
subsidyj51 = serializers.SerializerMethodField()
subsidy421a = serializers.SerializerMethodField()
nycha = serializers.SerializerMethodField()
unitsrentstabilized = serializers.SerializerMethodField()
rsunits_percent_lost = serializers.SerializerMethodField()
legalclassa = serializers.SerializerMethodField()
legalclassb = serializers.SerializerMethodField()
managementprogram = serializers.SerializerMethodField()
aepstatus = serializers.SerializerMethodField()
aepstartdate = serializers.SerializerMethodField()
aepdischargedate = serializers.SerializerMethodField()
def get_conhrecord(self, obj):
try:
return obj.propertyannotation.conhrecord
except Exception as e:
return None
def get_taxlien(self, obj):
try:
return obj.propertyannotation.taxlien
except Exception as e:
return None
def get_nycha(self, obj):
try:
return obj.propertyannotation.nycha
except Exception as e:
return None
def get_subsidy421a(self, obj):
try:
return obj.propertyannotation.subsidy421a
except Exception as e:
return None
def get_subsidyj51(self, obj):
try:
return obj.propertyannotation.subsidyj51
except Exception as e:
return None
def get_subsidyprograms(self, obj):
try:
return obj.propertyannotation.subsidyprograms
except Exception as e:
return None
def get_unitsrentstabilized(self, obj):
try:
return obj.propertyannotation.unitsrentstabilized
except Exception as e:
return None
def get_legalclassa(self, obj):
try:
return obj.propertyannotation.legalclassa
except Exception as e:
return None
def get_legalclassb(self, obj):
try:
return obj.propertyannotation.legalclassb
except Exception as e:
return None
def get_managementprogram(self, obj):
try:
return obj.propertyannotation.managementprogram
except Exception as e:
return None
def get_aepstatus(self, obj):
try:
return obj.propertyannotation.aepstatus
except Exception as e:
return None
def get_aepstartdate(self, obj):
try:
return obj.propertyannotation.aepstartdate
except Exception as e:
return None
def get_aepdischargedate(self, obj):
try:
return obj.propertyannotation.aepdischargedate
except Exception as e:
return None
def get_rsunits_percent_lost(self, obj):
try:
return obj.rentstabilizationrecord.get_percent_lost()
except Exception as e:
return 0
class ProfileSerializer(serializers.ModelSerializer):
url = serializers.SerializerMethodField()
days_since_joined = serializers.SerializerMethodField()
fullname = serializers.SerializerMethodField()
wastemonth = serializers.SerializerMethodField()
workmonth = serializers.SerializerMethodField()
performancemonth = serializers.SerializerMethodField()
email = serializers.SerializerMethodField()
surfaceappliedmonth = serializers.SerializerMethodField()
costmonth = serializers.SerializerMethodField()
position = serializers.SerializerMethodField()
def get_position(self, obj):
return obj.get_position_display()
def get_email(self, obj):
if obj.user.email == None or obj.user.email == "":
email = 'Unknown'
else:
email = obj.user.email
return email
def get_days_since_joined(self, obj):
return (now() - obj.user.date_joined).days
#get formatted image url
def get_url(self, obj):
return obj.image.url
#get user last name and surname if specified
def get_fullname(self, obj):
return obj.name()
#calculate wasted units of this month for this user
def get_wastemonth(self, obj):
#get first day of the month
first_day_month = datetime.today().replace(day=1)
#user is a tech
if obj.position == 'TN' or obj.position == 'TL':
w = Waste.objects.filter(tech__profile=obj,
date_waste__gte=first_day_month).count()
#user is in workshop
elif obj.position == 'WS':
w = WasteWorkshop.objects.filter(
employee=obj, date_waste__gte=first_day_month).count()
#user is a client
elif obj.position == 'CL':
w = Waste.objects.filter(ncr_responsible=obj,
date_waste__gte=first_day_month).count()
w += WasteWorkshop.objects.filter(
employee=obj, date_waste__gte=first_day_month).count()
else:
w = 'NA'
return w
#get reference applied/created number
def get_workmonth(self, obj):
first_day_month = datetime.today().replace(day=1)
#user is a tech
if obj.position == 'TN' or obj.position == 'TL':
w = ReferenceApplied.objects.filter(
tech__profile=obj, date_work__gte=first_day_month).count()
#user is in workshop
elif obj.position == 'WS':
cutted = Package.objects.filter(cut__employee=obj,
date_creation__gte=first_day_month)
packed = Package.objects.filter(packer__employee=obj,
date_creation__gte=first_day_month)
w = cutted.count() + packed.count()
for cut in cutted:
for pack in packed:
#user cutted and packed the same package
if cut.id == pack.id:
w = w - 1
else:
w = 'NA'
return w
def get_surfaceappliedmonth(self, obj):
first_day_month = datetime.today().replace(day=1)
s = 0
#user is a tech
if obj.position == 'TN' or obj.position == 'TL':
references_applied = ReferenceApplied.objects.filter(
tech__profile=obj, date_work__gte=first_day_month)
for applied in references_applied:
try:
s += applied.qty * applied.reference.surface
except:
pass
s = round(s, 2)
else:
s = 'NA'
return s
def get_costmonth(self, obj):
first_day_month = datetime.today().replace(day=1)
cw = 0
#user is a tech
if obj.position == 'TN' or obj.position == 'TL':
waste = Waste.objects.filter(tech__profile=obj,
date_waste__gte=first_day_month)
c = 0
for w in waste:
cw += w.reference.cost * w.qty
#total cost
c = cw + obj.salary
c = round(c, 2)
#user is in workshop
elif obj.position == 'WS':
waste = WasteWorkshop.objects.filter(
employee=obj, date_waste__gte=first_day_month)
c = 0
for w in waste:
cw += w.reference.cost * w.qty
#total cost
c = cw + obj.salary
c = round(c, 2)
#user is a client
elif obj.position == 'CL':
waste = Waste.objects.filter(ncr_responsible=obj,
date_waste__gte=first_day_month)
wasteworkshop = WasteWorkshop.objects.filter(
employee=obj, date_waste__gte=first_day_month)
c = 0
for w in waste:
cw += w.reference.cost * w.qty
for w in wasteworkshop:
cw += w.reference.cost * w.qty
#total cost
c = round(cw, 2)
else:
c = 'NA'
return c
def get_performancemonth(self, obj):
return 'Not yet'
class Meta:
model = Profile
fields = [
'url', 'days_since_joined', 'fullname', 'wastemonth',
'performancemonth', 'surfaceappliedmonth', 'costmonth',
'workmonth', 'email', 'position'
]
