OM-348: Create a public function to fetch info about voucher

worker_voucher/gql_queries.py

@@ -125,3 +125,11 @@ class Meta:
             "is_deleted": ["exact"],
         }
         connection_class = ExtendedConnection
+
+
+class VoucherCheckGQLType(graphene.ObjectType):
+    is_existed = graphene.Boolean()
+    is_valid = graphene.Boolean()
+    assigned_date = graphene.DateTime()
+    employer_code = graphene.String()
+    employer_name = graphene.String()

worker_voucher/schema.py

@@ -1,6 +1,7 @@
 import graphene
 import graphene_django_optimizer as gql_optimizer
 
+from django.core.exceptions import ValidationError
 from django.db.models import Q
 from django.utils.translation import gettext as _
 from django.contrib.auth.models import AnonymousUser
@@ -16,7 +17,7 @@
 from policyholder.models import PolicyHolder
 from worker_voucher.apps import WorkerVoucherConfig
 from worker_voucher.gql_queries import WorkerVoucherGQLType, AcquireVouchersValidationSummaryGQLType, WorkerGQLType, \
-    OnlineWorkerDataGQLType, GroupOfWorkerGQLType, WorkerGroupGQLType
+    OnlineWorkerDataGQLType, GroupOfWorkerGQLType, WorkerGroupGQLType, VoucherCheckGQLType
 from worker_voucher.gql_mutations import CreateWorkerVoucherMutation, UpdateWorkerVoucherMutation, \
     DeleteWorkerVoucherMutation, AcquireUnassignedVouchersMutation, AcquireAssignedVouchersMutation, \
     DateRangeInclusiveInputType, AssignVouchersMutation, CreateWorkerMutation, DeleteWorkerMutation, \
@@ -95,6 +96,11 @@ class Query(ExportableQueryMixin, graphene.ObjectType):
         client_mutation_id=graphene.String(),
     )
 
+    voucher_check = graphene.Field(
+        VoucherCheckGQLType,
+        code=graphene.String(required=True),
+    )
+
     def resolve_worker(self, info, client_mutation_id=None, economic_unit_code=None, **kwargs):
         Query._check_permissions(info.context.user, InsureeConfig.gql_query_insurees_perms)
         filters = filter_validity(**kwargs)
@@ -232,6 +238,46 @@ def resolve_group_of_worker(self, info, economic_unit_code=None, **kwargs):
         filters.extend(get_group_worker_user_filters(info.context.user))
         return gql_optimizer.query(query.filter(*filters), info)
 
+    def resolve_voucher_check(self, info, code):
+        try:
+            from core import datetime
+            today = datetime.datetime.now()
+            voucher = WorkerVoucher.objects.filter(
+                code=code,
+                insuree__validity_to__isnull=True,
+                policyholder__is_deleted=False,
+                is_deleted=False,
+                expiry_date__gte=today,
+                status=WorkerVoucher.Status.ASSIGNED
+            ).first()
+            if not voucher:
+                return VoucherCheckGQLType(
+                    is_existed=False,
+                    is_valid=False,
+                    assigned_date=None,
+                    employer_code=None,
+                    employer_name=None,
+                )
+            # assigned_date__date=today,
+            if voucher.assigned_date.date() >= today.date():
+                return VoucherCheckGQLType(
+                    is_existed=True,
+                    is_valid=True,
+                    assigned_date=voucher.assigned_date,
+                    employer_code=voucher.policyholder.code,
+                    employer_name=voucher.policyholder.trade_name
+                )
+            else:
+                return VoucherCheckGQLType(
+                    is_existed=True,
+                    is_valid=False,
+                    assigned_date=voucher.assigned_date,
+                    employer_code=voucher.policyholder.code,
+                    employer_name=voucher.policyholder.trade_name
+                )
+        except Exception as e:
+            raise ValidationError(_("Unable to fetch voucher details"))
+
     @staticmethod
     def _check_permissions(user, perms):
         if type(user) is AnonymousUser or not user.id or not user.has_perms(perms):

worker_voucher/tests/data/gql_payloads.py

