✨ Add (module): Pydantic schemas representation for API requests and responses

Author: jpcadena

app/config/exceptions.py

@@ -14,3 +14,14 @@ def __init__(self, message: str, note: str | None = None):
         super().__init__(message)
         if note:
             self.add_note(note)
+
+
+class ServiceException(Exception):  # type: ignore
+    """
+    Service Layer Exception class
+    """
+
+    def __init__(self, message: str, note: str | None = None):
+        super().__init__(message)
+        if note:
+            self.add_note(note)

app/config/utils.py

@@ -2,11 +2,17 @@
 A module for openapi utils in the app.config package.
 """
 
+import re
 from typing import Any
 
+import phonenumbers
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
 from fastapi.routing import APIRoute
+from pydantic_extra_types.phone_numbers import PhoneNumber
+
+from app.config.exceptions import ServiceException
+from app.config.settings import setting
 
 
 def remove_tag_from_operation_id(tag: str, operation_id: str) -> str:
@@ -107,3 +113,45 @@ def custom_openapi(app: FastAPI) -> dict[str, Any]:
     openapi_schema = modify_json_data(openapi_schema)
     app.openapi_schema = openapi_schema
     return app.openapi_schema
+
+
+def validate_password(password: str | None) -> str:
+    """
+    Validates a password based on given criteria.
+    :param password: The password to validate.
+    :type password: Optional[str]
+    :return: The validated password.
+    :rtype: str
+    """
+    if not password:
+        raise ServiceException("Password cannot be empty or None")
+    if not (
+        re.search("[A-Z]", password)
+        and re.search("[a-z]", password)
+        and re.search("[0-9]", password)
+        and re.search(setting.DB_USER_PASSWORD_CONSTRAINT, password)
+        and 8 <= len(password) <= 14
+    ):
+        raise ValueError("Password validation failed")
+    return password
+
+
+def validate_phone_number(
+    phone_number: PhoneNumber | None,
+) -> PhoneNumber | None:
+    """
+    Validate the phone number format
+    :param phone_number: The phone number to validate
+    :type phone_number: Optional[PhoneNumber]
+    :return: The validated phone number
+    :rtype: Optional[PhoneNumber]
+    """
+    if phone_number is None:
+        return None
+    try:
+        parsed_number = phonenumbers.parse(str(phone_number), None)
+    except phonenumbers.phonenumberutil.NumberParseException as exc:
+        raise ValueError from exc
+    if not phonenumbers.is_valid_number(parsed_number):
+        raise ValueError("Invalid phone number")
+    return phone_number

app/crud/user.py

@@ -34,14 +34,14 @@ def __init__(
     ):
         self.session: Session = session
 
-    def read_by_id(self, _id: PositiveInt) -> User | None:
+    def read_by_id(self, _id: PositiveInt) -> User:
         """
         Retrieve a user from the database by its id
         :param _id: The id of the user
         :type _id: IdSpecification
         :return: The user with the specified id, or None if no such
             user exists
-        :rtype: Optional[User]
+        :rtype: User
         """
         with self.session as session:
             stmt: Select[Any]
@@ -54,7 +54,7 @@ def read_by_id(self, _id: PositiveInt) -> User | None:
                 logger.error(sa_exc)
                 logger.info("Retrieving row with id: %s", _id)
                 raise DatabaseException(str(sa_exc)) from sa_exc
-            return User(db_obj)
+            return db_obj
 
     def read_users(
         self,

app/schemas/user.py

@@ -2,12 +2,124 @@
 A module for user in the app-schemas package.
 """
 
-from pydantic import BaseModel
+from datetime import date
 
+from phonenumbers import PhoneNumber
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
+from pydantic.config import JsonDict
+from pydantic_extra_types.phone_numbers import (
+    PhoneNumber as PydanticPhoneNumber,
+)
 
-class UserCreate(BaseModel):
-    pass
+from app.config.init_settings import init_setting
+from app.config.utils import validate_password, validate_phone_number
 
+user_example: JsonDict = {
+    "example": {
+        "username": "username",
+        "email": "[email protected]",
+        "birthdate": date(2004, 1, 1).strftime(init_setting.DATE_FORMAT),
+        "phone_number": str(PydanticPhoneNumber("+593987654321")),
+        "password": "Hk7pH9*35Fu&3U",
+    }
+}
 
-class UserUpdate(BaseModel):
-    pass
+
+class UserBase(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra=user_example,
+    )
+
+    username: str | None = Field(
+        default=None,
+        title="Username",
+        description="Username to identify the user",
+        min_length=4,
+        max_length=15,
+    )
+    email: EmailStr | None = Field(
+        default=None,
+        title="Email",
+        description="Preferred e-mail address of " "the User",
+    )
+    password: str | None = Field(
+        default=None,
+        title="Password",
+        description="Password of the User",
+        min_length=8,
+        max_length=14,
+    )
+    birthdate: date | None = Field(
+        default=None, title="Birthdate", description="Birthday of the User"
+    )
+    phone_number: PhoneNumber | None = Field(
+        default=None,
+        title="Phone number",
+        description="Preferred telephone number of the User",
+    )
+
+    @field_validator("phone_number", mode="before")
+    def validate_phone_number(
+        cls, v: PydanticPhoneNumber | None
+    ) -> PydanticPhoneNumber | None:
+        """
+        Validates the phone number attribute
+        :param v: The phone number value to validate
+        :type v: Optional[PhoneNumber]
+        :return: The validated phone number
+        :rtype: Optional[PhoneNumber]
+        """
+        return validate_phone_number(v)
+
+    @field_validator("password", mode="before")
+    def validate_password(cls, v: str | None) -> str:
+        """
+        Validates the password attribute
+        :param v: The password to be validated
+        :type v: Optional[str]
+        :return: The validated password
+        :rtype: str
+        """
+        return validate_password(v)
+
+
+class UserCreate(UserBase):
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    username: str
+    email: EmailStr
+    password: str
+
+
+class UserUpdate(UserBase):
+    """
+    Schema for updating a User record.
+    """
+
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+
+class User(UserBase):
+    model_config = ConfigDict(
+        from_attributes=True,
+    )
+
+    password: str = Field(
+        ...,
+        title="Hashed Password",
+        description="Hashed Password of the User",
+        min_length=60,
+        max_length=60,
+    )
+
+
+class UsersResponse(BaseModel):
+    """
+    Class representation for a list of users response
+    """
+
+    users: list[User]