class ThreadSerializer(serializers.ModelSerializer): chat_messages = serializers.SerializerMethodField(read_only=True) last_message = serializers.SerializerMethodField(read_only=True) un_read_count = serializers.SerializerMethodField(read_only=True) sender = UserProfileSerializer(read_only=True) reciever = UserProfileSerializer(read_only=True) class Meta: model = Thread fields = [ 'id', 'updated', 'timestamp', 'sender', 'reciever', 'chat_messages', 'last_message', 'un_read_count' ] def get_chat_messages(self, obj): messages = MessageSerializer(obj.messages.order_by('timestamp'), many=True) return messages.data def get_last_message(self, obj): serializer = MessageSerializer( obj.messages.order_by('timestamp').last(), many=False) return serializer.data def get_un_read_count(self, obj): messages = obj.messages.filter(is_read=False).count() return messages
class TestComReplyListSerializer(serializers.ModelSerializer): from_uid = UserProfileSerializer() to_uid = UserProfileSerializer() class Meta: model = VideoCommentReplyModel fields = ['id', 'comment_id', 'reply_id', 'from_uid', 'to_uid', 'reply_type', 'comment', 'point_love_nums', 'is_love', 'add_time']
class TaskReplyCommentReplyListSerializer(serializers.ModelSerializer): from_uid = UserProfileSerializer() to_uid = UserProfileSerializer() class Meta: model = TaskReplyCommentReplyModel fields = [ 'id', 'from_uid', 'to_uid', 'comment', 'point_nums', 'add_time' ]
def post(self, request, format=None): serializer = UserProfileSerializer(data=request.DATA) if serializer.is_valid(): serializer.save() return Response(None, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request): user_profile = self.get_user_profile(self) serializer = UserProfileSerializer(user_profile, data=request.data, partial=True) if serializer.is_valid(): serializer.save() return Response( {"Status 201": "User Profile updated successfully"}, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserProfileSerializer(data=request.data) if serializer.is_valid(): user = UserProfile.objects.create_user( email=request.data.get("email"), password=request.data.get("password")) serializer_user = UserProfileSerializer(user) return Response(serializer_user.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class MessageSerializer(serializers.ModelSerializer): message_status = serializers.CharField(source='get_message_status_display') sender = UserProfileSerializer() receiver = UserProfileSerializer(many=True) class Meta: model = Message fields = '__all__' def get_etype(self, obj): '''显示choice value''' return obj.get_etype_display()
class ComplaintSerializer(serializers.ModelSerializer): created_by = UserProfileSerializer() users_up_voted = UserProfileSerializer(many=True) tags = TagSerializer(many=True) comments = CommentSerializer(many=True) images = serializers.SlugRelatedField(many=True, read_only=True, slug_field='image_url') class Meta: model = Complaint fields = ( 'id', 'created_by', 'description', 'suggestions', 'location_details', 'report_date', 'status', 'latitude', 'longitude', 'location_description', 'tags', 'comments', 'users_up_voted', 'images' )
def profile(self, request): profile = { "email": request.user.email, "roles": get_user_roles(request.user), "is_superuser": request.user.is_superuser, } profile_serializer = UserProfileSerializer(data=profile) if not profile_serializer.is_valid(): return Response( {"detail": "Invalid user profile"}, status=status.HTTP_403_FORBIDDEN ) return Response(data=profile_serializer.data)
def test_raise_error_when_missing_required_field(self): # pylint: disable=no-self-use """ test raise error when missing required field """ incomplete_data = { 'id': 1, } serializer = UserProfileSerializer(data=incomplete_data) # Este ContextManager nos permite verificar que # se ejecute correctamente una Excepcion with pytest.raises(ValidationError): serializer.is_valid(raise_exception=True)
def create(cls, root, info, **kwargs): """ @description: 创建用户 @param {type} @return: """ data = kwargs.get("input") profile_data = data.pop("profile", None) user_ser = UserSerializer(data=data) ok, user = cls.save(user_ser, root, info) if not ok: return cls.get_errors(user) if not profile_data: return cls.perform_mutate(user, info) profile_data["user"] = user.id if info.context.user and ( info.context.user.is_staff or info.context.user.groups.all().filter(name="教师").first()): profile_data["creator"] = info.context.user.id profile_ser = UserProfileSerializer(data=profile_data) ok, profile = cls.save(profile_ser, root, info) if not ok: user.delete() return cls.get_errors(profile) return cls.perform_mutate(user, info)
class EvaluacionSerializer(serializers.ModelSerializer): preguntas = PreguntaSerializer(many=True) catedratico = UserProfileSerializer() curso = CursoSerializer() class Meta: model = Evaluacion fields = '__all__'
class CommentSerializer(serializers.ModelSerializer): commented_by = UserProfileSerializer() complaint = serializers.PrimaryKeyRelatedField(read_only=True) class Meta: model = ComplaintComment fields = ('id', 'time', 'text', 'commented_by', 'complaint')
class EvaluacionResueltaSerializer(serializers.ModelSerializer): evaluacion = EvaluacionSerializer() estudiante = UserProfileSerializer() evaluacion_resuelta_respuestas_seleccionadas = RespuestaSeleccionadaSerializer(many=True) class Meta: model = EvaluacionResuelta fields = '__all__'
class DriverReviewSerializer(serializers.ModelSerializer): """The serializer for the driver review model""" user = UserProfileSerializer(read_only=True) class Meta: model = DriverReviewModel fields = ('sort', 'user', 'stars', 'text', 'time_stamp') extra_kwargs = { 'sort': { 'read_only': True }, 'time_stamp': { 'read_only': True }, } def validate_stars(self, stars): """validates the number of stars the user entered for that review""" decimal_digits = str(stars - int(stars))[2:] if len(decimal_digits) > 1 or int(decimal_digits) % 5 != 0: raise serializers.ValidationError("invalid number of stars") return stars
class portalUserSerializer(serializers.ModelSerializer): user = UserProfileSerializer(read_only=True) class Meta: model = portalUser fields = ('user','resume','description','joined_team')
def get_profile(self, obj): try: user_profile = UserProfile.objects.get(user=obj.user) except ObjectDoesNotExist: user_profile = UserProfile.objects.create(user=obj.user) user_profile.save() return UserProfileSerializer(user_profile).data
class AchievementUserSerializer(serializers.ModelSerializer): """Serializer for Achievement model.""" body_detail = BodySerializerMin(read_only=True, source="body") event_detail = EventMinSerializer(read_only=True, source="event") user = UserProfileSerializer(read_only=True) class Meta: model = Achievement fields = ('id', 'title', 'description', 'admin_note', 'body_detail', 'dismissed', 'verified', 'user', 'body', 'verified_by', 'event', 'event_detail', 'offer') @staticmethod def setup_eager_loading(queryset): """Perform necessary eager loading of data.""" queryset = queryset.prefetch_related('body', 'user') return queryset def create(self, validated_data): validated_data['user'] = self.context['request'].user.profile validated_data['dismissed'] = False validated_data['verified'] = False return super().create(validated_data) def update(self, instance, validated_data): validated_data['verified_by'] = self.context['request'].user.profile return super().update(instance, validated_data)
def search(request): """EXPENSIVE: Search with query param `query` throughout the database.""" MIN_LENGTH = 3 req_query = request.GET.get("query") if not req_query or len(req_query) < MIN_LENGTH: return Response({"message": "No query or too short!"}, status=400) # Search bodies by name and description bodies = query_search(request, MIN_LENGTH, Body.objects, ['name', 'description']) # Search events by name and description events = get_prioritized( query_search(request, MIN_LENGTH, Event.objects, ['name', 'description'])[:20], request) # Search users by only name: don't add anything else here users = query_search(request, MIN_LENGTH, UserProfile.objects, ['name', 'ldap_id', 'roll_no'])[:20] return Response({ "bodies": BodySerializerMin(bodies, many=True).data, "events": EventSerializer(events, many=True).data, "users": UserProfileSerializer(users, many=True).data })
class RoleSerializerMin(serializers.ModelSerializer): users_detail = UserProfileSerializer(many=True, read_only=True, source='users') class Meta: model = BodyRole fields = ('id', 'name', 'body', 'users_detail', 'priority')
def followers(request): if request.method == 'GET': username = request.GET.get('username') followers_array = [] try: user = Users.objects.get(username=username) query = "SELECT users.id, name, username FROM `follow` LEFT JOIN users ON follow.user_id = users.id WHERE following_id =" + str( user.id) + " and status = 'active'" followers = Users.objects.raw(query) print query serializer = UserProfileSerializer(followers, many=True) return JsonResponse({ 'success': False, 'followers': serializer.data }) except Users.DoesNotExist: return JsonResponse({ 'success': False, 'message': 'user not found' }) return JsonResponse({'success': False, 'followers': []})
class TestVideoComListSerializer(serializers.ModelSerializer): user = UserProfileSerializer() child_com = TestComReplyListSerializer(many=True) class Meta: model = VideoComment fields = ['id', 'user', 'video', 'comment', 'point_love_nums', 'is_love', 'add_time', 'child_com']
class ParticipantSerializer(serializers.ModelSerializer): user = UserProfileSerializer(read_only=True) role = ChoiceField(choices=Participant.ROLE_CHOICES) class Meta: model = Participant fields = ['user', 'role']
def retrieve(self, request, pk): """Get a achievement offer.""" # Get current object offer = get_object_or_404(self.queryset, id=pk) data = OfferedAchievementSerializer(offer).data # Extra fields in user serializer extra_fields = [] # Query for getting users query = offer.achievements.filter( verified=True).prefetch_related('user') # Check for verification privilege if user_has_privilege(request.user.profile, offer.body.id, "VerA"): data['secret'] = offer.secret # Add extra fields for privileged users extra_fields = [ 'roll_no', 'email', 'contact_no', 'department_name', 'degree' ] else: # Filter out hidden achievements query = query.filter(hidden=False) # Get users haveing this achievement users = [a.user for a in query] data['users'] = UserProfileSerializer(users, many=True, context={ 'extra': extra_fields }).data return Response(data)
class RoleSerializer(serializers.ModelSerializer): """Role Serializer""" permissions = serializers.MultipleChoiceField(choices=PERMISSION_CHOICES) body_detail = BodySerializerMin(read_only=True, source='body') users_detail = UserProfileSerializer(many=True, read_only=True, source='users') bodies = serializers.SerializerMethodField() class Meta: model = BodyRole fields = ('id', 'name', 'inheritable', 'body', 'body_detail', 'bodies', 'permissions', 'users', 'users_detail', 'priority', 'official_post') @classmethod def get_bodies(cls, obj): """Gets bodies including children if inheritable.""" if not obj.inheritable: return BodySerializerMin([obj.body], many=True).data return BodySerializerMin(cls.get_children_recursive(obj.body, []), many=True).data @classmethod def get_children_recursive(cls, body, children): """Returns an array including a body and its children.""" for child_body_relation in body.children.all(): cls.get_children_recursive(child_body_relation.child, children) if body not in children: children.append(body) return children
class RelaySerializer(serializers.ModelSerializer): profile = UserProfileSerializer(read_only=True) class Meta: model = Relay fields = ['id', 'owner_id', 'profile', 'parent_id', 'time_created'] read_only_fields = ['owner_id']
class BearerTokenSerializer(serializers.Serializer): username = serializers.CharField(allow_null=True, required=False, write_only=True) password = serializers.CharField(write_only=True, allow_null=True, required=False, allow_blank=True) public_key = serializers.CharField(write_only=True, allow_null=True, allow_blank=True, required=False) token = serializers.CharField(read_only=True) keyword = serializers.SerializerMethodField() date_expired = serializers.DateTimeField(read_only=True) user = UserProfileSerializer(read_only=True) @staticmethod def get_keyword(obj): return 'Bearer' def create(self, validated_data): request = self.context.get('request') if request.user and not request.user.is_anonymous: user = request.user else: user_id = request.session.get('user_id') user = get_object_or_none(User, pk=user_id) if not user: raise serializers.ValidationError( "user id {} not exist".format(user_id)) token, date_expired = user.create_bearer_token(request) instance = {"token": token, "date_expired": date_expired, "user": user} return instance
class ResponseMessageListSerializer(serializers.ModelSerializer): sender_id = UserProfileSerializer() conversation_id = ConversationSerializer() class Meta: model = Messages fields = '__all__'
class TaskListSerializer(serializers.ModelSerializer): user = UserProfileSerializer() class Meta: model = TaskModel fields = [ 'user', 'title', 'content', 'mession_kind', 'point_nums', 'attention_nums', 'add_times' ]
class TaskReplyListSearializer(serializers.ModelSerializer): user = UserProfileSerializer() class Meta: model = TaskReplyModel fields = [ 'id', 'user', 'task', 'content', 'point_nums', 'comment_nums', 'add_times' ]
class LeaveMessageListSerializer(serializers.ModelSerializer): send_user = UserProfileSerializer() leaveM_Reply = LeaveMessageReplyListSerializer(many=True) class Meta: model = LeaveMessageModel fields = [ 'send_user', 'receive_user', "content", "leaveM_Reply", "add_time" ]