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