Implement project listing with pagination and sorting; add repository and service methods, update models and schemas, and include unit tests for functionality

app/controllers/projects.py

@@ -7,28 +7,64 @@ from typing import List
 
 router = APIRouter(prefix="/api/v1/projects", tags=["projects"])
 
-@router.get("/", response_model=List[ProjectOut])
-def list_projects(customer_id: int = None, status: str = None, skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
+from fastapi import APIRouter, Depends, status, Query
+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.paginated_response import PaginatedResponse
+from typing import List, Optional
+
+router = APIRouter(prefix="/api/v1/projects", tags=["projects"])
+
+@router.get("/", response_model=PaginatedResponse[ProjectOut])
+def list_projects(
+    customer_type: Optional[int] = Query(0, description="Customer type filter (0 for all types)", ge=0),
+    order_by: Optional[str] = Query("project_no", description="Field to order by"),
+    order_direction: Optional[str] = Query("asc", description="Order direction: asc or desc", regex="^(asc|desc)$"),
+    page: Optional[int] = Query(1, description="Page number (1-indexed)", ge=1),
+    page_size: Optional[int] = Query(10, description="Number of records per page", ge=1, le=100),
+    db: Session = Depends(get_db)
+):
+    """
+    Get paginated list of projects with filtering and sorting.
+    
+    - **customer_type**: Filter by customer type (0 = all types)
+    - **order_by**: Field name to sort by (project_no, project_name, etc.)
+    - **order_direction**: Sort direction (asc or desc)
+    - **page**: Page number starting from 1
+    - **page_size**: Number of records per page (max 100)
+    """
     service = ProjectService(db)
-    return service.list(customer_id, status, skip, limit)
+    return service.list_projects(
+        customer_type=customer_type,
+        order_by=order_by,
+        order_direction=order_direction,
+        page=page,
+        page_size=page_size
+    )
 
-@router.get("/{project_id}", response_model=ProjectOut)
-def get_project(project_id: int, db: Session = Depends(get_db)):
+@router.get("/{project_no}", response_model=ProjectOut)
+def get_project(project_no: int, db: Session = Depends(get_db)):
+    """Get a specific project by ProjectNo"""
     service = ProjectService(db)
-    return service.get(project_id)
+    return service.get(project_no)
 
 @router.post("/", response_model=ProjectOut, status_code=status.HTTP_201_CREATED)
 def create_project(project_in: ProjectCreate, db: Session = Depends(get_db)):
+    """Create a new project"""
     service = ProjectService(db)
     return service.create(project_in.dict())
 
-@router.put("/{project_id}", response_model=ProjectOut)
-def update_project(project_id: int, project_in: ProjectCreate, db: Session = Depends(get_db)):
+@router.put("/{project_no}", response_model=ProjectOut)
+def update_project(project_no: int, project_in: ProjectCreate, db: Session = Depends(get_db)):
+    """Update an existing project"""
     service = ProjectService(db)
-    return service.update(project_id, project_in.dict())
+    return service.update(project_no, project_in.dict())
 
-@router.delete("/{project_id}", status_code=status.HTTP_204_NO_CONTENT)
-def delete_project(project_id: int, db: Session = Depends(get_db)):
+@router.delete("/{project_no}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_project(project_no: int, db: Session = Depends(get_db)):
+    """Delete a project"""
     service = ProjectService(db)
-    service.delete(project_id)
+    service.delete(project_no)
     return None

app/core/exceptions.py

@@ -11,3 +11,7 @@ class NotFoundException(HTTPException):
 class BadRequestException(HTTPException):
     def __init__(self, detail: str = "Bad request"):
         super().__init__(status_code=status.HTTP_400_BAD_REQUEST, detail=detail)
+
+class RepositoryException(HTTPException):
+    def __init__(self, detail: str = "Database operation failed"):
+        super().__init__(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=detail)

app/db/models/project.py

@@ -1,17 +1,100 @@
-from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float, Boolean, Text, DECIMAL, Numeric
 from sqlalchemy.orm import relationship
 from app.db.base import Base
 from datetime import datetime
 
 class Project(Base):
-    __tablename__ = "projects"
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String(255), nullable=False)
-    customer_id = Column(Integer, ForeignKey("customers.id"), nullable=False)
-    start_date = Column(DateTime, nullable=True)
-    end_date = Column(DateTime, nullable=True)
-    status = Column(String(50), nullable=False)
-    budget = Column(Float, nullable=True)
-    description = Column(String(255), nullable=True)
-    created_at = Column(DateTime, default=datetime.utcnow)
-    customer = relationship("Customer")
+    __tablename__ = "Projects"  # Match actual SQL Server table name
+    
+    # Primary key - maps to ProjectNo
+    project_no = Column("ProjectNo", Integer, primary_key=True, index=True)
+    
+    # Basic project info
+    project_name = Column("ProjectName", String(500), nullable=True)
+    project_location = Column("ProjectLocation", String(50), nullable=True)
+    project_type = Column("ProjectType", String(50), nullable=True)
+    bid_date = Column("BidDate", DateTime, nullable=True)
+    start_date = Column("StartDate", DateTime, nullable=True)
+    is_awarded = Column("IsAwarded", Boolean, nullable=False, default=False)
+    notes = Column("Notes", Text, nullable=True)
+    
+    # Barrier and lease info
+    barrier_size = Column("BarrierSize", String(50), nullable=True)
+    lease_term = Column("LeaseTerm", String(50), nullable=True)
+    purchase_option = Column("PurchaseOption", Boolean, nullable=False, default=False)
+    lead_source = Column("LeadSource", String(50), nullable=True)
+    rep = Column("rep", String(50), nullable=True)
+    
+    # Engineer info
+    engineer_company_id = Column("EngineerCompanyId", Integer, nullable=True)
+    engineer_notes = Column("EngineerNotes", Text, nullable=True)
+    engineer_company = Column("EngineerCompany", String(75), nullable=True)
+    
+    # Status and customer info
+    status = Column("Status", Integer, nullable=True)
+    customer_type_id = Column("CustomertTypeId", Integer, nullable=True, default=1)
+    
+    # Billing address
+    bill_name = Column("Bill_Name", String(50), nullable=True)
+    bill_address1 = Column("Bill_Address1", String(50), nullable=True)
+    bill_address2 = Column("Bill_Address2", String(50), nullable=True)
+    bill_city = Column("Bill_City", String(30), nullable=True)
+    bill_state = Column("Bill_State", String(20), nullable=True)
+    bill_zip = Column("Bill_Zip", String(15), nullable=True)
+    bill_email = Column("Bill_Email", String(250), nullable=True)
+    bill_phone = Column("Bill_Phone", String(50), nullable=True)
+    
+    # Shipping address
+    ship_name = Column("Ship_Name", String(50), nullable=True)
+    ship_address1 = Column("Ship_Address1", String(50), nullable=True)
+    ship_address2 = Column("Ship_Address2", String(50), nullable=True)
+    ship_city = Column("Ship_City", String(30), nullable=True)
+    ship_state = Column("Ship_State", String(20), nullable=True)
+    ship_zip = Column("Ship_Zip", String(15), nullable=True)
+    ship_email = Column("Ship_Email", String(250), nullable=True)
+    ship_phone = Column("Ship_Phone", String(50), nullable=True)
+    ship_office_phone = Column("Ship_OfficePhone", String(50), nullable=True)
+    
+    # Payment and pricing info
+    acct_payable = Column("Acct_Payable", String(50), nullable=True)
+    payment_term_id = Column("PaymentTermId", Integer, nullable=True)
+    payment_note = Column("PaymentNote", String(25), nullable=True)
+    rental_price_id = Column("RentalPriceId", Integer, nullable=True)
+    purchase_price_id = Column("PurchasePriceId", Integer, nullable=True)
+    
+    # Shipping and freight info
+    est_ship_date_id = Column("EstShipDateId", Integer, nullable=True)
+    fob_id = Column("FOBId", Integer, nullable=True)
+    expedite_fee = Column("ExpediteFee", DECIMAL(10, 2), nullable=True)
+    est_freight_id = Column("EstFreightId", Integer, nullable=True)
+    est_freight_fee = Column("EstFreightFee", DECIMAL(10, 2), nullable=True)
+    ship_via = Column("ShipVia", String(50), nullable=True)
+    
+    # Financial info
+    tax_rate = Column("TaxRate", DECIMAL(10, 2), nullable=True)
+    weekly_charge = Column("WeeklyCharge", DECIMAL(10, 2), nullable=True)
+    commission = Column("Commission", DECIMAL(18, 2), nullable=True)
+    
+    # Project details
+    crew_members = Column("CrewMembers", Integer, nullable=True)
+    tack_hoes = Column("TackHoes", Integer, nullable=True)
+    water_pump = Column("WaterPump", Integer, nullable=True)
+    water_pump2 = Column("WaterPump2", Integer, nullable=True)
+    est_installation_time = Column("EstInstalationTime", Integer, nullable=True)
+    pipes = Column("Pipes", Integer, nullable=True)
+    timpers = Column("Timpers", Integer, nullable=True)
+    repair_kits = Column("RepairKits", String(50), nullable=True)
+    installation_advisor = Column("InstallationAdvisor", String(3000), nullable=True)
+    
+    # Employee and dates
+    employee_id = Column("EmployeeId", String(50), nullable=True)
+    advisor_id = Column("AdvisorId", String(50), nullable=True)
+    install_date = Column("InstallDate", DateTime, nullable=True)
+    
+    # Flags and options
+    fas_dam = Column("_FasDam", Boolean, nullable=False, default=False)
+    valid_for = Column("ValidFor", String(250), nullable=True)
+    is_international = Column("IsInternational", Boolean, nullable=True)
+    order_number = Column("OrderNumber", String(50), nullable=True)
+    same_bill_address = Column("SameBillAddress", Boolean, nullable=True)
+    install = Column("Install", Boolean, nullable=True)

app/db/repositories/project_repo.py

@@ -1,17 +1,122 @@
 from sqlalchemy.orm import Session
+from sqlalchemy import text, Row
 from app.db.models.project import Project
+from typing import List, Tuple, Dict, Any
+from app.core.exceptions import RepositoryException
+import logging
+
+logger = logging.getLogger(__name__)
 
 class ProjectRepository:
     def __init__(self, db: Session):
         self.db = db
 
-    def get(self, project_id: int):
-        return self.db.query(Project).filter(Project.id == project_id).first()
+    def get(self, project_no: int):
+        """Get a single project by ProjectNo"""
+        return self.db.query(Project).filter(Project.project_no == project_no).first()
+
+    def list_via_sp(self, customer_type: int = 0, order_by: str = "ProjectNo", 
+                   order_direction: str = "ASC", page: int = 1, page_size: int = 10) -> Tuple[List[Dict[str, Any]], int]:
+        """
+        Get projects list using stored procedure spProjectsGetList
+        
+        Args:
+            customer_type: Customer type filter (0 for all)
+            order_by: Column name to order by
+            order_direction: ASC or DESC
+            page: Page number (1-indexed)
+            page_size: Number of records per page
+            
+        Returns:
+            Tuple of (project_rows, total_count)
+        """
+        try:
+            # Call the stored procedure
+            sp_query = text("""
+                DECLARE @TotalRecords INT;
+                EXEC spProjectsGetList 
+                    @CustomerType = :customer_type,
+                    @OrderBy = :order_by,
+                    @OrderDirection = :order_direction,
+                    @Page = :page,
+                    @PageSize = :page_size,
+                    @TotalRecords = @TotalRecords OUTPUT;
+                SELECT @TotalRecords AS TotalRecords;
+            """)
+            
+            # Execute stored procedure
+            result = self.db.execute(sp_query, {
+                'customer_type': customer_type,
+                'order_by': order_by,
+                'order_direction': order_direction,
+                'page': page,
+                'page_size': page_size
+            })
+            
+            # Get all result sets
+            projects_data = []
+            total_records = 0
+            
+            # First result set contains project data
+            if result.returns_rows:
+                projects_rows = result.fetchall()
+                projects_data = [dict(row._mapping) for row in projects_rows]
+                
+                # Get next result set for total count
+                if result.nextset():
+                    total_result = result.fetchone()
+                    if total_result:
+                        total_records = total_result.TotalRecords
+            
+            logger.info(f"Retrieved {len(projects_data)} projects via stored procedure")
+            return projects_data, total_records
+            
+        except Exception as e:
+            logger.error(f"Error calling stored procedure: {e}")
+            # Fallback to direct SQL query
+            return self._list_fallback(customer_type, order_by, order_direction, page, page_size)
+
+    def _list_fallback(self, customer_type: int = 0, order_by: str = "ProjectNo", 
+                      order_direction: str = "ASC", page: int = 1, page_size: int = 10) -> Tuple[List[Dict[str, Any]], int]:
+        """
+        Fallback method using direct SQL query with pagination
+        """
+        try:
+            # Build the base query
+            base_query = "SELECT * FROM Projects"
+            count_query = "SELECT COUNT(*) as total FROM Projects"
+            
+            # Add WHERE clause if customer_type filter is specified
+            where_clause = ""
+            if customer_type > 0:
+                where_clause = f" WHERE CustomertTypeId = {customer_type}"
+            
+            # Add ORDER BY and pagination
+            order_clause = f" ORDER BY {order_by} {order_direction}"
+            offset = (page - 1) * page_size
+            limit_clause = f" OFFSET {offset} ROWS FETCH NEXT {page_size} ROWS ONLY"
+            
+            # Execute count query
+            total_result = self.db.execute(text(count_query + where_clause))
+            total_records = total_result.scalar()
+            
+            # Execute data query
+            data_query = base_query + where_clause + order_clause + limit_clause
+            result = self.db.execute(text(data_query))
+            projects_data = [dict(row._mapping) for row in result.fetchall()]
+            
+            logger.info(f"Retrieved {len(projects_data)} projects via fallback query")
+            return projects_data, total_records
+            
+        except Exception as e:
+            logger.error(f"Error in fallback query: {e}")
+            raise RepositoryException(f"Database error: {e}")
 
     def list(self, customer_id: int = None, status: str = None, skip: int = 0, limit: int = 10):
+        """Legacy list method for backward compatibility"""
         query = self.db.query(Project)
         if customer_id:
-            query = query.filter(Project.customer_id == customer_id)
+            query = query.filter(Project.customer_type_id == customer_id)
         if status:
             query = query.filter(Project.status == status)
         return query.offset(skip).limit(limit).all()

app/schemas/paginated_response.py

@@ -10,4 +10,4 @@ class PaginatedResponse(BaseModel, Generic[T]):
     total: int
 
     class Config:
-        orm_mode = True
+        from_attributes = True  # Updated for Pydantic v2

app/schemas/project.py

@@ -1,25 +1,110 @@
 from pydantic import BaseModel
 from typing import Optional
 from datetime import datetime
+from decimal import Decimal
 
 class ProjectCreate(BaseModel):
-    name: str
-    customer_id: int
+    project_name: Optional[str] = None
+    project_location: Optional[str] = None
+    project_type: Optional[str] = None
+    bid_date: Optional[datetime] = None
     start_date: Optional[datetime] = None
-    end_date: Optional[datetime] = None
-    status: str
-    budget: Optional[float] = None
-    description: Optional[str] = None
+    is_awarded: bool = False
+    notes: Optional[str] = None
+    barrier_size: Optional[str] = None
+    lease_term: Optional[str] = None
+    purchase_option: bool = False
+    lead_source: Optional[str] = None
+    rep: Optional[str] = None
+    engineer_company_id: Optional[int] = None
+    engineer_notes: Optional[str] = None
+    engineer_company: Optional[str] = None
+    status: Optional[int] = None
+    customer_type_id: Optional[int] = 1
+    
+    # Billing address
+    bill_name: Optional[str] = None
+    bill_address1: Optional[str] = None
+    bill_address2: Optional[str] = None
+    bill_city: Optional[str] = None
+    bill_state: Optional[str] = None
+    bill_zip: Optional[str] = None
+    bill_email: Optional[str] = None
+    bill_phone: Optional[str] = None
+    
+    # Shipping address
+    ship_name: Optional[str] = None
+    ship_address1: Optional[str] = None
+    ship_address2: Optional[str] = None
+    ship_city: Optional[str] = None
+    ship_state: Optional[str] = None
+    ship_zip: Optional[str] = None
+    ship_email: Optional[str] = None
+    ship_phone: Optional[str] = None
+    ship_office_phone: Optional[str] = None
 
 class ProjectOut(BaseModel):
-    id: int
-    name: str
-    customer_id: int
+    project_no: int
+    project_name: Optional[str] = None
+    project_location: Optional[str] = None
+    project_type: Optional[str] = None
+    bid_date: Optional[datetime] = None
     start_date: Optional[datetime] = None
-    end_date: Optional[datetime] = None
-    status: str
-    budget: Optional[float] = None
-    description: Optional[str] = None
+    is_awarded: bool = False
+    notes: Optional[str] = None
+    barrier_size: Optional[str] = None
+    lease_term: Optional[str] = None
+    purchase_option: bool = False
+    lead_source: Optional[str] = None
+    rep: Optional[str] = None
+    engineer_company_id: Optional[int] = None
+    engineer_notes: Optional[str] = None
+    engineer_company: Optional[str] = None
+    status: Optional[int] = None
+    customer_type_id: Optional[int] = None
+    
+    # Billing address
+    bill_name: Optional[str] = None
+    bill_address1: Optional[str] = None
+    bill_address2: Optional[str] = None
+    bill_city: Optional[str] = None
+    bill_state: Optional[str] = None
+    bill_zip: Optional[str] = None
+    bill_email: Optional[str] = None
+    bill_phone: Optional[str] = None
+    
+    # Shipping address
+    ship_name: Optional[str] = None
+    ship_address1: Optional[str] = None
+    ship_address2: Optional[str] = None
+    ship_city: Optional[str] = None
+    ship_state: Optional[str] = None
+    ship_zip: Optional[str] = None
+    ship_email: Optional[str] = None
+    ship_phone: Optional[str] = None
+    ship_office_phone: Optional[str] = None
+    
+    # Payment and pricing info
+    acct_payable: Optional[str] = None
+    payment_term_id: Optional[int] = None
+    payment_note: Optional[str] = None
+    rental_price_id: Optional[int] = None
+    purchase_price_id: Optional[int] = None
+    
+    # Financial info
+    tax_rate: Optional[Decimal] = None
+    weekly_charge: Optional[Decimal] = None
+    commission: Optional[Decimal] = None
+    
+    # Project details
+    crew_members: Optional[int] = None
+    install_date: Optional[datetime] = None
+    employee_id: Optional[str] = None
+    advisor_id: Optional[str] = None
+    
+    # Flags
+    is_international: Optional[bool] = None
+    order_number: Optional[str] = None
 
     class Config:
-        orm_mode = True
+        from_attributes = True  # Updated for Pydantic v2

app/services/project_service.py

@@ -2,34 +2,181 @@ from sqlalchemy.orm import Session
 from app.db.models.project import Project
 from app.db.repositories.project_repo import ProjectRepository
 from app.core.exceptions import NotFoundException
+from app.schemas.project import ProjectOut
+from app.schemas.paginated_response import PaginatedResponse
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
 
 class ProjectService:
+    # Allowed columns for ordering with their database column mappings
+    ALLOWED_ORDER_BY = {
+        "project_no": "ProjectNo",
+        "project_name": "ProjectName", 
+        "project_location": "ProjectLocation",
+        "project_type": "ProjectType",
+        "bid_date": "BidDate",
+        "start_date": "StartDate",
+        "status": "Status",
+        "is_awarded": "IsAwarded",
+        "customer_type_id": "CustomertTypeId"
+    }
+    
     def __init__(self, db: Session):
         self.repo = ProjectRepository(db)
 
-    def get(self, project_id: int):
-        project = self.repo.get(project_id)
+    def get(self, project_no: int):
+        """Get a single project by ProjectNo"""
+        project = self.repo.get(project_no)
         if not project:
             raise NotFoundException("Project not found")
         return project
 
+    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]:
+        """
+        Get paginated list of projects using stored procedure
+        
+        Args:
+            customer_type: Customer type filter (0 for all types)
+            order_by: Field name to order by (snake_case)
+            order_direction: "asc" or "desc"
+            page: Page number (1-indexed) 
+            page_size: Number of records per page
+            
+        Returns:
+            PaginatedResponse containing ProjectOut items
+        """
+        # Validate and normalize parameters
+        order_by = order_by.lower() if order_by else "project_no"
+        order_direction = order_direction.upper() if order_direction and order_direction.lower() in ["asc", "desc"] else "ASC"
+        
+        # Map Python field name to database column name
+        db_order_by = self.ALLOWED_ORDER_BY.get(order_by, "ProjectNo")
+        
+        # Validate pagination parameters
+        page = max(1, page)
+        page_size = min(max(1, page_size), 100)  # Limit max page size to 100
+        
+        # Validate customer_type
+        customer_type = max(0, customer_type) if customer_type else 0
+        
+        logger.info(f"Listing projects: customer_type={customer_type}, order_by={db_order_by}, "
+                   f"direction={order_direction}, page={page}, page_size={page_size}")
+        
+        # Call repository method
+        projects_data, total_count = self.repo.list_via_sp(
+            customer_type=customer_type,
+            order_by=db_order_by,
+            order_direction=order_direction,
+            page=page,
+            page_size=page_size
+        )
+        
+        # Transform database rows to Pydantic models
+        project_items = []
+        for row_data in projects_data:
+            try:
+                # Transform database column names to schema field names
+                transformed_data = self._transform_db_row_to_schema(row_data)
+                project_out = ProjectOut(**transformed_data)
+                project_items.append(project_out)
+            except Exception as e:
+                logger.warning(f"Error transforming project row: {e}")
+                continue
+        
+        return PaginatedResponse[ProjectOut](
+            items=project_items,
+            page=page,
+            page_size=page_size,
+            total=total_count
+        )
+
+    def _transform_db_row_to_schema(self, row_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Transform database row data to match ProjectOut schema field names
+        Maps database column names (PascalCase) to Python field names (snake_case)
+        """
+        # Database column to schema field mapping
+        field_mapping = {
+            'ProjectNo': 'project_no',
+            'ProjectName': 'project_name',
+            'ProjectLocation': 'project_location', 
+            'ProjectType': 'project_type',
+            'BidDate': 'bid_date',
+            'StartDate': 'start_date',
+            'IsAwarded': 'is_awarded',
+            'Notes': 'notes',
+            'BarrierSize': 'barrier_size',
+            'LeaseTerm': 'lease_term',
+            'PurchaseOption': 'purchase_option',
+            'LeadSource': 'lead_source',
+            'rep': 'rep',
+            'EngineerCompanyId': 'engineer_company_id',
+            'EngineerNotes': 'engineer_notes',
+            'EngineerCompany': 'engineer_company',
+            'Status': 'status',
+            'CustomertTypeId': 'customer_type_id',
+            'Bill_Name': 'bill_name',
+            'Bill_Address1': 'bill_address1',
+            'Bill_Address2': 'bill_address2',
+            'Bill_City': 'bill_city',
+            'Bill_State': 'bill_state',
+            'Bill_Zip': 'bill_zip',
+            'Bill_Email': 'bill_email',
+            'Bill_Phone': 'bill_phone',
+            'Ship_Name': 'ship_name',
+            'Ship_Address1': 'ship_address1',
+            'Ship_Address2': 'ship_address2',
+            'Ship_City': 'ship_city',
+            'Ship_State': 'ship_state',
+            'Ship_Zip': 'ship_zip',
+            'Ship_Email': 'ship_email',
+            'Ship_Phone': 'ship_phone',
+            'Ship_OfficePhone': 'ship_office_phone',
+            'Acct_Payable': 'acct_payable',
+            'PaymentTermId': 'payment_term_id',
+            'PaymentNote': 'payment_note',
+            'RentalPriceId': 'rental_price_id',
+            'PurchasePriceId': 'purchase_price_id',
+            'TaxRate': 'tax_rate',
+            'WeeklyCharge': 'weekly_charge',
+            'Commission': 'commission',
+            'CrewMembers': 'crew_members',
+            'InstallDate': 'install_date',
+            'EmployeeId': 'employee_id',
+            'AdvisorId': 'advisor_id',
+            'IsInternational': 'is_international',
+            'OrderNumber': 'order_number'
+        }
+        
+        transformed = {}
+        for db_column, value in row_data.items():
+            schema_field = field_mapping.get(db_column)
+            if schema_field:
+                transformed[schema_field] = value
+        
+        return transformed
+
     def list(self, customer_id: int = None, status: str = None, skip: int = 0, limit: int = 10):
+        """Legacy list method for backward compatibility"""
         return self.repo.list(customer_id, status, skip, limit)
 
     def create(self, data):
         project = Project(**data)
         return self.repo.create(project)
 
-    def update(self, project_id: int, data):
-        project = self.repo.get(project_id)
+    def update(self, project_no: int, data):
+        project = self.repo.get(project_no)
         if not project:
             raise NotFoundException("Project not found")
         for k, v in data.items():
             setattr(project, k, v)
         return self.repo.update(project)
 
-    def delete(self, project_id: int):
-        project = self.repo.get(project_id)
+    def delete(self, project_no: int):
+        project = self.repo.get(project_no)
         if not project:
             raise NotFoundException("Project not found")
         self.repo.delete(project)

app/tests/unit/test_projects_list.py

@@ -0,0 +1,185 @@
+import pytest
+from unittest.mock import Mock, patch
+from app.services.project_service import ProjectService
+from app.schemas.project import ProjectOut
+from app.schemas.paginated_response import PaginatedResponse
+
+
+class TestProjectService:
+    """Test ProjectService list_projects functionality"""
+    
+    def test_list_projects_default_parameters(self):
+        """Test list_projects with default parameters"""
+        # Mock database session
+        mock_db = Mock()
+        
+        # Mock repository response
+        mock_projects_data = [
+            {
+                'ProjectNo': 1,
+                'ProjectName': 'Test Project 1',
+                'ProjectLocation': 'Location 1',
+                'ProjectType': 'Type A',
+                'Status': 1,
+                'IsAwarded': True,
+                'CustomertTypeId': 1
+            },
+            {
+                'ProjectNo': 2,
+                'ProjectName': 'Test Project 2',
+                'ProjectLocation': 'Location 2',
+                'ProjectType': 'Type B',
+                'Status': 2,
+                'IsAwarded': False,
+                'CustomertTypeId': 2
+            }
+        ]
+        total_count = 2
+        
+        # Create service and mock repository
+        service = ProjectService(mock_db)
+        service.repo.list_via_sp = Mock(return_value=(mock_projects_data, total_count))
+        
+        # Call the method
+        result = service.list_projects()
+        
+        # Verify result
+        assert isinstance(result, PaginatedResponse)
+        assert len(result.items) == 2
+        assert result.page == 1
+        assert result.page_size == 10
+        assert result.total == 2
+        
+        # Verify first project
+        first_project = result.items[0]
+        assert isinstance(first_project, ProjectOut)
+        assert first_project.project_no == 1
+        assert first_project.project_name == 'Test Project 1'
+        assert first_project.project_location == 'Location 1'
+        assert first_project.is_awarded is True
+        
+    def test_list_projects_with_custom_parameters(self):
+        """Test list_projects with custom parameters"""
+        mock_db = Mock()
+        
+        mock_projects_data = []
+        total_count = 0
+        
+        service = ProjectService(mock_db)
+        service.repo.list_via_sp = Mock(return_value=(mock_projects_data, total_count))
+        
+        # Call with custom parameters
+        result = service.list_projects(
+            customer_type=1,
+            order_by="project_name",
+            order_direction="desc",
+            page=2,
+            page_size=5
+        )
+        
+        # Verify repository was called with correct mapped parameters
+        service.repo.list_via_sp.assert_called_once_with(
+            customer_type=1,
+            order_by="ProjectName",  # Should be mapped to database column
+            order_direction="DESC",
+            page=2,
+            page_size=5
+        )
+        
+        # Verify result structure
+        assert result.page == 2
+        assert result.page_size == 5
+        assert result.total == 0
+        assert len(result.items) == 0
+    
+    def test_list_projects_parameter_validation(self):
+        """Test parameter validation and normalization"""
+        mock_db = Mock()
+        service = ProjectService(mock_db)
+        service.repo.list_via_sp = Mock(return_value=([], 0))
+        
+        # Test invalid order_by defaults to project_no
+        service.list_projects(order_by="invalid_field")
+        service.repo.list_via_sp.assert_called_with(
+            customer_type=0,
+            order_by="ProjectNo",  # Should default to ProjectNo
+            order_direction="ASC",
+            page=1,
+            page_size=10
+        )
+        
+        # Test invalid order_direction defaults to ASC
+        service.list_projects(order_direction="invalid")
+        service.repo.list_via_sp.assert_called_with(
+            customer_type=0,
+            order_by="ProjectNo",
+            order_direction="ASC",  # Should default to ASC
+            page=1,
+            page_size=10
+        )
+        
+        # Test negative page number becomes 1
+        service.list_projects(page=-1)
+        service.repo.list_via_sp.assert_called_with(
+            customer_type=0,
+            order_by="ProjectNo",
+            order_direction="ASC",
+            page=1,  # Should be normalized to 1
+            page_size=10
+        )
+        
+        # Test page_size over limit becomes 100
+        service.list_projects(page_size=500)
+        service.repo.list_via_sp.assert_called_with(
+            customer_type=0,
+            order_by="ProjectNo",
+            order_direction="ASC",
+            page=1,
+            page_size=100  # Should be capped at 100
+        )
+
+    def test_transform_db_row_to_schema(self):
+        """Test database row transformation to schema"""
+        mock_db = Mock()
+        service = ProjectService(mock_db)
+        
+        # Test database row data
+        db_row = {
+            'ProjectNo': 123,
+            'ProjectName': 'Test Project',
+            'ProjectLocation': 'Test Location',
+            'ProjectType': 'Test Type',
+            'BidDate': '2024-01-01',
+            'StartDate': '2024-01-15',
+            'IsAwarded': True,
+            'Status': 1,
+            'CustomertTypeId': 2,
+            'Bill_Name': 'Bill Name',
+            'Ship_Name': 'Ship Name',
+            'UnknownColumn': 'Should be ignored'  # This should be ignored
+        }
+        
+        # Transform the data
+        result = service._transform_db_row_to_schema(db_row)
+        
+        # Verify transformation
+        expected_fields = {
+            'project_no': 123,
+            'project_name': 'Test Project',
+            'project_location': 'Test Location',
+            'project_type': 'Test Type',
+            'bid_date': '2024-01-01',
+            'start_date': '2024-01-15',
+            'is_awarded': True,
+            'status': 1,
+            'customer_type_id': 2,
+            'bill_name': 'Bill Name',
+            'ship_name': 'Ship Name'
+        }
+        
+        for field, expected_value in expected_fields.items():
+            assert result[field] == expected_value
+        
+        # Verify unknown column is not included
+        assert 'UnknownColumn' not in result
+        assert 'unknown_column' not in result

test_api.py

@@ -0,0 +1,49 @@
+import requests
+import json
+
+def test_projects_list_endpoint():
+    """Test the projects list endpoint"""
+    base_url = "http://localhost:8001"
+    
+    try:
+        # Test basic endpoint
+        response = requests.get(f"{base_url}/api/v1/projects/")
+        print(f"Status Code: {response.status_code}")
+        print(f"Response Headers: {dict(response.headers)}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Response structure: {list(data.keys())}")
+            print(f"Number of items: {len(data.get('items', []))}")
+            print(f"Page: {data.get('page')}")
+            print(f"Page size: {data.get('page_size')}")
+            print(f"Total: {data.get('total')}")
+            
+            if data.get('items'):
+                print(f"First item keys: {list(data['items'][0].keys())}")
+        else:
+            print(f"Error response: {response.text}")
+            
+        # Test with parameters
+        params = {
+            "customer_type": 1,
+            "order_by": "project_name",
+            "order_direction": "desc",
+            "page": 1,
+            "page_size": 5
+        }
+        
+        response2 = requests.get(f"{base_url}/api/v1/projects/", params=params)
+        print(f"\nWith parameters - Status Code: {response2.status_code}")
+        
+        if response2.status_code == 200:
+            data2 = response2.json()
+            print(f"Filtered results - Total: {data2.get('total')}, Items: {len(data2.get('items', []))}")
+        
+    except requests.exceptions.ConnectionError:
+        print("Server is not running on port 8001")
+    except Exception as e:
+        print(f"Error testing endpoint: {e}")
+
+if __name__ == "__main__":
+    test_projects_list_endpoint()