maleo-metadata-client 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

maleo/metadata/client/services/blood_type.py

@@ -1,379 +1,322 @@
 import json
 from copy import deepcopy
-from Crypto.PublicKey.RSA import RsaKey
 from datetime import datetime, timezone
-from redis.asyncio.client import Redis
-from typing import Dict, List, Literal, Optional, Union, overload
+from typing import Literal, Union, overload
 from uuid import UUID
-from maleo.soma.authorization import BearerAuth
-from maleo.soma.dtos.configurations.cache.redis import RedisCacheNamespaces
-from maleo.soma.enums.cardinality import Cardinality
-from maleo.soma.enums.environment import Environment
-from maleo.soma.enums.expiration import Expiration
-from maleo.soma.enums.logging import LogLevel
-from maleo.soma.enums.operation import OperationTarget
-from maleo.soma.managers.client.maleo import MaleoClientService
-from maleo.soma.managers.client.http import HTTPClientManager
-from maleo.soma.managers.credential import CredentialManager
-from maleo.soma.schemas.authentication import OptionalAuthentication
-from maleo.soma.schemas.data import DataPair
-from maleo.soma.schemas.operation.context import (
-    OperationContextSchema,
-    OperationOriginSchema,
-    OperationLayerSchema,
-    OperationTargetSchema,
-)
-from maleo.soma.schemas.operation.resource import (
-    ReadSingleResourceOperationSchema,
-    ReadMultipleResourceOperationSchema,
+from maleo.database.enums import Connection
+from maleo.database.utils import build_cache_key
+from maleo.enums.cardinality import Cardinality
+from maleo.enums.connection import Header
+from maleo.logging.enums import Level
+from maleo.managers.client.maleo.config import MaleoMetadataClientConfig
+from maleo.managers.client.maleo import MaleoClientService
+from maleo.metadata.constants.blood_type import BLOOD_TYPE_RESOURCE
+from maleo.metadata.schemas.blood_type import (
+    ReadMultipleParameter,
+    ReadSingleParameter,
+    StandardBloodTypeSchema,
+    FullBloodTypeSchema,
 )
-from maleo.soma.schemas.operation.resource.action import ReadResourceOperationAction
-from maleo.soma.schemas.operation.resource.result import (
-    ReadSingleResourceOperationResult,
-    ReadMultipleResourceOperationResult,
+from maleo.metadata.enums.blood_type import Granularity
+from maleo.metadata.utils.blood_type import get_schema_model
+from maleo.schemas.connection import ConnectionContext
+from maleo.schemas.exception.factory import Factory as MaleoExceptionFactory
+from maleo.schemas.mixins.filter import convert as convert_filter
+from maleo.schemas.mixins.sort import convert as convert_sort
+from maleo.schemas.operation.action.resource import ReadResourceOperationAction
+from maleo.schemas.operation.enums import OperationType, Target
+from maleo.schemas.operation.mixins import Timestamp
+from maleo.schemas.operation.resource import (
+    ReadMultipleResourceOperation,
+    ReadSingleResourceOperation,
 )
-from maleo.soma.schemas.operation.timestamp import OperationTimestamp
-from maleo.soma.schemas.pagination import FlexiblePagination
-from maleo.soma.schemas.parameter.general import ReadSingleQueryParameterSchema
-from maleo.soma.schemas.request import RequestContext
-from maleo.soma.schemas.response import (
-    SingleDataResponseSchema,
-    MultipleDataResponseSchema,
+from maleo.schemas.pagination import StrictPagination
+from maleo.schemas.response import (
+    MultipleDataResponse,
+    ReadMultipleDataResponse,
+    SingleDataResponse,
+    ReadSingleDataResponse,
 )
-from maleo.soma.schemas.service import ServiceContext
-from maleo.soma.utils.cache import build_key
-from maleo.soma.utils.logging import ClientLogger
-from maleo.soma.utils.merger import merge_dicts
-from maleo.soma.utils.token import reencode
-from maleo.metadata.constants.blood_type import RESOURCE
-from maleo.metadata.schemas.data.blood_type import BloodTypeDataSchema
-from maleo.metadata.schemas.parameter.client.blood_type import (
-    ReadMultipleParameter,
-    ReadMultipleQueryParameter,
+from maleo.schemas.security.authorization import (
+    OptionalAnyAuthorization,
+    AnyAuthorization,
+    Factory as AuthorizationFactory,
 )
-from maleo.metadata.schemas.parameter.general.blood_type import ReadSingleParameter
+from maleo.schemas.security.impersonation import OptionalImpersonation
+from maleo.types.dict import OptionalStringToStringDict
+from maleo.utils.merger import merge_dicts
 
 
-class BloodTypeClientService(MaleoClientService):
-    def __init__(
-        self,
-        environment: Environment,
-        key: str,
-        url: str,
-        operation_origin: OperationOriginSchema,
-        logger: ClientLogger,
-        credential_manager: CredentialManager,
-        http_client_manager: HTTPClientManager,
-        private_key: RsaKey,
-        redis: Redis,
-        redis_namespaces: RedisCacheNamespaces,
-        service_context: ServiceContext,
-    ):
-        super().__init__(
-            environment,
-            key,
-            url,
-            operation_origin,
-            logger,
-            credential_manager,
-            http_client_manager,
-            private_key,
-            redis,
-            redis_namespaces,
-            service_context,
-        )
-        self._namespace = self._redis_namespaces.create(
-            self._key,
-            RESOURCE.aggregate(),
-            origin=self._CACHE_ORIGIN,
-            layer=self._CACHE_LAYER,
-        )
-        self._default_operation_context = OperationContextSchema(
-            origin=self._operation_origin,
-            layer=OperationLayerSchema(type=self._OPERATION_LAYER_TYPE, details=None),
-            target=OperationTargetSchema(
-                type=self._OPERATION_TARGET_TYPE, details=None
-            ),
-        )
+class BloodTypeClientService(MaleoClientService[MaleoMetadataClientConfig]):
+    resource = BLOOD_TYPE_RESOURCE
 
     @overload
     async def read(
         self,
         cardinality: Literal[Cardinality.MULTIPLE],
+        granularity: Literal[Granularity.STANDARD],
         *,
         operation_id: UUID,
-        request_context: RequestContext,
-        authentication: OptionalAuthentication,
+        resource_operation_action: ReadResourceOperationAction,
+        connection_context: ConnectionContext,
+        authorization: AnyAuthorization,
+        impersonation: OptionalImpersonation = None,
         parameters: ReadMultipleParameter,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> ReadMultipleResourceOperationResult[
-        BloodTypeDataSchema, FlexiblePagination, None
-    ]: ...
+        headers: OptionalStringToStringDict = None,
+    ) -> ReadMultipleDataResponse[StandardBloodTypeSchema, StrictPagination, None]: ...
+    @overload
+    async def read(
+        self,
+        cardinality: Literal[Cardinality.MULTIPLE],
+        granularity: Literal[Granularity.FULL],
+        *,
+        operation_id: UUID,
+        resource_operation_action: ReadResourceOperationAction,
+        connection_context: ConnectionContext,
+        authorization: AnyAuthorization,
+        impersonation: OptionalImpersonation = None,
+        parameters: ReadMultipleParameter,
+        headers: OptionalStringToStringDict = None,
+    ) -> ReadMultipleDataResponse[FullBloodTypeSchema, StrictPagination, None]: ...
+    @overload
+    async def read(
+        self,
+        cardinality: Literal[Cardinality.SINGLE],
+        granularity: Literal[Granularity.STANDARD],
+        *,
+        operation_id: UUID,
+        resource_operation_action: ReadResourceOperationAction,
+        connection_context: ConnectionContext,
+        authorization: AnyAuthorization,
+        impersonation: OptionalImpersonation = None,
+        parameters: ReadSingleParameter,
+        headers: OptionalStringToStringDict = None,
+    ) -> ReadSingleDataResponse[StandardBloodTypeSchema, None]: ...
     @overload
     async def read(
         self,
         cardinality: Literal[Cardinality.SINGLE],
+        granularity: Literal[Granularity.FULL],
         *,
         operation_id: UUID,
-        request_context: RequestContext,
-        authentication: OptionalAuthentication,
+        resource_operation_action: ReadResourceOperationAction,
+        connection_context: ConnectionContext,
+        authorization: AnyAuthorization,
+        impersonation: OptionalImpersonation = None,
         parameters: ReadSingleParameter,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> ReadSingleResourceOperationResult[BloodTypeDataSchema, None]: ...
+        headers: OptionalStringToStringDict = None,
+    ) -> ReadSingleDataResponse[FullBloodTypeSchema, None]: ...
     async def read(
         self,
         cardinality: Cardinality,
+        granularity: Granularity,
         *,
         operation_id: UUID,
-        request_context: RequestContext,
-        authentication: OptionalAuthentication,
+        resource_operation_action: ReadResourceOperationAction,
+        connection_context: ConnectionContext,
+        authorization: OptionalAnyAuthorization = None,
+        impersonation: OptionalImpersonation = None,
         parameters: Union[ReadMultipleParameter, ReadSingleParameter],
-        headers: Optional[Dict[str, str]] = None,
+        headers: OptionalStringToStringDict = None,
     ) -> Union[
-        ReadMultipleResourceOperationResult[
-            BloodTypeDataSchema, FlexiblePagination, None
-        ],
-        ReadSingleResourceOperationResult[BloodTypeDataSchema, None],
+        ReadMultipleDataResponse[StandardBloodTypeSchema, StrictPagination, None],
+        ReadMultipleDataResponse[FullBloodTypeSchema, StrictPagination, None],
+        ReadSingleDataResponse[StandardBloodTypeSchema, None],
+        ReadSingleDataResponse[FullBloodTypeSchema, None],
     ]:
-        operation_action = ReadResourceOperationAction()
-        executed_at = datetime.now(tz=timezone.utc)
+        redis_client = self._redis.manager.client.get(Connection.ASYNC)
+        data_model_cls = get_schema_model(granularity)
 
-        # Get function identifier
-        func = self.__class__
-        module, qualname = func.__module__, func.__qualname__
+        executed_at = datetime.now(tz=timezone.utc)
 
         # Define arguments being used in this function
-        positional_arguments = [cardinality]
+        positional_arguments = [cardinality, granularity]
         keyword_arguments = {
-            "authentication": authentication.model_dump(
-                mode="json",
-                exclude={
-                    "credentials": {
-                        "token": {
-                            "payload": {
-                                "iat_dt",
-                                "iat",
-                                "exp_dt",
-                                "exp",
-                            }
-                        }
-                    }
-                },
+            "authorization": (
+                authorization.model_dump(mode="json")
+                if authorization is not None
+                else None
             ),
             "parameters": parameters.model_dump(mode="json"),
         }
 
         # Define full function string
-        function = f"{qualname}({json.dumps(positional_arguments)}|{json.dumps(keyword_arguments)})"
+        ext = f"({json.dumps(positional_arguments)}|{json.dumps(keyword_arguments)})"
 
-        # Define full cache key
-        cache_key = build_key(module, function, namespace=self._namespace)
+        # Define full cache_key
+        cache_key = build_cache_key(ext, namespace=self._namespace)
 
         if parameters.use_cache:
-            operation_context = deepcopy(self._default_operation_context)
-            operation_context.target.type = OperationTarget.CACHE
+            # Initialize cache operation context
+            operation_context = deepcopy(self._operation_context)
+            operation_context.target.type = Target.CACHE
 
-            # Check redis for data
-            result_str = await self._redis.get(cache_key)
+            redis_response_str = await redis_client.get(cache_key)
 
-            if result_str is not None:
-                completed_at = datetime.now(tz=timezone.utc)
-
-                if isinstance(parameters, ReadMultipleParameter):
-                    result = ReadMultipleResourceOperationResult[
-                        BloodTypeDataSchema, FlexiblePagination, None
-                    ].model_validate(json.loads(result_str))
-                    ReadMultipleResourceOperationSchema[
-                        OptionalAuthentication,
-                        BloodTypeDataSchema,
-                        FlexiblePagination,
-                        None,
+            if redis_response_str is not None:
+                operation_timestamp = Timestamp.completed_now(executed_at)
+                if cardinality is Cardinality.MULTIPLE:
+                    response = ReadMultipleDataResponse[
+                        data_model_cls, StrictPagination, None
+                    ].model_validate_json(redis_response_str)
+                    ReadMultipleResourceOperation[
+                        data_model_cls, StrictPagination, None
                     ](
-                        service_context=self._service_context,
+                        application_context=self._application_context,
                         id=operation_id,
                         context=operation_context,
-                        timestamp=OperationTimestamp(
-                            executed_at=executed_at,
-                            completed_at=completed_at,
-                            duration=(completed_at - executed_at).total_seconds(),
-                        ),
-                        summary="Successfully retrieved multiple blood types from cache",
-                        request_context=request_context,
-                        authentication=authentication,
-                        action=operation_action,
-                        resource=RESOURCE,
-                        result=result,
+                        action=resource_operation_action,
+                        resource=self.resource,
+                        timestamp=operation_timestamp,
+                        summary=f"Successfully retrieved {cardinality} {granularity} blood types from cache",
+                        connection_context=connection_context,
+                        authentication=None,
+                        authorization=authorization,
+                        impersonation=impersonation,
+                        response=response,
                     ).log(
-                        self._logger, LogLevel.INFO
+                        self._logger, Level.INFO
                     )
-                elif isinstance(parameters, ReadSingleParameter):
-                    result = ReadSingleResourceOperationResult[
-                        BloodTypeDataSchema, None
-                    ].model_validate(json.loads(result_str))
-                    ReadSingleResourceOperationSchema[
-                        OptionalAuthentication, BloodTypeDataSchema, None
-                    ](
-                        service_context=self._service_context,
+                elif cardinality is Cardinality.SINGLE:
+                    response = ReadSingleDataResponse[
+                        data_model_cls, None
+                    ].model_validate_json(redis_response_str)
+                    ReadSingleResourceOperation[data_model_cls, None](
+                        application_context=self._application_context,
                         id=operation_id,
                         context=operation_context,
-                        timestamp=OperationTimestamp(
-                            executed_at=executed_at,
-                            completed_at=completed_at,
-                            duration=(completed_at - executed_at).total_seconds(),
-                        ),
-                        summary="Successfully retrieved single blood type from cache",
-                        request_context=request_context,
-                        authentication=authentication,
-                        action=operation_action,
-                        resource=RESOURCE,
-                        result=result,
-                    ).log(
-                        self._logger, LogLevel.INFO
-                    )
-                return result
+                        action=resource_operation_action,
+                        resource=self.resource,
+                        timestamp=operation_timestamp,
+                        summary=f"Successfully retrieved {cardinality} {granularity} blood type from cache",
+                        connection_context=connection_context,
+                        authentication=None,
+                        authorization=authorization,
+                        impersonation=impersonation,
+                        response=response,
+                    ).log(self._logger, Level.INFO)
+
+                return response  # type: ignore
+
+        operation_context = deepcopy(self._operation_context)
+        operation_context.target.type = Target.MICROSERVICE
 
-        operation_context = deepcopy(self._default_operation_context)
         async with self._http_client_manager.get() as http_client:
-            # Create headers
             base_headers = {
-                "content-type": "application/json",
-                "x-operation-id": str(operation_id),
+                Header.CONTENT_TYPE.value: "application/json",
+                Header.X_OPERATION_ID.value: str(operation_id),
             }
+            if impersonation is not None:
+                base_headers[Header.X_USER_ID.value] = str(impersonation.user_id)
+                if impersonation.organization_id is not None:
+                    base_headers[Header.X_ORGANIZATION_ID.value] = str(
+                        impersonation.organization_id
+                    )
+
             if headers is not None:
                 headers = merge_dicts(base_headers, headers)
             else:
                 headers = base_headers
 
-            # Create auth
-            token = None
-            if authentication.credentials.token is not None:
-                try:
-                    token = reencode(
-                        payload=authentication.credentials.token.payload,
-                        key=self._private_key,
-                    )
-                except Exception:
-                    pass
-
-            auth = BearerAuth(token) if token is not None else None
+            if authorization is not None:
+                auth = AuthorizationFactory.httpx_auth(
+                    scheme=authorization.scheme, authorization=authorization.credentials
+                )
+            else:
+                auth = None
 
             if isinstance(parameters, ReadMultipleParameter):
-                # Define URL
-                url = f"{self._url}/v1/{RESOURCE.identifiers[0].url_slug}/"
-
-                # Parse parameters to query params
-                params = ReadMultipleQueryParameter.model_validate(
-                    parameters.model_dump()
-                ).model_dump(
-                    exclude={"sort_columns", "date_filters"}, exclude_none=True
+                url = f"{self._config.url}/v1/{self.resource.identifiers[0].slug}/"
+                parameters.date_filters
+                params = parameters.model_dump(
+                    mode="json",
+                    include={
+                        "ids",
+                        "uuids",
+                        "statuses",
+                        "keys",
+                        "names",
+                        "search",
+                        "page",
+                        "limit",
+                        "granularity",
+                        "use_cache",
+                    },
                 )
+                params["filters"] = convert_filter(parameters.date_filters)
+                params["sorts"] = convert_sort(parameters.sort_columns)
             elif isinstance(parameters, ReadSingleParameter):
-                # Define URL
-                url = f"{self._url}/v1/{RESOURCE.identifiers[0].url_slug}/{parameters.identifier}/{parameters.value}"
-
-                # Parse parameters to query params
-                params = ReadSingleQueryParameterSchema.model_validate(
-                    parameters.model_dump()
-                ).model_dump(exclude_none=True)
+                url = f"{self._config.url}/v1/{self.resource.identifiers[0].slug}/{parameters.identifier}/{parameters.value}"
+                params = parameters.model_dump(
+                    mode="json", include={"granularity", "use_cache"}
+                )
 
-            # Send request and wait for response
             response = await http_client.get(
-                url=url, params=params, headers=headers, auth=auth
+                url, params=params, headers=headers, auth=auth
             )
 
-            if response.is_success:
-                completed_at = datetime.now(tz=timezone.utc)
-
-                if isinstance(parameters, ReadMultipleParameter):
-                    validated_response = MultipleDataResponseSchema[
-                        BloodTypeDataSchema, FlexiblePagination, None
-                    ].model_validate(response.json())
-                    data = DataPair[List[BloodTypeDataSchema], None](
-                        old=validated_response.data,
-                        new=None,
-                    )
-                    result = ReadMultipleResourceOperationResult[
-                        BloodTypeDataSchema, FlexiblePagination, None
-                    ](
-                        data=data,
-                        pagination=validated_response.pagination,
-                        metadata=None,
-                        other=None,
-                    )
-                    ReadMultipleResourceOperationSchema[
-                        OptionalAuthentication,
-                        BloodTypeDataSchema,
-                        FlexiblePagination,
-                        None,
-                    ](
-                        service_context=self._service_context,
-                        id=operation_id,
-                        context=operation_context,
-                        timestamp=OperationTimestamp(
-                            executed_at=executed_at,
-                            completed_at=completed_at,
-                            duration=(completed_at - executed_at).total_seconds(),
-                        ),
-                        summary="Successfully retrieved multiple blood types from http request",
-                        request_context=request_context,
-                        authentication=authentication,
-                        action=operation_action,
-                        resource=RESOURCE,
-                        result=result,
-                    ).log(
-                        self._logger, level=LogLevel.INFO
-                    )
-                elif isinstance(parameters, ReadSingleParameter):
-                    validated_response = SingleDataResponseSchema[
-                        BloodTypeDataSchema, None
-                    ].model_validate(response.json())
-                    data = DataPair[BloodTypeDataSchema, None](
-                        old=validated_response.data,
-                        new=None,
-                    )
-                    result = ReadSingleResourceOperationResult[
-                        BloodTypeDataSchema, None
-                    ](
-                        data=data,
-                        pagination=validated_response.pagination,
-                        metadata=None,
-                        other=None,
-                    )
-                    ReadSingleResourceOperationSchema[
-                        OptionalAuthentication, BloodTypeDataSchema, None
-                    ](
-                        service_context=self._service_context,
-                        id=operation_id,
-                        context=operation_context,
-                        timestamp=OperationTimestamp(
-                            executed_at=executed_at,
-                            completed_at=completed_at,
-                            duration=(completed_at - executed_at).total_seconds(),
-                        ),
-                        summary="Successfully retrieved single blood type from http request",
-                        request_context=request_context,
-                        authentication=authentication,
-                        action=operation_action,
-                        resource=RESOURCE,
-                        result=result,
-                    ).log(
-                        self._logger, level=LogLevel.INFO
-                    )
+            operation_timestamp = Timestamp.completed_now(executed_at)
 
-                if parameters.use_cache:
-                    await self._redis.set(
-                        cache_key, result.model_dump_json(), Expiration.EXP_1MO.value
-                    )
+            if response.is_error:
+                raise MaleoExceptionFactory.from_httpx(
+                    response,
+                    operation_type=OperationType.REQUEST,
+                    application_context=self._application_context,
+                    operation_id=operation_id,
+                    operation_context=operation_context,
+                    operation_action=resource_operation_action,
+                    operation_timestamp=operation_timestamp,
+                    connection_context=connection_context,
+                    authentication=None,
+                    authorization=authorization,
+                    impersonation=impersonation,
+                    logger=self._logger,
+                )
 
-                return result
+            if isinstance(parameters, ReadMultipleParameter):
+                validated_response = MultipleDataResponse[
+                    data_model_cls, StrictPagination, None
+                ].model_validate(response.json())
+                service_response = ReadMultipleDataResponse[
+                    data_model_cls, StrictPagination, None
+                ].new(
+                    data=validated_response.data,
+                    pagination=validated_response.pagination,
+                )
+                ReadMultipleResourceOperation[data_model_cls, StrictPagination, None](
+                    application_context=self._application_context,
+                    id=operation_id,
+                    context=operation_context,
+                    action=resource_operation_action,
+                    resource=BLOOD_TYPE_RESOURCE,
+                    timestamp=operation_timestamp,
+                    summary=f"Successfully retrieved multiple {granularity} blood types from microservice",
+                    connection_context=connection_context,
+                    authentication=None,
+                    authorization=authorization,
+                    impersonation=impersonation,
+                    response=service_response,
+                ).log(self._logger, Level.INFO)
+            elif isinstance(parameters, ReadSingleParameter):
+                validated_response = SingleDataResponse[
+                    data_model_cls, None
+                ].model_validate(response.json())
+                service_response = ReadSingleDataResponse[data_model_cls, None].new(
+                    data=validated_response.data,
+                )
+                ReadSingleResourceOperation[data_model_cls, None](
+                    application_context=self._application_context,
+                    id=operation_id,
+                    context=operation_context,
+                    action=resource_operation_action,
+                    resource=BLOOD_TYPE_RESOURCE,
+                    timestamp=operation_timestamp,
+                    summary=f"Successfully retrieved single {granularity} blood type from microservice",
+                    connection_context=connection_context,
+                    authentication=None,
+                    authorization=authorization,
+                    impersonation=impersonation,
+                    response=service_response,
+                ).log(self._logger, Level.INFO)
 
-            self._raise_resource_http_request_error(
-                response=response,
-                operation_id=operation_id,
-                operation_context=operation_context,
-                executed_at=executed_at,
-                operation_action=operation_action,
-                request_context=request_context,
-                authentication=authentication,
-                resource=RESOURCE,
-            )
+            return service_response  # type: ignore