def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response('account created', status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_long_introduction_validate(self): """Test retrieve user fields successful""" long_introduction = "logn_introduction " * 500 data = {'introduction': long_introduction} serializer = UserSerializer(instance=self.organizer, data=data) self.assertFalse(serializer.is_valid()) self.assertCountEqual(serializer.errors.keys(), ['introduction'])
def create_user_clock(request, user_id): try: user = User.objects.get(pk=user_id) except: return HttpResponse(status=404) received_data = JSONParser().parse(request) user_data = UserSerializer(user).data user_data['name'] = received_data['name'] user_data['drinking'] = received_data['drinking'] user_data['smoking'] = received_data['smoking'] clock_ser = ClockSerializer(data={'time': initial_time(received_data)}) if clock_ser.is_valid(): clock = clock_ser.save() user_data['clock'] = clock_ser.data serializer = UserSerializer(data=user_data) if serializer.is_valid(): user.name = user_data['name'] user.drinking = user_data['drinking'] user.smoking = user_data['smoking'] user.clock = Clock.objects.get(pk=clock.pk) user.save() return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400) return JsonResponse(clock_ser.errors, status=400)
def add_user(request, format=None): data = request.data serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_updating_other_field_with_userserialize(self): """Test not updating other fields""" serializer = UserSerializer(instance=self.organizer, data={'email': fake.safe_email()}) self.assertTrue(serializer.is_valid()) serializer.save() self.assertEqual(self.organizer.email, self.email)
class ProjectDetailSerializer(serializers.ModelSerializer): """Serializer for project object""" projectLeader = UserSerializer(many=False) members = UserSerializer(many=True) places = PlaceDetailSerializer(many=True) class Meta: model = Project fields = ('id', 'name', 'members', 'places', 'abreviation', 'beginYear', 'endYear', 'description', 'projectLeader') read_only_fields = ('id', ) required_fields = ('name', 'beginYear', 'projectLeader') def create(self): pass def assign_user(self, project_id, user_id): project = Project.objects.get(id=project_id) user = get_user_model().objects.get(id=user_id) ProjectMembership.objects.create(user=user, project=project, is_active=True) return project def assign_place(self, project_id, place_id): project = Project.objects.get(id=project_id) place = Place.objects.get(id=place_id) project.places.add(place) return project
def create_user(request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = User.objects.create_user( email=serializer.validated_data['email'], password=serializer.validated_data['password'], first_name=serializer.validated_data['first_name'], last_name=serializer.validated_data['last_name'], phone=serializer.validated_data['phone'], firebase_uid=serializer.validated_data['firebase_uid'], birthday=serializer.validated_data['birthday'], gender=serializer.validated_data['gender']) # if 'birthday' in serializer.validated_data: # user.birthday = serializer.validated_data['birthday'] # # if 'gender' in serializer.validated_data: # user.gender = serializer.validated_data['gender'] user.save() if user: jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER payload = jwt_payload_handler(user) token = jwt_encode_handler(payload) print(token) context = {**serializer.data, 'token': token} return Response(context, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_long_user_family_name_validate(self): """Test retrieve user fields successful""" long_family_name = "long_family_name " * 500 data = {'family_name': long_family_name} serializer = UserSerializer(instance=self.organizer, data=data) self.assertFalse(serializer.is_valid()) self.assertCountEqual(serializer.errors.keys(), ['family_name'])
class TaskSerializer(serializers.ModelSerializer): creator = UserSerializer(read_only=True) executor = UserSerializer() class Meta: model = ProjectMember fields = '__all__'
class ScorelineSerializer(serializers.ModelSerializer): """Serializer for Scoreline object""" # tournament = serializers.StringRelatedField(many=True) # game = serializers.StringRelatedField(many=True) tournament = TournamentSerializer() game = GameSerializer() first_player = UserSerializer() second_player = UserSerializer() # tournament = serializers.PrimaryKeyRelatedField( # # many=True, # queryset=Tournament.objects.all() # ) # game = serializers.PrimaryKeyRelatedField( # # many=True, # queryset=Game.objects.all() # ) def validate(self, data): """Check that the start is before the stop.""" if data['first_player_score'] + data['draw_score'] + data['second_player_score'] > 10: raise serializers.ValidationError("Scoreline cannot be grater than 10") return data class Meta: model = Scoreline fields = ('id', 'tournament', 'game', 'first_player', 'second_player', 'first_player_score', 'second_player_score', 'draw_score') read_only_fields = ('id',)
class FriendsSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) created = serializers.DateTimeField(read_only=True) stats = serializers.IntegerField() user_id = serializers.IntegerField() friend_id = serializers.IntegerField() friend = UserSerializer(many=False, read_only=True) user = UserSerializer(many=False, read_only=True) # friend_id = serializers.RelatedField(source=settings.AUTH_USER_MODEL, read_only=True) # user_id = serializers.RelatedField(source=settings.AUTH_USER_MODEL, read_only=True) class Meta: model = Friends fields = [ 'id', 'created', 'stats', 'user_id', 'friend_id', 'friend', 'user' ] def create(self, validated_data): print(validated_data) return Friends.objects.create(**validated_data) # Friends.objects.create( # userId=User.objects.get(id=1), # friendId=User.objects.get(id=1) # )
def test_name(self) -> None: data = { "name": "A" * 43, } serializer = UserSerializer(data=data) assert serializer.is_valid() is False assert str(serializer.errors["name"][0]) == "I am happy to see you 42."
class LabIpSerializer(serializers.ModelSerializer): # lab = LabSerializer(read_only=True, many=False) student1 = UserSerializer(read_only=True) student2 = UserSerializer(read_only=True) class Meta: model = LabIp fields = ('id', 'ip', 'lab', 'date_created', 'date_modified', 'student1','student2') read_only_fields = ('lab',) depth = 2 def create(self, validated_data): ip = self.initial_data.get('ip', '') print(self.initial_data) # ip = validated_data.get('ip', "") # ip = self.initial_data['lab_id'] # to get request args lab_id = self.initial_data['lab_id'] # student_id = self.initial_data['student_id'] # print('student_id ============', self.initial_data['student_id']) print('lab id ============', self.initial_data['lab_id']) # student = User.objects.get(pk=student_id) # print(student) lab = Lab.objects.get(pk=lab_id) lab_ip = LabIp(ip=ip, lab=lab) lab_ip.save() return lab_ip
def post(self, request, pk): print(request.data) serializer = UserSerializer(data=request.data) if not serializer.is_valid(): return JsonResponse(data=None, status=400, safe=False) user = UserInfo.objects.filter(id=pk).first() user_obj = serializer.update(user, serializer.validated_data) result = UserSerializer(user_obj) user_data = result.data user_roles = user_obj.roles.all() permissions = [] if user_roles: for role in user_roles: ret = {'id': None, 'title': None, 'code': None} permission = role.permissions.all() if permission: for per in permission: ret = { 'id': per.id, 'title': per.title, 'code': per.code } permissions.append(ret) user_data['permissions'] = permissions return JsonResponse(data={ 'flag': True, 'user': user_data }, status=200, safe=False)
def to_representation(self, instance): data = super(WorkItemSerializer, self).to_representation(instance) data['created_by'] = UserSerializer(instance=instance.created_by).data data['assigned_to'] = UserSerializer(instance=instance.assigned_to).data data['task'] = TaskSerializer(instance=instance.task).data data['section'] = SectionSerializer(instance=instance.section).data return data
def put(self, request, pk, format=None): user = self.get_object(pk) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None): user = request.user serializer = UserSerializer(user, request.data, partial=True) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def update_user_info(request): request.data['contact'] = request.user.contact # keep contact inviriant, password is automatically safe serializer = UserSerializer(request.user, data=request.data) if serializer.is_valid(): serializer.save() return CostaResponse('0', 'OK')
def get(self, request): try: user_id = request.user.id except: return Response({"message": "Token is not valid."}, status=status.HTTP_401_UNAUTHORIZED) conversations = Conversation.objects.filter(user1_id=user_id) | Conversation.objects.filter(user2_id=user_id) conversations = conversations.order_by('-last_message_timestamp') number_of_unseen = 0 responseList = [] for conversation in conversations: d = {} d["id"] = conversation.id is_user1 = conversation.user1.id == user_id message = Message.objects.filter(conversation_id=conversation.id).order_by('-timestamp')[0] d["last_message_body"] = message.body d["last_message_timestamp"] = message.timestamp if is_user1: d["user_id"] = conversation.user2.id d = {**d, **UserSerializer(conversation.user2).data} d["is_visited"] = message.is_visited_by_user1 if not message.is_visited_by_user1: number_of_unseen = number_of_unseen + 1 else: d["user_id"] = conversation.user1.id d = {**d, **UserSerializer(conversation.user1).data} d["is_visited"] = message.is_visited_by_user2 if not message.is_visited_by_user2: number_of_unseen = number_of_unseen + 1 d["id"] = conversation.id responseList.append(d) response = {} response["new_messages"] = number_of_unseen response["conversations"] = responseList return Response(response)
def get(self, request, id): try: user_id = request.user.id user = request.user except: return Response({"message": "Token is not valid."}, status=status.HTTP_401_UNAUTHORIZED) try: conversation = Conversation.objects.get(id=id) except: return Response({"message": "Conversation is not valid."}, status=HTTP_404_NOT_FOUND) is_user1 = conversation.user1.id == user_id messages = Message.objects.filter(conversation_id=id).order_by('timestamp') messageList = [] for message in messages: serializer = MessageSerializer(message).data if is_user1: message.is_visited_by_user1 = True other_user = conversation.user2 serializer["am_I_user1"] = True else: message.is_visited_by_user2 = True other_user = conversation.user1 serializer["am_I_user1"] = False message.save() if is_user1 == message.is_user1: serializer = {**serializer, **UserSerializer(user).data} serializer["user_id"] = user.id else: serializer = {**serializer, **UserSerializer(other_user).data} serializer["user_id"] = other_user.id messageList.append(serializer) return Response(messageList)
def create_user(request): serialized = UserSerializer(data=request.data) if serialized.is_valid(): serialized.save() return Response("You have successfully created user!",status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() UserProfile.objects.create(user=NewUser.objects.get(id=serializer.data['id'])) return Response({'status': 'success'}, status=status.HTTP_201_CREATED) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): profile = UserProfile.objects.get(user=request.user) serializer = UserSerializer(instance=profile, data=request.data) if serializer.is_valid(): logger.critical('user ' + profile.first_name + ' updated account') serializer.save() return Response(serializer.data)
def test_update_user_successful(self): """Test update user fields successful""" data = {'is_guide': False} serializer = UserSerializer(instance=self.organizer, data=data) self.assertTrue(serializer.is_valid()) serializer.save() self.assertEqual(serializer.data['is_guide'], data['is_guide'])
class ProdPartnerSerializer(serializers.ModelSerializer): pro_user = UserSerializer(many=True) pro_uuid = serializers.CharField(write_only=True) pro_create = UserSerializer() class Meta: model = ProdPartner exclude = ('create_time', 'update_time', 'id')
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() logger.info(f"user with username={request.data.get('username')} was created.") return Response(serializer.data) logger.error(serializer.errors) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk): user = self.get_object(pk) serializer = UserSerializer(user, data=request.data, partial=True) if serializer.is_valid(): serializer.save() return Response(response_data(True, serializer.data)) else: return Response(response_data(False, serializer.errors), status=status.HTTP_400_BAD_REQUEST)
def post(self, request): json_parser = JSONParser() data = json_parser.parse(request) serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def updateUser(request): # 根据id修改数据 if User.objects.filter(id=request.data['id']): user = User.objects.get(id=request.data['id']) ser = UserSerializer(instance=user, data=request.data) # 注意指定参数 if ser.is_valid(): ser.save() return Response(str('success')) return Response(ser.errors) return Response(str('没有此id'))
def post(self, request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(status=status.HTTP_501_NOT_IMPLEMENTED) return Response(status=status.HTTP_406_NOT_ACCEPTABLE, data=serializer.errors)
def get(self, request): u""" 获取用户列表 --- parameters: - name: index description: 分页显示第几页 paramType: query required: false - name: number description: 每页显示几条数据 paramType: query required: false - name: descent description: 需要倒序的字段,用逗号分开,默认通过ID 正序 paramType: query required: false - name: is_page description: 是否需要分页,default=1 ('0', '不需要分页'),('1', '需要分页') paramType: query required: false """ query_dict = request.query_params.dict().copy() index, number, sort_tuple, descent = gen_page_info(query_dict) is_page = query_dict.pop('is_page', '1') user_objs = User.objects.order_by(*sort_tuple).all() if is_page == '1': paginator = Paginator(user_objs, number) try: pg = paginator.page(index) except PageNotAnInteger: # If page is not an integer, deliver first page. index = 1 pg = paginator.page(index) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. index = paginator.num_pages pg = paginator.page(index) serializer = UserSerializer(pg, many=True) res = serializer.data logger.info('正常返回分页:%s:' % (index)) return BackstageHTTPResponse(data=res, message=u'正常返回分页').to_response() else: serializer = UserSerializer(user_objs, many=True) res = serializer.data logger.info('正常返回所有数据') return BackstageHTTPResponse(data=res, message=u'正常返回所有数据').to_response()
def add_update(data): ''' @summary: add (if no) or update a user record. @parm data: a dict for the User's serializer. @return: None. ''' try: user = User.objects.get(openid=data['openid']) user_se = UserSerializer(user, data=data, partial=True) except User.DoesNotExist: user_se = UserSerializer(data=data) if user_se.is_valid(): user_se.save()