feat(projects): add endpoints to retrieve project customers and customer details with pagination

app/controllers/projects.py

@@ -3,7 +3,7 @@ from sqlalchemy.orm import Session
 from app.db.session import get_db
 from app.services.project_service import ProjectService
 from app.schemas.project import ProjectCreate, ProjectOut
-from app.schemas.project_detail import ProjectDetailOut
+from app.schemas.project_detail import ProjectDetailOut, ProjectCustomerOut
 from app.schemas.paginated_response import PaginatedResponse
 from typing import List, Optional
 
@@ -42,6 +42,41 @@ def get_project(project_no: int, db: Session = Depends(get_db)):
     service = ProjectService(db)
     return service.get_detailed(project_no)
 
+
+@router.get("/{project_no}/customers", response_model=List[ProjectCustomerOut])
+def get_project_customers(
+    project_no: int,
+    page: Optional[int] = Query(1, description="Page number (1-indexed)", ge=1),
+    page_size: Optional[int] = Query(100, description="Number of records per page", ge=1, le=1000),
+    db: Session = Depends(get_db)
+):
+    """Get customers associated with a specific project (by ProjectNo)
+
+    Returns a paginated list of customers for the project. Pagination defaults
+    to page=1 and page_size=100 to avoid very large responses.
+    """
+    service = ProjectService(db)
+    # Use the dedicated service method to fetch only customers for the project
+    return service.get_customers(project_no, page=page, page_size=page_size)
+
+
+@router.get("/{project_no}/customers/{customer_id}", response_model=ProjectCustomerOut)
+def get_project_customer_detail(
+    project_no: int,
+    customer_id: str,
+    db: Session = Depends(get_db)
+):
+    """Get detailed bidder information for a specific customer on a project
+    
+    Returns the complete bidder details including barrier sizes, contacts, and notes
+    for the specified project number and customer ID combination.
+    
+    - **project_no**: The project number
+    - **customer_id**: The customer ID (CustId from Bidders table)
+    """
+    service = ProjectService(db)
+    return service.get_project_customer_detail(project_no, customer_id)
+
 @router.post("/", response_model=ProjectOut, status_code=status.HTTP_201_CREATED)
 def create_project(project_in: ProjectCreate, db: Session = Depends(get_db)):
     """

app/db/repositories/bidder_repo.py

@@ -6,6 +6,7 @@ from app.schemas.paginated_response import PaginatedResponse
 from app.core.exceptions import NotFoundException
 from typing import List, Optional
 import logging
+from sqlalchemy import text
 
 logger = logging.getLogger(__name__)
 
@@ -58,6 +59,168 @@ class BidderRepository:
                 total=0
             )
 
+    # --- Raw SQL helpers for project-related customer data ---
+    def fetch_project_bidders_raw(self, project_no: int, page: int = 1, page_size: int = 100):
+        """Return raw bidder rows for a given project using direct SQL (dicts).
+
+        This method is intended to be used by higher-level services that will
+        map database column names to schema fields.
+        """
+        try:
+            with self.db.get_bind().connect() as conn:
+                bidders_query = text(f"""
+                    SELECT 
+                        ProjNo as proj_no,
+                        CustId as cust_id, 
+                        Quote as quote,
+                        Contact as contact,
+                        Phone as phone,
+                        Notes as notes,
+                        DateLastContact as date_last_contact,
+                        DateFollowup as date_followup,
+                        [Primary] as is_primary,
+                        CustType as cust_type,
+                        EmailAddress as email_address,
+                        Id,
+                        Fax as fax,
+                        OrderNr as order_nr,
+                        CustomerPO as customer_po,
+                        ShipDate as ship_date,
+                        DeliverDate as deliver_date,
+                        ReplacementCost as replacement_cost,
+                        QuoteDate as quote_date,
+                        InvoiceDate as invoice_date,
+                        LessPayment as less_payment,
+                        Enabled as enabled,
+                        EmployeeId as employee_id
+                    FROM Bidders 
+                    WHERE ProjNo = :project_no
+                    ORDER BY [Primary] DESC, Id
+                    OFFSET :offset ROWS FETCH NEXT :limit ROWS ONLY
+                """,
+                )
+
+                offset = max(0, (page - 1) * page_size)
+                limit = max(1, min(page_size, 1000))
+                result = conn.execute(bidders_query, {"project_no": project_no, "offset": offset, "limit": limit})
+                rows = result.fetchall()
+                columns = result.keys()
+                return [dict(zip(columns, row)) for row in rows]
+        except Exception as e:
+            logger.warning(f"Error fetching project bidders raw for project {project_no}: {e}")
+            return []
+
+    def fetch_project_bidder_by_customer_id_raw(self, project_no: int, customer_id: str):
+        """Fetch a single bidder for a specific project and customer ID.
+        
+        Returns a single dict or None if not found.
+        """
+        try:
+            with self.db.get_bind().connect() as conn:
+                bidder_query = text("""
+                    SELECT 
+                        ProjNo as proj_no,
+                        CustId as cust_id, 
+                        Quote as quote,
+                        Contact as contact,
+                        Phone as phone,
+                        Notes as notes,
+                        DateLastContact as date_last_contact,
+                        DateFollowup as date_followup,
+                        [Primary] as is_primary,
+                        CustType as cust_type,
+                        EmailAddress as email_address,
+                        Id,
+                        Fax as fax,
+                        OrderNr as order_nr,
+                        CustomerPO as customer_po,
+                        ShipDate as ship_date,
+                        DeliverDate as deliver_date,
+                        ReplacementCost as replacement_cost,
+                        QuoteDate as quote_date,
+                        InvoiceDate as invoice_date,
+                        LessPayment as less_payment,
+                        Enabled as enabled,
+                        EmployeeId as employee_id
+                    FROM Bidders 
+                    WHERE ProjNo = :project_no AND CustId = :customer_id
+                """)
+                
+                result = conn.execute(bidder_query, {"project_no": project_no, "customer_id": customer_id})
+                row = result.fetchone()
+                if row:
+                    columns = result.keys()
+                    return dict(zip(columns, row))
+                return None
+        except Exception as e:
+            logger.warning(f"Error fetching bidder for project {project_no}, customer {customer_id}: {e}")
+            return None
+
+    def get_bidder_barrier_sizes_raw(self, bidder_id: int):
+        """Return raw barrier size rows for a bidder (list of dicts)."""
+        try:
+            with self.db.get_bind().connect() as conn:
+                direct_query = text("""
+                    SELECT Id, InventoryId, BarrierSizeId, InstallAdvisorFees, 
+                           IsStandard, Width, Length, CableUnits, Height, Price
+                    FROM BiddersBarrierSizes 
+                    WHERE BidderId = :bidder_id
+                    ORDER BY Id
+                """)
+                result = conn.execute(direct_query, {"bidder_id": bidder_id})
+                if result.returns_rows:
+                    rows = result.fetchall()
+                    cols = result.keys()
+                    return [dict(zip(cols, r)) for r in rows]
+                return []
+        except Exception as e:
+            logger.warning(f"Error fetching barrier sizes for bidder {bidder_id}: {e}")
+            return []
+
+    def get_bidder_contacts_raw(self, bidder_id: int):
+        """Return raw contact rows for a bidder."""
+        try:
+            with self.db.get_bind().connect() as conn:
+                contacts_query = text("""
+                    SELECT bc.Id, bc.ContactId, bc.BidderId, bc.Enabled,
+                           c.FirstName, c.LastName, c.Title, c.EmailAddress,
+                           c.WorkPhone, c.MobilePhone
+                    FROM BidderContact bc
+                    INNER JOIN Contacts c ON bc.ContactId = c.ContactID
+                    WHERE bc.BidderId = :bidder_id
+                    ORDER BY bc.Id
+                """)
+                result = conn.execute(contacts_query, {"bidder_id": bidder_id})
+                if result.returns_rows:
+                    rows = result.fetchall()
+                    cols = result.keys()
+                    return [dict(zip(cols, r)) for r in rows]
+                return []
+        except Exception as e:
+            logger.warning(f"Error fetching contacts for bidder {bidder_id}: {e}")
+            return []
+
+    def get_bidder_notes_raw(self, bidder_id: int):
+        """Return raw bidder notes rows."""
+        try:
+            with self.db.get_bind().connect() as conn:
+                notes_query = text("""
+                    SELECT Id, BidderId, Date, EmployeeID, 
+                           CAST(Notes AS nvarchar(max)) as Notes
+                    FROM BidderNote 
+                    WHERE BidderId = :bidder_id
+                    ORDER BY Date DESC
+                """)
+                result = conn.execute(notes_query, {"bidder_id": bidder_id})
+                if result.returns_rows:
+                    rows = result.fetchall()
+                    cols = result.keys()
+                    return [dict(zip(cols, r)) for r in rows]
+                return []
+        except Exception as e:
+            logger.warning(f"Error fetching bidder notes for {bidder_id}: {e}")
+            return []
+
     def get_by_project_no(self, proj_no: str, page: int = 1, page_size: int = 10, 
                           order_by: str = "Id", order_dir: str = "ASC") -> PaginatedResponse[BidderOut]:
         """Get bidders for a specific project using Bidders table directly."""

app/services/project_service.py

@@ -113,6 +113,132 @@ class ProjectService:
             logger.debug(f"Detail data: {detail_data}")
             raise NotFoundException("Error processing detailed project data")
 
+    def get_customers(self, project_no: int, page: int = 1, page_size: int = 100) -> List[ProjectCustomerOut]:
+        """
+        Public method to retrieve customers for a specific project.
+
+        This is a thin wrapper around the internal `_get_project_customers`
+        implementation so controllers can request only the customer data
+        without constructing the full detailed project payload.
+        """
+        # Use repository-level SQL with pagination and map results to schema objects
+        return self._get_project_customers(project_no, page=page, page_size=page_size)
+
+    def get_project_customer_detail(self, project_no: int, customer_id: str) -> ProjectCustomerOut:
+        """
+        Get detailed bidder information for a specific customer on a project.
+        
+        Args:
+            project_no: The project number
+            customer_id: The customer ID (CustId)
+            
+        Returns:
+            ProjectCustomerOut: Complete bidder details with nested data
+            
+        Raises:
+            NotFoundException: If the bidder is not found
+        """
+        from app.db.repositories.bidder_repo import BidderRepository
+        
+        bidder_repo = BidderRepository(self.db)
+        bidder_data = bidder_repo.fetch_project_bidder_by_customer_id_raw(project_no, customer_id)
+        
+        if not bidder_data:
+            raise NotFoundException(f"Bidder not found for project {project_no} and customer {customer_id}")
+        
+        bidder_id = bidder_data.get('Id')
+        
+        # Fetch related data
+        barrier_rows = bidder_repo.get_bidder_barrier_sizes_raw(bidder_id)
+        contacts_rows = bidder_repo.get_bidder_contacts_raw(bidder_id)
+        notes_rows = bidder_repo.get_bidder_notes_raw(bidder_id)
+        
+        # Map barrier rows to BarrierSizeOut
+        barrier_sizes = []
+        for br in barrier_rows:
+            barrier_sizes.append(BarrierSizeOut(
+                id=br.get('Id', 0),
+                inventory_id=str(br.get('InventoryId', '')) if br.get('InventoryId') is not None else None,
+                bidder_id=bidder_id,
+                barrier_size_id=br.get('BarrierSizeId', 0),
+                install_advisor_fees=br.get('InstallAdvisorFees'),
+                is_standard=bool(br.get('IsStandard', True)),
+                width=br.get('Width'),
+                length=br.get('Length'),
+                cable_units=br.get('CableUnits'),
+                height=br.get('Height'),
+                price=br.get('Price')
+            ))
+        
+        # Map contacts
+        contacts = []
+        for cr in contacts_rows:
+            contacts.append(ContactOut(
+                id=cr.get('Id'),
+                contact_id=cr.get('ContactId'),
+                bidder_id=bidder_id,
+                enabled=bool(cr.get('Enabled', True)),
+                first_name=cr.get('FirstName'),
+                last_name=cr.get('LastName'),
+                title=cr.get('Title'),
+                email=cr.get('EmailAddress'),
+                phones=[],
+                phone1=cr.get('WorkPhone'),
+                phone2=cr.get('MobilePhone')
+            ))
+        
+        # Map notes
+        bidder_notes = []
+        for nr in notes_rows:
+            bidder_notes.append(BidderNoteOut(
+                id=nr.get('Id'),
+                bidder_id=bidder_id,
+                date=nr.get('Date'),
+                employee_id=nr.get('EmployeeID'),
+                notes=nr.get('Notes', '')
+            ))
+        
+        # Create customer object with proper type conversions
+        replacement_cost = bidder_data.get('replacement_cost')
+        if replacement_cost == '' or replacement_cost is None:
+            replacement_cost = None
+        
+        cust_type = bidder_data.get('cust_type')
+        if cust_type is not None:
+            cust_type = str(cust_type)
+        
+        customer = ProjectCustomerOut(
+            proj_no=bidder_data.get('proj_no', 0),
+            cust_id=str(bidder_data.get('cust_id', '')),
+            quote=bidder_data.get('quote'),
+            contact=bidder_data.get('contact'),
+            phone=bidder_data.get('phone'),
+            notes=bidder_data.get('notes'),
+            date_last_contact=bidder_data.get('date_last_contact'),
+            date_followup=bidder_data.get('date_followup'),
+            primary=bool(bidder_data.get('is_primary', False)),
+            cust_type=cust_type,
+            email_address=bidder_data.get('email_address'),
+            id=bidder_id,
+            fax=bidder_data.get('fax'),
+            order_nr=bidder_data.get('order_nr'),
+            customer_po=bidder_data.get('customer_po'),
+            ship_date=bidder_data.get('ship_date'),
+            deliver_date=bidder_data.get('deliver_date'),
+            replacement_cost=replacement_cost,
+            quote_date=bidder_data.get('quote_date'),
+            invoice_date=bidder_data.get('invoice_date'),
+            less_payment=bidder_data.get('less_payment'),
+            barrier_sizes=barrier_sizes,
+            contacts=contacts,
+            bidder_notes=bidder_notes,
+            bid_date=bidder_data.get('date_last_contact'),  # Using last contact as bid date
+            enabled=bool(bidder_data.get('enabled', True)),
+            employee_id=str(bidder_data.get('employee_id')) if bidder_data.get('employee_id') is not None else None
+        )
+        
+        return customer
+
     def list_projects(self, customer_type: int = 0, order_by: str = "project_no", 
                      order_direction: str = "asc", page: int = 1, page_size: int = 10) -> PaginatedResponse[ProjectOut]:
         """
