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

maleo/identity/mixins/user_profile.py

@@ -1,13 +1,8 @@
 from pydantic import BaseModel, Field
 from typing import Annotated, Generic
-from maleo.types.datetime import OptDateT
 from maleo.types.string import OptStrT
 
 
-class IdCard(BaseModel, Generic[OptStrT]):
-    id_card: Annotated[OptStrT, Field(..., description="User's Id Card", max_length=16)]
-
-
 class LeadingTitle(BaseModel, Generic[OptStrT]):
     leading_title: Annotated[
         OptStrT, Field(..., description="User's Leading Title", max_length=25)
@@ -38,21 +33,9 @@ class EndingTitle(BaseModel, Generic[OptStrT]):
     ]
 
 
-class FullName(BaseModel, Generic[OptStrT]):
-    full_name: Annotated[
-        OptStrT, Field(..., description="User's Full Name", max_length=200)
-    ]
-
-
-class BirthPlace(BaseModel, Generic[OptStrT]):
-    birth_place: Annotated[
-        OptStrT, Field(..., description="User's Birth Place", max_length=50)
-    ]
-
-
-class BirthDate(BaseModel, Generic[OptDateT]):
-    birth_date: Annotated[OptDateT, Field(..., description="User's birth date")]
-
-
 class AvatarName(BaseModel, Generic[OptStrT]):
     avatar_name: Annotated[OptStrT, Field(..., description="User's Avatar Name")]
+
+
+class AvatarUrl(BaseModel, Generic[OptStrT]):
+    avatar_url: Annotated[OptStrT, Field(..., description="User's Avatar URL")]

maleo/identity/models.py

@@ -1,16 +1,28 @@
 from datetime import date
-from sqlalchemy import ForeignKey, UniqueConstraint, and_
-from sqlalchemy.dialects.postgresql import UUID as PostgreSQLUUID
-from sqlalchemy.orm import Mapped, declared_attr, mapped_column, relationship
-from sqlalchemy.types import Date, Enum, Integer, String, Text
+from sqlalchemy import CheckConstraint, ForeignKey, UniqueConstraint
+from sqlalchemy.dialects.postgresql import JSONB, UUID as PostgreSQLUUID
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.types import Boolean, Date, Enum, Integer, String, Text
 from uuid import UUID, uuid4
-from maleo.enums.identity import BloodType, OptBloodType, Gender, OptGender
-from maleo.enums.organization import OrganizationType, OrganizationRole
+from maleo.enums.identity import (
+    BloodType,
+    OptBloodType,
+    Rhesus,
+    OptRhesus,
+    Gender,
+    OptGender,
+)
+from maleo.enums.organization import (
+    OrganizationType,
+    OrganizationRelation as OrganizationRelationEnum,
+    OrganizationRole,
+)
 from maleo.enums.medical import MedicalRole
 from maleo.enums.system import SystemRole
 from maleo.enums.user import UserType
 from maleo.schemas.model import DataIdentifier, DataStatus, DataTimestamp
 from maleo.types.integer import OptInt
+from maleo.types.misc import OptListOfAnyOrStrToAnyDict
 from maleo.types.string import OptStr
 
 
@@ -40,6 +52,77 @@ class APIKey(
     )
 
 
