def test_usermodelserializer_deserialization(self): """Checks new User instance creation using UserModelSerializer""" serializer = UserModelSerializer(data=self.data) self.assertTrue( serializer.is_valid(), msg="""User deserialization should be valid since all mandatory fields are present.""")
def test_usermodelserializer_deserialization_existing_email(self): """Checks new User instance creation using UserModelSerializer Test if UserModelSerializer deserialization is invalid due to e-mail already in database.""" data = self.data data['email'] = self.email serializer = UserModelSerializer(data=data) self.assertFalse( serializer.is_valid(), msg="""User deserialization should not be valid since the e-mail already exists in the database.""") self.assertIn('non_field_errors', serializer.errors) self.assertEqual(str(serializer.errors.get('non_field_errors')[0]), EMAIL_ALREADY_REGISTERED_ERROR)
def login(self, request): """User sign in.""" print(request.data) # First clear everything before login logout(request) serializer = UserLoginSerializer(data=request.data) if not serializer.is_valid(raise_exception=False): data = { "info": "password or username are not valid", "failure": "validation failed", } return Response(data, status=status.HTTP_403_FORBIDDEN) user, token = serializer.save() data = { "info": "success validation", "success": "user validated", "user": UserModelSerializer(user).data, "access_token": token, } response = Response(data, status=status.HTTP_201_CREATED) # Use default django authentication login(request, user) return response
def signup(self, request): """ Creates an user in the database with is_verified value = False """ serializer = UserSignUpSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() data = UserModelSerializer(user).data return Response(data, status=status.HTTP_201_CREATED)
def deactive(self, request, pk=None): user = User.objects.get(pk=pk) serializer = UserDeactiveSerializer(user, request.data) serializer.is_valid(raise_exception=True) user = serializer.save() data = UserModelSerializer(user).data return Response(data, status=status.HTTP_200_OK)
def login(self, request): """Inicio de sesion de Usuarios.""" serializer = UserLoginSerializer(data=request.data) serializer.is_valid(raise_exception=True) user, token = serializer.save() data = {'user': UserModelSerializer(user).data, 'access_token': token} return Response(data, status=status.HTTP_200_OK)
class HitModelSerializer(serializers.ModelSerializer): hitman = UserModelSerializer(read_only=True) manager = UserModelSerializer(read_only=True) class Meta: model = Hit fields = ( 'pk', 'target', 'description', 'status', 'created_at', 'last_modified', 'hitman', 'manager', )
def fetch_image(self, request, pk=None): user = User.objects.get(id=self.kwargs['pk']) if user.image == 'null': return Response("User doesn\'t have an image.", status=status.HTTP_204_NO_CONTENT) serializer = UserModelSerializer(user) return Response(serializer.data['image'], status=status.HTTP_200_OK)
def login(self, request): """User sign in.""" serializer = UserLoginSerializer(data=request.data) serializer.is_valid(raise_exception=True) user, token = serializer.save() data = {'user': UserModelSerializer(user).data, 'access_token': token} return Response(data, status=status.HTTP_201_CREATED)
def test_usermodelserializer_deserialization_missing_field(self): """Checks new User instance creation using UserModelSerializer Test if UserModelSerializer deserialization is invalid due to missing mandatory field.""" data = self.data data.pop('phones') serializer = UserModelSerializer(data=data) self.assertFalse( serializer.is_valid(), msg="""User deserialization should not be valid since the phones field is missing.""") self.assertIn('non_field_errors', serializer.errors) self.assertEqual(str(serializer.errors.get('non_field_errors')[0]), MISSING_FIELD_ERROR)
def signup(self, request): """User sign up.""" serializer = UserSignUpSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() data = UserModelSerializer(user).data return Response(data, status=status.HTTP_201_CREATED)
def user_info(request): opponent_param = request.query_params.get("user") current_user_param = request.query_params.get("current_user") current_user = User.objects.get(username=current_user_param) try: other_user = User.objects.get(username=opponent_param) except User.DoesNotExist: other_user = None if other_user != None: usr = UserModelSerializer(other_user).data opponent = User.objects.get(username=opponent_param) friend_result = True try: friend = BetFriend.objects.get( Q(Q(user_a=opponent) & Q(user_b=current_user)) | Q(Q(user_a=current_user) & Q(user_b=opponent))) except BetFriend.DoesNotExist: friend = None friend_result = True if friend else False requested_result = True try: requested = FriendRequest.objects.get( Q( Q(sent_by=opponent) & Q(received_by=current_user) & Q(is_accepted=False)) | Q( Q(received_by=opponent) & Q(sent_by=current_user) & Q(is_accepted=False))) except FriendRequest.DoesNotExist: requested = None requested_result = True if requested else False else: usr = "******" friend_result = None requested_result = None # if result!= True: # try: # requested = FriendRequest.objects.get(Q(Q(sent_by = opponent) & Q(received_by = current_user)) | Q(Q(sent_by = current_user) & Q(received_by = opponent))) # except FriendRequest.DoesNotExist: # requested = None # result = "Wating" if requested else False data = { "user": usr, "requested": requested_result, "friendship": friend_result } return Response(data)
def retrieve(self, request, *args, **kwargs): instance = self.get_object() serializer = TeamModelSerializer(instance) users = User.objects.all().filter(team=serializer.data['id']) serializer_user = UserModelSerializer(users, many=True) data = serializer.data data['users'] = serializer_user.data return Response(data, status=status.HTTP_200_OK)
def retrieve(self, request, *args, **kwargs): user = self.get_object() albums = Album.objects.filter(sold_by=user) data = { 'user': UserModelSerializer(user).data, 'albums': AlbumModelSerializer(albums, many=True).data } return Response(data)
def signup(self, request): """Registro de Usuarios.""" serializer = UserSignupSerializer(data=request.data) serializer.is_valid(raise_exception=True) # Validamos los datos user = serializer.save() # Creacion un usuario y lo retornamos data = UserModelSerializer(user).data # Serializamos los datos # Enviamos los datos serializados como respuesta. return Response(data, status=status.HTTP_201_CREATED)
def register(self, request): user = request.user serializer = UserSignUpSerializer(data=request.data, context={"request": self.request}) serializer.is_valid(raise_exception=True) user = serializer.save() data = UserModelSerializer(user).data return Response(data, status=status.HTTP_201_CREATED)
def list(self, request, *args, **kwargs): instance = self.get_object() team = instance.team serializer_team = TeamModelSerializer(team) users = User.objects.all().filter(team=team) serializer_user = UserModelSerializer(users, many=True) data = serializer_team.data data['users'] = serializer_user.data return Response(data, status=status.HTTP_200_OK)
def profile(self, request, *args, **kwargs): user = self.get_object() user_detail = user.detail partial = request.method == 'PATCH' serializer = UserDetailsModelSerializer(user_detail, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) serializer.save() data = UserModelSerializer(user).data return Response(data)
def update(self, request, *args, **kwargs): user = self.get_object() profile = user.profile partial = request.method == 'PATCH' serializer = ProfileModelSerializer(profile, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) serializer.save() data = UserModelSerializer(user).data return Response(data)
def post(self, request, *args, **kwargs): serializer = UserSignupSerializers(data=request.data) if serializer.is_valid(): user = serializer.save() print(user) data ={ 'user': UserModelSerializer(user).data, } return Response(data, status=status.HTTP_201_CREATED) data = 'bad request' return Response(data, status=status.HTTP_400_BAD_REQUEST)
class MembershipModelSerializer(serializers.ModelSerializer): """ Member model serializer """ user = UserModelSerializer(read_only=True) invited_by = serializers.StringRelatedField() class Meta: model = MemberShip fields = ('user', 'is_admin', 'is_active', 'used_invitations', 'remaining_invitations', 'invited_by', 'rides_taken', 'rides_offered') read_only_fields = ('user', 'used_invitations', 'invited_by', 'ride')
def signup(self, request): """User sign up.""" serializer = UserSignUpSerializer(data=request.data) serializer.is_valid(raise_exception=True) user, profile = serializer.save() newFavouriteList = MusicList(title='My', type_list='favourites') newFavouriteList.save() profile.musiclists.set([ newFavouriteList, ]) data = UserModelSerializer(user).data return Response(data, status=status.HTTP_201_CREATED)
class RideModelSerializer(serializers.ModelSerializer): """ Ride model serializer """ offered_by= UserModelSerializer(read_only=True) offered_in=serializers.StringRelatedField() passangers= UserModelSerializer(read_only=True,many=True) class Meta: model=Rides fields= '__all__' #Dar todos los campos read_only_fields=( 'offered_by', 'offered_in' ) def update(self,instance,data): """ Allow updates only before departure date """ now=timezone.now() if instance.departure_date<=now: raise serializers.ValidationError('Ongoing rides cannot be modifed') return super(RideModelSerializer,self).update(instance,data)
def hitmen(self, request): user = self.request.user if user.is_bigboss(): users = User.objects.exclude(pk=user.pk) elif user.is_manager(): users = User.objects.filter(manager=user) else: return Response(None, status=status.HTTP_403_FORBIDDEN) users = UserModelSerializer(users, many=True).data return Response(users, status=status.HTTP_200_OK)
def customer(self, request, *args, **kwargs): """Update/partial update customer's data.""" user = self.get_object() customer = user.customer # True if it's PATCH, False otherwise partial = request.method == 'PATCH' serializer = CustomerModelSerializer(customer, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) serializer.save() data = UserModelSerializer(user).data return Response(data)
def signup(self, request): notification_token = request.query_params.get("notification_token") # current_user_param = request.data["username"] # current_user = User.objects.get(username = current_user_param) # profile = current_user.profile # profile.notification_token = notification_token # profile.save() # all_data = [request.data, notification_token] serealizer = UserSignUpSerializer(data=request.data) serealizer.is_valid(raise_exception=True) user, jwt = serealizer.save() data = {"user": UserModelSerializer(user).data, "jwt": jwt} return Response(data, status=status.HTTP_201_CREATED)
def login(self, request): notification_token = request.query_params.get("notification_token") current_user_param = request.data["username"] current_user = User.objects.get(username=current_user_param) profile = current_user.profile profile.notification_token = notification_token profile.save() serealizer = UserLoginSerializer(data=request.data) serealizer.is_valid(raise_exception=True) user, token = serealizer.save() data = {"user": UserModelSerializer(user).data, "jwt": token} return Response(data, status=status.HTTP_201_CREATED)
class MembershipModelSerializer(serializers.ModelSerializer): joined_at = serializers.DateTimeField(source='created', read_only=True) user = UserModelSerializer(read_only=True) invited_by = serializers.StringRelatedField() class Meta: model = Membership fields = [ 'user', 'is_admin', 'is_active', 'used_invitations', 'remaining_invitations', 'invited_by', 'rides_taken', 'rides_offered', 'joined_at' ] read_only_fields = [ 'user', 'used_invitations', 'rides_taken', 'rides_offered' ]
def auth(self, request): serialized_user = UserModelSerializer(request.user) print(dict(serialized_user.data)) if not serialized_user or serialized_user.data['username'] == '': response = {'error': 'not auth'} stat = status.HTTP_403_FORBIDDEN else: response = { "data": serialized_user.data, } stat = status.HTTP_200_OK return Response(response, status=stat)
def hitman(self, request, pk=None): user = self.request.user try: if user.is_bigboss(): hitman = User.objects.get(pk=pk) elif user.is_manager(): hitman = User.objects.get(pk=pk, manager=user) elif user.is_hitman() and user.pk == pk: hitman = User.objects.get(pk=pk) else: return Response(None, status=status.HTTP_403_FORBIDDEN) except User.DoesNotExist: return Response(None, status=status.HTTP_404_NOT_FOUND) hitman = UserModelSerializer(user).data return Response(hitman, status=status.HTTP_200_OK)