feat: Updated endpoint endpoints/contact.post.py via AI with auto lint fixes

endpoints/contact.post.py

@@ -1,24 +1,16 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, status
 from sqlalchemy.orm import Session
 from core.database import get_db
 from schemas.contact import ContactCreate, ContactSchema
-from helpers.contact_helpers import create_contact, sanitize_contact_input, validate_contact_data, format_contact_response
+from utils.contact_helpers import sanitize_contact_input, create_contact, format_contact_response
 
 router = APIRouter()
 
-@router.post("/contact", status_code=status.HTTP_201_CREATED, response_model=ContactSchema)
+@router.post("/contact", response_model=ContactSchema, status_code=status.HTTP_201_CREATED)
 async def create_contact_submission(
     contact_data: ContactCreate,
     db: Session = Depends(get_db)
 ):
     sanitized_data = sanitize_contact_input(contact_data.dict())
-    validation_errors = validate_contact_data(sanitized_data)
-    
-    if validation_errors:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=validation_errors
-        )
-    
     contact = create_contact(db=db, contact_data=ContactCreate(**sanitized_data))
     return format_contact_response(contact)

helpers/contact_helpers.py

@@ -3,11 +3,11 @@ from sqlalchemy.orm import Session
 from models.contact import Contact
 from schemas.contact import ContactCreate, ContactSchema
 from fastapi import HTTPException, status
-from pydantic import EmailStr
+import email_validator
 
 def validate_contact_data(contact_data: Dict[str, Any]) -> Dict[str, str]:
     """
-    Validates contact form submission data.
+    Validates contact form submission data with enhanced validation.
 
     Args:
         contact_data (Dict[str, Any]): The contact form data to validate.
@@ -17,21 +17,26 @@ def validate_contact_data(contact_data: Dict[str, Any]) -> Dict[str, str]:
     """
     errors = {}
     
-    # Check required fields
+    # Validate name
     if not contact_data.get("name"):
         errors["name"] = "Name is required"
-    elif len(contact_data["name"].strip()) < 1:
+    elif not contact_data["name"].strip():
-        errors["name"] = "Name cannot be empty"
+        errors["name"] = "Name cannot consist of only whitespace"
     
+    # Validate email with enhanced validation
     if not contact_data.get("email"):
         errors["email"] = "Email is required"
-    elif not isinstance(contact_data["email"], EmailStr):
+    else:
-        errors["email"] = "Invalid email format"
+        try:
+            email_validator.validate_email(contact_data["email"])
+        except email_validator.EmailNotValidError:
+            errors["email"] = "Invalid email format - please provide a valid email address"
     
+    # Validate message
     if not contact_data.get("message"):
         errors["message"] = "Message is required"
-    elif len(contact_data["message"].strip()) < 1:
+    elif not contact_data["message"].strip():
-        errors["message"] = "Message cannot be empty"
+        errors["message"] = "Message cannot consist of only whitespace"
         
     return errors
 
@@ -78,7 +83,7 @@ def format_contact_response(contact: Contact) -> ContactSchema:
 
 def sanitize_contact_input(contact_data: Dict[str, Any]) -> Dict[str, Any]:
     """
-    Sanitizes contact form input data.
+    Sanitizes contact form input data with enhanced validation.
 
     Args:
         contact_data (Dict[str, Any]): Raw contact form data.
@@ -97,4 +102,13 @@ def sanitize_contact_input(contact_data: Dict[str, Any]) -> Dict[str, Any]:
     if "message" in contact_data:
         sanitized["message"] = contact_data["message"].strip()
         
+    # Ensure all required fields are present
+    required_fields = ["name", "email", "message"]
+    for field in required_fields:
+        if field not in sanitized or not sanitized[field]:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"{field.capitalize()} is required"
+            )
+            
     return sanitized

schemas/contact.py

@@ -1,20 +1,72 @@
-from pydantic import BaseModel, Field, EmailStr
+from pydantic import BaseModel, Field, EmailStr, validator
 from typing import Optional
 from datetime import datetime
 from uuid import UUID
 
 class ContactBase(BaseModel):
-    name: str = Field(..., min_length=1, description="Contact name")
+    name: str = Field(
-    email: EmailStr = Field(..., description="Contact email address")
+        ..., 
-    message: str = Field(..., min_length=1, description="Contact message")
+        min_length=1, 
+        description="Contact name",
+        error_messages={"min_length": "Name cannot be empty"}
+    )
+    email: EmailStr = Field(
+        ..., 
+        description="Contact email address",
+        error_messages={"type": "Invalid email format"}
+    )
+    message: str = Field(
+        ..., 
+        min_length=1, 
+        description="Contact message",
+        error_messages={"min_length": "Message cannot be empty"}
+    )
+
+    @validator('name')
+    def validate_name(cls, v):
+        if not v.strip():
+            raise ValueError("Name cannot consist of only whitespace")
+        return v.strip()
+
+    @validator('message')
+    def validate_message(cls, v):
+        if not v.strip():
+            raise ValueError("Message cannot consist of only whitespace")
+        return v.strip()
 
 class ContactCreate(ContactBase):
     pass
 
 class ContactUpdate(BaseModel):
-    name: Optional[str] = Field(None, min_length=1, description="Contact name")
+    name: Optional[str] = Field(
-    email: Optional[EmailStr] = Field(None, description="Contact email address") 
+        None, 
-    message: Optional[str] = Field(None, min_length=1, description="Contact message")
+        min_length=1, 
+        description="Contact name",
+        error_messages={"min_length": "Name cannot be empty"}
+    )
+    email: Optional[EmailStr] = Field(
+        None, 
+        description="Contact email address",
+        error_messages={"type": "Invalid email format"}
+    )
+    message: Optional[str] = Field(
+        None, 
+        min_length=1, 
+        description="Contact message",
+        error_messages={"min_length": "Message cannot be empty"}
+    )
+
+    @validator('name')
+    def validate_name(cls, v):
+        if v is not None and not v.strip():
+            raise ValueError("Name cannot consist of only whitespace")
+        return v.strip() if v else v
+
+    @validator('message')
+    def validate_message(cls, v):
+        if v is not None and not v.strip():
+            raise ValueError("Message cannot consist of only whitespace")
+        return v.strip() if v else v
 
 class ContactSchema(ContactBase):
     id: UUID