@@ -568,134 +694,116 @@ class ProjectService:
         
         return detail_data
 
-    def _get_project_customers(self, project_no: int) -> List[ProjectCustomerOut]:
+    def _get_project_customers(self, project_no: int, page: int = 1, page_size: int = 100) -> List[ProjectCustomerOut]:
         """
         Get customers associated with a project using stored procedures with fallback to direct SQL
         """
         try:
-            customers = []
-            
-            # First try using the stored procedure
-            with self.db.get_bind().connect() as conn:
-                try:
-                    logger.info(f"Attempting to get customers for project {project_no} using stored procedure")
-                    result = conn.execute(text('''
-                        EXEC spBiddersGetListByParam 
-                        @CustomerID = 0,
-                        @ProjectNo = :project_no,
-                        @CustTypeId = 0
-                    '''), {'project_no': project_no})
-                    rows = result.fetchall()
-                    
-                    if rows:
-                        logger.info(f"Stored procedure returned {len(rows)} customers for project {project_no}")
-                        for row in rows:
-                            row_data = dict(zip([desc[0] for desc in result.description], row))
-                            # Process stored procedure results...
-                            # Note: We'd need to map SP column names to our expected format
-                            # For now, fall through to direct SQL approach
-                        if not customers:  # If SP data processing didn't work, fall back
-                            raise Exception("Stored procedure returned data but processing failed")
-                    else:
-                        logger.warning(f"Stored procedure returned 0 customers for project {project_no}, falling back to direct SQL")
-                        raise Exception("No data from stored procedure")
-                        
-                except Exception as sp_error:
-                    logger.warning(f"Error using stored procedure for project {project_no}: {sp_error}")
-                    # Fall back to direct SQL query
-                    
-                    # Get bidders for this project using direct SQL (working approach)
-                    bidders_query = text("""
-                        SELECT 
-                            ProjNo as proj_no,
-                            CustId as cust_id, 
-                            Quote as quote,
-                            Contact as contact,
-                            Phone as phone,
-                            Notes as notes,
-                            DateLastContact as date_last_contact,
-                            DateFollowup as date_followup,
-                            [Primary] as is_primary,
-                            CustType as cust_type,
-                            EmailAddress as email_address,
-                            Id,
-                            Fax as fax,
-                            OrderNr as order_nr,
-                            CustomerPO as customer_po,
-                            ShipDate as ship_date,
-                            DeliverDate as deliver_date,
-                            ReplacementCost as replacement_cost,
-                            QuoteDate as quote_date,
-                            InvoiceDate as invoice_date,
-                            LessPayment as less_payment,
-                            Enabled as enabled,
-                            EmployeeId as employee_id
-                        FROM Bidders 
-                        WHERE ProjNo = :project_no
-                        ORDER BY [Primary] DESC, Id
-                    """)
-                    
-                    result = conn.execute(bidders_query, {"project_no": project_no})
-                    bidder_rows = result.fetchall()
-                    
-                    logger.info(f"Direct SQL returned {len(bidder_rows)} customers for project {project_no}")
-                    
-                    for bidder_row in bidder_rows:
-                        bidder_data = dict(zip(result.keys(), bidder_row))
-                        bidder_id = bidder_data['Id']
-                        
-                        # Get barrier sizes for this bidder
-                        barrier_sizes = self._get_bidder_barrier_sizes(bidder_id)
-                        
-                        # Get contacts for this bidder
-                        contacts = self._get_bidder_contacts(bidder_id)
-                        
-                        # Get bidder notes for this bidder
-                        bidder_notes = self._get_bidder_notes(bidder_id)
-                        
-                        # Create customer object with proper type conversions
-                        replacement_cost = bidder_data.get('replacement_cost')
-                        if replacement_cost == '' or replacement_cost is None:
-                            replacement_cost = None
-                        
-                        cust_type = bidder_data.get('cust_type')
-                        if cust_type is not None:
-                            cust_type = str(cust_type)
-                        
-                        customer = ProjectCustomerOut(
-                            proj_no=bidder_data.get('proj_no', 0),
-                            cust_id=str(bidder_data.get('cust_id', '')),
-                            quote=bidder_data.get('quote'),
-                            contact=bidder_data.get('contact'),
-                            phone=bidder_data.get('phone'),
-                            notes=bidder_data.get('notes'),
-                            date_last_contact=bidder_data.get('date_last_contact'),
-                            date_followup=bidder_data.get('date_followup'),
-                            primary=bool(bidder_data.get('is_primary', False)),
-                            cust_type=cust_type,
-                            email_address=bidder_data.get('email_address'),
-                            id=bidder_id,
-                            fax=bidder_data.get('fax'),
-                            order_nr=bidder_data.get('order_nr'),
-                            customer_po=bidder_data.get('customer_po'),
-                            ship_date=bidder_data.get('ship_date'),
-                            deliver_date=bidder_data.get('deliver_date'),
-                            replacement_cost=replacement_cost,
-                            quote_date=bidder_data.get('quote_date'),
-                            invoice_date=bidder_data.get('invoice_date'),
-                            less_payment=bidder_data.get('less_payment'),
-                            barrier_sizes=barrier_sizes,
-                            contacts=contacts,
-                            bidder_notes=bidder_notes,
-                            bid_date=bidder_data.get('date_last_contact'),  # Using last contact as bid date
-                            enabled=bool(bidder_data.get('enabled', True)),
-                            employee_id=bidder_data.get('employee_id')
-                        )
-                        
-                        customers.append(customer)
+            from app.db.repositories.bidder_repo import BidderRepository
             
