maleo-identity 0.0.97__py3-none-any.whl → 0.0.100__py3-none-any.whl

maleo/identity/constants/api_key.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+API_KEY_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="api_keys",
+            name="API Keys",
+            slug="api-keys",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/organization.py

@@ -1,18 +1,4 @@
-from typing import Callable, Dict
-from uuid import UUID
 from maleo.schemas.resource import Resource, ResourceIdentifier
-from ..enums.organization import IdentifierType
-from ..types.organization import IdentifierValueType
-
-
-IDENTIFIER_VALUE_TYPE_MAP: Dict[
-    IdentifierType,
-    Callable[..., IdentifierValueType],
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.KEY: str,
-}
 
 
 ORGANIZATION_RESOURCE = Resource(

maleo/identity/constants/organization_registration_code.py

@@ -1,19 +1,4 @@
-from typing import Callable, Dict
-from uuid import UUID
 from maleo.schemas.resource import Resource, ResourceIdentifier
-from ..enums.organization_registration_code import IdentifierType
-from ..types.organization_registration_code import IdentifierValueType
-
-
-IDENTIFIER_VALUE_TYPE_MAP: Dict[
-    IdentifierType,
-    Callable[..., IdentifierValueType],
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.ORGANIZATION_ID: int,
-    IdentifierType.CODE: UUID,
-}
 
 
 ORGANIZATION_REGISTRATION_CODE_RESOURCE = Resource(

maleo/identity/constants/organization_relation.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+ORGANIZATION_RELATION_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="organization_relations",
+            name="Organization Relations",
+            slug="organization-relations",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/patient.py

@@ -0,0 +1,7 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+PATIENT_RESOURCE = Resource(
+    identifiers=[ResourceIdentifier(key="patients", name="Patients", slug="patients")],
+    details=None,
+)

maleo/identity/constants/user.py

@@ -1,19 +1,4 @@
-from typing import Callable, Dict
-from uuid import UUID
 from maleo.schemas.resource import Resource, ResourceIdentifier
-from ..enums.user import IdentifierType
-from ..types.user import IdentifierValueType
-
-
-IDENTIFIER_VALUE_TYPE_MAP: Dict[
-    IdentifierType,
-    Callable[..., IdentifierValueType],
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.EMAIL: str,
-    IdentifierType.USERNAME: str,
-}
 
 
 USER_RESOURCE = Resource(

maleo/identity/constants/user_medical_role.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+USER_MEDICAL_ROLE_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="user_medical_roles",
+            name="User Medical Roles",
+            slug="user-medical-roles",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/user_organization_role.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+USER_ORGANIZATION_ROLE_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="user_organization_roles",
+            name="User Organization Roles",
+            slug="user-organization-roles",
+        )
+    ],
+    details=None,
+)

maleo/identity/constants/user_profile.py

@@ -1,19 +1,4 @@
-from typing import Callable, Dict
-from uuid import UUID
 from maleo.schemas.resource import Resource, ResourceIdentifier
