def patch(self, request):
profile = self.get_object(pk=request.user.id)
serializer = CustomUserSerializer(profile, request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status.HTTP_200_OK)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
class AllPersonalBookingSerializer(ModelSerializer):
gym_member = CustomUserSerializer()
gym_trainer = CustomUserSerializer()
class Meta:
model = PersonalTraining
fields = "__all__"
def post(self, request, format='json'):
serializer = CustomUserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
json = serializer.data
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class EgovernmentRequestExtendedSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(many=False)
approver = CustomUserSerializer(many=False)
class Meta:
model = EgovernmentRequest
fields = '__all__'
def user_register(request):
with transaction.atomic():
serializer = CustomUserSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
Account.generate(user)
return Response(status=status.HTTP_201_CREATED)
class NotificationSerializer(serializers.ModelSerializer):
notification_for = CustomUserSerializer(source="user",
read_only=True,
many=False)
created_by = CustomUserSerializer(source="auther",
read_only=True,
many=False)
post_data = PostSerializer(source="post", read_only=True, many=False)
class Meta:
model = Notification
fields = '__all__'
def post(self, request):
serializer = CustomUserSerializer(data=request.data)
current_user = request.user
if not request.data:
return Response({"error": "Missing message body in request"},
status=status.HTTP_400_BAD_REQUEST)
if serializer.is_valid():
serializer.update(current_user)
return Response({'success': 'User profile updated successfully!'},
status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_creates_a_user(self):
data = {"email": "*****@*****.**", "password": "******"}
user_count = len(get_user_model().objects.exclude(email=settings.ANONYMOUS_USER_NAME))
self.assertEqual(user_count, 0)
serializer = CustomUserSerializer(data=data)
self.assertTrue(serializer.is_valid())
serializer.save()
user_count = len(get_user_model().objects.exclude(email=settings.ANONYMOUS_USER_NAME))
self.assertEqual(user_count, 1)
user = get_user_model().objects.exclude(email=settings.ANONYMOUS_USER_NAME).first()
self.assertEqual("*****@*****.**", user.email)
def deactivate(self, request, *args, **kwargs):
user = self.get_object()
user.is_active = False
user.save()
serializer = CustomUserSerializer(user, many=False)
return Response(serializer.data)
class InviteUserSerializer(serializers.ModelSerializer):
user_invited = CustomUserSerializer(source="user", read_only=True)
group_data = GroupSerializer(source="group", read_only=True)
class Meta:
model = InviteUser
fields = '__all__'
class JoiningRequestSerializer(serializers.ModelSerializer):
request_by = CustomUserSerializer(source="user", read_only=True)
group_data = GroupSerializer(source="group", read_only=True)
class Meta:
model = JoiningRequest
fields = '__all__'
class TopicSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(read_only=True)
posts = PostSerializer(many=True, read_only=True)
class Meta:
model = Topic
fields ='__all__'
class FeedSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(many=False)
meta_data = serializers.SerializerMethodField()
class Meta:
model = Post
fields = '__all__'
def get_meta_data(self, obj):
rated_by_logged_in = PostRank.objects.filter(
ranker=self.context.get('request').user, post=obj.id).first()
if rated_by_logged_in is not None:
post_rank_serializer = PostRankSerializer(rated_by_logged_in,
many=False)
rating_by_login = post_rank_serializer.data.get('rank')
else:
rating_by_login = 0
ratings = PostRank.objects.filter(post=obj.id)
votes = ratings.count()
average_rank = None
if ratings.exists():
average_rank = ratings.last().average_rank
ratings = {
"rating_by_login": rating_by_login,
"votes": votes,
"average_rating": average_rank
}
comments_count = PostComment.objects.filter(post=obj.id).count()
views_count = PostView.objects.filter(post=obj.id).count()
counts = {"comments_count": comments_count, "views_count": views_count}
return {"ratings": ratings, "counts": counts}
class TrainerDetailSerializer(ModelSerializer):
user = CustomUserSerializer(read_only=True)
specialities = TrainerSpecialtySerializer(many=True, read_only=True)
class Meta:
model = TrainerProfile
fields = '__all__'
class FollowerListSerializer(serializers.ModelSerializer):
following = CustomUserSerializer(many=False)
meta_data = serializers.SerializerMethodField()
class Meta:
model = UserRelationship
fields = "__all__"
def get_meta_data(self, obj):
is_following = False
follower = UserRelationship.objects.filter(
follower=obj.following.id,
following=self.context.get("request").user.id)
if follower.exists():
is_following = True
user_types = UserType.objects.filter(user=obj.follower.id)
user_types_serializer = UserTypeSerializer(user_types, many=True)
user_types = []
try:
user_profile = UserDetail.objects.get(user=obj.following.id)
user_profile_serializer = UserDetailSerializer(user_profile,
many=False)
user_profile_data = user_profile_serializer.data
except UserDetail.DoesNotExist:
user_profile_data = None
for type in user_types_serializer.data:
user_types.append(type['user_type'])
return {
"is_following": is_following,
"user_types": user_types,
"user_profile": user_profile_data
}
class CommentSerializer(serializers.HyperlinkedModelSerializer):
author = CustomUserSerializer(read_only=True)
author_pk = serializers.PrimaryKeyRelatedField(
queryset=CustomUser.objects.all(), source="author", write_only=True)
class Meta:
model = Comment
fields = [
"url",
"id",
"author",
"author_pk",
"content",
"date_pub_timestamp",
"to_post",
"likes_count",
]
def is_liked_by_user(self, comment):
user = self.context["request"].user
print(user)
return comment.is_liked_by_user(user)
def get_fields(self):
fields = super(CommentSerializer, self).get_fields()
fields["is_liked_by_user"] = serializers.SerializerMethodField(
"is_liked_by_user")
return fields
def approve_egov(self, request, *args, **kwargs):
user = self.get_object()
user.user_type = 'EG'
user.save()
serializer = CustomUserSerializer(user)
return Response(serializer.data)
class BookLoanCreateRequestSerializer(serializers.ModelSerializer):
"""
BookLoanCreateRequestSerializer serializes book loan request,
restricts user to pass status field in the request. Default
status of a loan is 'PENDING'
"""
borrower = CustomUserSerializer(read_only=True,
default=serializers.CurrentUserDefault())
class Meta:
model = BookLoan
fields = '__all__'
extra_kwargs = {
'created_at': {
'read_only': True
},
'due_date': {
'read_only': True
},
'returned_date': {
'read_only': True
},
'borrower': {
'read_only': True
},
'status': {
'read_only': True
},
}
def studentSingle(request,pk):
try:
student = CustomUser.objects.get(id=pk)
serializer = CustomUserSerializer(student, many=False)
return Response(serializer.data)
except:
raise Exception("An error occured")
def studentList(request):
try:
students = CustomUser.objects.filter(is_student=True)
serializer = CustomUserSerializer(students, many=True)
return Response(serializer.data)
except:
raise Exception("An error occured")
class PostSerializer(serializers.ModelSerializer):
created_by = CustomUserSerializer(source="user", read_only=True)
meta_data = serializers.SerializerMethodField()
class Meta:
model = Post
fields = "__all__"
def get_meta_data(self, obj):
rated_by_logged_in = PostRank.objects.filter(
ranker=self.context.get('request').user, post=obj.id).first()
if rated_by_logged_in is not None:
post_rank_serializer = PostRankSerializer(rated_by_logged_in,
many=False)
rating_by_login = post_rank_serializer.data.get('rank')
else:
rating_by_login = 0
post_rating = PostRank.objects.filter(post=obj.id)
avg_rating = 0
if post_rating.exists():
avg_rating = post_rating.last().average_rank
post_views = PostView.objects.filter(post=obj.id).count()
votes = post_rating.count()
ratings = {
"rating_by_login": rating_by_login,
"votes": votes,
"average_rating": avg_rating
}
return {
"avg_rating": avg_rating,
"post_views": post_views,
"ratings": ratings
}
class SearchProfileSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(required=True)
gender = serializers.CharField(source='get_gender_display')
class Meta:
model = Profile
fields = ['id', 'user', 'about', 'location', 'birth_date', 'gender']
class ListVoteSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(read_only=True)
election = ElectionSerializerWithoutCandidates(read_only=True)
candidate = CandidateSerializer(read_only=True)
class Meta:
model = Vote
fields = ('id', 'user', 'election', 'candidate')
class ScoreSerializer(serializers.ModelSerializer):
ratings = serializers.FloatField(required=False, allow_null=True)
sitter = CustomUserSerializer(read_only=True)
class Meta:
model = Score
fields = ['sitter', 'ratings', 'overall']
class DocumentRequestExtendedSerializer(serializers.ModelSerializer):
user = CustomUserSerializer(many=False)
document_request_item = DocumentRequestItemSerializer(many=True)
class Meta:
model = DocumentRequest
fields = '__all__'
class GroupMemberSerializer(serializers.ModelSerializer):
member_user = CustomUserSerializer(source="member", read_only=True)
# group_data = GroupSerializer(source="group", read_only=True)
class Meta:
model = GroupMembers
fields = '__all__'
class ChatMediaSerializer(serializers.ModelSerializer):
created_by = CustomUserSerializer(source="user",
many=False,
read_only=True)
class Meta:
model = ChatMedia
fields = '__all__'
def user_detail(request, pk):
try:
user = CustomUser.objects.get(pk=pk)
# find a single user with an id
if request.method == 'GET':
user_serializer = CustomUserSerializer(user)
return JsonResponse(user_serializer.data)
# update a user by the id in the request
elif request.method == 'PUT':
user_data = JSONParser().parse(request)
user_serializer = CustomUserSerializer(user, data=user_data)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse(user_serializer.data)
return JsonResponse(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
# delete a user with the specified id
elif request.method == 'DELETE':
user.delete()
return JsonResponse({'message': 'User was deleted successfully!'}, status=status.HTTP_204_NO_CONTENT)
except CustomUser.DoesNotExist:
return JsonResponse({'message': 'The user does not exist'}, status=status.HTTP_404_NOT_FOUND)
def lol(self, request, *args, **kwargs):
users = CustomUser.objects.all()
serializer = CustomUserSerializer(users, many=True)
for user in users:
print(user.email, ': ', user.id)
return Response(serializer.data)
def add_egov_quota(self, request, *args, **kwargs):
user = self.get_object()
if user.user_type == 'EG':
user.egov_quota = 5
user.save()
serializer = CustomUserSerializer(user)
return Response(serializer.data)
