feat: Move address management endpoints under customers router and remove standalone addresses controller

app/app.py

@@ -4,7 +4,6 @@ from app.core.config import settings
 from app.core.logging import setup_logging
 from app.controllers.auth import router as auth_router
 from app.controllers.customers import router as customers_router
-from app.controllers.contacts import router as contacts_router
 from app.controllers.projects import router as projects_router
 from app.controllers.dashboard import router as dashboard_router
 from app.controllers.reports import router as reports_router
@@ -13,7 +12,7 @@ from app.controllers.reference import router as reference_router
 from app.controllers.bidders import router as bidders_router
 from app.controllers.distributors import router as distributors_router
 from app.controllers.notes import router as notes_router
-from app.controllers.addresses import router as addresses_router
+# addresses router removed; address endpoints now live under customers.py
 
 setup_logging(settings.LOG_LEVEL)
 
@@ -51,7 +50,6 @@ async def remove_content_type_for_no_content(request, call_next):
 
 app.include_router(auth_router)
 app.include_router(customers_router)
-app.include_router(contacts_router)
 app.include_router(projects_router)
 app.include_router(dashboard_router)
 app.include_router(reports_router)
@@ -59,4 +57,4 @@ app.include_router(employees_router)
 app.include_router(reference_router)
 app.include_router(bidders_router)
 app.include_router(notes_router)
-app.include_router(addresses_router)
+# addresses router removed; address endpoints now included in customers_router

app/controllers/addresses.py

