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()
