Refactor/issue 29 add pydantic validations

app/Entities/UserDTOs/certification_entity.py

@@ -1,93 +1,35 @@
-from typing import Optional,List
+from typing import Optional, List, Annotated
 from uuid import UUID
 from datetime import datetime, date
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, Field
 from Schema.SQL.Enums.enums import (CertificationType, Tools)
+
+
 class CreateCertification(BaseModel):
     profile_id: UUID
-    name: str
+    name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     type: CertificationType
-    issuing_organization: str
+    issuing_organization: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     issue_date: date
     expiry_date: Optional[date] = None
-    credential_id: str
-    credential_url:str
-    tools:Optional[List[Tools]]
+    credential_id: Annotated[str, Field(min_length=1, strip_whitespace=True)]
+    credential_url: Annotated[str, Field(min_length=1, strip_whitespace=True)]
+    tools: Optional[List[Tools]] = None
     issuing_organization_logo: Optional[str] = None
 
-    @field_validator('name')
-    def name_must_not_be_empty(cls ,v):
-        if not v.strip():
-            raise ValueError("Name cannot be empty.")
-        return v.strip()
-
-    @field_validator('issuing_organization')
-    def issuing_organization_must_not_be_empty(cls, v):
-        if not v.strip():
-            raise ValueError("Issuing Organization cannot be empty.")
-        return v.strip()
-
-    @field_validator('issue_date')
-    def issue_date_must_not_be_empty(cls, v):
-        if v is None:
-            raise ValueError("Issue Date cannot be empty.")
-        return v
-
-    @field_validator('credential_id')
-    def credential_id_must_not_be_empty(cls,v):
-        if not v.strip():
-            raise ValueError("Credential id cannot be empty.")
-        return v.strip()
-
-    @field_validator('credential_url')
-    def credential_url_must_not_be_empty(cls,v):
-        if not v.strip():
-            raise ValueError("Credential url cannot be empty.")
-        return v.strip()
-
 
 class UpdateCertification(BaseModel):
     profile_id: Optional[UUID] = None
-    name: Optional[str] = None
+    name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     type: Optional[CertificationType] = None
-    issuing_organization: Optional[str] = None
+    issuing_organization: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     issue_date: Optional[date] = None
     expiry_date: Optional[date] = None
-    credential_id: Optional[str] = None
-    credential_url: Optional[str] = None
+    credential_id: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
+    credential_url: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     tools: Optional[List[Tools]] = None
     issuing_organization_logo: Optional[str] = None
 
-    @field_validator('name')
-    def name_must_not_be_empty(cls ,v):
-        if v is not None and not v.strip():
-            raise ValueError("Name cannot be empty.")
-        return v.strip() if v else v
-
-    @field_validator('issuing_organization')
-    def issuing_organization_must_not_be_empty(cls, v):
-        if v is not None and not v.strip():
-            raise ValueError("Issuing Organization cannot be empty.")
-        return v.strip() if v else v
-
-    @field_validator('issue_date')
-    def issue_date_must_not_be_empty(cls, v):
-        # For optional updates, v can be None, which is valid
-        # If v is provided, it should be a valid date (validated by pydantic automatically)
-        return v
-
-    @field_validator('credential_id')
-    def credential_id_must_not_be_empty(cls,v):
-        if v is not None and not v.strip():
-            raise ValueError("Credential id cannot be empty.")
-        return v.strip() if v else v
-
-    @field_validator('credential_url')
-    def credential_url_must_not_be_empty(cls,v):
-        if v is not None and not v.strip():
-            raise ValueError("Credential url cannot be empty.")
-        return v.strip() if v else v
-
 
 class ReadCertification(BaseModel):
     id: UUID

app/Entities/UserDTOs/education_entity.py

@@ -1,25 +1,25 @@
 from __future__ import annotations
 
-from typing import Optional, List
+from typing import Optional, List, Annotated
 from uuid import UUID
 from datetime import datetime
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, Field
 
 from Schema.SQL.Enums.enums import SchoolType, WorkLocationType, Tools, Degree
 
 class CreateEducation(BaseModel):
     profile_id: UUID
