akvo / partos-pat / #50

Committed 10 Sep 2024 10:17AM UTC coverage: 86.335% (+1.8%) from 84.562%

Build # #50

Build Type

push

coveralls-python

Committed by

web-flow

Commit Message

Merge pull request #14 from akvo/feature/13-login-page-and-backend

Feature/13 login page and backend

Run Details

40 of 62 branches covered (64.52%)

Branch coverage included in aggregate %.

377 of 421 relevant lines covered (89.55%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.53

backend/api/v1/v1_users/views.py

from datetime import datetime
from drf_spectacular.utils import (
    extend_schema,
    OpenApiParameter,
)
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.response import Response
from drf_spectacular.types import OpenApiTypes
from django.utils import timezone
from django.http import HttpResponseRedirect
from django.conf import settings
from django.contrib.auth import authenticate
from rest_framework.permissions import IsAuthenticated
from rest_framework_simplejwt.tokens import RefreshToken

from api.v1.v1_users.serializers import (
    RegisterSerializer,
    UserSerializer,
    VerifyTokenSerializer,
    LoginSerializer,
)
from api.v1.v1_users.models import SystemUser
from utils.custom_serializer_fields import validate_serializers_message
from utils.default_serializers import DefaultResponseSerializer
from utils.email_helper import send_email, EmailTypes


@extend_schema(
    request=RegisterSerializer,
    responses={201: UserSerializer, 401: DefaultResponseSerializer},
    tags=["Auth"],
)
@api_view(["POST"])
def register(request, version):
    serializer = RegisterSerializer(data=request.data)
    if not serializer.is_valid():
        return Response(
            {"message": validate_serializers_message(serializer.errors)},
            status=status.HTTP_400_BAD_REQUEST,
        )
    user = serializer.save()

    if not settings.TEST_ENV:
        send_email(
            type=EmailTypes.user_register,
            context={
                "send_to": [user.email],
                "name": user.full_name,
                "verification_code": user.verification_code,
            },
        )

    user = UserSerializer(instance=user).data
    response = Response(
        data=user,
        status=status.HTTP_201_CREATED,
    )
    return response


@extend_schema(
    responses={200: DefaultResponseSerializer},
    tags=["Auth"],
    parameters=[
        OpenApiParameter(
            name="token",
            required=True,
            type=OpenApiTypes.STR,
            location=OpenApiParameter.QUERY,
        ),
    ],
)
@api_view(["GET"])
def verify_token(request, version):
    serializer = VerifyTokenSerializer(data=request.GET)
    if not serializer.is_valid():
        return Response(
            {"message": validate_serializers_message(serializer.errors)},
            status=status.HTTP_400_BAD_REQUEST,
        )
    token = serializer.validated_data.get("token")
    user = SystemUser.objects.get(verification_code=token)
    if user.is_verified:
        return HttpResponseRedirect(f"{settings.WEBDOMAIN}/en/login")
    user.is_verified = True
    user.updated = timezone.now()
    user.save()
    return HttpResponseRedirect(f"{settings.WEBDOMAIN}/en/login?verified=true")


@extend_schema(
    request=LoginSerializer,
    responses={200: UserSerializer, 401: DefaultResponseSerializer},
    tags=["Auth"],
)
@api_view(["POST"])
def login(request, version):
    serializer = LoginSerializer(data=request.data)
    if not serializer.is_valid():
        return Response(
            {
                "message": validate_serializers_message(serializer.errors)
            },
            status=status.HTTP_400_BAD_REQUEST,
        )

    user = authenticate(
        email=serializer.validated_data["email"],
        password=serializer.validated_data["password"],
    )

    if user:
        user.last_login = timezone.now()
        user.save()
        refresh = RefreshToken.for_user(user)
        # Get the expiration time of the new token
        expiration_time = datetime.fromtimestamp(
            refresh.access_token["exp"]
        )
        expiration_time = timezone.make_aware(expiration_time)

        data = {}
        data["user"] = UserSerializer(instance=user).data
        data["token"] = str(refresh.access_token)
        data["expiration_time"] = expiration_time
        response = Response(
            data,
            status=status.HTTP_200_OK,
        )
        response.set_cookie(
            "AUTH_TOKEN", str(refresh.access_token), expires=expiration_time
        )
        return response
    return Response(
        {"message": "Invalid login credentials"},
        status=status.HTTP_401_UNAUTHORIZED,
    )


@extend_schema(
    responses={200: UserSerializer},
    tags=["Auth"],
    summary="Get user details from token",
)
@api_view(["GET"])
@permission_classes([IsAuthenticated])
def get_profile(request, version):
    return Response(
        UserSerializer(instance=request.user).data,
        status=status.HTTP_200_OK
    )

1	from datetime import datetime	1✔
2	from drf_spectacular.utils import (	1✔
3	extend_schema,
4	OpenApiParameter,
5	)
6	from rest_framework import status	1✔
7	from rest_framework.decorators import api_view, permission_classes	1✔
8	from rest_framework.response import Response	1✔
9	from drf_spectacular.types import OpenApiTypes	1✔
10	from django.utils import timezone	1✔
11	from django.http import HttpResponseRedirect	1✔
12	from django.conf import settings	1✔
13	from django.contrib.auth import authenticate	1✔
14	from rest_framework.permissions import IsAuthenticated	1✔
15	from rest_framework_simplejwt.tokens import RefreshToken	1✔
16
17	from api.v1.v1_users.serializers import (	1✔
18	RegisterSerializer,
19	UserSerializer,
20	VerifyTokenSerializer,
21	LoginSerializer,
22	)
23	from api.v1.v1_users.models import SystemUser	1✔
24	from utils.custom_serializer_fields import validate_serializers_message	1✔
25	from utils.default_serializers import DefaultResponseSerializer	1✔
26	from utils.email_helper import send_email, EmailTypes	1✔
27
28
29	@extend_schema(	1✔
30	request=RegisterSerializer,
31	responses={201: UserSerializer, 401: DefaultResponseSerializer},
32	tags=["Auth"],
33	)
34	@api_view(["POST"])	1✔
35	def register(request, version):	1✔
36	serializer = RegisterSerializer(data=request.data)	1✔
37	if not serializer.is_valid():	1✔
38	return Response(	1✔
39	{"message": validate_serializers_message(serializer.errors)},
40	status=status.HTTP_400_BAD_REQUEST,
41	)
42	user = serializer.save()	1✔
43
44	if not settings.TEST_ENV:	1!
45	send_email(	×
46	type=EmailTypes.user_register,
47	context={
48	"send_to": [user.email],
49	"name": user.full_name,
50	"verification_code": user.verification_code,
51	},
52	)
53
54	user = UserSerializer(instance=user).data	1✔
55	response = Response(	1✔
56	data=user,
57	status=status.HTTP_201_CREATED,
58	)
59	return response	1✔
60
61
62	@extend_schema(	1✔
63	responses={200: DefaultResponseSerializer},
64	tags=["Auth"],
65	parameters=[
66	OpenApiParameter(
67	name="token",
68	required=True,
69	type=OpenApiTypes.STR,
70	location=OpenApiParameter.QUERY,
71	),
72	],
73	)
74	@api_view(["GET"])	1✔
75	def verify_token(request, version):	1✔
76	serializer = VerifyTokenSerializer(data=request.GET)	1✔
77	if not serializer.is_valid():	1✔
78	return Response(	1✔
79	{"message": validate_serializers_message(serializer.errors)},
80	status=status.HTTP_400_BAD_REQUEST,
81	)
82	token = serializer.validated_data.get("token")	1✔
83	user = SystemUser.objects.get(verification_code=token)	1✔
84	if user.is_verified:	1✔
85	return HttpResponseRedirect(f"{settings.WEBDOMAIN}/en/login")	1✔
86	user.is_verified = True	1✔
87	user.updated = timezone.now()	1✔
88	user.save()	1✔
89	return HttpResponseRedirect(f"{settings.WEBDOMAIN}/en/login?verified=true")	1✔
90
91
92	@extend_schema(	1✔
93	request=LoginSerializer,
94	responses={200: UserSerializer, 401: DefaultResponseSerializer},
95	tags=["Auth"],
96	)
97	@api_view(["POST"])	1✔
98	def login(request, version):	1✔
99	serializer = LoginSerializer(data=request.data)	1✔
100	if not serializer.is_valid():	1✔
101	return Response(	1✔
102	{
103	"message": validate_serializers_message(serializer.errors)
104	},
105	status=status.HTTP_400_BAD_REQUEST,
106	)
107
108	user = authenticate(	1✔
109	email=serializer.validated_data["email"],
110	password=serializer.validated_data["password"],
111	)
112
113	if user:	1✔
114	user.last_login = timezone.now()	1✔
115	user.save()	1✔
116	refresh = RefreshToken.for_user(user)	1✔
117	# Get the expiration time of the new token
118	expiration_time = datetime.fromtimestamp(	1✔
119	refresh.access_token["exp"]
120	)
121	expiration_time = timezone.make_aware(expiration_time)	1✔
122
123	data = {}	1✔
124	data["user"] = UserSerializer(instance=user).data	1✔
125	data["token"] = str(refresh.access_token)	1✔
126	data["expiration_time"] = expiration_time	1✔
127	response = Response(	1✔
128	data,
129	status=status.HTTP_200_OK,
130	)
131	response.set_cookie(	1✔
132	"AUTH_TOKEN", str(refresh.access_token), expires=expiration_time
133	)
134	return response	1✔
135	return Response(	1✔
136	{"message": "Invalid login credentials"},
137	status=status.HTTP_401_UNAUTHORIZED,
138	)
139
140
141	@extend_schema(	1✔
142	responses={200: UserSerializer},
143	tags=["Auth"],
144	summary="Get user details from token",
145	)
146	@api_view(["GET"])	1✔
147	@permission_classes([IsAuthenticated])	1✔
148	def get_profile(request, version):	1✔
149	return Response(	1✔
150	UserSerializer(instance=request.user).data,
151	status=status.HTTP_200_OK
152	)

akvo / partos-pat / #50

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous