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"
]