-    school_name: str
+    school_name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     school_logo_url: Optional[str] = None
     school_type: SchoolType
     degree: Degree
-    course_field_name: str
+    course_field_name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     currently_studying: bool
     location: Optional[CreateLocation] = None
     location_type: WorkLocationType
-    start_date_month: int
+    start_date_month: Annotated[int, Field(ge=1, le=12)]
     start_date_year: int
-    end_date_month: Optional[int] = None
+    end_date_month: Optional[Annotated[int, Field(ge=1, le=12)]] = None
     end_date_year: Optional[int] = None
     description_general: str
     description_detailed: Optional[str] = None
@@ -29,37 +29,19 @@ class CreateEducation(BaseModel):
     cgpa: Optional[float] = None
     tools_used: Optional[List[Tools]] = None
 
-    @field_validator("school_name")
-    def school_must_not_be_empty(cls, v):
-        if not v.strip():
-            raise ValueError("school_name cannot be empty")
-        return v.strip()
-
-    @field_validator("course_field_name")
-    def field_must_not_be_empty(cls, v):
-        if not v.strip():
-            raise ValueError("course_field_name cannot be empty")
-        return v.strip()
-
-    @field_validator("start_date_month", "end_date_month")
-    def validate_month(cls, v):
-        if v is not None and (v < 1 or v > 12):
-            raise ValueError("Month must be between 1 and 12")
-        return v
-
 
 class UpdateEducation(BaseModel):
-    school_name: Optional[str] = None
+    school_name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     school_logo_url: Optional[str] = None
     school_type: Optional[SchoolType] = None
     degree: Optional[Degree] = None
-    course_field_name: Optional[str] = None
+    course_field_name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     currently_studying: Optional[bool] = None
     location: Optional[CreateLocation] = None
     location_type: Optional[WorkLocationType] = None
-    start_date_month: Optional[int] = None
+    start_date_month: Optional[Annotated[int, Field(ge=1, le=12)]] = None
     start_date_year: Optional[int] = None
-    end_date_month: Optional[int] = None
+    end_date_month: Optional[Annotated[int, Field(ge=1, le=12)]] = None
     end_date_year: Optional[int] = None
     description_general: Optional[str] = None
     description_detailed: Optional[str] = None
@@ -69,24 +51,6 @@ class UpdateEducation(BaseModel):
     cgpa: Optional[float] = None
     tools_used: Optional[List[Tools]] = None
 
-    @field_validator("school_name")
-    def school_must_not_be_empty(cls, v):
-        if v is not None and not v.strip():
-            raise ValueError("school_name cannot be empty")
-        return v.strip() if v else v
-
-    @field_validator("course_field_name")
-    def field_must_not_be_empty(cls, v):
-        if v is not None and not v.strip():
-            raise ValueError("course_field_name cannot be empty")
-        return v.strip() if v else v
-
-    @field_validator("start_date_month", "end_date_month")
-    def validate_month(cls, v):
-        if v is not None and (v < 1 or v > 12):
-            raise ValueError("Month must be between 1 and 12")
-        return v
-
 class ReadEducation(BaseModel):
     id: UUID
     profile_id: UUID

app/Entities/UserDTOs/links_entity.py

@@ -1,57 +1,39 @@
-from typing import Optional
+from typing import Optional, Annotated
 from uuid import UUID
 from datetime import datetime
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, Field
 
 class CreateLinks(BaseModel):
     user_id: UUID
     portfolio_link: Optional[str] = None
-    github_user_name: str
+    github_user_name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     github_link: Optional[str] = None
-    linkedin_user_name: str
+    linkedin_user_name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     linkedin_link: Optional[str] = None
-    leetcode_user_name: str
+    leetcode_user_name: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     leetcode_link: Optional[str] = None
-    orcid_id: Optional[str] = None
+    orcid_id: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     orcid_link: Optional[str] = None
     primary_email: Optional[str] = None
     secondary_email: Optional[str] = None
     school_email: Optional[str] = None
     work_email: Optional[str] = None
 
