def test_patch_own_profile(self):
"""
A user PATCHes their own profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False)
self.client.force_login(self.user1)
with mute_signals(post_save):
new_profile = ProfileFactory.create(filled_out=False)
new_profile.user.social_auth.create(
provider=EdxOrgOAuth2.name,
uid="{}_edx".format(new_profile.user.username)
)
patch_data = ProfileSerializer(new_profile).data
del patch_data['image']
resp = self.client.patch(self.url1, content_type="application/json", data=json.dumps(patch_data))
assert resp.status_code == 200
old_profile = Profile.objects.get(user__username=self.user1.username)
for key, value in patch_data.items():
field = ProfileSerializer().fields[key]
if isinstance(field, (ListSerializer, SerializerMethodField, ReadOnlyField)) or field.read_only is True:
# these fields are readonly
continue
elif isinstance(field, DateField):
assert getattr(old_profile, key) == parse(value).date()
else:
assert getattr(old_profile, key) == value
def test_add_employment(self):
"""
Test that we handle adding an employment correctly
"""
employment_object = {
"city": "NY",
"state_or_territory": "NY",
"country": "USA",
"company_name": "XYZ-ABC",
"position": "SSE",
"industry": "IT",
"end_date": "2016-05-17",
"start_date": "2016-05-28"
}
user1 = UserFactory.create()
user2 = UserFactory.create()
serializer = ProfileSerializer(instance=user1.profile, data={
'work_history': [employment_object], 'education': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert user1.profile.work_history.count() == 1
employment = user1.profile.work_history.first()
employment_object['id'] = employment.id
assert EmploymentSerializer(employment).data == employment_object
# Other profile did not get the employment assigned to it
assert user2.profile.work_history.count() == 0
def test_add_education(self):
"""
Test that we handle adding an Education correctly
"""
education_object = {
'degree_name': DOCTORATE,
'graduation_date': '9876-04-23',
'field_of_study': 'subject',
'online_degree': True,
'school_name': 'school_name',
'school_city': 'school_city',
'school_state_or_territory': 'school_state_or_territory',
'school_country': 'school_country,'
}
user1 = UserFactory.create()
user2 = UserFactory.create()
serializer = ProfileSerializer(instance=user1.profile, data={
'education': [education_object], 'work_history': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert user1.profile.education.count() == 1
education = user1.profile.education.first()
education_object['id'] = education.id
education_data = EducationSerializer(education).data
assert education_data == education_object
# Other profile did not get the education assigned to it
assert user2.profile.education.count() == 0
def test_creating_two_profiles_with_identic_emails(self):
data = \
{
"user":
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
}
}
data2 = \
{
"user":
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
}
}
error = False
profile1 = ProfileSerializer.create(ProfileSerializer(), validated_data=data)
try:
profile2 = ProfileSerializer.create(ProfileSerializer(), validated_data=data2)
except:
error = 'User with this email already exist' in traceback.format_exc()
self.assertTrue(True)
self.assertTrue(error)
def post(self, request, *args, **kwargs):
profile = request.user.base_profile()
serializer = ProfileSerializer(data=request.data, instance=profile)
if serializer.is_valid():
data = serializer.save()
response_data = update_template(
**{
'as_json': False,
'status': status.HTTP_200_OK,
'request': request,
'result': ProfileSerializer(data).data
})
return Response(response_data, status=status.HTTP_200_OK)
else:
response_data = update_template(
**{
'as_json': False,
'status': status.HTTP_500_INTERNAL_SERVER_ERROR,
'request': request,
'result': serializer.errors
})
return Response(response_data,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def test_patch_own_profile(self):
"""
A user PATCHes their own profile
"""
with mute_signals(post_save):
ProfileFactory.create(user=self.user1,
filled_out=False,
agreed_to_terms_of_service=False)
self.client.force_login(self.user1)
with mute_signals(post_save):
new_profile = ProfileFactory.create(filled_out=False)
new_profile.user.social_auth.create(provider=EdxOrgOAuth2.name,
uid="{}_edx".format(
new_profile.user.username))
patch_data = ProfileSerializer().to_representation(new_profile)
resp = self.client.patch(self.url1,
content_type="application/json",
data=json.dumps(patch_data))
assert resp.status_code == 200
old_profile = Profile.objects.get(user__username=self.user1.username)
for key, value in patch_data.items():
field = ProfileSerializer().fields[key]
if isinstance(field, (ListSerializer, SerializerMethodField,
ReadOnlyField)) or field.read_only is True:
# these fields are readonly
continue
elif isinstance(field, DateField):
assert getattr(old_profile, key) == parse(value).date()
else:
assert getattr(old_profile, key) == value
def patch(self, request, *args, **kwargs):
profile = self.get_object()
serializer = ProfileSerializer(profile,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response(status=HTTP_200_OK)
return Response(data=serializer.errors, status=HTTP_400_BAD_REQUEST)
class OrderSerializer(WritableNestedModelSerializer):
customer = ProfileSerializer()
courier = ProfileSerializer()
items = OrderItemSerializer(many=True)
class Meta:
model = Order
fields = ('id', 'customer', 'courier', 'items', 'delivery_address', 'initial_delivery_fee', 'final_delivery_fee', 'order_status', 'order_time', 'acceptance_time', 'completion_time')
read_only_fields = ('id',)
def patch(self, request):
user = request.user
profile = Profile.objects.get(user=user)
serializer = ProfileSerializer(profile,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_creating_simple_profile(self):
data = \
{
"user":
{
"username": "******",
"email": "*****@*****.**",
"password": "******"
}
}
profile = ProfileSerializer.create(ProfileSerializer(), validated_data=data)
profile2 = Profile.objects.get(id=1)
self.assertEquals(profile2, profile)
def create(self, request):
user_serializer = self.serializer_class(data=request.data,)
profile_serializer = ProfileSerializer(data=request.data,)
if user_serializer.is_valid() and profile_serializer.is_valid():
place = request.data['place']
user = user_serializer.save()
user.set_password(request.data['password'])
user.save()
Profile.objects.create(place=place, user=user)
return Response(user_serializer.data)
else:
return Response(profile_serializer.errors if user_serializer.is_valid() else user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_profile(request):
jwt_token = request.data.get('token')
name = request.data.get('name')
is_professor = request.data.get('is_professor')
# Validação do token
client = Client()
response = client.post('/token_verify/', request.data)
if response.status_code != HTTP_200_OK:
return response
# Decodificação do usuário
user_obj = jwt.decode(jwt_token, SECRET_KEY, algorithms=['HS256'])
user = User.objects.get(pk=user_obj['user_id'])
if is_professor:
is_professor = ast.literal_eval(is_professor)
else:
return Response(data={'error': 'Parametro invalido: is_professor'},
status=HTTP_400_BAD_REQUEST)
# Obtendo profile
if is_professor:
profile = Profile(user=user, is_professor=is_professor)
profile.save()
professor = Professor(profile=profile)
professor.save()
if name:
profile.name = name
classes = []
all_classes = Class.objects.all()
for each in all_classes:
for professor_name in each.professors:
if professor_name == name:
classes.append([each.discipline.code, each.name])
professor.classes = classes
professor.save()
profile.save()
serializer = ProfileSerializer(profile)
else:
profile = Profile(user=user, is_professor=is_professor)
profile.save()
student = Student(profile=profile)
student.save()
if name:
profile.name = name
profile.save()
serializer = ProfileSerializer(profile)
return Response(data=serializer.data, status=HTTP_200_OK)
class FollowingSerializer(serializers.ModelSerializer):
# 해당 유저의 팔로잉 리스트
profile = ProfileSerializer(source='from_user.profile', read_only=True)
class Meta:
model = Relation
fields = ('id', 'to_user', 'profile')
class CommentSerializer(serializers.ModelSerializer):
"""serializer for comments"""
author = ProfileSerializer(read_only=True, required=False)
createdAt = serializers.SerializerMethodField(method_name="get_created_at")
updatedAt = serializers.SerializerMethodField(method_name="get_updated_at")
body = serializers.CharField(
required=True, error_messages={"blank": "Comment can not be blank."})
class Meta:
model = Comment
fields = ("id", "author", "body", "createdAt", "updatedAt")
def create(self, validated_data):
article = self.context["article"]
author = self.context["author"]
return Comment.objects.create(author=author,
article=article,
**validated_data)
def get_created_at(self, instance):
return instance.created_at.isoformat()
def get_updated_at(self, instance):
return instance.updated_at.isoformat()
class CommentSerializer(serializers.ModelSerializer):
author = ProfileSerializer(required=False)
createdAt = serializers.SerializerMethodField(method_name='get_created_at')
updatedAt = serializers.SerializerMethodField(method_name='get_updated_at')
class Meta:
model = Comment
fields = (
'id',
'author',
'body',
'createdAt',
'updatedAt',
)
def create(self, validated_data):
article = self.context['article']
author = self.context['author']
return Comment.objects.create(author=author,
article=article,
**validated_data)
def get_created_at(self, instance):
return instance.created_at.isoformat()
def get_updated_at(self, instance):
return instance.updated_at.isoformat()
class UserSerializer(serializers.ModelSerializer):
password = serializers.CharField(
max_length=128,
min_length=8,
write_only=True
)
profile = ProfileSerializer(write_only=True)
bio = serializers.CharField(source='profile.bio', read_only=True)
image = serializers.CharField(source='profile.image', read_only=True)
class Meta:
model = User
fields = (
'email', 'username', 'password', 'token',
'profile', 'bio', 'image',
)
read_only_fields = ('token',)
def update(self, instance, validated_data):
password = validated_data.pop('password', None)
profile_data = validated_data.pop('profile', {})
for (key, value) in validated_data.items():
setattr(instance, key, value)
if password is not None:
instance.set_password(password)
instance.save()
for (key, value) in profile_data.items():
setattr(instance.profile, key, value)
instance.profile.save()
return instance
class PatientConnectionSerializer(serializers.ModelSerializer):
doctor = DoctorProfileSerializer()
patient = ProfileSerializer()
class Meta:
model = PatientConnection
fields = ('id', 'created', 'doctor', 'patient')
def get(self, request):
bg = self.request.query_params.get('bg', None)
district = self.request.query_params.get('district', None)
if (district == 'District' or district == ''):
district = None
if (bg == 'Blood Group' or bg == ''):
bg = None
if bg is None and district is None:
self.profile = Profile.objects.all()
if bg is not None and district is None:
self.profile = Profile.objects.filter(blood_group=bg)
if bg is None and district is not None:
self.profile = Profile.objects.filter(district=district)
if bg is not None and district is not None:
self.profile = Profile.objects.filter(blood_group=bg,
district=district)
serializer = ProfileSerializer(self.profile, many=True)
return Response(serializer.data, status=HTTP_200_OK)
class CreatedFriendshipInvitationSerializer(serializers.ModelSerializer):
friend = ProfileSerializer(many=False, read_only=True, source='invited')
friend_uuid = serializers.UUIDField(write_only=True, format='hex')
def validate(self, data):
try:
invited = Profile.objects.get(
external_uuid=data['friend_uuid'].hex)
except ObjectDoesNotExist:
raise serializers.ValidationError(
"Unable to find invited profile.")
inviting = self.context['request'].user
if Friendship.objects.filter(source=inviting, target=invited).exists():
raise serializers.ValidationError(
"Invite profile is already a friend.")
return {
'inviting': inviting,
'invited': invited,
}
def create(self, validated_data):
return self.Meta.model.objects.create(**validated_data)
class Meta:
model = FriendshipInvitation
fields = ('id', 'friend', 'friend_uuid')
def test_staff_sees_entire_profile(self):
"""
Staff should be able to see the entire profile despite the account privacy
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user2,
account_privacy=Profile.PRIVATE)
ProfileFactory.create(user=self.user1,
verified_micromaster_user=False)
program = ProgramFactory.create()
ProgramEnrollment.objects.create(
program=program,
user=profile.user,
)
Role.objects.create(
program=program,
role=Staff.ROLE_ID,
user=self.user1,
)
self.client.force_login(self.user1)
resp = self.client.get(self.url2)
profile_data = ProfileSerializer(profile).data
assert resp.json() == format_image_expectation(profile_data)
def test_program_enrolled_user_serializer(self): # pylint: disable=no-self-use
"""
Asserts the output of the serializer for program-enrolled users (ProgramEnrollments)
"""
with mute_signals(post_save):
profile = ProfileFactory.create()
EducationFactory.create(profile=profile)
EmploymentFactory.create(profile=profile)
program = ProgramFactory.create()
course = CourseFactory.create(program=program)
course_runs = [
CourseRunFactory.create(course=course) for _ in range(2)
]
for course_run in course_runs:
CachedCertificateFactory.create(user=profile.user,
course_run=course_run)
CachedEnrollmentFactory.create(user=profile.user,
course_run=course_run)
program_enrollment = ProgramEnrollment.objects.create(
user=profile.user, program=program)
assert serialize_program_enrolled_user(program_enrollment) == {
'_id': program_enrollment.id,
'id': program_enrollment.id,
'user_id': profile.user.id,
'email': profile.user.email,
'profile': ProfileSerializer().to_representation(profile),
'program': UserProgramSerializer.serialize(program_enrollment)
}
def test_no_thumbnail_change_if_image_upload(self, image_already_exists,
thumb_already_exists):
"""
A patch without an image upload should not touch the image or the thumbnail
"""
with mute_signals(post_save):
profile = ProfileFactory.create(user=self.user1,
filled_out=False,
agreed_to_terms_of_service=False)
if image_already_exists is False:
profile.image = None
if thumb_already_exists is False:
profile.image_small = None
profile.image_medium = None
profile.save()
self.client.force_login(self.user1)
patch_data = ProfileSerializer(profile).data
del patch_data['image']
del patch_data['image_small']
del patch_data['image_medium']
resp = self.client.patch(self.url1,
content_type="application/json",
data=json.dumps(patch_data))
assert resp.status_code == 200
profile.refresh_from_db()
assert bool(profile.image) == image_already_exists
assert bool(profile.image_small) == thumb_already_exists
assert bool(profile.image_medium) == thumb_already_exists
def serialize_program_enrolled_user(program_enrollment):
"""
Serializes a program-enrolled user for use with Elasticsearch.
Args:
program_enrollment (ProgramEnrollment): A program_enrollment to serialize
Returns:
dict: The data to be sent to Elasticsearch or None if it shouldn't be indexed
"""
user = program_enrollment.user
serialized = {
'id': program_enrollment.id,
'_id': program_enrollment.id,
'user_id': user.id,
'email': user.email,
}
try:
serialized['profile'] = filter_current_work(
ProfileSerializer(user.profile).data)
except Profile.DoesNotExist:
log.exception('User %s has no profile', user.username)
return None
serialized['program'] = UserProgramSearchSerializer.serialize(
program_enrollment)
return serialized
def set_profile(request):
jwt_token = request.data.get('token')
name = request.data.get('name')
client = Client()
response = client.post('/token_verify/', request.data)
if response.status_code != HTTP_200_OK:
return response
# Decodificação do usuário
user_obj = jwt.decode(jwt_token, SECRET_KEY, algorithms=['HS256'])
user = User.objects.get(pk=user_obj['user_id'])
if name:
try:
profile = Profile.objects.get(user=user)
except:
return Response(
data={'error': 'Erro terminal: Usuario nao possui perfil'},
status=HTTP_400_BAD_REQUEST)
profile.name = name
profile.save()
serializer = ProfileSerializer(profile)
else:
return Response(data={'error': 'Nome invalido'},
status=HTTP_400_BAD_REQUEST)
return Response(data=serializer.data, status=HTTP_200_OK)
class ProductSerializer(serializers.Serializer):
id = serializers.ReadOnlyField()
created = serializers.DateTimeField()
vendor = ProfileSerializer()
name = serializers.CharField()
price = serializers.FloatField()
photo = serializers.CharField()
def serialize_program_enrolled_user(program_enrollment):
"""
Serializes a program-enrolled user for use with Elasticsearch.
Args:
program_enrollment (ProgramEnrollment): A program_enrollment to serialize
Returns:
dict: The data to be sent to Elasticsearch
"""
user = program_enrollment.user
serialized = {
'id': program_enrollment.id,
'_id': program_enrollment.id,
'user_id': user.id,
'email': user.email
}
try:
serialized['profile'] = ProfileSerializer().to_representation(
user.profile)
except Profile.DoesNotExist:
# Just in case
pass
serialized['program'] = UserProgramSerializer.serialize(program_enrollment)
return serialized
class BlockSerializer(serializers.ModelSerializer):
# 해당 유저의 블록 리스트
profile = ProfileSerializer(source='to_user.profile', read_only=True)
class Meta:
model = Relation
fields = ('id', 'from_user', 'profile')
class ArticleSerializer(serializers.ModelSerializer):
author = ProfileSerializer(read_only=True)
description = serializers.CharField(required=False)
slug = serializers.SlugField(required=False)
favorited = serializers.SerializerMethodField()
favoritesCount = serializers.SerializerMethodField(
method_name='get_favorites_count')
tagList = TagRelatedField(many=True, required=False, source='tags')
createdAt = serializers.SerializerMethodField(method_name='get_created_at')
updatedAt = serializers.SerializerMethodField(method_name='get_updated_at')
class Meta:
model = Article
fields = (
'author',
'body',
'createdAt',
'description',
'favorited',
'favoritesCount',
'slug',
'tagList',
'title',
'updatedAt',
)
def create(self, validated_data):
author = self.context.get('author', None)
tags = validated_data.pop('tags', [])
article = Article.objects.create(author=author, **validated_data)
for tag in tags:
article.tags.add(tag)
return article
def get_created_at(self, instance):
return instance.created_at.isoformat()
def get_favorited(self, instance):
request = self.context.get('request', None)
if request is None:
return False
if not request.user.is_authenticated():
return False
return request.user.profile.has_favorited(instance)
def get_favorites_count(self, instance):
return instance.favorited_by.count()
def get_updated_at(self, instance):
return instance.updated_at.isoformat()
class MyFileDetailSerializer(serializers.ModelSerializer):
"""My file detail serializer"""
user = ProfileSerializer(source="user.profile", read_only=True)
class Meta:
model = File
fields = "__all__"
class UploadFileSerializer(serializers.ModelSerializer):
"""File serializer"""
user = ProfileSerializer(source="user.profile", read_only=True)
class Meta:
model = File
fields = "__all__"
def test_update_employment_different_profile(self):
"""
Make sure we can't edit an employment for a different profile
"""
with mute_signals(post_save):
employment1 = EmploymentFactory.create()
employment2 = EmploymentFactory.create()
employment_object = EmploymentSerializer(employment1).data
employment_object['id'] = employment2.id
serializer = ProfileSerializer(instance=employment1.profile, data={
'work_history': [employment_object], 'education': []
})
serializer.is_valid(raise_exception=True)
with self.assertRaises(ValidationError) as ex:
serializer.save()
assert ex.exception.detail == ["Work history {} does not exist".format(employment2.id)]
def update(self, request, pk=None):
user = self.get_object()
profile = Profile.objects.filter(user_id=user.pk,)
user_serializer = self.serializer_class(user, data=request.data,)
profile_serializer = ProfileSerializer(profile, data=request.data,)
if user_serializer.is_valid() and profile_serializer.is_valid():
place = request.data['place']
user_serializer.save()
user.set_password(request.data['password'])
user.save()
profile.update(place=place, user=user)
return Response(user_serializer.data)
else:
return Response(profile_serializer.errors if user_serializer.is_valid() else user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class OrderFeeActionSerializer(WritableNestedModelSerializer):
user = ProfileSerializer()
#for_order = OrderSerializer()
class Meta:
model = OrderFeeAction
fields = ('id', 'user', 'amount', 'was_counter_offer', 'is_final_fee', 'offer_made_time', 'offer_accept_time')
read_only_fields = ('id', 'user', 'amount', 'offer_made_time')
def test_update_education(self):
"""
Test that we handle updating an Education correctly
"""
with mute_signals(post_save):
education = EducationFactory.create()
education_data = EducationSerializer(education).data
education_data['degree_name'] = BACHELORS
serializer = ProfileSerializer(instance=education.profile, data={
'education': [education_data], 'work_history': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert education.profile.education.count() == 1
education = education.profile.education.first()
assert EducationSerializer(education).data == education_data
def test_update_employment(self):
"""
Test that we handle updating an employment correctly
"""
with mute_signals(post_save):
employment = EmploymentFactory.create()
employment_object = EmploymentSerializer(employment).data
employment_object['position'] = "SE"
serializer = ProfileSerializer(instance=employment.profile, data={
'work_history': [employment_object], 'education': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert employment.profile.work_history.count() == 1
employment = employment.profile.work_history.first()
assert EmploymentSerializer(employment).data == employment_object
class UserWithProfileSerializer(serializers.ModelSerializer):
from albums.serializers import AlbumSerializer
profile = ProfileSerializer(source="profile_user", read_only=True)
albums = AlbumSerializer(source="album_user", read_only=True, many=True)
class Meta:
model = User
fields = ["id", "username", "email", "profile", "albums"]
def test_delete_education(self):
"""
Test that we delete Educations which aren't specified in the PATCH
"""
with mute_signals(post_save):
education1 = EducationFactory.create()
EducationFactory.create(profile=education1.profile)
# has a different profile
education3 = EducationFactory.create()
assert education1.profile.education.count() == 2
education_object1 = EducationSerializer(education1).data
serializer = ProfileSerializer(instance=education1.profile, data={
'education': [education_object1], 'work_history': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert education1.profile.education.count() == 1
assert education1.profile.education.first() == education1
# Other profile is unaffected
assert education3.profile.education.count() == 1
def test_delete_employment(self):
"""
Test that we delete employments which aren't specified in the PATCH
"""
with mute_signals(post_save):
employment1 = EmploymentFactory.create()
EmploymentFactory.create(profile=employment1.profile)
# has a different profile
employment3 = EmploymentFactory.create()
assert employment1.profile.work_history.count() == 2
employment_object1 = EmploymentSerializer(employment1).data
serializer = ProfileSerializer(instance=employment1.profile, data={
'work_history': [employment_object1], 'education': []
})
serializer.is_valid(raise_exception=True)
serializer.save()
assert employment1.profile.work_history.count() == 1
assert employment1.profile.work_history.first() == employment1
# Other profile is unaffected
assert employment3.profile.work_history.count() == 1
