def to_representation(self, instance):
response = super().to_representation(instance)
response["requesting_users"] = users_serializers.UserSerializer(
instance.requesting_users, many=True).data
return response
def retrieve(self, request, pk=None):
"""
If provided 'pk' is "me" then return the current user.
"""
if request.user and pk == 'me':
return Response(serializers.UserSerializer(request.user).data)
return super(UsersViewSet, self).retrieve(request, pk)
class ProfileCompnayViewSerializer(serializers.ModelSerializer):
user = users_serializer.UserSerializer(many=False, read_only=True)
category = CategorySerializer(many=False, read_only=True)
class Meta:
model = Profile_company
fields = ('pk', 'user', 'category', "company_name", "telephone",
"picture", "location", "rfc", "addres", "is_active")
def create_user(request, format=None):
serializer = serializers.UserCreateSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
user = serializers.UserSerializer(request.data)
return Response({'user': user.data})
else:
return Response({'errors': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
try:
queryset = CustomUser.objects.get(id=request.user.id)
except CustomUser.DoesNotExist:
return Response({'error': 'User does not exist'},
status=status.HTTP_404_NOT_FOUND)
serializer = serializers.UserSerializer(queryset, many=False)
return Response(data=serializer.data, status=status.HTTP_200_OK)
def put(self, request, format=None):
serializer = serializers.UserCreateSerializer(request.user,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
user = serializers.UserSerializer(request.user)
return Response({'user': user.data})
else:
return Response({'errors': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def list(self, request):
username = request.GET.get('username', None)
if (username != None):
user = userModels.User.objects.filter(username=username)
if (len(user) != 1):
return HttpResponse(json.dumps(None), status=409)
else:
user = user[0]
serializer = userSerializer.UserSerializer(user)
return JsonResponse(serializer.data,
status=status.HTTP_201_CREATED)
def get_current_user(self, request, *args, **kwargs):
serializer = serial.UserSerializer(request.user)
response_data = serializer.data
# Add access request status
if u.AccessRequest.objects.filter(user_id=request.user.id):
access_request = u.AccessRequest.objects.filter(
user_id=request.user.id)[0]
if access_request.approved:
response_data['accessRequestStatus'] = 'approved'
else:
response_data['accessRequestStatus'] = 'pending'
else:
response_data['accessRequestStatus'] = None
return Response(response_data)
def post(self, request):
serializer = serializers.UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.validated_data
user_obj = User.objects.create(
username=user['username'],
email=user['email'],
first_name=user['first_name'],
last_name=user['last_name'],
)
user_obj.set_password(user['password'])
user_obj.save()
content = {'content': user, 'message': 'SUCCESS', 'status': 'SUCCESSFUL'}
return Response(data=content, status=status.HTTP_201_CREATED)
content = {'content': '', 'message': serializer.errors, 'status': 'FAILURE'}
return Response(content, status=status.HTTP_400_BAD_REQUEST)
def follow(self, request):
user = request.user
follow_pk = request.GET.get("follow_pk", None)
target_user = User.objects.get(pk=follow_pk)
if user.id is not None:
try:
FollowRelation.objects.get(follower=target_user)
except FollowRelation.DoesNotExist:
FollowRelation.objects.create(follower=target_user)
target = FollowRelation.objects.get(follower=target_user).followee
if user == target_user:
return Response(status=status.HTTP_400_BAD_REQUEST)
if user in target.all():
target.remove(user)
else:
target.add(user)
FollowRelation.objects.get(follower=target_user).save()
serializer = user_serializer.UserSerializer(target_user).data
return Response(data=serializer, status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
user = serializers.UserSerializer(request.user)
return Response({'user': user.data})
def to_representation(self, instance):
"""
:param instance: EventUser instance
:return: UserSerializer data
"""
return user_serializers.UserSerializer(instance=instance.user_id).data
def list(self, request, *args, **kwargs):
all_users = User.objects.all()
serializer = serializers.UserSerializer(instance=all_users, many=True)
return Response(serializer.data)
def get(self, request, format=None):
users = User.objects.all()
serializer = serializers.UserSerializer(users, many=True)
return Response(serializer.data)