+            customers = []
+            # Use BidderRepository for bidder-related queries
+            bidder_repo = BidderRepository(self.db)
+            bidder_rows = bidder_repo.fetch_project_bidders_raw(project_no, page=page, page_size=page_size)
+
+            logger.info(f"Repository returned {len(bidder_rows)} bidders for project {project_no}")
+
+            for bidder_data in bidder_rows:
+                bidder_id = bidder_data.get('Id')
+
+                # Use repository helpers to fetch related bidder data
+                barrier_rows = bidder_repo.get_bidder_barrier_sizes_raw(bidder_id)
+                contacts_rows = bidder_repo.get_bidder_contacts_raw(bidder_id)
+                notes_rows = bidder_repo.get_bidder_notes_raw(bidder_id)
+
+                # Map barrier rows to BarrierSizeOut
+                barrier_sizes = []
+                for br in barrier_rows:
+                    barrier_sizes.append(BarrierSizeOut(
+                        id=br.get('Id', 0),
+                        inventory_id=str(br.get('InventoryId', '')) if br.get('InventoryId') is not None else None,
+                        bidder_id=bidder_id,
+                        barrier_size_id=br.get('BarrierSizeId', 0),
+                        install_advisor_fees=br.get('InstallAdvisorFees'),
+                        is_standard=bool(br.get('IsStandard', True)),
+                        width=br.get('Width'),
+                        length=br.get('Length'),
+                        cable_units=br.get('CableUnits'),
+                        height=br.get('Height'),
+                        price=br.get('Price')
+                    ))
+
+                # Map contacts
+                contacts = []
+                for cr in contacts_rows:
+                    contacts.append(ContactOut(
+                        id=cr.get('Id'),
+                        contact_id=cr.get('ContactId'),
+                        bidder_id=bidder_id,
+                        enabled=bool(cr.get('Enabled', True)),
+                        first_name=cr.get('FirstName'),
+                        last_name=cr.get('LastName'),
+                        title=cr.get('Title'),
+                        email=cr.get('EmailAddress'),
+                        phones=[],
+                        phone1=cr.get('WorkPhone'),
+                        phone2=cr.get('MobilePhone')
+                    ))
+
+                # Map notes
+                bidder_notes = []
+                for nr in notes_rows:
+                    bidder_notes.append(BidderNoteOut(
+                        id=nr.get('Id'),
+                        bidder_id=bidder_id,
+                        date=nr.get('Date'),
+                        employee_id=nr.get('EmployeeID'),
+                        notes=nr.get('Notes', '')
+                    ))
+
+                # Create customer object with proper type conversions
+                replacement_cost = bidder_data.get('replacement_cost')
+                if replacement_cost == '' or replacement_cost is None:
+                    replacement_cost = None
+
+                cust_type = bidder_data.get('cust_type')
+                if cust_type is not None:
+                    cust_type = str(cust_type)
+
+                customer = ProjectCustomerOut(
+                    proj_no=bidder_data.get('proj_no', 0),
+                    cust_id=str(bidder_data.get('cust_id', '')),
+                    quote=bidder_data.get('quote'),
+                    contact=bidder_data.get('contact'),
+                    phone=bidder_data.get('phone'),
+                    notes=bidder_data.get('notes'),
+                    date_last_contact=bidder_data.get('date_last_contact'),
+                    date_followup=bidder_data.get('date_followup'),
+                    primary=bool(bidder_data.get('is_primary', False)),
+                    cust_type=cust_type,
+                    email_address=bidder_data.get('email_address'),
+                    id=bidder_id,
+                    fax=bidder_data.get('fax'),
+                    order_nr=bidder_data.get('order_nr'),
+                    customer_po=bidder_data.get('customer_po'),
+                    ship_date=bidder_data.get('ship_date'),
+                    deliver_date=bidder_data.get('deliver_date'),
+                    replacement_cost=replacement_cost,
+                    quote_date=bidder_data.get('quote_date'),
+                    invoice_date=bidder_data.get('invoice_date'),
+                    less_payment=bidder_data.get('less_payment'),
+                    barrier_sizes=barrier_sizes,
+                    contacts=contacts,
+                    bidder_notes=bidder_notes,
+                    bid_date=bidder_data.get('date_last_contact'),  # Using last contact as bid date
+                    enabled=bool(bidder_data.get('enabled', True)),
+                    employee_id=str(bidder_data.get('employee_id')) if bidder_data.get('employee_id') is not None else None
+                )
+
+                customers.append(customer)
+
             return customers