-    @field_validator("github_user_name", "linkedin_user_name", "leetcode_user_name")
-    def validate_not_empty(cls, v: str):
-        if not v.strip():
-            raise ValueError("Field cannot be empty")
-        return v.strip()
-
-    @field_validator("orcid_id")
-    def validate_orcid_not_empty(cls, v: Optional[str]):
-        if v is not None and not v.strip():
-            raise ValueError("Field cannot be empty")
-        return v.strip() if v else v
-
 class UpdateLinks(BaseModel):
     portfolio_link: Optional[str] = None
-    github_user_name: Optional[str] = None
+    github_user_name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     github_link: Optional[str] = None
-    linkedin_user_name: Optional[str] = None
+    linkedin_user_name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     linkedin_link: Optional[str] = None
-    leetcode_user_name: Optional[str] = None
+    leetcode_user_name: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     leetcode_link: Optional[str] = None
-    orcid_id: Optional[str] = None
+    orcid_id: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     orcid_link: Optional[str] = None
     primary_email: Optional[str] = None
     secondary_email: Optional[str] = None
     school_email: Optional[str] = None
     work_email: Optional[str] = None
 
-    @field_validator("github_user_name", "linkedin_user_name", "leetcode_user_name", "orcid_id")
-    def validate_not_empty_if_present(cls, v: Optional[str]):
-        if v is not None and not v.strip():
-            raise ValueError("Field cannot be empty")
-        return v.strip() if v else v
-
 class ReadLinks(BaseModel):
     id: UUID
     user_id: UUID

app/Entities/UserDTOs/location_entity.py

@@ -1,47 +1,23 @@
-from typing import Optional
+from typing import Optional, Annotated
 from uuid import UUID
 from datetime import datetime
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, Field
 
 class CreateLocation(BaseModel):
     id: Optional[UUID] = None
     city: str
     state: Optional[str] = None
-    country: str
+    country: Annotated[str, Field(min_length=1, strip_whitespace=True)]
     longitude: Optional[float] = None
     latitude: Optional[float] = None
 
-    @field_validator('city')
-    def city_must_not_be_empty(cls, v):
-        if not v.strip():
-            raise ValueError('city cannot be empty')
-        return v.strip()
-
-    @field_validator('country')
-    def country_must_not_be_empty(cls, v):
-        if not v.strip():
-            raise ValueError('country cannot be empty')
-        return v.strip()
-
 class UpdateLocation(BaseModel):
-    city: Optional[str] = None
+    city: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     state: Optional[str] = None
-    country: Optional[str] = None
+    country: Optional[Annotated[str, Field(min_length=1, strip_whitespace=True)]] = None
     longitude: Optional[float] = None
     latitude: Optional[float] = None
 
-    @field_validator('city')
-    def city_must_not_be_empty(cls, v):
-        if v is not None and not v.strip():
-            raise ValueError('city cannot be empty')
-        return v.strip() if v else v
-
-    @field_validator('country')
-    def country_must_not_be_empty(cls, v):
-        if v is not None and not v.strip():
-            raise ValueError('country cannot be empty')
-        return v.strip() if v else v
-
 class ReadLocation(BaseModel):
     id: UUID
     city: str

app/Entities/UserDTOs/profile_entity.py

@@ -1,30 +1,18 @@
 from typing import Optional
 from uuid import UUID
 from datetime import datetime
-from pydantic import BaseModel, validator
+from pydantic import BaseModel
 
 # ----------------------
 # Input DTOs
 # ----------------------
 class CreateProfile(BaseModel):
     user_id: UUID
 
-    @validator('user_id')
-    def user_id_must_be_valid_uuid(cls, v):
-        if not v:
-            raise ValueError('user_id cannot be empty')
-        return v
-
 
 class UpdateProfile(BaseModel):
     user_id: Optional[UUID] = None
 
-    @validator('user_id')
-    def user_id_must_be_valid_uuid(cls, v):
-        if v is not None and not v:
-            raise ValueError('user_id cannot be empty')
-        return v
-
 
 # ----------------------
 # Output DTO