-from ..enums.user_profile import IdentifierType
-from ..types.user_profile import IdentifierValueType
-
-
-IDENTIFIER_VALUE_TYPE_MAP: Dict[
-    IdentifierType,
-    Callable[..., IdentifierValueType],
-] = {
-    IdentifierType.ID: int,
-    IdentifierType.UUID: UUID,
-    IdentifierType.USER_ID: int,
-    IdentifierType.ID_CARD: str,
-}
 
 
 USER_PROFILE_RESOURCE = Resource(

maleo/identity/constants/user_system_role.py

@@ -0,0 +1,13 @@
+from maleo.schemas.resource import Resource, ResourceIdentifier
+
+
+USER_SYSTEM_ROLE_RESOURCE = Resource(
+    identifiers=[
+        ResourceIdentifier(
+            key="user_system_roles",
+            name="User System Roles",
+            slug="user-system-roles",
+        )
+    ],
+    details=None,
+)

maleo/identity/dtos.py

@@ -0,0 +1,295 @@
+from datetime import date
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Generic, Self, TypeVar, Type
+from maleo.enums.identity import (
+    OptBloodType,
+    BloodTypeMixin,
+    OptRhesus,
+    RhesusMixin,
+    Gender,
+    OptGender,
+    GenderMixin,
+)
+from maleo.enums.medical import MedicalRole, FullMedicalRoleMixin
+from maleo.enums.organization import (
+    OrganizationRole,
+    FullOrganizationRoleMixin,
+    OrganizationType,
+    FullOrganizationTypeMixin,
+)
+from maleo.enums.status import DataStatus as DataStatusEnum, SimpleDataStatusMixin
+from maleo.enums.system import SystemRole, FullSystemRoleMixin
+from maleo.enums.user import UserType, FullUserTypeMixin
+from maleo.schemas.mixins.identity import (
+    DataIdentifier,
+    IntOrganizationId,
+    IntUserId,
+    BirthDate,
+    DateOfBirth,
+    IntSourceId,
+    IntTargetId,
+)
+from maleo.schemas.mixins.timestamp import DataTimestamp
+from maleo.types.datetime import OptDate
+from maleo.types.string import OptStr
+from .mixins.common import IdCard, FullName, BirthPlace, PlaceOfBirth
+from .mixins.organization_registration_code import Code, MaxUses, CurrentUses
+from .mixins.organization_relation import IsBidirectional, Metadata
+from .mixins.organization import Key as OrganizationKey, Name as OrganizationName
+from .mixins.patient import Passport
+from .mixins.user_profile import (
+    LeadingTitle,
+    FirstName,
+    MiddleName,
+    LastName,
+    EndingTitle,
+    AvatarName,
+)
+from .mixins.user import Username, Email, Phone
+from .validators.patient import validate_id_card_or_passport
+
+
+class PatientDTO(
+    RhesusMixin[OptRhesus],
+    BloodTypeMixin[OptBloodType],
+    GenderMixin[Gender],
+    DateOfBirth[date],
+    PlaceOfBirth[OptStr],
+    FullName[str],
+    Passport[OptStr],
+    IdCard[OptStr],
+    IntOrganizationId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    @model_validator(mode="after")
+    def chk_id_card_or_passport(self) -> Self:
+        validate_id_card_or_passport(self.id_card, self.passport)
+        return self
+
+
+class OrganizationRegistrationCodeDTO(
+    CurrentUses,
+    MaxUses[int],
+    Code[str],
+    IntOrganizationId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+OptOrganizationRegistrationCodeDTO = OrganizationRegistrationCodeDTO | None
+
+
+class OrganizationRegistrationCodeDTOMixin(BaseModel):
+    registration_code: Annotated[
+        OptOrganizationRegistrationCodeDTO,
+        Field(None, description="Organization's registration code"),
+    ] = None
+
+
+class StandardOrganizationDTO(
+    OrganizationName[str],
+    OrganizationKey[str],
+    FullOrganizationTypeMixin[OrganizationType],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class SourceOrganizationDTOMixin(BaseModel):
+    source: Annotated[
+        StandardOrganizationDTO, Field(..., description="Source organization")
+    ]
+
+
+class TargetOrganizationDTOMixin(BaseModel):
+    target: Annotated[
+        StandardOrganizationDTO, Field(..., description="Target organization")
+    ]
+
+
+class OrganizationRelationDTO(
+    Metadata,
+    IsBidirectional[bool],
+    TargetOrganizationDTOMixin,
+    IntTargetId[int],
+    SourceOrganizationDTOMixin,
+    IntSourceId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class OrganizationRelationsDTOMixin(BaseModel):
+    relations: Annotated[
+        list[OrganizationRelationDTO],
+        Field(list[OrganizationRelationDTO](), description="Relations"),
+    ] = list[OrganizationRelationDTO]()
+
+
+class FullOrganizationDTO(
+    OrganizationRelationsDTOMixin,
+    OrganizationRegistrationCodeDTOMixin,
+    StandardOrganizationDTO,
+):
+    pass
+
+
+AnyOrganizationDTOType = Type[StandardOrganizationDTO] | Type[FullOrganizationDTO]
+AnyOrganizationDTO = StandardOrganizationDTO | FullOrganizationDTO
+AnyOrganizationDTOT = TypeVar("AnyOrganizationDTOT", bound=AnyOrganizationDTO)
+
+
+class OrganizationDTOMixin(BaseModel, Generic[AnyOrganizationDTOT]):
+    organization: Annotated[AnyOrganizationDTOT, Field(..., description="Organization")]
+
+
+class UserMedicalRoleDTO(
+    FullMedicalRoleMixin[MedicalRole],
+    IntOrganizationId[int],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserMedicalRolesDTOMixin(BaseModel):
+    medical_roles: Annotated[
+        list[UserMedicalRoleDTO],
+        Field(list[UserMedicalRoleDTO](), description="Medical roles"),
+    ] = list[UserMedicalRoleDTO]()
+
+
+class UserOrganizationRoleDTO(
+    FullOrganizationRoleMixin[OrganizationRole],
+    IntOrganizationId[int],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationRolesDTOMixin(BaseModel):
+    organization_roles: Annotated[
+        list[UserOrganizationRoleDTO],
+        Field(list[UserOrganizationRoleDTO](), description="Organization roles"),
+    ] = list[UserOrganizationRoleDTO]()
+
+
+class UserProfileDTO(
+    AvatarName[str],
+    BloodTypeMixin[OptBloodType],
+    GenderMixin[OptGender],
+    BirthDate[OptDate],
+    BirthPlace[OptStr],
+    FullName[str],
+    EndingTitle[OptStr],
+    LastName[str],
+    MiddleName[OptStr],
+    FirstName[str],
+    LeadingTitle[OptStr],
+    IdCard[OptStr],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+OptUserProfileDTO = UserProfileDTO | None
+
+
+class UserProfileDTOMixin(BaseModel):
+    profile: Annotated[OptUserProfileDTO, Field(None, description="User's Profile")] = (
+        None
+    )
+
+
+class UserSystemRoleDTO(
+    FullSystemRoleMixin[SystemRole],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserSystemRolesDTOMixin(BaseModel):
+    system_roles: Annotated[
+        list[UserSystemRoleDTO],
+        Field(
+            list[UserSystemRoleDTO](),
+            description="User's system roles",
+            min_length=1,
+        ),
+    ] = list[UserSystemRoleDTO]()
+
+
+class StandardUserDTO(
+    UserProfileDTOMixin,
+    Phone[str],
+    Email[str],
+    Username[str],
+    FullUserTypeMixin[UserType],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationDTO(
+    UserMedicalRolesDTOMixin,
+    UserOrganizationRolesDTOMixin,
+    OrganizationDTOMixin[StandardOrganizationDTO],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class UserOrganizationsDTOMixin(BaseModel):
+    organizations: Annotated[
+        list[UserOrganizationDTO],
+        Field(list[UserOrganizationDTO](), description="Organizations"),
+    ] = list[UserOrganizationDTO]()
+
+
+class FullUserDTO(UserOrganizationsDTOMixin, StandardUserDTO):
+    pass
+
+
+AnyUserDTOType = Type[StandardUserDTO] | Type[FullUserDTO]
+AnyUserDTO = StandardUserDTO | FullUserDTO
+AnyUserDTOT = TypeVar("AnyUserDTOT", bound=AnyUserDTO)
+
+
+class UserDTOMixin(BaseModel, Generic[AnyUserDTOT]):
+    user: Annotated[AnyUserDTOT, Field(..., description="User")]
+
+
+class UserAndOrganizationDTO(
+    UserMedicalRolesDTOMixin,
+    UserOrganizationRolesDTOMixin,
+    OrganizationDTOMixin[StandardOrganizationDTO],
+    UserDTOMixin[StandardUserDTO],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass

maleo/identity/enums/api_key.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    API_KEY = "api_key"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

maleo/identity/enums/organization.py

@@ -21,10 +21,9 @@ class IdentifierType(StrEnum):
         return [e.value for e in cls]
 
 
-class SchemaType(StrEnum):
-    CORE = "core"
-    COMPLETE = "complete"
+class ExpandableField(StrEnum):
+    ORGANIZATION_TYPE = "organization_type"
 
-    @classmethod
-    def choices(cls) -> ListOfStrs:
-        return [e.value for e in cls]
+
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/enums/organization_relation.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

maleo/identity/enums/patient.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    ID_CARD = "id_card"
+    PASSPORT = "passport"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]
+
+
+class ExpandableField(StrEnum):
+    GENDER = "gender"
+    BLOOD_TYPE = "blood_type"
+
+
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/enums/user.py

@@ -22,10 +22,14 @@ class IdentifierType(StrEnum):
         return [e.value for e in cls]
 
 
-class SchemaType(StrEnum):
-    CORE = "core"
-    COMPLETE = "complete"
+class ExpandableField(StrEnum):
+    USER_TYPE = "user_type"
+    GENDER = "gender"
+    BLOOD_TYPE = "blood_type"
+    SYSTEM_ROLE = "system_role"
+    MEDICAL_ROLE = "medical_role"
+    ORGANIZATION_ROLE = "organization_role"
 
-    @classmethod
-    def choices(cls) -> ListOfStrs:
-        return [e.value for e in cls]
+
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/enums/user_medical_role.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

maleo/identity/enums/user_organization_role.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

maleo/identity/enums/user_profile.py

@@ -11,3 +11,12 @@ class IdentifierType(StrEnum):
     @classmethod
     def choices(cls) -> ListOfStrs:
         return [e.value for e in cls]
+
+
+class ExpandableField(StrEnum):
+    GENDER = "gender"
+    BLOOD_TYPE = "blood_type"
+
+
+ListOfExpandableFields = list[ExpandableField]
+OptListOfExpandableFields = ListOfExpandableFields | None

maleo/identity/enums/user_system_role.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+from maleo.types.string import ListOfStrs
+
+
+class IdentifierType(StrEnum):
+    ID = "id"
+    UUID = "uuid"
+    COMPOSITE = "composite"
+
+    @classmethod
+    def choices(cls) -> ListOfStrs:
+        return [e.value for e in cls]

maleo/identity/mixins/api_key.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+from typing import Annotated
+
+
+class APIKey(BaseModel):
+    api_key: Annotated[str, Field(..., description="API Key", max_length=255)]

maleo/identity/mixins/common.py

@@ -0,0 +1,29 @@
+from pydantic import Field
+from typing import Annotated, Generic
+from maleo.schemas.mixins.identity import (
+    IdCard as BaseIdCard,
+    FullName as BaseFullName,
+    BirthPlace as BaseBirthPlace,
+    PlaceOfBirth as BasePlaceOfBirth,
+)
+from maleo.types.string import OptStrT
+
+
+class IdCard(BaseIdCard[OptStrT], Generic[OptStrT]):
+    id_card: Annotated[OptStrT, Field(..., description="Id Card", max_length=16)]
+
+
+class FullName(BaseFullName[OptStrT], Generic[OptStrT]):
+    full_name: Annotated[OptStrT, Field(..., description="Full Name", max_length=200)]
+
+
+class BirthPlace(BaseBirthPlace[OptStrT], Generic[OptStrT]):
+    birth_place: Annotated[
+        OptStrT, Field(..., description="Birth Place", max_length=50)
+    ]
+
+
+class PlaceOfBirth(BasePlaceOfBirth[OptStrT], Generic[OptStrT]):
+    place_of_birth: Annotated[
+        OptStrT, Field(..., description="Place of Birth", max_length=50)
+    ]

maleo/identity/mixins/organization_relation.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+from typing import Annotated, Generic
+from maleo.types.boolean import OptBoolT
+from maleo.types.misc import OptListOfAnyOrStrToAnyDict
+
+
+class IsBidirectional(BaseModel, Generic[OptBoolT]):
+    is_bidirectional: Annotated[OptBoolT, Field(..., description="Is Bidirectional")]
+
+
+class Metadata(BaseModel):
+    metadata: Annotated[
+        OptListOfAnyOrStrToAnyDict, Field(None, description="Metadata")
+    ] = None

maleo/identity/mixins/patient.py

@@ -0,0 +1,8 @@
+from pydantic import Field
+from typing import Annotated, Generic
+from maleo.schemas.mixins.identity import Passport as BasePassport
+from maleo.types.string import OptStrT
+
+
+class Passport(BasePassport, Generic[OptStrT]):
+    passport: Annotated[OptStrT, Field(..., description="Passport", max_length=9)]