Lruzicki/draft

.gitignore

@@ -0,0 +1,11 @@
+*.pyc
+**/venv
+**/.env
+**/.idea
+**/__pycache__
+build
+dist
+*.egg-info
+**/.vscode
+**/*.mo
+locale/__init__.py

govstack_test_harness_api/apps.py

@@ -4,3 +4,21 @@
 class TestHarnessApiConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'govstack_test_harness_api'
+
+    IM_CLIENT = 'eGovStack/GOV/90000009/digitalregistries'
+
+    digital_registry = {
+        "birth_registry": {
+            "1": {
+                'ID': 'ID'
+            }
+        },
+        "registryname": {
+            "111": {
+                'ID': 'chfId',
+                'FirstName': 'otherNames',
+                'LastName': 'lastName',
+                'BirthCertificateID': 'json_ext'
+            }
+        }
+    }

govstack_test_harness_api/building_blocks/bb-digital-registries/controllers/record_exists_controller.py

@@ -0,0 +1,12 @@
+from ..services.record_exists_service import RecordExistsService
+from ..services.services import get_query_content_values, login_with_env_variables
+
+
+def check_if_record_exists(data, jwt, context):
+    content_values = get_query_content_values(data['query']['content'], data['registryname'], data['versionnumber'])
+    service = RecordExistsService(
+        jwt,
+        context=context,
+        validated_data=data,
+    )
+    return service.execute()

govstack_test_harness_api/building_blocks/bb-digital-registries/gql/gql_queries.py

@@ -0,0 +1,96 @@
+def get_record_exists_query(registry_name, version_number, uuid, field):
+    query = f"""
+    {{
+        recordExists(registryName: "{registry_name}", versionNumber: "{version_number}", uuid: "{uuid}", field: "{field}") {{
+            edges {{
+                node {{
+                    id
+                    {field}
+                }}
+            }}
+        }}
+    }}
+    """
+    return query
+
+
+def get_update_registry_query(uuid="", chf_id="", update_fields="") -> str:
+    query = f'''
+                mutation {{
+                  updateInsuree(
+                    input: {{
+                      clientMutationId: "552f8e55-ed5a-4e1e-a159-ea8f8cec0560"
+                      clientMutationLabel: "Update insuree"
+                      uuid: "{uuid}"
+                      chfId: "{chf_id}"
+                {update_fields}
+                genderId: "F"
+                head: true
+                dob: "1974-06-11"
+                cardIssued:false
+                familyId: 1
+                relationshipId: 4
+                    }}
+                  ) {{
+                    clientMutationId
+                    internalId
+                  }}
+                }}
+                '''
+    return query
+
+
+def get_insurees_query(variable_values: str = "", fetched_fields: str = "") -> str:
+    return f'''
+            query GetInsurees {{
+                insurees({variable_values}) {{
+                    edges{{
+                        node{{
+                            {fetched_fields}
+                        }}
+                    }}
+                }}
+            }}
+            '''
+
+
+def create_insurees_query(variables: dict) -> str:
+    return f'''
+    mutation {{
+        createInsuree(
+            input: {{
+                clientMutationLabel: "{variables['clientMutationLabel']}"
+                chfId: "{variables['chfId']}"
+                lastName: "{variables['lastName']}"
+                otherNames: "{variables['otherNames']}"
+                genderId: "{variables['genderId']}"
+                dob: "{variables['dob']}"
+                head: {str(variables['head']).lower()}
+                cardIssued: {str(variables['cardIssued']).lower()}
+                jsonExt: "{variables['jsonExt']}"
+                familyId: 1
+            }}
+        ) {{
+            clientMutationId
+            internalId
+        }}
+    }}
+    '''
+
+
+def delete_insuree_query(uuid):
+    return f'''mutation
+    {{
+        deleteInsurees(
+            input: {{
+            clientMutationId: "c164412c-45a6-4f3f-8a2b-4290739751e2"
+            clientMutationLabel: "Delete insuree"
+
+            uuid: "{uuid}", uuids: ["{uuid}"]
+        }}
+    ) {{
+        clientMutationId
+    internalId
+    }}
+    }}
+    '''

govstack_test_harness_api/building_blocks/bb-digital-registries/gql/graphene_client.py

@@ -0,0 +1,46 @@
+import graphene
+from graphene.test import Client
+# from gql import gql, Client
+# from gql.transport.requests import RequestsHTTPTransport
+from insuree.schema import Query, Mutation
+from graphene import Schema
+
+
+class GrapheneClient:
+    def __init__(self):
+        self._client = Client(Schema(query=Query, mutation=Mutation))
+
+    def execute_query(self, query, context, variables=None):
+        print("context: ", context)
+
+        if variables is None:
+            variables = {}
+        print("variables: ", variables)
+        return self._client.execute(query, context=context, variables=variables)
+
+    def execute_mutation(self, mutation, variables=None):
+        if variables is None:
+            variables = {}
+
+        return self._client.execute(mutation, variables=variables)
+
+
+# class GrapheneClient:
+#     def __init__(self, url, headers=None):
+#         if headers is None:
+#             headers = {}
+#         print(url)
+#         self._transport = RequestsHTTPTransport(url=url, headers=headers, use_json=True)
+#         self._client = Client(transport=self._transport, fetch_schema_from_transport=True)
+#
+#     def execute_query(self, query, variables=None):
+#         if variables is None:
+#             variables = {}
+#
+#         return self._client.execute(gql(query), variable_values=variables)
+#
+#     def execute_mutation(self, mutation, variables=None):
+#         if variables is None:
+#             variables = {}
+#
+#         return self._client.execute(gql(mutation), variable_values=variables)

govstack_test_harness_api/building_blocks/bb-digital-registries/serializers/record_exists_serializer.py

@@ -0,0 +1,7 @@
+from rest_framework import serializers
+
+
+class RecordExistsSerializer(serializers.Serializer):
+    query = serializers.JSONField()
+    registryname = serializers.CharField(max_length=200)
+    versionnumber = serializers.IntegerField()

govstack_test_harness_api/building_blocks/bb-digital-registries/services/record_exists_service.py

@@ -0,0 +1,30 @@
+# W pliku record_exists_service.py
+from graphene import Schema
+
+from ..gql.graphene_client import GrapheneClient
+from ..gql.gql_queries import get_record_exists_query, get_insurees_query
+from .services import get_client, get_values_for_insurees, get_search_insurees_arguments
+from insuree.schema import Query, Mutation
+from django.conf import global_settings
+
+
+class RecordExistsService:
+    def __init__(self, jwt_token, context, validated_data):
+        self.context = context
+        self.validated_data = validated_data
+        # self.headers = {"Authorization": "Bearer " + jwt_token}
+        self.client = GrapheneClient()
+
+    def execute(self):
+        variables = get_values_for_insurees(
+            self.validated_data['query']['content'],
+            self.validated_data["registryname"],
+            self.validated_data["versionnumber"]
+        )
+        variable_values = get_search_insurees_arguments(
+            self.validated_data['query']['content'],
+            self.validated_data["registryname"],
+            self.validated_data["versionnumber"]
+        )
+        query = get_insurees_query(variable_values, "lastName")
+        return self.client.execute_query(query, self.context, variables)

govstack_test_harness_api/building_blocks/bb-digital-registries/services/services.py

@@ -0,0 +1,96 @@
+import os
+from types import SimpleNamespace
+from django.contrib.auth.models import AnonymousUser
+from graphene import Schema
+from graphene.test import Client
+from unittest import mock
+from core.schema import Query as CoreQuery, Mutation as CoreMutation
+from django.apps import apps
+
+app_config = apps.get_app_config('govstack_test_harness_api')
+
+
+def get_client(schema, query, mutation):
+    return Client(schema=schema(query=query, mutation=mutation))
+
+
+def create_base_context():
+    user = mock.Mock(is_anonymous=False)
+    user.has_perm = mock.MagicMock(return_value=False)
+    return SimpleNamespace(user=user)
+
+
+def get_context(request):
+    if request.user.is_authenticated:
+        context = create_base_context()
+        context.user = request.user
+    else:
+        context = SimpleNamespace(user=request.user)
+    return context
+
+
+def get_query_content_values(query_content: dict, registry_name: str, version: str) -> dict:
+    content_values = {}
+    if not query_content:
+        return {}
+
+    json_mapping = app_config.digital_registry.get(registry_name, {}).get(version, {})
+    for input_key, output_key in json_mapping.items():
+        content_values[output_key] = query_content.get(input_key, "")
+    return content_values
+
+
+def get_values_for_insurees(content_values: dict, registry_name: str, version: str) -> dict:
+    json_mapping = app_config.digital_registry.get(registry_name, {}).get(version, {})
+    mapped_values = {json_mapping[key]: value for key, value in content_values.items() if key in json_mapping}
+    return {
+        'clientMutationLabel': f"Create insuree - {mapped_values.get('chfId', '')}",
+        'chfId': f"{mapped_values.get('chfId', '')}",
+        'lastName': f"{mapped_values.get('lastName', '')}",
+        'otherNames': f"{mapped_values.get('otherNames', '')}",
+        'genderId': mapped_values.get('Gender', 'M'),
+        'dob': mapped_values.get('BirthDate', '2000-06-20'),
+        'head': mapped_values.get('Head', True),
+        'cardIssued': False,
+        'jsonExt': '{}',
+    }
+
+
+def get_search_insurees_arguments(query_content: dict, registry_name: str, version: str) -> str:
+    insurees_arguments = ""
+    json_mapping = app_config.digital_registry.get(registry_name, {}).get(str(version), {})
+    for key, value in json_mapping.items():
+        if key in query_content:
+            insurees_arguments += f'{value}: "{query_content[key]}",'
+
+    if insurees_arguments.endswith(','):
+        return insurees_arguments[:-1]
+    return insurees_arguments
+
+
+def get_update_fields(write_values) -> str:
+    field_mapping = {
+        "LastName": "lastName",
+        "FirstName": "otherNames"
+    }
+    return "".join(f'{field_mapping[key]}: "{value}" '
+                            for key, value in write_values.items()
+                            if value and key in field_mapping)
+
+
+def login_with_env_variables(request):
+    client = get_client(Schema, CoreQuery, CoreMutation)
+    username = os.getenv('login_openIMIS')
+    password = os.getenv('password_openIMIS')
+
+    mutation = f'''
+      mutation {{
+          tokenAuth(username: "{username}", password: "{password}") {{
+              token
+              refreshExpiresIn
+          }}
+      }}
+      '''
+    context = get_context(request)
+    client.execute(mutation, context=context)
+    return context