+class Patient(
+    DataStatus,
+    DataTimestamp,
+    DataIdentifier,
+):
+    __tablename__ = "patients"
+    organization_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("organizations.id", ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    id_card: Mapped[OptStr] = mapped_column(
+        name="id_card", type_=String(16), unique=True
+    )
+    passport: Mapped[OptStr] = mapped_column(
+        name="passport", type_=String(9), unique=True
+    )
+    name: Mapped[str] = mapped_column(name="name", type_=String(200), nullable=False)
+    place_of_birth: Mapped[OptStr] = mapped_column(
+        name="place_of_birth", type_=String(50)
+    )
+    date_of_birth: Mapped[date] = mapped_column(
+        name="date_of_birth", type_=Date, nullable=False
+    )
+    gender: Mapped[Gender] = mapped_column(
+        name="gender", type_=Enum(Gender, name="gender"), nullable=False
+    )
+    blood_type: Mapped[OptBloodType] = mapped_column(
+        name="blood_type", type_=Enum(BloodType, name="blood_type")
+    )
+    rhesus: Mapped[OptRhesus] = mapped_column(
+        name="rhesus", type_=Enum(Rhesus, name="rhesus")
+    )
+
+    __table_args__ = (
+        CheckConstraint(
+            "id_card IS NOT NULL OR passport IS NOT NULL",
+            name="chk_id_card_or_passport",
+        ),
+    )
+
+
+class OrganizationRelation(
+    DataStatus,
+    DataTimestamp,
+    DataIdentifier,
+):
+    __tablename__ = "organization_relations"
+    source_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("organizations.id", ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    target_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("organizations.id", ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    relation: Mapped[OrganizationRelationEnum] = mapped_column(
+        name="relation",
+        type_=Enum(OrganizationRelationEnum, name="organization_relation"),
+        nullable=False,
+    )
+    is_bidirectional: Mapped[bool] = mapped_column(
+        name="is_bidirectional", type_=Boolean, default=False, nullable=False
+    )
+    metadata: Mapped[OptListOfAnyOrStrToAnyDict] = mapped_column(
+        name="metadata", type_=JSONB, default=None
+    )
+
+
 class OrganizationRegistrationCode(
     DataStatus,
     DataTimestamp,
@@ -62,15 +145,6 @@ class OrganizationRegistrationCode(
         name="current_uses", type_=Integer, nullable=False, default=0
     )
 
-    # Relationship
-    @declared_attr
-    def organization(cls) -> Mapped["Organization"]:
-        return relationship(
-            "Organization",
-            back_populates="registration_code",
-            uselist=False,  # 👈 ensures one-to-one, not one-to-many
-        )
-
 
 class Organization(
     DataStatus,
@@ -96,24 +170,6 @@ class Organization(
         nullable=False,
     )
 
-    # Relationship
-    @declared_attr
-    def registration_code(cls) -> Mapped["OrganizationRegistrationCode | None"]:
-        return relationship(
-            "OrganizationRegistrationCode",
-            back_populates="organization",
-            uselist=False,
-            cascade="all, delete-orphan",
-        )
-
-    @declared_attr
-    def users(cls) -> Mapped[list["UserOrganization"]]:
-        return relationship(
-            "UserOrganization",
-            back_populates="organization",
-            cascade="all, delete-orphan",
-        )
-
 
 class UserMedicalRole(DataStatus, DataTimestamp, DataIdentifier):
     __tablename__ = "user_medical_roles"
@@ -206,11 +262,6 @@ class UserProfile(
         name="avatar_name", type_=Text, nullable=False
     )
 
-    # Relationships
-    @declared_attr
-    def user(cls) -> Mapped["User"]:
-        return relationship("User", back_populates="profile")
-
 
 class UserSystemRole(
     DataStatus,
@@ -234,11 +285,6 @@ class UserSystemRole(
         UniqueConstraint("user_id", "system_role", name="uq_user_system_role"),
     )
 
-    # Relationships
-    @declared_attr
-    def user(cls) -> Mapped["User"]:
-        return relationship("User", back_populates="system_roles")
-
 
 class User(
     DataStatus,
@@ -263,24 +309,6 @@ class User(
         name="password", type_=String(255), nullable=False
     )
 
-    @declared_attr
-    def organizations(cls) -> Mapped[list["UserOrganization"]]:
-        return relationship(
-            "UserOrganization", back_populates="user", cascade="all, delete-orphan"
-        )
-
-    @declared_attr
-    def profile(cls) -> Mapped["UserProfile | None"]:
-        return relationship(
-            "UserProfile", back_populates="user", cascade="all, delete-orphan"
-        )
-
-    @declared_attr
-    def system_roles(cls) -> Mapped[list["UserSystemRole"]]:
-        return relationship(
-            "UserSystemRole", back_populates="user", cascade="all, delete-orphan"
-        )
-
 
 class UserOrganization(
     DataStatus,
@@ -303,37 +331,3 @@ class UserOrganization(
     __table_args__ = (
         UniqueConstraint("user_id", "organization_id", name="uq_user_organization"),
     )
-
-    # Relationships
-    @declared_attr
-    def user(cls) -> Mapped["User"]:
-        return relationship("User", back_populates="organizations")
-
-    @declared_attr
-    def organization(cls) -> Mapped["Organization"]:
-        return relationship("Organization", back_populates="users")
-
-    @declared_attr
-    def organization_roles(cls) -> Mapped[list["UserOrganizationRole"]]:
-        return relationship(
-            "UserOrganizationRole",
-            primaryjoin=and_(
-                UserOrganization.user_id == UserOrganizationRole.user_id,
-                UserOrganization.organization_id
-                == UserOrganizationRole.organization_id,
-            ),
-            viewonly=True,
-            lazy="selectin",
-        )
-
-    @declared_attr
-    def medical_roles(cls) -> Mapped[list["UserMedicalRole"]]:
-        return relationship(
-            "UserMedicalRole",
-            primaryjoin=and_(
-                UserOrganization.user_id == UserMedicalRole.user_id,
-                UserOrganization.organization_id == UserMedicalRole.organization_id,
-            ),
-            viewonly=True,
-            lazy="selectin",
-        )

maleo/identity/schemas/api_key.py

@@ -0,0 +1,128 @@
+from typing import Literal, Tuple, overload
+from uuid import UUID
+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 (
+    Ids,
+    UUIDs,
+    IntUserId,
+    IntUserIds,
+    IntOrganizationId,
+    IntOrganizationIds,
+)
+from maleo.schemas.mixins.sort import convert as convert_sort
+from maleo.schemas.parameter import (
+    ReadSingleParameter as BaseReadSingleParameter,
+    ReadPaginatedMultipleParameter,
+    DeleteSingleParameter as BaseDeleteSingleParameter,
+)
+from maleo.types.dict import StrToAnyDict
+from maleo.types.integer import OptInt, OptListOfInts
+from maleo.types.uuid import OptListOfUUIDs
+from ..enums.api_key import IdentifierType
+from ..types.api_key import IdentifierValueType
+
+
+class CreateParameter(
+    IntOrganizationId[OptInt],
+    IntUserId[int],
+):
+    pass
+
+
+class ReadMultipleParameter(
+    ReadPaginatedMultipleParameter,
+    IntOrganizationIds[OptListOfInts],
+    IntUserIds[OptListOfInts],
+    UUIDs[OptListOfUUIDs],
+    Ids[OptListOfInts],
+):
+    @property
+    def _query_param_fields(self) -> set[str]:
+        return {
+            "ids",
+            "uuids",
+            "statuses",
+            "user_ids",
+            "organization_ids",
+            "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[IdentifierType, IdentifierValueType]):
+    @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.COMPOSITE],
+        identifier_value: Tuple[int, OptInt],
+        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_type=identifier_type,
+            identifier_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 DeleteSingleParameter(
+    BaseDeleteSingleParameter[IdentifierType, IdentifierValueType]
+):
+    pass