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)