akvo / iwsims-demo / #93

Committed 30 Apr 2025 07:36AM UTC coverage: 86.373% (+0.07%) from 86.3%

Build # #93

Build Type

Pull #29

coveralls-python

Committed by

ifirmawan

Commit Message

[#28] Remove any county, sub-County terms in the backend

Pull Request Pull Request #29: Feature/28 eng 1232 data submission by admin super admin

Run Details

2591 of 3118 branches covered (83.1%)

Branch coverage included in aggregate %.

5915 of 6730 relevant lines covered (87.89%)

0.88 hits per line

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

91.89

backend/api/v1/v1_forms/views.py

# Create your views here.
from drf_spectacular.types import OpenApiTypes
from drf_spectacular.utils import (
    extend_schema,
    OpenApiParameter,
    inline_serializer,
)

from rest_framework import status, serializers
from rest_framework.decorators import api_view, permission_classes
from rest_framework.generics import get_object_or_404
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response

from api.v1.v1_forms.models import (
    Forms,
    FormApprovalAssignment,
)
from api.v1.v1_forms.serializers import (
    ListFormSerializer,
    WebFormDetailSerializer,
    FormDataSerializer,
    FormApproverRequestSerializer,
    FormApproverResponseSerializer,
)
from api.v1.v1_profile.models import Administration
from api.v1.v1_data.functions import get_cache, create_cache
from utils.custom_permissions import IsSuperAdmin, IsAdmin
from utils.custom_serializer_fields import validate_serializers_message


@extend_schema(
    responses={200: ListFormSerializer(many=True)},
    tags=["Form"],
    summary="To get list of forms",
    description="To get list of forms",
)
@api_view(["GET"])
def list_form(request, version):
    instance = Forms.objects.all()
    return Response(
        ListFormSerializer(instance=instance, many=True).data,
        status=status.HTTP_200_OK,
    )


@extend_schema(
    responses={200: WebFormDetailSerializer},
    tags=["Form"],
    summary="To get form in webform format",
)
@api_view(["GET"])
@permission_classes([IsAuthenticated])
def web_form_details(request, version, form_id):
    administration = request.user.user_access.administration
    cache_name = f"webform-{form_id}-{administration.id}"
    cache_data = get_cache(cache_name)
    if cache_data:
        return Response(cache_data, content_type="application/json;")
    instance = get_object_or_404(Forms, pk=form_id)
    instance = WebFormDetailSerializer(
        instance=instance, context={"user": request.user}
    ).data
    create_cache(cache_name, instance)
    return Response(instance, status=status.HTTP_200_OK)


@extend_schema(
    responses={200: FormDataSerializer},
    tags=["Form"],
    summary="To get form data",
)
@api_view(["GET"])
def form_data(request, version, form_id):
    cache_name = f"form-{form_id}"
    cache_data = get_cache(cache_name)
    if cache_data:
        return Response(cache_data, content_type="application/json;")
    instance = get_object_or_404(Forms, pk=form_id)
    instance = FormDataSerializer(instance=instance).data
    create_cache(cache_name, instance)
    return Response(instance, status=status.HTTP_200_OK)


@extend_schema(
    parameters=[
        OpenApiParameter(
            name="administration_id",
            required=True,
            type=OpenApiTypes.NUMBER,
            location=OpenApiParameter.QUERY,
        ),
        OpenApiParameter(
            name="form_id",
            required=True,
            type=OpenApiTypes.NUMBER,
            location=OpenApiParameter.QUERY,
        ),
    ],
    responses={200: FormApproverResponseSerializer(many=True)},
    tags=["Form"],
    summary="To get approver user list",
)
@api_view(["GET"])
@permission_classes([IsAuthenticated, IsSuperAdmin | IsAdmin])
def form_approver(request, version):
    serializer = FormApproverRequestSerializer(data=request.GET)
    if not serializer.is_valid():
        return Response(
            {"message": validate_serializers_message(serializer.errors)},
            status=status.HTTP_400_BAD_REQUEST,
        )

    instance = Administration.objects.filter(
        parent=serializer.validated_data.get("administration_id"),
    )
    instance = [serializer.validated_data.get("administration_id")] + list(
        instance
    )
    return Response(
        FormApproverResponseSerializer(
            instance=instance,
            many=True,
            context={"form": serializer.validated_data.get("form_id")},
        ).data,
        status=status.HTTP_200_OK,
    )


@extend_schema(
    responses={
        (200, "application/json"): inline_serializer(
            "CheckFormApproverSerializer",
            fields={
                "count": serializers.IntegerField(),
            },
        )
    },
    tags=["Form"],
    summary="To check approver for defined form_id & logged in user",
)
@api_view(["GET"])
@permission_classes([IsAuthenticated])
def check_form_approver(request, form_id, version):
    form = get_object_or_404(Forms, pk=form_id)
    # find administration id from logged in user
    if not request.user.user_access.administration.path:
        return Response(
            {"message": "National level does not have an approver"},
            status=status.HTTP_404_NOT_FOUND,
        )
    adm_ids = request.user.user_access.administration.path[:-1].split(".")
    adm_ids += [request.user.user_access.administration_id]
    adm_ids = [int(adm) for adm in adm_ids]
    # check into form approval assignment table
    approver = FormApprovalAssignment.objects.filter(
        form=form, administration_id__in=adm_ids
    ).count()
    return Response({"count": approver}, status=status.HTTP_200_OK)

1	# Create your views here.
2	from drf_spectacular.types import OpenApiTypes	1✔
3	from drf_spectacular.utils import (	1✔
4	extend_schema,
5	OpenApiParameter,
6	inline_serializer,
7	)
8
9	from rest_framework import status, serializers	1✔
10	from rest_framework.decorators import api_view, permission_classes	1✔
11	from rest_framework.generics import get_object_or_404	1✔
12	from rest_framework.permissions import IsAuthenticated	1✔
13	from rest_framework.response import Response	1✔
14
15	from api.v1.v1_forms.models import (	1✔
16	Forms,
17	FormApprovalAssignment,
18	)
19	from api.v1.v1_forms.serializers import (	1✔
20	ListFormSerializer,
21	WebFormDetailSerializer,
22	FormDataSerializer,
23	FormApproverRequestSerializer,
24	FormApproverResponseSerializer,
25	)
26	from api.v1.v1_profile.models import Administration	1✔
27	from api.v1.v1_data.functions import get_cache, create_cache	1✔
28	from utils.custom_permissions import IsSuperAdmin, IsAdmin	1✔
29	from utils.custom_serializer_fields import validate_serializers_message	1✔
30
31
32	@extend_schema(	1✔
33	responses={200: ListFormSerializer(many=True)},
34	tags=["Form"],
35	summary="To get list of forms",
36	description="To get list of forms",
37	)
38	@api_view(["GET"])	1✔
39	def list_form(request, version):	1✔
40	instance = Forms.objects.all()	×
41	return Response(	×
42	ListFormSerializer(instance=instance, many=True).data,
43	status=status.HTTP_200_OK,
44	)
45
46
47	@extend_schema(	1✔
48	responses={200: WebFormDetailSerializer},
49	tags=["Form"],
50	summary="To get form in webform format",
51	)
52	@api_view(["GET"])	1✔
53	@permission_classes([IsAuthenticated])	1✔
54	def web_form_details(request, version, form_id):	1✔
55	administration = request.user.user_access.administration	1✔
56	cache_name = f"webform-{form_id}-{administration.id}"	1✔
57	cache_data = get_cache(cache_name)	1✔
58	if cache_data:	1✔
59	return Response(cache_data, content_type="application/json;")	1✔
60	instance = get_object_or_404(Forms, pk=form_id)	1✔
61	instance = WebFormDetailSerializer(	1✔
62	instance=instance, context={"user": request.user}
63	).data
64	create_cache(cache_name, instance)	1✔
65	return Response(instance, status=status.HTTP_200_OK)	1✔
66
67
68	@extend_schema(	1✔
69	responses={200: FormDataSerializer},
70	tags=["Form"],
71	summary="To get form data",
72	)
73	@api_view(["GET"])	1✔
74	def form_data(request, version, form_id):	1✔
75	cache_name = f"form-{form_id}"	1✔
76	cache_data = get_cache(cache_name)	1✔
77	if cache_data:	1!
78	return Response(cache_data, content_type="application/json;")	×
79	instance = get_object_or_404(Forms, pk=form_id)	1✔
80	instance = FormDataSerializer(instance=instance).data	1✔
81	create_cache(cache_name, instance)	1✔
82	return Response(instance, status=status.HTTP_200_OK)	1✔
83
84
85	@extend_schema(	1✔
86	parameters=[
87	OpenApiParameter(
88	name="administration_id",
89	required=True,
90	type=OpenApiTypes.NUMBER,
91	location=OpenApiParameter.QUERY,
92	),
93	OpenApiParameter(
94	name="form_id",
95	required=True,
96	type=OpenApiTypes.NUMBER,
97	location=OpenApiParameter.QUERY,
98	),
99	],
100	responses={200: FormApproverResponseSerializer(many=True)},
101	tags=["Form"],
102	summary="To get approver user list",
103	)
104	@api_view(["GET"])	1✔
105	@permission_classes([IsAuthenticated, IsSuperAdmin \| IsAdmin])	1✔
106	def form_approver(request, version):	1✔
107	serializer = FormApproverRequestSerializer(data=request.GET)	1✔
108	if not serializer.is_valid():	1!
109	return Response(	×
110	{"message": validate_serializers_message(serializer.errors)},
111	status=status.HTTP_400_BAD_REQUEST,
112	)
113
114	instance = Administration.objects.filter(	1✔
115	parent=serializer.validated_data.get("administration_id"),
116	)
117	instance = [serializer.validated_data.get("administration_id")] + list(	1✔
118	instance
119	)
120	return Response(	1✔
121	FormApproverResponseSerializer(
122	instance=instance,
123	many=True,
124	context={"form": serializer.validated_data.get("form_id")},
125	).data,
126	status=status.HTTP_200_OK,
127	)
128
129
130	@extend_schema(	1✔
131	responses={
132	(200, "application/json"): inline_serializer(
133	"CheckFormApproverSerializer",
134	fields={
135	"count": serializers.IntegerField(),
136	},
137	)
138	},
139	tags=["Form"],
140	summary="To check approver for defined form_id & logged in user",
141	)
142	@api_view(["GET"])	1✔
143	@permission_classes([IsAuthenticated])	1✔
144	def check_form_approver(request, form_id, version):	1✔
145	form = get_object_or_404(Forms, pk=form_id)	1✔
146	# find administration id from logged in user
147	if not request.user.user_access.administration.path:	1✔
148	return Response(	1✔
149	{"message": "National level does not have an approver"},
150	status=status.HTTP_404_NOT_FOUND,
151	)
152	adm_ids = request.user.user_access.administration.path[:-1].split(".")	1✔
153	adm_ids += [request.user.user_access.administration_id]	1✔
154	adm_ids = [int(adm) for adm in adm_ids]	1✔
155	# check into form approval assignment table
156	approver = FormApprovalAssignment.objects.filter(	1✔
157	form=form, administration_id__in=adm_ids
158	).count()
159	return Response({"count": approver}, status=status.HTTP_200_OK)	1✔

akvo / iwsims-demo / #93

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