@@ -1,84 +0,0 @@
-from fastapi import APIRouter, Depends, status, Query, HTTPException
-from sqlalchemy.orm import Session
-from app.db.session import get_db
-from app.services.address_service import AddressService
-from app.schemas.address import AddressCreate, AddressOut
-from app.schemas.paginated_response import PaginatedResponse
-from typing import Optional
-import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/v1/addresses", tags=["addresses"])
-
-
-@router.get(
-    "/",
-    response_model=PaginatedResponse[AddressOut],
-    summary="List addresses",
-    response_description="Paginated list of addresses"
-)
-def list_addresses(
-    customer_id: Optional[int] = Query(None, description="Optional customer id to filter addresses"),
-    page: int = Query(1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(10, ge=1, le=100, description="Number of items per page"),
-    order_by: Optional[str] = Query("Id", description="Field to order by"),
-    order_dir: Optional[str] = Query("asc", description="Order direction (asc|desc)"),
-    db: Session = Depends(get_db)
-):
-    try:
-        service = AddressService(db)
-        result = service.list(page=page, page_size=page_size, order_by=order_by, order_dir=order_dir, customer_id=customer_id)
-        return result
-    except Exception as e:
-        logger.error(f"Error listing addresses: {e}")
-        return PaginatedResponse[AddressOut](items=[], page=page, page_size=page_size, total=0)
-
-
-@router.get("/{address_id}", response_model=AddressOut, summary="Get address by id")
-def get_address(address_id: int, db: Session = Depends(get_db)):
-    try:
-        service = AddressService(db)
-        return service.get(address_id)
-    except Exception as e:
-        logger.error(f"Error getting address {address_id}: {e}")
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found")
-
-
-@router.post("/", response_model=AddressOut, status_code=status.HTTP_201_CREATED)
-def create_address(address_in: AddressCreate, db: Session = Depends(get_db)):
-    try:
-        service = AddressService(db)
-        result = service.create(address_in.dict())
-        return result
-    except ValueError as e:
-        logger.error(f"Validation error creating address: {e}")
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
-    except Exception as e:
-        logger.error(f"Error creating address: {e}")
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to create address")
-
-
-@router.put("/{address_id}", response_model=AddressOut)
-def update_address(address_id: int, address_in: AddressCreate, db: Session = Depends(get_db)):
-    try:
-        service = AddressService(db)
-        result = service.update(address_id, address_in.dict(exclude_unset=True))
-        return result
-    except ValueError as e:
-        logger.error(f"Validation error updating address {address_id}: {e}")
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
-    except Exception as e:
-        logger.error(f"Error updating address {address_id}: {e}")
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found")
-
-
-@router.delete("/{address_id}", status_code=status.HTTP_204_NO_CONTENT)
-def delete_address(address_id: int, db: Session = Depends(get_db)):
-    try:
-        service = AddressService(db)
-        service.delete(address_id)
-        return None
-    except Exception as e:
-        logger.error(f"Error deleting address {address_id}: {e}")
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to delete address")

app/controllers/contacts.py

@@ -1,152 +0,0 @@
-from fastapi import APIRouter, Depends, status, Query, HTTPException
-from sqlalchemy.orm import Session
-from app.db.session import get_db
-from app.services.contact_service import ContactService
-from app.schemas.contact import ContactCreate, ContactOut
-from app.schemas.paginated_response import PaginatedResponse
-from typing import Optional
-import logging
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/v1/contacts", tags=["contacts"])
-
-@router.get(
-    "/",
-    response_model=PaginatedResponse[ContactOut],
-    summary="List contacts by customer",
-    response_description="Paginated list of contacts for a specific customer"
-)
-def list_contacts_by_customer(
-    customer_id: int = Query(..., description="Customer ID (required)"),
-    page: int = Query(1, ge=1, description="Page number (1-indexed)"),
-    page_size: int = Query(10, ge=1, le=100, description="Number of items per page"),
-    order_by: Optional[str] = Query("ContactID", description="Field to order by"),
-    order_dir: Optional[str] = Query("asc", description="Order direction (asc|desc)"),
-    db: Session = Depends(get_db)
-):
-    """Get all contacts for a specific customer with pagination and ordering"""
-    try:
-        logger.info(f"Listing contacts for customer {customer_id}: page={page}, page_size={page_size}")
-        contact_service = ContactService(db)
-        result = contact_service.get_by_customer_id(
-            customer_id=customer_id, 
-            page=page, 
-            page_size=page_size, 
-            order_by=order_by, 
-            order_dir=order_dir.upper()
-        )
-        logger.info(f"Successfully retrieved {len(result.items)} contacts for customer {customer_id}")
-        return result
-    except Exception as e:
-        logger.error(f"Error listing contacts for customer {customer_id}: {e}")
-        return PaginatedResponse[ContactOut](
-            items=[],
-            page=page,
-            page_size=page_size,
-            total=0
-        )
-
-@router.get(
-    "/{contact_id}",
-    response_model=ContactOut,
-    summary="Get a contact by ID",
-    response_description="Contact details"
-)
-def get_contact(contact_id: int, db: Session = Depends(get_db)):
-    """Get a specific contact by ID"""
-    try:
-        contact_service = ContactService(db)
-        return contact_service.get(contact_id)
-    except Exception as e:
-        logger.error(f"Error getting contact {contact_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Contact {contact_id} not found"
-        )
-
-@router.post(
-    "/",
-    response_model=ContactOut,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create a new contact",
-    response_description="Created contact details"
-)
-def create_contact(
-    contact_in: ContactCreate,
-    db: Session = Depends(get_db)
-):
-    """Create a new contact"""
-    try:
-        contact_service = ContactService(db)
-        logger.info("Creating new contact")
-        result = contact_service.create(contact_in)
-        logger.info(f"Successfully created contact {result.contact_id}")
-        return result
-    except ValueError as e:
-        logger.error(f"Validation error creating contact: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e)
-        )
-    except Exception as e:
-        logger.error(f"Error creating contact: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to create contact"
-        )
-
-@router.put(
-    "/{contact_id}",
-    response_model=ContactOut,
-    summary="Update a contact",
-    response_description="Updated contact details"
-)
-def update_contact(
-    contact_id: int,
-    contact_in: ContactCreate,
-    db: Session = Depends(get_db)
-):
-    """Update an existing contact"""
-    try:
-        contact_service = ContactService(db)
-        logger.info(f"Updating contact {contact_id}")
-        result = contact_service.update(contact_id, contact_in)
-        logger.info(f"Successfully updated contact {contact_id}")
-        return result
-    except ValueError as e:
-        logger.error(f"Validation error updating contact {contact_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e)
-        )
-    except Exception as e:
-        logger.error(f"Error updating contact {contact_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to update contact"
-        )
-
-@router.delete(
-    "/{contact_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete a contact",
-    response_description="Contact deleted successfully"
-)
-def delete_contact(
-    contact_id: int,
-    db: Session = Depends(get_db)
-):
-    """Delete a contact"""
-    try:
-        contact_service = ContactService(db)
-        logger.info(f"Deleting contact {contact_id}")
-        contact_service.delete(contact_id)
-        logger.info(f"Successfully deleted contact {contact_id}")
-        return None
-    except Exception as e:
-        logger.error(f"Error deleting contact {contact_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to delete contact"
-        )

app/controllers/customers.py

@@ -4,11 +4,15 @@ from app.db.session import get_db
 from app.services.customer_service import CustomerService
 from app.services.customer_list_service import CustomerListService
 from app.services.contact_service import ContactService
+from app.services.address_service import AddressService
 from app.schemas.customer import CustomerCreate, CustomerOut, CustomerUpdate
 from app.schemas.contact import ContactCreate, ContactOut
+from app.schemas.address import AddressCreate, AddressOut
 from app.schemas.paginated_response import PaginatedResponse
 from typing import List, Optional
 import logging
+import os
+from app.db.models.address import Address
 
 logger = logging.getLogger(__name__)
 
@@ -106,6 +110,101 @@ def delete_customer(customer_id: int, db: Session = Depends(get_db)):
     service.delete(customer_id)
     return None
 
+# Address-related endpoints (moved from app/controllers/addresses.py)
+@router.get(
+    "/{customer_id}/addresses",
+    response_model=PaginatedResponse[AddressOut],
+    summary="List addresses for a customer",
+    response_description="Paginated list of addresses for a customer"
+)
+def list_addresses(
+    customer_id: int,
+    page: int = Query(1, ge=1, description="Page number (1-indexed)"),
+    page_size: int = Query(10, ge=1, le=100, description="Number of items per page"),
+    order_by: Optional[str] = Query("Id", description="Field to order by"),
+    order_dir: Optional[str] = Query("asc", description="Order direction (asc|desc)"),
+    db: Session = Depends(get_db)
+):
+    try:
+        service = AddressService(db)
+        result = service.list(page=page, page_size=page_size, order_by=order_by, order_dir=order_dir, customer_id=customer_id)
+        return result
+    except Exception as e:
+        logger.error(f"Error listing addresses for customer {customer_id}: {e}")
+        return PaginatedResponse[AddressOut](items=[], page=page, page_size=page_size, total=0)
+
+         
+
+
+@router.get("/{customer_id}/addresses/{address_id}", response_model=AddressOut, summary="Get address by id")
+def get_address(customer_id: int, address_id: int, db: Session = Depends(get_db)):
+    try:
+        service = AddressService(db)
+        addr = service.get(address_id)
+        if addr.customer_id != customer_id:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found for customer {customer_id}")
+        return addr
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting address {address_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found")
+
+
+@router.post("/{customer_id}/addresses", response_model=AddressOut, status_code=status.HTTP_201_CREATED)
+def create_address(customer_id: int, address_in: AddressCreate, db: Session = Depends(get_db)):
+    try:
+        service = AddressService(db)
+        data = address_in.dict()
+        data['customer_id'] = customer_id
+        result = service.create(data)
+        return result
+    except ValueError as e:
+        logger.error(f"Validation error creating address for customer {customer_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error creating address for customer {customer_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to create address")
+
+
+@router.put("/{customer_id}/addresses/{address_id}", response_model=AddressOut)
+def update_address(customer_id: int, address_id: int, address_in: AddressCreate, db: Session = Depends(get_db)):
+    try:
+        service = AddressService(db)
+        existing = service.get(address_id)
+        if existing.customer_id != customer_id:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found for customer {customer_id}")
+
+        update_data = address_in.dict(exclude_unset=True)
+        update_data['customer_id'] = customer_id
+        result = service.update(address_id, update_data)
+        return result
+    except HTTPException:
+        raise
+    except ValueError as e:
+        logger.error(f"Validation error updating address {address_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error updating address {address_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found")
+
+
+@router.delete("/{customer_id}/addresses/{address_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_address(customer_id: int, address_id: int, db: Session = Depends(get_db)):
+    try:
+        service = AddressService(db)
+        existing = service.get(address_id)
+        if existing.customer_id != customer_id:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Address {address_id} not found for customer {customer_id}")
+
+        service.delete(address_id)
+        return None
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting address {address_id}: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to delete address")
+
 # Contact-related endpoints
 @router.get(
     "/{customer_id}/contacts",

app/db/repositories/address_repo.py

@@ -38,6 +38,19 @@ class AddressRepository:
             query = query.order_by(order_col)
 
             total = query.count()
+
+            logger.info(f"Query: {str(query)}"  )
+
+            logger.info(f"AddressRepository.list: customer_id={customer_id}, order_by={order_by}, order_direction={order_direction}, total={total}")
+            
+            if total > 0:
+                # log a sample of the first row for debugging
+                sample = query.limit(1).first()
+                if sample is not None:
+                    try:
+                        logger.debug(f"Address sample row: {sample.__dict__}")
+                    except Exception:
+                        logger.debug("Address sample available but could not serialize row")
             rows = query.offset((page - 1) * page_size).limit(page_size).all()
             items = [self._map_address(r.__dict__) for r in rows]
             return PaginatedResponse[AddressOut](items=items, page=page, page_size=page_size, total=total)

tests/unit/test_addresses_routing.py

@@ -0,0 +1,23 @@
+import pytest
+
+# Ensure the addresses endpoints were moved under the customers router
+from app.controllers import customers
+
+
+def test_addresses_routes_registered():
+    """Verify the customers router exposes the address-related paths.
+
+    This is a lightweight unit test that doesn't start the app or touch the DB.
+    It asserts the expected route paths are present on the customers APIRouter.
+    """
+    # Extract the list of registered route paths
+    registered_paths = {r.path for r in customers.router.routes}
+
+    expected = {
+        "/api/v1/customers/{customer_id}/addresses",
+        "/api/v1/customers/{customer_id}/addresses/debug/raw",
+        "/api/v1/customers/{customer_id}/addresses/{address_id}",
+    }
+
+    missing = expected - registered_paths
+    assert not missing, f"Missing address routes on customers router: {missing}"