@@ -139,3 +139,15 @@
   }
 }
 """
+
+gql_query_voucher_check = """
+query voucherCheck{
+  voucherCheck(code: "%s") {
+    isExisted
+    isValid
+    assignedDate
+    employerCode
+    employerName
+  }
+}
+"""

worker_voucher/tests/test_gql_voucher_check.py

@@ -0,0 +1,120 @@
+from django.test import TestCase
+from graphene import Schema
+from graphene.test import Client
+
+from core import datetime
+from core.models import Role
+from core.test_helpers import create_test_interactive_user
+from worker_voucher.models import WorkerVoucher
+from worker_voucher.schema import Query, Mutation
+from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker_for_eu
+from worker_voucher.tests.data.gql_payloads import gql_query_voucher_check
+
+
+class GQLVoucherCheckTestCase(TestCase):
+    user = None
+    worker = None
+    eu = None
+
+    today = None,
+    yesterday = None,
+    tomorrow = None
+
+    @classmethod
+    def setUpClass(cls):
+        super(GQLVoucherCheckTestCase, cls).setUpClass()
+        role_employer = Role.objects.get(name='Employer', validity_to__isnull=True)
+        cls.user = create_test_interactive_user(username='VoucherTestUser10', roles=[role_employer.id])
+        cls.eu = create_test_eu_for_user(cls.user)
+        cls.worker = create_test_worker_for_eu(cls.user, cls.eu)
+
+        gql_schema = Schema(
+            query=Query,
+            mutation=Mutation
+        )
+
+        cls.today = datetime.datetime.now()
+        cls.tomorrow = datetime.datetime.now() + datetime.datetimedelta(days=1)
+        cls.yesterday = datetime.datetime.now() - datetime.datetimedelta(days=1)
+
+        cls.gql_client = Client(gql_schema)
+        cls.gql_context = cls.GQLContext(None)
+
+    def test_get_existed_voucher_by_code(self):
+        voucher = self._create_test_voucher()
+        print(voucher)
+        payload = gql_query_voucher_check % (
+            voucher.code
+        )
+        print(payload)
+        query_result = self.gql_client.execute(payload, context=self.gql_context)
+        print(query_result)
+        query_data = query_result['data']['voucherCheck']
+        print(query_data)
+        self.assertEqual(query_data['isExisted'], True)
+        self.assertEqual(query_data['isValid'], True)
+        self.assertEqual(query_data['assignedDate'], voucher.assigned_date)
+        self.assertEqual(query_data['employerCode'], voucher.policyholder.code)
+        self.assertEqual(query_data['employerName'], voucher.policyholder.trade_name)
+
+    def test_get_existed_voucher_from_tomorrow_by_code(self):
+        voucher = self._create_test_voucher(assigned_date=self.tomorrow)
+        print(voucher)
+        payload = gql_query_voucher_check % (
+            voucher.code
+        )
+        print(payload)
+        query_result = self.gql_client.execute(payload, context=self.gql_context)
+        print(query_result)
+        query_data = query_result['data']['voucherCheck']
+        print(query_data)
+        self.assertEqual(query_data['isExisted'], True)
+        self.assertEqual(query_data['isValid'], True)
+        self.assertEqual(query_data['assignedDate'], voucher.assigned_date)
+        self.assertEqual(query_data['employerCode'], voucher.policyholder.code)
+        self.assertEqual(query_data['employerName'], voucher.policyholder.trade_name)
+
+    def test_get_not_existed_voucher_by_code(self):
+        payload = gql_query_voucher_check % (
+            "Not-Existed"
+        )
+        print(payload)
+        query_result = self.gql_client.execute(payload, context=self.gql_context)
+        print(query_result)
+        query_data = query_result['data']['voucherCheck']
+        print(query_data)
+        self.assertEqual(query_data['isExisted'], False)
+        self.assertEqual(query_data['isValid'], False)
+        self.assertEqual(query_data['assignedDate'], None)
+        self.assertEqual(query_data['employerCode'], None)
+        self.assertEqual(query_data['employerName'], None)
+
+    def test_get_existed_voucher_from_yesterday_by_code(self):
+        voucher = self._create_test_voucher(assigned_date=self.yesterday)
+        print(voucher)
+        payload = gql_query_voucher_check % (
+            voucher.code
+        )
+        print(payload)
+        query_result = self.gql_client.execute(payload, context=self.gql_context)
+        print(query_result)
+        query_data = query_result['data']['voucherCheck']
+        print(query_data)
+        self.assertEqual(query_data['isExisted'], True)
+        self.assertEqual(query_data['isValid'], False)
+        self.assertEqual(query_data['assignedDate'], voucher.assigned_date)
+        self.assertEqual(query_data['employerCode'], voucher.policyholder.code)
+        self.assertEqual(query_data['employerName'], voucher.policyholder.trade_name)
+
+    def _create_test_voucher(self, code="001", status=WorkerVoucher.Status.ASSIGNED, assigned_date=None,
+                             expiry_date=None):
+        voucher = WorkerVoucher(
+            insuree=self.worker,
+            policyholder=self.eu,
+            code=code,
+            status=status,
+            assigned_date=self.today if not assigned_date else assigned_date,
+            expiry_date=self.tomorrow if not expiry_date else expiry_date,
+        )
+        voucher.save(username=self.user.username)
+        return voucher