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

maleo/identity/schemas/common.py

@@ -1,35 +1,97 @@
-from pydantic import BaseModel, Field
-from typing import Annotated, Generic, TypeVar, Type
-from maleo.enums.identity import OptBloodType, BloodTypeMixin, OptGender, GenderMixin
-from maleo.enums.medical import MedicalRole, FullMedicalRoleMixin
-from maleo.enums.organization import (
-    OrganizationRole,
+from datetime import date
+from pydantic import BaseModel, Field, model_validator
+from typing import Annotated, Generic, Self, TypeVar, Type
+from maleo.enums.identity import OptRhesus, RhesusMixin
+from maleo.metadata.schemas.organization_role import (
     FullOrganizationRoleMixin,
-    OrganizationType,
-    FullOrganizationTypeMixin,
+    KeyOrStandardSchema as KeyOrStandardOrganizationRoleSchema,
 )
 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
+from maleo.metadata.schemas.blood_type import (
+    FullBloodTypeMixin,
+    OptKeyOrStandardSchema as OptKeyOrStandardBloodTypeSchema,
+)
+from maleo.metadata.schemas.gender import (
+    FullGenderMixin,
+    KeyOrStandardSchema as KeyOrStandardGenderSchema,
+    OptKeyOrStandardSchema as OptKeyOrStandardGenderSchema,
+)
+from maleo.metadata.schemas.medical_role import (
+    FullMedicalRoleMixin,
+    KeyOrStandardSchema as KeyOrStandardMedicalRoleSchema,
+)
+from maleo.metadata.schemas.organization_type import (
+    FullOrganizationTypeMixin,
+    KeyOrStandardSchema as KeyOrStandardOrganizationTypeSchema,
+)
+from maleo.metadata.schemas.system_role import (
+    FullSystemRoleMixin,
+    KeyOrStandardSchema as KeyOrStandardSystemRoleSchema,
+)
+from maleo.metadata.schemas.user_type import (
+    FullUserTypeMixin,
+    KeyOrStandardSchema as KeyOrStandardUserTypeSchema,
+)
+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.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, 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 (
-    IdCard,
     LeadingTitle,
     FirstName,
     MiddleName,
     LastName,
     EndingTitle,
-    FullName,
-    BirthPlace,
-    BirthDate,
-    AvatarName,
+    AvatarUrl,
 )
 from ..mixins.user import Username, Email, Phone
+from ..validators.patient import validate_id_card_or_passport
+
+
+class APIKeySchema(
+    APIKey,
+    IntOrganizationId[OptInt],
+    IntUserId[int],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class PatientSchema(
+    RhesusMixin[OptRhesus],
+    FullBloodTypeMixin[OptKeyOrStandardBloodTypeSchema],
+    FullGenderMixin[KeyOrStandardGenderSchema],
+    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 OrganizationRegistrationCodeSchema(
@@ -54,10 +116,36 @@ class OrganizationRegistrationCodeSchemaMixin(BaseModel):
     ] = None
 
 
-class StandardOrganizationCoreSchema(
+class StandardOrganizationSchema(
     OrganizationName[str],
     OrganizationKey[str],
-    FullOrganizationTypeMixin[OrganizationType],
+    FullOrganizationTypeMixin[KeyOrStandardOrganizationTypeSchema],
+    SimpleDataStatusMixin[DataStatusEnum],
+    DataTimestamp,
+    DataIdentifier,
+):
+    pass
+
+
+class SourceOrganizationSchemaMixin(BaseModel):
+    source: Annotated[
+        StandardOrganizationSchema, Field(..., description="Source organization")
+    ]
+
+
+class TargetOrganizationSchemaMixin(BaseModel):
+    target: Annotated[
+        StandardOrganizationSchema, Field(..., description="Target organization")
+    ]
+
+
+class OrganizationRelationSchema(
+    Metadata,
+    IsBidirectional[bool],
+    TargetOrganizationSchemaMixin,
+    IntTargetId[int],
+    SourceOrganizationSchemaMixin,
+    IntSourceId[int],
     SimpleDataStatusMixin[DataStatusEnum],
     DataTimestamp,
     DataIdentifier,
@@ -65,30 +153,35 @@ class StandardOrganizationCoreSchema(
     pass
 
 
-class FullOrganizationCoreSchema(
+class OrganizationRelationsSchemaMixin(BaseModel):
+    relations: Annotated[
+        list[OrganizationRelationSchema],
+        Field(list[OrganizationRelationSchema](), description="Relations"),
+    ] = list[OrganizationRelationSchema]()
+
+
+class FullOrganizationSchema(
     OrganizationRegistrationCodeSchemaMixin,
-    StandardOrganizationCoreSchema,
+    StandardOrganizationSchema,
 ):
     pass
 
 
-AnyOrganizationCoreSchemaType = (
-    Type[StandardOrganizationCoreSchema] | Type[FullOrganizationCoreSchema]
-)
-AnyOrganizationCoreSchema = StandardOrganizationCoreSchema | FullOrganizationCoreSchema
-AnyOrganizationCoreSchemaT = TypeVar(
-    "AnyOrganizationCoreSchemaT", bound=AnyOrganizationCoreSchema
+AnyOrganizationSchemaType = (
+    Type[StandardOrganizationSchema] | Type[FullOrganizationSchema]
 )
+AnyOrganizationSchema = StandardOrganizationSchema | FullOrganizationSchema
+AnyOrganizationSchemaT = TypeVar("AnyOrganizationSchemaT", bound=AnyOrganizationSchema)
 
 
-class OrganizationCoreSchemaMixin(BaseModel, Generic[AnyOrganizationCoreSchemaT]):
+class OrganizationSchemaMixin(BaseModel, Generic[AnyOrganizationSchemaT]):
     organization: Annotated[
-        AnyOrganizationCoreSchemaT, Field(..., description="Organization")
+        AnyOrganizationSchemaT, Field(..., description="Organization")
     ]
 
 
 class UserMedicalRoleSchema(
-    FullMedicalRoleMixin[MedicalRole],
+    FullMedicalRoleMixin[KeyOrStandardMedicalRoleSchema],
     IntOrganizationId[int],
     IntUserId[int],
     SimpleDataStatusMixin[DataStatusEnum],
@@ -106,7 +199,7 @@ class UserMedicalRolesSchemaMixin(BaseModel):
 
 
 class UserOrganizationRoleSchema(
-    FullOrganizationRoleMixin[OrganizationRole],
+    FullOrganizationRoleMixin[KeyOrStandardOrganizationRoleSchema],
     IntOrganizationId[int],
     IntUserId[int],
     SimpleDataStatusMixin[DataStatusEnum],
@@ -123,10 +216,10 @@ class UserOrganizationRolesSchemaMixin(BaseModel):
     ] = list[UserOrganizationRoleSchema]()
 
 
-class UserProfileCoreSchema(
-    AvatarName[str],
-    BloodTypeMixin[OptBloodType],
-    GenderMixin[OptGender],
+class UserProfileSchema(
+    AvatarUrl[str],
+    FullBloodTypeMixin[OptKeyOrStandardBloodTypeSchema],
+    FullGenderMixin[OptKeyOrStandardGenderSchema],
     BirthDate[OptDate],
     BirthPlace[OptStr],
     FullName[str],
@@ -144,17 +237,17 @@ class UserProfileCoreSchema(
     pass
 
 
-OptUserProfileCoreSchema = UserProfileCoreSchema | None
+OptUserProfileSchema = UserProfileSchema | None
 
 
-class UserProfileCoreSchemaMixin(BaseModel):
+class UserProfileSchemaMixin(BaseModel):
     profile: Annotated[
-        OptUserProfileCoreSchema, Field(None, description="User's Profile")
+        OptUserProfileSchema, Field(None, description="User's Profile")
     ] = None
 
 
-class UserSystemRoleCoreSchema(
-    FullSystemRoleMixin[SystemRole],
+class UserSystemRoleSchema(
+    FullSystemRoleMixin[KeyOrStandardSystemRoleSchema],
     IntUserId[int],
     SimpleDataStatusMixin[DataStatusEnum],
     DataTimestamp,
@@ -163,23 +256,23 @@ class UserSystemRoleCoreSchema(
     pass
 
 
-class UserSystemRolesCoreSchemaMixin(BaseModel):
+class UserSystemRolesSchemaMixin(BaseModel):
     system_roles: Annotated[
-        list[UserSystemRoleCoreSchema],
+        list[UserSystemRoleSchema],
         Field(
-            list[UserSystemRoleCoreSchema](),
+            list[UserSystemRoleSchema](),
             description="User's system roles",
             min_length=1,
         ),
-    ] = list[UserSystemRoleCoreSchema]()
+    ] = list[UserSystemRoleSchema]()
 
 
-class StandardUserCoreSchema(
-    UserProfileCoreSchemaMixin,
+class StandardUserSchema(
+    UserProfileSchemaMixin,
     Phone[str],
     Email[str],
     Username[str],
-    FullUserTypeMixin[UserType],
+    FullUserTypeMixin[KeyOrStandardUserTypeSchema],
     SimpleDataStatusMixin[DataStatusEnum],
     DataTimestamp,
     DataIdentifier,
@@ -187,29 +280,10 @@ class StandardUserCoreSchema(
     pass
 
 
-class FullUserCoreSchema(UserSystemRolesCoreSchemaMixin, StandardUserCoreSchema):
-    pass
-
-
-AnyUserCoreSchemaType = Type[StandardUserCoreSchema] | Type[FullUserCoreSchema]
-AnyUserCoreSchema = StandardUserCoreSchema | FullUserCoreSchema
-AnyUserCoreSchemaT = TypeVar("AnyUserCoreSchemaT", bound=AnyUserCoreSchema)
-
-
-class UserCoreSchemaMixin(BaseModel, Generic[AnyUserCoreSchemaT]):
-    user: Annotated[AnyUserCoreSchemaT, Field(..., description="User")]
-
-
-class UserAndOrganizationSchema(
+class UserOrganizationSchema(
     UserMedicalRolesSchemaMixin,
     UserOrganizationRolesSchemaMixin,
-):
-    pass
-
-
-class UserOrganizationSchema(
-    UserAndOrganizationSchema,
-    OrganizationCoreSchemaMixin[StandardOrganizationCoreSchema],
+    OrganizationSchemaMixin[StandardOrganizationSchema],
     SimpleDataStatusMixin[DataStatusEnum],
     DataTimestamp,
     DataIdentifier,
@@ -224,68 +298,26 @@ class UserOrganizationsSchemaMixin(BaseModel):
     ] = list[UserOrganizationSchema]()
 
 
-class StandardUserCompleteSchema(UserOrganizationsSchemaMixin, StandardUserCoreSchema):
+class FullUserSchema(UserSystemRolesSchemaMixin, StandardUserSchema):
     pass
 
 
-class FullUserCompleteSchema(UserOrganizationsSchemaMixin, FullUserCoreSchema):
-    pass
-
+AnyUserSchemaType = Type[StandardUserSchema] | Type[FullUserSchema]
+AnyUserSchema = StandardUserSchema | FullUserSchema
+AnyUserSchemaT = TypeVar("AnyUserSchemaT", bound=AnyUserSchema)
 
-AnyUserCompleteSchemaType = (
-    Type[StandardUserCompleteSchema] | Type[FullUserCompleteSchema]
-)
-AnyUserCompleteSchema = StandardUserCompleteSchema | FullUserCompleteSchema
-AnyUserCompleteSchemaT = TypeVar("AnyUserCompleteSchemaT", bound=AnyUserCompleteSchema)
 
+class UserSchemaMixin(BaseModel, Generic[AnyUserSchemaT]):
+    user: Annotated[AnyUserSchemaT, Field(..., description="User")]
 
-AnyUserSchemaType = AnyUserCoreSchemaType | AnyUserCompleteSchemaType
-AnyUserSchema = AnyUserCoreSchema | AnyUserCompleteSchema
-AnyUserSchemaT = TypeVar("AnyUserSchemaT", bound=AnyUserSchema)
 
-
-class OrganizationUserSchema(
-    UserAndOrganizationSchema,
-    UserCoreSchemaMixin[StandardUserCoreSchema],
+class UserAndOrganizationSchema(
+    UserMedicalRolesSchemaMixin,
+    UserOrganizationRolesSchemaMixin,
+    OrganizationSchemaMixin[StandardOrganizationSchema],
+    UserSchemaMixin[StandardUserSchema],
     SimpleDataStatusMixin[DataStatusEnum],
     DataTimestamp,
     DataIdentifier,
 ):
     pass
-
-
-class OrganizationUsersSchemaMixin(BaseModel):
-    users: Annotated[
-        list[OrganizationUserSchema],
-        Field(list[OrganizationUserSchema](), description="Users"),
-    ] = list[OrganizationUserSchema]()
-
-
-class StandardOrganizationCompleteSchema(
-    OrganizationUsersSchemaMixin, StandardOrganizationCoreSchema
-):
-    pass
-
-
-class FullOrganizationCompleteSchema(
-    OrganizationUsersSchemaMixin, FullOrganizationCoreSchema
-):
-    pass
-
-
-AnyOrganizationCompleteSchemaType = (
-    Type[StandardOrganizationCompleteSchema] | Type[FullOrganizationCompleteSchema]
-)
-AnyOrganizationCompleteSchema = (
-    StandardOrganizationCompleteSchema | FullOrganizationCompleteSchema
-)
-AnyOrganizationCompleteSchemaT = TypeVar(
-    "AnyOrganizationCompleteSchemaT", bound=AnyOrganizationCompleteSchema
-)
-
-
-AnyOrganizationSchemaType = (
-    AnyOrganizationCoreSchemaType | AnyOrganizationCompleteSchemaType
-)
-AnyOrganizationSchema = AnyOrganizationCoreSchema | AnyOrganizationCompleteSchema
-AnyOrganizationSchemaT = TypeVar("AnyOrganizationSchemaT", bound=AnyOrganizationSchema)

maleo/identity/schemas/organization.py

@@ -1,7 +1,8 @@
 from pydantic import BaseModel, Field
-from typing import Generic, Literal, TypeVar, overload
+from typing import Annotated, Generic, Literal, TypeVar, overload
 from uuid import UUID
 from maleo.enums.organization import (
+    OptOrganizationRelation,
     OrganizationType,
     OptOrganizationType,
     FullOrganizationTypeMixin,
@@ -28,19 +29,41 @@ from maleo.schemas.parameter import (
     DeleteSingleParameter as BaseDeleteSingleParameter,
 )
 from maleo.types.dict import StrToAnyDict
-from maleo.types.integer import OptListOfInts
+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 ..enums.organization import IdentifierType, OptListOfExpandableFields
 from ..mixins.organization import Key, Name
 from ..types.organization import IdentifierValueType
 
 
-class CreateParameter(Name[str], Key[str], FullOrganizationTypeMixin[OrganizationType]):
+class Expand(BaseModel):
+    expand: Annotated[
+        OptListOfExpandableFields, Field(None, description="Expand", min_length=1)
+    ] = None
+
+
+class CreateQuery(Expand):
+    pass
+
+
+class InsertData(Name[str], Key[str], FullOrganizationTypeMixin[OrganizationType]):
+    pass
+
+
+class CreateData(InsertData):
+    related_to: Annotated[OptInt, Field(None, description="Related to", ge=1)] = None
+    relation: Annotated[
+        OptOrganizationRelation, Field(None, description="Relation")
+    ] = None
+
+
+class CreateParameter(CreateQuery, CreateData):
     pass
 
 
 class ReadMultipleParameter(
+    Expand,
     ReadPaginatedMultipleParameter,
     Names[OptListOfStrs],
     Keys[OptListOfStrs],
@@ -61,6 +84,7 @@ class ReadMultipleParameter(
             "page",
             "limit",
             "use_cache",
+            "expand",
         }
 
     def to_query_params(self) -> StrToAnyDict:
@@ -73,7 +97,9 @@ class ReadMultipleParameter(
         return params
 
 
-class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValueType]):
+class ReadSingleParameter(
+    Expand, BaseReadSingleParameter[IdentifierType, IdentifierValueType]
+):
     @overload
     @classmethod
     def new(
@@ -82,6 +108,7 @@ class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValu
         identifier_value: int,
         statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
         use_cache: bool = True,
+        expand: OptListOfExpandableFields = None,
     ) -> "ReadSingleParameter": ...
     @overload
     @classmethod
@@ -91,6 +118,7 @@ class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValu
         identifier_value: UUID,
         statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
         use_cache: bool = True,
+        expand: OptListOfExpandableFields = None,
     ) -> "ReadSingleParameter": ...
     @overload
     @classmethod
@@ -100,6 +128,7 @@ class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValu
         identifier_value: str,
         statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
         use_cache: bool = True,
+        expand: OptListOfExpandableFields = None,
     ) -> "ReadSingleParameter": ...
     @classmethod
     def new(
@@ -108,17 +137,19 @@ class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValu
         identifier_value: IdentifierValueType,
         statuses: ListOfDataStatuses = list(FULL_DATA_STATUSES),
         use_cache: bool = True,
+        expand: OptListOfExpandableFields = None,
     ) -> "ReadSingleParameter":
         return cls(
             identifier_type=identifier_type,
             identifier_value=identifier_value,
             statuses=statuses,
             use_cache=use_cache,
+            expand=expand,
         )
 
     def to_query_params(self) -> StrToAnyDict:
         return self.model_dump(
-            mode="json", include={"statuses", "use_cache"}, exclude_none=True
+            mode="json", include={"statuses", "use_cache", "expand"}, exclude_none=True
         )
 
 
@@ -140,6 +171,7 @@ class UpdateDataMixin(BaseModel, Generic[UpdateDataT]):
 
 
 class UpdateParameter(
+    Expand,
     UpdateDataMixin[UpdateDataT],
     IdentifierTypeValue[
         IdentifierType,
@@ -151,6 +183,7 @@ class UpdateParameter(
 
 
 class StatusUpdateParameter(
+    Expand,
     BaseStatusUpdateParameter[IdentifierType, IdentifierValueType],
 ):
     pass

maleo/identity/schemas/organization_registration_code.py

@@ -11,8 +11,8 @@ from maleo.schemas.mixins.identity import (
     IdentifierTypeValue,
     Ids,
     IntOrganizationId,
+    IntOrganizationIds,
     UUIDs,
-    UUIDOrganizationIds,
 )
 from maleo.schemas.mixins.sort import convert as convert_sort
 from maleo.schemas.parameter import (
@@ -30,15 +30,15 @@ from ..mixins.organization_registration_code import Code, MaxUses
 from ..types.organization_registration_code import IdentifierValueType
 
 
-class BaseCreateParameter(
+class StandardCreateParameter(
     MaxUses[int],
     Code[OptStr],
 ):
     pass
 
 
-class CreateParameter(
-    BaseCreateParameter,
+class FullCreateParameter(
+    StandardCreateParameter,
     IntOrganizationId[int],
 ):
     pass
@@ -47,7 +47,7 @@ class CreateParameter(
 class ReadMultipleParameter(
     ReadPaginatedMultipleParameter,
     Codes[OptListOfStrs],
-    UUIDOrganizationIds[OptListOfUUIDs],
+    IntOrganizationIds[OptListOfInts],
     UUIDs[OptListOfUUIDs],
     Ids[OptListOfInts],
 ):
@@ -103,6 +103,15 @@ class ReadSingleParameter(BaseReadSingleParameter[IdentifierType, IdentifierValu
         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,