def create(self, validated_data):
affiliations_serializer = TagSerializer(
many=True, data=validated_data.pop('affiliations'))
instance = super().create(validated_data)
set_tags(instance, affiliations_serializer, 'affiliations')
instance.save()
return instance
class MemberProfileListSerializer(serializers.ModelSerializer):
date_joined = serializers.DateTimeField(source='user.date_joined',
read_only=True,
format='%c')
username = serializers.CharField(source='user.username')
profile_url = serializers.URLField(source='get_absolute_url',
read_only=True)
tags = TagSerializer(many=True)
avatar = serializers.SerializerMethodField(
) # needed to materialize the FK relationship for wagtailimages
bio = MarkdownField()
research_interests = MarkdownField()
def get_avatar(self, instance):
request = self.context.get('request')
if request and request.accepted_media_type != 'text/html':
return instance.picture.get_rendition(
'fill-150x150').url if instance.picture else None
return instance.picture
class Meta:
model = MemberProfile
fields = (
'date_joined',
'name',
'profile_url',
'tags',
'username',
'avatar',
'bio',
'research_interests',
'full_member',
'is_reviewer',
'degrees',
)
def update(self, instance, validated_data):
raw_tags = TagSerializer(many=True, data=validated_data.pop('tags'))
user = instance.user
raw_user = validated_data.pop('user')
user.first_name = raw_user['first_name']
user.last_name = raw_user['last_name']
user.save()
new_email = self.initial_data['email']
raw_institution = {
'name': validated_data.pop('institution_name'),
'url': validated_data.pop('institution_url')
}
institution = instance.institution
if institution:
institution.name = raw_institution.get('name')
institution.url = raw_institution.get('url')
institution.save()
else:
institution = Institution.objects.create(**raw_institution)
instance.institution = institution
# Full members cannot downgrade their status
if instance.full_member:
validated_data['full_member'] = True
else:
validated_data['full_member'] = bool(
self.initial_data['full_member'])
obj = super().update(instance, validated_data)
self.save_tags(instance, raw_tags)
self.save_email(user, new_email)
return obj
class ContributorSerializer(serializers.ModelSerializer):
# Need an ID for Vue-Multiselect
id = serializers.IntegerField(read_only=True)
user = RelatedMemberProfileSerializer(required=False, allow_null=True)
affiliations = TagSerializer(many=True)
profile_url = serializers.SerializerMethodField()
def get_existing_contributor(self, validated_data):
user = validated_data.get('user')
username = user.get('username') if user else None
if username is not None:
return User.objects.get(
username=username), Contributor.objects.filter(
user__username=username).first()
else:
name = {
'given_name': validated_data['given_name'],
'family_name': validated_data['family_name']
}
return None, Contributor.objects.filter(**name).first()
def save(self, **kwargs):
if self.instance is None:
validated_data = dict(
list(self.validated_data.items()) + list(kwargs.items()))
user, self.instance = self.get_existing_contributor(validated_data)
if user:
kwargs['user_id'] = user.id
self.validated_data.pop('user')
return super().save(**kwargs)
def get_profile_url(self, instance):
user = instance.user
if user:
return user.member_profile.get_absolute_url()
else:
return "{0}?{1}".format(reverse('home:profile-list'),
urlencode({'query': instance.name}))
def update(self, instance, validated_data):
affiliations_serializer = TagSerializer(
many=True, data=validated_data.pop('affiliations'))
instance = super().update(instance, validated_data)
set_tags(instance, affiliations_serializer, 'affiliations')
instance.save()
return instance
def create(self, validated_data):
affiliations_serializer = TagSerializer(
many=True, data=validated_data.pop('affiliations'))
instance = super().create(validated_data)
set_tags(instance, affiliations_serializer, 'affiliations')
instance.save()
return instance
class Meta:
model = Contributor
fields = ('id', 'given_name', 'middle_name', 'family_name', 'name',
'email', 'user', 'type', 'affiliations', 'profile_url')
def get_tags(self, obj):
if hasattr(obj, 'donation_tags'):
tag_list = []
for lol in obj.donation_tags.all():
tag_list.append(lol.tag)
serializer = TagSerializer(tag_list, many=True)
return serializer.data
def create(self, validated_data):
serialized_tags = TagSerializer(many=True,
data=validated_data.pop('tags'))
codebase = Codebase(**validated_data)
codebase.submitter = self.context['request'].user
codebase.identifier = codebase.uuid
set_tags(codebase, serialized_tags)
codebase.save()
return codebase
def create(self, request, *args, **kwargs):
"""Overwrite create method"""
name = request.data.get("name", None)
if name:
queryset = self.get_queryset()
tag = queryset.filter(name=name).first()
if tag:
return response.Response(TagSerializer(tag).data)
return super().create(request, *args, **kwargs)
def update(self, instance, validated_data):
programming_languages = TagSerializer(
many=True, data=validated_data.pop('programming_languages'))
platform_tags = TagSerializer(many=True,
data=validated_data.pop('platform_tags'))
raw_license = validated_data.pop('license')
existing_license = License.objects.get(name=raw_license['name'])
set_tags(instance, programming_languages, 'programming_languages')
set_tags(instance, platform_tags, 'platform_tags')
instance = super().update(instance, validated_data)
instance.license = existing_license
instance.draft = False
instance.save()
return instance
def test_retreive_tags(self):
Tag.objects.create(tag_name=fake.name(), company=self.company)
res = self.client.get(TAG_URL)
tags = Tag.objects.all().order_by('-id')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
class PeerReviewReviewerSerializer(serializers.ModelSerializer):
tags = TagSerializer(many=True)
class Meta:
model = MemberProfile
fields = (
'id',
'avatar_url',
'degrees',
'name',
'tags',
)
class PostSerializer(PostBaseSerializer):
images = ImageSerializer(many=True, read_only=True)
categories = CategorySerializer(many=True, read_only=True)
tags = TagSerializer(many=True, read_only=True)
thumbnail = serializers.CharField(read_only=True)
def create(self, validated_data):
super().create(validated_data)
class Meta:
fields = "__all__"
model = Post
def test_name_max_length_check_respected(self):
too_long = Tag._meta.get_field('name').max_length + 1
name_too_long = TagSerializer(data={'name': 'a'*too_long})
self.assertFalse(name_too_long.is_valid())
valid_name = TagSerializer(data={'name': 'fishing'})
self.assertTrue(valid_name.is_valid())
class RelatedCodebaseSerializer(serializers.ModelSerializer,
FeaturedImageMixin):
"""
Sparse codebase serializer
"""
all_contributors = ContributorSerializer(many=True, read_only=True)
tags = TagSerializer(many=True)
version_number = serializers.ReadOnlyField(
source='latest_version.version_number')
first_published_at = serializers.DateTimeField(
read_only=True, format=DATE_PUBLISHED_FORMAT)
last_published_on = serializers.DateTimeField(read_only=True,
format=DATE_PUBLISHED_FORMAT)
summarized_description = serializers.CharField(read_only=True)
live = serializers.SerializerMethodField()
def get_live(self, instance):
return instance.live
def create(self, validated_data):
return create(self.Meta.model, validated_data, self.context)
def update(self, instance, validated_data):
return update(super().update, instance, validated_data)
class Meta:
model = Codebase
fields = (
'all_contributors',
'tags',
'title',
'first_published_at',
'last_published_on',
'identifier',
'version_number',
'featured_image',
'summarized_description',
'description',
'live',
'peer_reviewed',
'repository_url',
)
class CodebaseSerializer(serializers.ModelSerializer, FeaturedImageMixin):
absolute_url = serializers.URLField(source='get_absolute_url',
read_only=True)
all_contributors = ContributorSerializer(many=True, read_only=True)
date_created = serializers.DateTimeField(
read_only=True, default=serializers.CreateOnlyDefault(timezone.now))
download_count = serializers.IntegerField(read_only=True)
first_published_at = serializers.DateTimeField(
format=DATE_PUBLISHED_FORMAT, read_only=True)
last_published_on = serializers.DateTimeField(format=DATE_PUBLISHED_FORMAT,
read_only=True)
latest_version_number = serializers.ReadOnlyField(
source='latest_version.version_number')
releases = serializers.SerializerMethodField()
submitter = LinkedUserSerializer(read_only=True,
default=serializers.CurrentUserDefault())
summarized_description = serializers.CharField(read_only=True)
identifier = serializers.ReadOnlyField()
tags = TagSerializer(many=True)
# FIXME: output should be raw markdown, not rendered
description = MarkdownField()
def get_releases(self, obj):
request = self.context.get('request')
user = request.user if request else User.get_anonymous()
queryset = CodebaseRelease.objects.filter(
codebase_id=obj.pk).accessible(user).order_by('-version_number')
# queryset = obj.releases.order_by('-version_number')
return RelatedCodebaseReleaseSerializer(queryset,
read_only=True,
many=True,
context=self.context).data
def create(self, validated_data):
serialized_tags = TagSerializer(many=True,
data=validated_data.pop('tags'))
codebase = Codebase(**validated_data)
codebase.submitter = self.context['request'].user
codebase.identifier = codebase.uuid
set_tags(codebase, serialized_tags)
codebase.save()
return codebase
def update(self, instance, validated_data):
validated_data['draft'] = False
return update(super().update, instance, validated_data)
class Meta:
model = Codebase
fields = (
'absolute_url',
'all_contributors',
'date_created',
'download_count',
'featured_image',
'repository_url',
'first_published_at',
'last_published_on',
'latest_version_number',
'releases',
'submitter',
'summarized_description',
'tags',
'description',
'title',
'doi',
'identifier',
'id',
'references_text',
'associated_publication_text',
'replication_text',
'peer_reviewed',
)
class MemberProfileSerializer(serializers.ModelSerializer):
"""
FIXME: references library.Codebase, keeping in home for now to avoid circular dependencies in core
"""
# User fields
date_joined = serializers.DateTimeField(source='user.date_joined',
read_only=True,
format='%B %d %Y')
family_name = serializers.CharField(source='user.last_name')
given_name = serializers.CharField(source='user.first_name')
username = serializers.CharField(source='user.username', read_only=True)
user_pk = serializers.IntegerField(source='user.pk', read_only=True)
email = serializers.SerializerMethodField()
# Followers
follower_count = serializers.ReadOnlyField(source='user.following.count')
following_count = serializers.ReadOnlyField(source='user.followers.count')
codebases = RelatedCodebaseSerializer(source='user.codebases',
many=True,
read_only=True)
# Institution
institution_name = serializers.CharField(allow_blank=True)
institution_url = serializers.URLField(allow_blank=True)
# MemberProfile
avatar = serializers.SerializerMethodField(
) # needed to materialize the FK relationship for wagtailimages
orcid_url = serializers.ReadOnlyField()
github_url = serializers.ReadOnlyField()
tags = TagSerializer(many=True)
profile_url = serializers.URLField(source='get_absolute_url',
read_only=True)
bio = MarkdownField()
research_interests = MarkdownField()
def get_email(self, instance):
request = self.context.get('request')
if request and request.user.is_anonymous:
return None
else:
return instance.email
def get_avatar(self, instance):
request = self.context.get('request')
if request and request.accepted_media_type != 'text/html':
return instance.picture.get_rendition(
'fill-150x150').url if instance.picture else None
return instance.picture
def save_email(self, user, new_email):
if user.email != new_email:
try:
validate_email(new_email)
# Check if any user other the user currently being edited has an email account with the same address as the
# new email
users_with_email = MemberProfile.objects.find_users_with_email(
new_email, exclude_user=user)
if users_with_email.exists():
logger.warning(
"Unable to register email %s, already owned by [%s]",
user.email, users_with_email)
raise DrfValidationError(
{'email': ["This email address is already taken."]})
except ValidationError as e:
raise DrfValidationError({'email': e.messages})
sender = self.context.get('request')
EmailAddress.objects.get(primary=True,
user=user).change(sender,
new_email,
confirm=True)
logger.warning(
'email change for user [pk: %s] %s -> %s, awaiting confirmation.',
user.id, user.email, new_email)
@transaction.atomic
def update(self, instance, validated_data):
raw_tags = TagSerializer(many=True, data=validated_data.pop('tags'))
user = instance.user
raw_user = validated_data.pop('user')
user.first_name = raw_user['first_name']
user.last_name = raw_user['last_name']
user.save()
new_email = self.initial_data['email']
raw_institution = {
'name': validated_data.pop('institution_name'),
'url': validated_data.pop('institution_url')
}
institution = instance.institution
if institution:
institution.name = raw_institution.get('name')
institution.url = raw_institution.get('url')
institution.save()
else:
institution = Institution.objects.create(**raw_institution)
instance.institution = institution
# Full members cannot downgrade their status
if instance.full_member:
validated_data['full_member'] = True
else:
validated_data['full_member'] = bool(
self.initial_data['full_member'])
obj = super().update(instance, validated_data)
self.save_tags(instance, raw_tags)
self.save_email(user, new_email)
return obj
@staticmethod
def save_tags(instance, tags):
if not tags.is_valid():
raise serializers.ValidationError(tags.errors)
db_tags = tags.save()
instance.tags.clear()
instance.tags.add(*db_tags)
instance.save()
class Meta:
model = MemberProfile
fields = (
# User
'date_joined',
'family_name',
'given_name',
'profile_url',
'username',
'email',
'user_pk',
# Follower
'follower_count',
'following_count',
'codebases',
# institution
'institution_name',
'institution_url',
# MemberProfile
'avatar',
'bio',
'name',
'degrees',
'full_member',
'tags',
'orcid_url',
'github_url',
'personal_url',
'is_reviewer',
'professional_url',
'profile_url',
'research_interests',
'name',
)
def load_people_detail(self):
"""load all the residents and save to db"""
file = os.path.join('./resources/', 'people.json')
data = pd.read_json(file)
# load tags
tags = [{'name': x} for x in list(set(chain(*data.tags.values)))]
self.to_db(TagSerializer(data=tags, many=True), 'Tag')
# # load foods
foods = [{
'name': x
} for x in list(set(chain(*data.favouriteFood.values)))]
self.to_db(FoodSerializer(data=foods, many=True), 'Food')
# load people
json_data = self.read_json_file(file)
for data in json_data:
resident = People()
resident._id = data['_id']
resident.guid = data['guid']
resident.index = data['index']
resident.name = data['name']
resident.age = data['age']
resident.has_died = False if data['has_died'] == "false" or data[
'has_died'] == False else True
resident.balance = Decimal(data['balance'].strip('$').replace(
',', ''))
resident.picture = data['picture']
resident.eye_color = data['eyeColor']
resident.gender = data['gender']
resident.company = Company.objects.get(index=data['company_id'] -
1)
resident.email = data['email']
resident.phone = data['phone']
resident.address = data['address']
resident.about = data['about']
resident.registered = dateutil.parser.parse(data['registered'])
resident.save()
tags = data.pop('tags') if 'tags' in data else None
if tags:
for value in tags:
resident.tags.add(Tag.objects.get(name=value))
resident.save()
favourite_foods = data.pop(
'favouriteFood') if 'favouriteFood' in data else None
if favourite_foods:
for food in favourite_foods:
resident.favourite_foods.add(Food.objects.get(name=food))
resident.save()
friends = data.pop('friends') if 'friends' in data else None
if friends:
resident.friends = ','.join(
str(friend['index']) for friend in friends)
resident.save()
self.stdout.write(self.style.SUCCESS('load people success !'))
class CodebaseReleaseSerializer(serializers.ModelSerializer):
absolute_url = serializers.URLField(
source='get_absolute_url',
read_only=True,
help_text=_('URL to the detail page of the codebase'))
citation_text = serializers.ReadOnlyField()
codebase = CodebaseSerializer(read_only=True)
release_contributors = ReleaseContributorSerializer(
read_only=True, source='index_ordered_release_contributors', many=True)
date_created = serializers.DateTimeField(format=YMD_DATETIME_FORMAT,
read_only=True)
first_published_at = serializers.DateTimeField(
format=DATE_PUBLISHED_FORMAT, read_only=True)
last_published_on = serializers.DateTimeField(format=DATE_PUBLISHED_FORMAT,
read_only=True)
license = LicenseSerializer()
live = serializers.ReadOnlyField()
os_display = serializers.ReadOnlyField(source='get_os_display')
platforms = TagSerializer(many=True, source='platform_tags')
programming_languages = TagSerializer(many=True)
submitter = LinkedUserSerializer(read_only=True, label='Submitter')
version_number = serializers.ReadOnlyField()
release_notes = MarkdownField(max_length=2048)
urls = serializers.SerializerMethodField()
review_status = serializers.SerializerMethodField()
def get_urls(self, instance):
request_peer_review_url = instance.get_request_peer_review_url()
review = instance.get_review()
review_url = review.get_absolute_url() if review else None
notify_reviewers_of_changes_url = instance.get_notify_reviewers_of_changes_url(
) if review else None
return {
'request_peer_review': request_peer_review_url,
'review': review_url,
'notify_reviewers_of_changes': notify_reviewers_of_changes_url
}
def get_review_status(self, instance):
return instance.review.status if instance.get_review() else None
class Meta:
model = CodebaseRelease
fields = (
'absolute_url',
'citation_text',
'release_contributors',
'date_created',
'dependencies',
'release_notes',
'documentation',
'doi',
'download_count',
'embargo_end_date',
'first_published_at',
'last_modified',
'last_published_on',
'license',
'live',
'os',
'os_display',
'peer_reviewed',
'platforms',
'programming_languages',
'submitted_package',
'submitter',
'codebase',
'review_status',
'version_number',
'id',
'share_url',
'urls',
)