-            
+
         except Exception as e:
             logger.warning(f"Error retrieving customers for project {project_no}: {e}")
             return []

app/tests/unit/test_project_customers.py

@@ -0,0 +1,190 @@
+import pytest
+from unittest.mock import Mock
+from app.services.project_service import ProjectService
+from app.schemas.project_detail import ProjectCustomerOut, BarrierSizeOut, ContactOut, BidderNoteOut
+
+from unittest.mock import MagicMock
+import app.controllers.projects as projects_controller
+
+
+def make_sample_bidder_row():
+    return {
+        'proj_no': 123,
+        'cust_id': 'CUST123',
+        'quote': None,
+        'contact': 'Jane Doe',
+        'phone': '555-1234',
+        'notes': 'Important customer',
+        'date_last_contact': None,
+        'date_followup': None,
+        'is_primary': 1,
+        'cust_type': 2,
+        'email_address': 'jane@example.com',
+        'Id': 10,
+        'fax': None,
+        'order_nr': None,
+        'customer_po': None,
+        'ship_date': None,
+        'deliver_date': None,
+        'replacement_cost': None,
+        'quote_date': None,
+        'invoice_date': None,
+        'less_payment': None,
+        'enabled': 1,
+        'employee_id': 5
+    }
+
+
+def test_get_customers_service_calls_repo_methods(monkeypatch):
+    mock_db = Mock()
+    service = ProjectService(mock_db)
+
+    # Mock BidderRepository since service now creates its own instance
+    from app.db.repositories.bidder_repo import BidderRepository
+    mock_bidder_repo = Mock(spec=BidderRepository)
+    mock_bidder_repo.fetch_project_bidders_raw = Mock(return_value=[make_sample_bidder_row()])
+    mock_bidder_repo.get_bidder_barrier_sizes_raw = Mock(return_value=[{'Id': 1, 'InventoryId': 'INV1', 'BarrierSizeId': 42, 'InstallAdvisorFees': None, 'IsStandard': 1, 'Width': 10, 'Length': 20, 'CableUnits': 2, 'Height': 5, 'Price': None}])
+    mock_bidder_repo.get_bidder_contacts_raw = Mock(return_value=[{'Id': 2, 'ContactId': 200, 'BidderId': 10, 'Enabled': 1, 'FirstName': 'John', 'LastName': 'Smith', 'Title': 'Mgr', 'EmailAddress': 'john@example.com', 'WorkPhone': '555', 'MobilePhone': '999'}])
+    mock_bidder_repo.get_bidder_notes_raw = Mock(return_value=[{'Id': 3, 'BidderId': 10, 'Date': '2020-01-01T00:00:00', 'EmployeeID': '5', 'Notes': 'Note text'}])
+
+    # Patch BidderRepository instantiation
+    def fake_bidder_repo_init(db):
+        return mock_bidder_repo
+    
+    monkeypatch.setattr('app.db.repositories.bidder_repo.BidderRepository', fake_bidder_repo_init)
+
+    customers = service.get_customers(123)
+
+    assert isinstance(customers, list)
+    assert len(customers) == 1
+    cust = customers[0]
+    assert isinstance(cust, ProjectCustomerOut)
+    assert cust.cust_id == 'CUST123'
+    assert cust.contact == 'Jane Doe'
+    assert cust.id == 10
+    assert len(cust.barrier_sizes) == 1
+    assert len(cust.contacts) == 1
+    assert len(cust.bidder_notes) == 1
+
+
+def test_get_project_customers_endpoint_monkeypatched(monkeypatch):
+    # Monkeypatch the ProjectService.get_customers to return a known value
+    sample = ProjectCustomerOut(
+        proj_no=123,
+        cust_id='CUST999',
+        quote=None,
+        contact='Endpoint User',
+        phone='123',
+        notes=None,
+        date_last_contact=None,
+        date_followup=None,
+        primary=True,
+        cust_type='1',
+        email_address='end@example.com',
+        id=99,
+        fax=None,
+        order_nr=None,
+        customer_po=None,
+        ship_date=None,
+        deliver_date=None,
+        replacement_cost=None,
+        quote_date=None,
+        invoice_date=None,
+        less_payment=None,
+        barrier_sizes=[],
+        contacts=[],
+        bidder_notes=[],
+        bid_date=None,
+        enabled=True,
+        employee_id=None
+    )
+
+    def fake_get_customers(self, project_no, page=1, page_size=100):
+        return [sample]
+
+    monkeypatch.setattr('app.services.project_service.ProjectService.get_customers', fake_get_customers)
+
+    # Call controller function directly, injecting a mock DB session
+    fake_db = MagicMock()
+    result = projects_controller.get_project_customers(123, page=1, page_size=10, db=fake_db)
+    assert isinstance(result, list)
+    assert result[0].cust_id == 'CUST999'
+    assert result[0].id == 99
+
+
+def test_get_project_customer_detail_service(monkeypatch):
+    """Test ProjectService.get_project_customer_detail method"""
+    mock_db = Mock()
+    service = ProjectService(mock_db)
+    
+    sample_bidder = make_sample_bidder_row()
+    sample_bidder['cust_id'] = 'CUST456'
+    
+    # Mock BidderRepository methods
+    from app.db.repositories.bidder_repo import BidderRepository
+    mock_bidder_repo = Mock(spec=BidderRepository)
+    mock_bidder_repo.fetch_project_bidder_by_customer_id_raw = Mock(return_value=sample_bidder)
+    mock_bidder_repo.get_bidder_barrier_sizes_raw = Mock(return_value=[])
+    mock_bidder_repo.get_bidder_contacts_raw = Mock(return_value=[])
+    mock_bidder_repo.get_bidder_notes_raw = Mock(return_value=[])
+    
+    # Patch BidderRepository instantiation
+    def fake_bidder_repo_init(db):
+        return mock_bidder_repo
+    
+    monkeypatch.setattr('app.db.repositories.bidder_repo.BidderRepository', fake_bidder_repo_init)
+    
+    customer = service.get_project_customer_detail(123, 'CUST456')
+    
+    assert isinstance(customer, ProjectCustomerOut)
+    assert customer.cust_id == 'CUST456'
+    assert customer.id == 10
+    assert customer.contact == 'Jane Doe'
+    mock_bidder_repo.fetch_project_bidder_by_customer_id_raw.assert_called_once_with(123, 'CUST456')
+
+
+def test_get_project_customer_detail_endpoint(monkeypatch):
+    """Test controller endpoint for specific customer detail"""
+    sample = ProjectCustomerOut(
+        proj_no=123,
+        cust_id='CUST777',
+        quote=None,
+        contact='Detail User',
+        phone='456',
+        notes='Specific customer',
+        date_last_contact=None,
+        date_followup=None,
+        primary=False,
+        cust_type='2',
+        email_address='detail@example.com',
+        id=77,
+        fax=None,
+        order_nr='ORD123',
+        customer_po='PO456',
+        ship_date=None,
+        deliver_date=None,
+        replacement_cost=None,
+        quote_date=None,
+        invoice_date=None,
+        less_payment=None,
+        barrier_sizes=[],
+        contacts=[],
+        bidder_notes=[],
+        bid_date=None,
+        enabled=True,
+        employee_id='EMP5'
+    )
+    
+    def fake_get_customer_detail(self, project_no, customer_id):
+        return sample
+    
+    monkeypatch.setattr('app.services.project_service.ProjectService.get_project_customer_detail', fake_get_customer_detail)
+    
+    fake_db = MagicMock()
+    result = projects_controller.get_project_customer_detail(123, 'CUST777', db=fake_db)
+    
+    assert isinstance(result, ProjectCustomerOut)
+    assert result.cust_id == 'CUST777'
+    assert result.id == 77
+    assert result.order_nr == 'ORD123'
+    assert result.employee_id == 'EMP5'