class CommentUserSerializer(serializers.ModelSerializer):
author = UserDetailSerializer()
reply_to = UserDetailSerializer()
class Meta:
model = CommentReply
fields = "__all__"
def post(self, request, *args, **kwargs):
user = BusinessUser.get_user_detail(request)
if isinstance(user, Exception):
return Response({'Error': user.args}, status=status.HTTP_400_BAD_REQUEST)
serializer = UserDetailSerializer(data=user)
if serializer.is_valid():
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
user_detail = self.get_user_object(request)
if isinstance(user_detail, Exception):
return Response({'Detail': user_detail.args},
status=status.HTTP_400_BAD_REQUEST)
serializer = UserDetailSerializer(data=user_detail)
if not serializer.is_valid():
return Response({'Detail': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.data, status=status.HTTP_200_OK)
def test_expected_fields(self):
"""Tests expected serializer fields for validated data
email
"""
user_data = factory.build(dict, FACTORY_CLASS=UserFactory)
serializer = UserDetailSerializer(data=user_data)
is_valid = serializer.is_valid()
print("Errors: ", serializer.errors)
assert is_valid, "serializer validation test"
assert serializer.validated_data.keys() == set(['email'])
class CommentSerializer(serializers.ModelSerializer):
child_replys = CommentReplySerializer(many=True)
author = UserDetailSerializer()
class Meta:
model = Comment
fields = "__all__"
def jwt_response_payload_handler(token, user=None, request=None):
return {
'token': token,
'user': UserDetailSerializer(user, context={
'request': request
}).data
}
class VideoDetailSerializer(serializers.ModelSerializer):
'''
视频详情序列化
'''
# 序列化时，如果存在ForeignKey这样的字段，比如user，默认序列化的是id，如果要序列化这个ForeignKey对于的model，则需要重载对应的字段，这样这个字段会根据其UserDetailSerializer嵌入到序列化中
user = UserDetailSerializer()
like_num = serializers.SerializerMethodField()
# 当前登录的用户点赞此视频 id
like_id = serializers.SerializerMethodField()
class Meta:
model = Video
fields = '__all__'
def get_like_num(self, instance):
likes = instance.likes.all()
return len(likes)
def get_like_id(self, instance):
'''
查找授权的用户是否对此视频点赞了
用户登录后才会有此字段，方便返回给客户端删除点赞的
:param instance: video instance
:return:
'''
request = self.context.get('request')
user = request.user
if user != None and isinstance(user, User):
likes = instance.likes.filter(sender=user)
if len(likes):
return likes[0].pk
return -1
class GetCasesSerializer(serializers.ModelSerializer):
category = CategorySerializer()
submitter = UserDetailSerializer()
class Meta:
model = Cases
fields = "__all__"
def test_user_detail_filled_all_the_data(self):
""" Заполнена вся информация"""
user_data = {
'username': '******',
'name': 'test_user',
'email': '*****@*****.**',
'first_name': 'Test',
'last_name': 'Testovich',
'phone_number': '79998880066',
'date_of_birth': '1990-01-01',
'gender': 'male',
'country': 'RU',
'description': 'Some test information',
'location': 'Test place',
}
user = User.objects.create(**user_data)
data = UserDetailSerializer(user).data
expected_data = {
'id': user.id,
'username': '******',
'name': 'test_user',
'email': '*****@*****.**',
'first_name': 'Test',
'last_name': 'Testovich',
'phone_number': '79998880066',
'date_of_birth': '1990-01-01',
'gender': 'male',
'country': 'RU'
}
self.assertEqual(expected_data, data)
class ScheduleDetailSerializer(serializers.ModelSerializer):
'''
约运动详情
'''
school = SchoolSerializer1()
user = UserDetailSerializer()
sport = SportsSerializer()
sport_time = serializers.DateTimeField(required=True,
format='%Y-%m-%d %H:%M:%S')
sport_end_time = serializers.DateTimeField(required=True,
format='%Y-%m-%d %H:%M:%S')
joiners = serializers.SerializerMethodField()
def get_joiners(self, obj):
all_joiners = JoinSchedule.objects.filter(schedule_id=obj.id, )
all_joiners_json = JoinScheduleDetailSerializer(
all_joiners,
many=True,
context={
'request': self.context['request']
}).data
return all_joiners_json
class Meta:
model = Schedule
fields = '__all__'
class CommentSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
parent_user = serializers.SerializerMethodField()
comment = serializers.CharField(source='comment_html')
class Meta:
model = BlogComment
fields = [
'id',
'comment',
'user',
'parent_user',
'submit_date',
'parent',
'name',
]
extra_kwargs = {'submit_date': {'format': '%Y-%m-%d %H:%M:%S'}}
def get_parent_user(self, obj):
if obj.parent:
return UserDetailSerializer(obj.parent.user).data
def save(self, **kwargs):
comment = kwargs.pop('comment')
comment.save()
# 必须设置 instance 用于序列化
self.instance = comment
return comment
class ComicListSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
episode_count = SerializerMethodField(read_only=True)
comment_count = SerializerMethodField(read_only=True)
comic_detail_url = comic_detail_url
comic_delete_url = comic_delete_url
comic_update_url = comic_update_url
class Meta:
model = Comic
read_only_fields = [
'episode_count',
'comment_count',
]
fields = [
'user',
'title',
'tag',
'slug',
'view_count',
'description',
'timestamp',
'thumbnail',
'episode_count',
'comment_count',
'comic_detail_url',
'comic_delete_url',
'comic_update_url',
]
def get_episode_count(self, obj):
return obj.episode_count
def get_comment_count(self, obj):
return obj.comment_count
class EpisodeSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
episode_delete_url = episode_delete_url
episode_update_url = episode_update_url
episode_detail_url = episode_detail_url
comment_count = SerializerMethodField(read_only=True)
class Meta:
model = Episode
read_only_true = [
'timestamp',
'view_count',
'episode_delete_url',
'episode_update_url',
'episode_detail_url',
'comment_count',
]
fields = [
'title',
'user',
'thumbnail',
'content',
'view_count',
'comments',
'comment_count',
'timestamp',
'episode_delete_url',
'episode_update_url',
'episode_detail_url',
]
def get_comment_count(self, obj):
return obj.comment_count
class ParticipantSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
role = ChoiceField(choices=Participant.ROLE_CHOICES)
class Meta:
model = Participant
fields = ['user', 'role']
class UserCommentsSerializer(serializers.ModelSerializer):
comentslist = serializers.SerializerMethodField('get_coments_list')
snapid = serializers.SerializerMethodField('get_snap_status')
user = UserDetailSerializer(read_only=True)
add_time = serializers.DateTimeField(read_only=True, format='%Y-%m-%d %H:%M')
class Meta:
model = UserComments
fields = "__all__"
def get_coments_list(self, obj):
try:
subcoment = UserComments.objects.filter(comment_type=2, comment_id=obj.id)
if subcoment:
countnum = len(subcoment)
return {'count': countnum, 'list': subcoment}
else:
return {'count': 0}
except Exception as e:
print(e)
return {'count': 0}
def get_snap_status(self, obj):
try:
snap = UserSnap.objects.filter(snap_type=2, snap_id=obj.id, user=self.context['request'].user).first()
if snap:
return snap.id
else:
return 0
except Exception as e:
print(e)
return 0
def retrieve(self, request, *args, **kwargs):
resp = {}
JSCODE = request.GET.get('JSCODE', None)
if not JSCODE:
code = 400
resp['msg'] = 'JSCODE不可为空'
return Response(data=resp, status=code)
dict_result = make_openid(JSCODE)
if dict_result.get('errmsg'):
code = 400
resp['msg'] = '创建失败'
return Response(data=resp, status=code)
openid = dict_result.get('openid')
if not openid:
code = 400
resp['msg'] = 'openid获取失败'
return Response(data=resp, status=code)
yesno = UserProfile.objects.filter(is_active=True,
openid=openid).first()
if not yesno:
code = 400
resp['msg'] = '用户未绑定'
return Response(data=resp, status=code)
code = 200
data = UserDetailSerializer(yesno).data
return Response(data=data, status=code)
class ArticleSerializer(serializers.ModelSerializer):
category = CategorySerializer1()
tags = TagSerializer1()
author = UserDetailSerializer()
class Meta:
model = Article
fields = "__all__"
def profile_detail(self, request):
"""Метод для получения данных о конкретном юзере."""
if request.user.is_anonymous:
return Response(self.unauthorized, HTTP_404_NOT_FOUND)
serializer = UserDetailSerializer(
request.user, context=self.get_serializer_context())
return Response(serializer.data, HTTP_200_OK)
class TeamDetailSerializer(serializers.ModelSerializer):
'''
查询使用
'''
competition = CompetitionSerializer()
team_captain = UserDetailSerializer()
team_member1 = UserDetailSerializer()
team_member2 = UserDetailSerializer()
team_member3 = UserDetailSerializer()
def validate(self, attrs):
return attrs
class Meta:
model = TeamProfile
fields = '__all__'
class UserLeavingMessageDetailSerializer(serializers.ModelSerializer):
add_time = serializers.DateTimeField(read_only=True,
format='%Y-%m-%d %H:%M')
user = UserDetailSerializer()
class Meta:
model = UserLeavingMessage
fields = ('user', 'message', 'subject', 'file', 'add_time', 'id')
def test_user_detail_serializer(self):
"""
Testing UserDetailSerializer serializer
"""
user_data = {
"email": fake.email(),
"first_name": fake.first_name(),
"last_name": fake.last_name(),
"phone": fake.phone_number(),
"role_id": self.role.id,
"password": "******",
"date_of_add": datetime.datetime.now(),
"login": "******",
}
serializer = UDS(data=user_data)
valid = serializer.is_valid()
self.assertTrue(valid)
def get_author(self, obj):
if obj.anonymous:
user = User.objects.filter(id=999).first()
else:
user = obj.user
user_serializer = UserDetailSerializer(
user, context={'request': self.context['request']})
return user_serializer.data
class CommentsSerializer2(serializers.ModelSerializer):
article = ArticleSerializers()
critics = UserDetailSerializer()
create_time = serializers.DateTimeField(read_only=True, format='%Y-%m-%d %H:%M:%S')
class Meta:
model = Comments
fields = "__all__"
def user_thumbnail_details(self, request):
"""
api to return details of user thumbnail
"""
response = {}
ids = request.query_params.get('ids', None)
count = request.query_params.get('count', None)
if not ids and not count:
response['detail'] = "Invalid Query parameters"
return Response(response, status=status.HTTP_400_BAD_REQUEST)
# getting list of user #id
user_ids = ids.split(',') if ids else None
if user_ids:
try:
user_ids = list(map(int, user_ids))
except ValueError:
response['detail'] = "Invalid User ids"
return Response(response, status=status.HTTP_400_BAD_REQUEST)
user_profile_queryset = Profile.objects.filter(
user__id__in=user_ids)
serializer = UserDetailSerializer(user_profile_queryset,
context={'request': request},
many=True)
# if serializer.is_valid():
return Response(serializer.data)
try:
count = int(count)
except ValueError:
response['detail'] = "Invalid value of count"
return Response(response, status=status.HTTP_400_BAD_REQUEST)
queryset = self.queryset.order_by('-id')[:count]
serializer = UserDetailSerializer(queryset,
many=True,
context={'request': request})
return Response(serializer.data)
def get_receiver(self, like):
obj = like.receiver_content_type.get_object_for_this_type(
pk=like.receiver_object_id)
if like.receiver_content_type.app_label == 'user': # user
# 在提供序列化器对象的时候，REST framework会向对象的context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。
serializer = UserDetailSerializer(instance=obj,
context=self.context)
return serializer.data
return {}
class UserCommentDetailSerializer(serializers.ModelSerializer):
add_time = serializers.DateTimeField(read_only=True,
format='%Y-%m-%d %H:%M')
user = UserDetailSerializer()
acticle = BlogActicleSerializers()
class Meta:
model = UserComment
fields = ('user', 'acticle', 'comment_content', 'file', 'add_time',
'id')
def info(request):
User = get_user_model()
if request.method=='GET':
token=request.GET.get('token')
toke_user = []
toke_user = jwt_decode_handler(token)
user_id = toke_user["user_id"]
user_info = User.objects.get(pk= user_id)
serializer = UserDetailSerializer(user_info)
return JsonResponse(serializer.data, status=200)
def parUpdate(self, request):
body = request.data
decoded = jwt_decode_handler(
request.headers['Authorization'].split(' ')[1])
print(request.FILES)
user = UserDetail.objects.get(username=decoded['username'])
if (body.__contains__('username')):
username = body['username']
user.username = username
if (body.__contains__('first_name')):
first_name = body['first_name']
user.first_name = first_name
if (body.__contains__('last_name')):
last_name = body['last_name']
user.last_name = last_name
if (body.__contains__('email')):
email = body['email']
user.email = email
if (body.__contains__('phone')):
phone = body['phone']
user.phone = phone
if (body.__contains__('gender')):
gender = body['gender']
user.gender = gender
# if (body.__contains__('birthdate')):
# birthdate = body['birthdate']
# user.birthdate = birthdate
if (body.__contains__('is_tutor')):
is_tutor = body['is_tutor']
if not bool(is_tutor):
is_tutor = True if is_tutor == 'true' else False
user.is_tutor = is_tutor
if (body.__contains__('language')):
languageId = body['language'] # Trae el id
language = Language.objects.get(id=languageId)
user.language = language
if (body.__contains__('location')):
locationId = body['location']
location = Location.objects.get(id=locationId)
user.location = location
if (body.__contains__('institution')):
institutionId = body['institution']
institution = Institution.objects.get(id=institutionId)
user.institution = institution
if (body.__contains__('career')):
careerId = body['career']
career = Career.objects.get(id=careerId)
user.career = career
if (body.__contains__('password')):
newPw = body['password']
if newPw != '':
user.set_password(newPw)
user.save()
return Response(UserDetailSerializer(user).data)
class JoinScheduleDetailSerializer(serializers.ModelSerializer):
'''
加入约运动详情人员序列化
'''
user = UserDetailSerializer()
add_time = serializers.DateTimeField(read_only=True,
format='%Y-%m-%d %H:%M:%S')
class Meta:
model = JoinSchedule
fields = '__all__'
class CommentChildSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Comment
fields = [
'user',
'id',
'content',
'timestamp',
]
