maleo-identity 0.0.85__py3-none-any.whl → 0.1.24__py3-none-any.whl

maleo/identity/schemas/common.py

@@ -0,0 +1,335 @@
+from datetime import date
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, TypeVar, Type
+from maleo.enums.identity import OptRhesus, RhesusMixin
+from maleo.enums.status import DataStatus as DataStatusEnum, SimpleDataStatusMixin
+from maleo.metadata.schemas.blood_type import (
+    OptKeyOrStandardSchema as BloodTypeOptKeyOrStandardSchema,
+    FullBloodTypeMixin,
+)
+from maleo.metadata.schemas.gender import (
+    OptKeyOrStandardSchema as GenderOptKeyOrStandardSchema,
+    KeyOrStandardSchema as GenderKeyOrStandardSchema,
+    FullGenderMixin,
+)
+from maleo.metadata.schemas.medical_role import (
+    KeyOrStandardSchema as MedicalRoleKeyOrStandardSchema,
+    FullMedicalRoleMixin,
+)
+from maleo.metadata.schemas.organization_role import (
+    KeyOrStandardSchema as OrganizationRoleKeyOrStandardSchema,
+    FullOrganizationRoleMixin,
+)
+from maleo.metadata.schemas.organization_type import (
+    KeyOrStandardSchema as OrganizationTypeKeyOrStandardSchema,
+    FullOrganizationTypeMixin,
+)
+from maleo.metadata.schemas.system_role import (
+    KeyOrStandardSchema as SystemRoleKeyOrStandardSchema,
+    FullSystemRoleMixin,
+)
+from maleo.metadata.schemas.user_type import (
+    KeyOrStandardSchema as UserTypeKeyOrStandardSchema,
+    FullUserTypeMixin,
+)
+from maleo.schemas.mixins.identity import (
+    DataIdentifier,
+    IntOrganizationId,
+    IntUserId,
+    BirthDate,
+    DateOfBirth,
+)
+from maleo.schemas.mixins.timestamp import LifecycleTimestamp
+from maleo.types.datetime import OptDate
+from maleo.types.integer import OptInt
+from maleo.types.string import OptStr
+from ..mixins.common import IdCard, FullName, BirthPlace, PlaceOfBirth
+from ..mixins.api_key import APIKey
+from ..mixins.organization_registration_code import Code, CurrentUses
+from ..mixins.organization_relation import IsBidirectional, Meta
+from ..mixins.organization import Key as OrganizationKey, Name as OrganizationName
+from ..mixins.patient import PatientIdentity
+from ..mixins.user_profile import (
+    LeadingTitle,
+    FirstName,
+    MiddleName,
+    LastName,
+    EndingTitle,
+    AvatarName,
+    AvatarUrl,
+)
+from ..mixins.user import Username, Email, Phone
+
+
+class APIKeySchema(
+    APIKey,
+    IntOrganizationId[OptInt],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class PatientSchema(
+    RhesusMixin[OptRhesus],
+    FullBloodTypeMixin[BloodTypeOptKeyOrStandardSchema],
+    FullGenderMixin[GenderKeyOrStandardSchema],
+    DateOfBirth[date],
+    PlaceOfBirth[OptStr],
+    FullName[str],
+    PatientIdentity,
+    IntOrganizationId[int],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class OrganizationRegistrationCodeSchema(
+    CurrentUses,
+    Code[str],
+    IntOrganizationId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+OptOrganizationRegistrationCodeSchema = OrganizationRegistrationCodeSchema | None
+
+
+class OrganizationRegistrationCodeSchemaMixin(BaseModel):
+    registration_code: Annotated[
+        OptOrganizationRegistrationCodeSchema,
+        Field(None, description="Organization's registration code"),
+    ] = None
+
+
+class StandardOrganizationSchema(
+    OrganizationName[str],
+    OrganizationKey[str],
+    FullOrganizationTypeMixin[OrganizationTypeKeyOrStandardSchema],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class SourceOrganizationSchemaMixin(BaseModel):
+    source: Annotated[
+        StandardOrganizationSchema, Field(..., description="Source organization")
+    ]
+
+
+class SourceOrganizationRelationSchema(
+    Meta,
+    IsBidirectional[bool],
+    SourceOrganizationSchemaMixin,
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class SourceOrganizationRelationsSchemaMixin(BaseModel):
+    sources: Annotated[
+        list[SourceOrganizationRelationSchema],
+        Field(list[SourceOrganizationRelationSchema](), description="Sources"),
+    ] = list[SourceOrganizationRelationSchema]()
+
+
+class TargetOrganizationSchemaMixin(BaseModel):
+    target: Annotated[
+        StandardOrganizationSchema, Field(..., description="Target organization")
+    ]
+
+
+class TargetOrganizationRelationSchema(
+    Meta,
+    IsBidirectional[bool],
+    TargetOrganizationSchemaMixin,
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class TargetOrganizationRelationsSchemaMixin(BaseModel):
+    targets: Annotated[
+        list[TargetOrganizationRelationSchema],
+        Field(list[TargetOrganizationRelationSchema](), description="Targets"),
+    ] = list[TargetOrganizationRelationSchema]()
+
+
+class FullOrganizationSchema(
+    TargetOrganizationRelationsSchemaMixin,
+    SourceOrganizationRelationsSchemaMixin,
+    OrganizationRegistrationCodeSchemaMixin,
+    StandardOrganizationSchema,
+):
+    pass
+
+
+AnyOrganizationSchemaType = (
+    Type[StandardOrganizationSchema] | Type[FullOrganizationSchema]
+)
+AnyOrganizationSchema = StandardOrganizationSchema | FullOrganizationSchema
+AnyOrganizationSchemaT = TypeVar("AnyOrganizationSchemaT", bound=AnyOrganizationSchema)
+
+
+class OrganizationSchemaMixin(BaseModel, Generic[AnyOrganizationSchemaT]):
+    organization: Annotated[
+        AnyOrganizationSchemaT, Field(..., description="Organization")
+    ]
+
+
+class UserMedicalRoleSchema(
+    FullMedicalRoleMixin[MedicalRoleKeyOrStandardSchema],
+    IntOrganizationId[int],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserMedicalRolesSchemaMixin(BaseModel):
+    medical_roles: Annotated[
+        list[UserMedicalRoleSchema],
+        Field(list[UserMedicalRoleSchema](), description="Medical roles"),
+    ] = list[UserMedicalRoleSchema]()
+
+
+class UserOrganizationRoleSchema(
+    FullOrganizationRoleMixin[OrganizationRoleKeyOrStandardSchema],
+    IntOrganizationId[int],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationRolesSchemaMixin(BaseModel):
+    organization_roles: Annotated[
+        list[UserOrganizationRoleSchema],
+        Field(list[UserOrganizationRoleSchema](), description="Organization roles"),
+    ] = list[UserOrganizationRoleSchema]()
+
+
+class UserProfileSchema(
+    AvatarUrl[OptStr],
+    AvatarName[str],
+    FullBloodTypeMixin[BloodTypeOptKeyOrStandardSchema],
+    FullGenderMixin[GenderOptKeyOrStandardSchema],
+    BirthDate[OptDate],
+    BirthPlace[OptStr],
+    FullName[str],
+    EndingTitle[OptStr],
+    LastName[str],
+    MiddleName[OptStr],
+    FirstName[str],
+    LeadingTitle[OptStr],
+    IdCard[OptStr],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+OptUserProfileSchema = UserProfileSchema | None
+
+
+class UserProfileSchemaMixin(BaseModel):
+    profile: Annotated[
+        OptUserProfileSchema, Field(None, description="User's Profile")
+    ] = None
+
+
+class UserSystemRoleSchema(
+    FullSystemRoleMixin[SystemRoleKeyOrStandardSchema],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserSystemRolesSchemaMixin(BaseModel):
+    system_roles: Annotated[
+        list[UserSystemRoleSchema],
+        Field(
+            list[UserSystemRoleSchema](),
+            description="User's system roles",
+            min_length=1,
+        ),
+    ] = list[UserSystemRoleSchema]()
+
+
+class StandardUserSchema(
+    UserProfileSchemaMixin,
+    Phone[str],
+    Email[str],
+    Username[str],
+    FullUserTypeMixin[UserTypeKeyOrStandardSchema],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationSchema(
+    UserMedicalRolesSchemaMixin,
+    UserOrganizationRolesSchemaMixin,
+    OrganizationSchemaMixin[StandardOrganizationSchema],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationsSchemaMixin(BaseModel):
+    organizations: Annotated[
+        list[UserOrganizationSchema],
+        Field(list[UserOrganizationSchema](), description="Organizations"),
+    ] = list[UserOrganizationSchema]()
+
+
+class FullUserSchema(UserSystemRolesSchemaMixin, StandardUserSchema):
+    pass
+
+
+AnyUserSchemaType = Type[StandardUserSchema] | Type[FullUserSchema]
+AnyUserSchema = StandardUserSchema | FullUserSchema
+AnyUserSchemaT = TypeVar("AnyUserSchemaT", bound=AnyUserSchema)
+
+
+class UserSchemaMixin(BaseModel, Generic[AnyUserSchemaT]):
+    user: Annotated[AnyUserSchemaT, Field(..., description="User")]
+
+
+class UserAndOrganizationSchema(
+    UserMedicalRolesSchemaMixin,
+    UserOrganizationRolesSchemaMixin,
+    OrganizationSchemaMixin[StandardOrganizationSchema],
+    UserSchemaMixin[StandardUserSchema],
+    SimpleDataStatusMixin[DataStatusEnum],
+    LifecycleTimestamp,
+    DataIdentifier,
+):
+    pass

maleo/identity/schemas/organization.py

@@ -0,0 +1,311 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic, Literal, TypeVar, overload
+from uuid import UUID
+from maleo.enums.organization import (
+    OptOrganizationRelation,
+    OrganizationType,
+    OptOrganizationType,
+    FullOrganizationTypeMixin,
+    OptListOfOrganizationTypes,
+    FullOrganizationTypesMixin,
+)
+from maleo.enums.status import (
+    ListOfDataStatuses,
+    FULL_DATA_STATUSES,
+)
+from maleo.schemas.mixins.filter import convert as convert_filter
+from maleo.schemas.mixins.identity import (
+    IdentifierMixin,
+    Ids,
+    UUIDs,
+    Keys,
+    Names,
+)
+from maleo.schemas.mixins.sort import convert as convert_sort
+from maleo.schemas.operation.enums import ResourceOperationStatusUpdateType
+from maleo.schemas.parameter import (
+    ReadSingleParameter as BaseReadSingleParameter,
+    ReadPaginatedMultipleParameter,
+    StatusUpdateParameter as BaseStatusUpdateParameter,
+    DeleteSingleParameter as BaseDeleteSingleParameter,
+)
+from maleo.types.dict import StrToAnyDict
+from maleo.types.integer import OptInt, OptListOfInts
+from maleo.types.string import OptStr, OptListOfStrs
+from maleo.types.uuid import OptListOfUUIDs
+from ..enums.organization import IdentifierType
+from ..mixins.organization import Key, Name, OrganizationIdentifier
+from ..types.organization import IdentifierValueType
+
+
+class InsertData(Name[str], Key[str], FullOrganizationTypeMixin[OrganizationType]):
+    pass
+
+
+class CreateParameter(InsertData):
+    related_to: Annotated[OptInt, Field(None, description="Related to", ge=1)] = None
+    relation: Annotated[
+        OptOrganizationRelation, Field(None, description="Relation")
+    ] = None
+
+
+class ReadMultipleParameter(
+    ReadPaginatedMultipleParameter,
+    Names[OptListOfStrs],
+    Keys[OptListOfStrs],
+    FullOrganizationTypesMixin[OptListOfOrganizationTypes],
+    UUIDs[OptListOfUUIDs],
+    Ids[OptListOfInts],
+):
+    ids: Annotated[OptListOfInts, Field(None, description="Ids")] = None
+    uuids: Annotated[OptListOfUUIDs, Field(None, description="UUIDs")] = None
+    organization_types: Annotated[
+        OptListOfOrganizationTypes, Field(None, description="Organization Types")
+    ] = None
+    keys: Annotated[OptListOfStrs, Field(None, description="Keys")] = None
+    names: Annotated[OptListOfStrs, Field(None, description="Names")] = None
+
+    @property
+    def _query_param_fields(self) -> set[str]:
+        return {
+            "ids",
+            "uuids",
+            "statuses",
+            "organization_types",
+            "keys",
+            "names",
+            "search",
+            "page",
+            "limit",
+            "use_cache",
+        }
+
+    def to_query_params(self) -> StrToAnyDict:
+        params = self.model_dump(
+            mode="json", include=self._query_param_fields, exclude_none=True
+        )
+        params["filters"] = convert_filter(self.date_filters)
+        params["sorts"] = convert_sort(self.sort_columns)
+        params = {k: v for k, v in params.items()}
+        return params
+
+
+class ReadSingleParameter(BaseReadSingleParameter[OrganizationIdentifier]):
+    @classmethod
+    def from_identifier(
+        cls,
+        identifier: OrganizationIdentifier,
+        statuses: ListOfDataStatuses = FULL_DATA_STATUSES,
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter":
+        return cls(identifier=identifier, statuses=statuses, use_cache=use_cache)
+
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.ID],
+        identifier_value: int,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.UUID],
+        identifier_value: UUID,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.KEY],
+        identifier_value: str,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter": ...
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
+        use_cache: bool = True,
+    ) -> "ReadSingleParameter":
+        return cls(
+            identifier=OrganizationIdentifier(
+                type=identifier_type, value=identifier_value
+            ),
+            statuses=statuses,
+            use_cache=use_cache,
+        )
+
+    def to_query_params(self) -> StrToAnyDict:
+        return self.model_dump(
+            mode="json", include={"statuses", "use_cache"}, exclude_none=True
+        )
+
+
+class FullUpdateData(Name[str], Key[str], FullOrganizationTypeMixin[OrganizationType]):
+    pass
+
+
+class PartialUpdateData(
+    Name[OptStr], Key[OptStr], FullOrganizationTypeMixin[OptOrganizationType]
+):
+    pass
+
+
+UpdateDataT = TypeVar("UpdateDataT", FullUpdateData, PartialUpdateData)
+
+
+class UpdateDataMixin(BaseModel, Generic[UpdateDataT]):
+    data: UpdateDataT = Field(..., description="Update data")
+
+
+class UpdateParameter(
+    UpdateDataMixin[UpdateDataT],
+    IdentifierMixin[OrganizationIdentifier],
+    Generic[UpdateDataT],
+):
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.ID],
+        identifier_value: int,
+        data: UpdateDataT,
+    ) -> "UpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.UUID],
+        identifier_value: UUID,
+        data: UpdateDataT,
+    ) -> "UpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.KEY],
+        identifier_value: str,
+        data: UpdateDataT,
+    ) -> "UpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        data: UpdateDataT,
+    ) -> "UpdateParameter": ...
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        data: UpdateDataT,
+    ) -> "UpdateParameter":
+        return cls(
+            identifier=OrganizationIdentifier(
+                type=identifier_type, value=identifier_value
+            ),
+            data=data,
+        )
+
+
+class StatusUpdateParameter(
+    BaseStatusUpdateParameter[OrganizationIdentifier],
+):
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.ID],
+        identifier_value: int,
+        type: ResourceOperationStatusUpdateType,
+    ) -> "StatusUpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.UUID],
+        identifier_value: UUID,
+        type: ResourceOperationStatusUpdateType,
+    ) -> "StatusUpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.KEY],
+        identifier_value: str,
+        type: ResourceOperationStatusUpdateType,
+    ) -> "StatusUpdateParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        type: ResourceOperationStatusUpdateType,
+    ) -> "StatusUpdateParameter": ...
+    @classmethod
+    def new(
+        cls,
+        identifier_type: IdentifierType,
+        identifier_value: IdentifierValueType,
+        type: ResourceOperationStatusUpdateType,
+    ) -> "StatusUpdateParameter":
+        return cls(
+            identifier=OrganizationIdentifier(
+                type=identifier_type, value=identifier_value
+            ),
+            type=type,
+        )
+
+
+class DeleteSingleParameter(BaseDeleteSingleParameter[OrganizationIdentifier]):
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: Literal[IdentifierType.ID], identifier_value: int
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: Literal[IdentifierType.UUID], identifier_value: UUID
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls,
+        identifier_type: Literal[IdentifierType.KEY],
+        identifier_value: str,
+    ) -> "DeleteSingleParameter": ...
+    @overload
+    @classmethod
+    def new(
+        cls, identifier_type: IdentifierType, identifier_value: IdentifierValueType
+    ) -> "DeleteSingleParameter": ...
+    @classmethod
+    def new(
+        cls, identifier_type: IdentifierType, identifier_value: IdentifierValueType
+    ) -> "DeleteSingleParameter":
+        return cls(
+            identifier=OrganizationIdentifier(
+                type=identifier_type, value=identifier_value
+            )
+        )