feat: Add Bidder model, repository, service, and schemas

- Implemented Bidder model with various fields in bidder.py.
- Created BidderRepository for CRUD operations and pagination in bidder_repo.py.
- Developed BidderService to handle business logic for bidders.
- Added Pydantic schemas for Bidder creation and output validation.
- Refactored ContactRepository to use direct SQLAlchemy queries instead of stored procedures.
- Updated SQL prompt for retrieving customer data.

app/app.py

@@ -10,6 +10,7 @@ from app.controllers.dashboard import router as dashboard_router
 from app.controllers.reports import router as reports_router
 from app.controllers.employees import router as employees_router
 from app.controllers.reference import router as reference_router
+from app.controllers.bidders import router as bidders_router
 
 setup_logging(settings.LOG_LEVEL)
 
@@ -31,3 +32,4 @@ app.include_router(dashboard_router)
 app.include_router(reports_router)
 app.include_router(employees_router)
 app.include_router(reference_router)
+app.include_router(bidders_router)

app/controllers/bidders.py

@@ -0,0 +1,250 @@
+from fastapi import APIRouter, Depends, status, Query, HTTPException
+from sqlalchemy.orm import Session
+from app.db.session import get_db
+from app.services.bidder_service import BidderService
+from app.schemas.bidder import BidderCreate, BidderOut
+from app.schemas.paginated_response import PaginatedResponse
+from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Common query parameter descriptions
+PAGE_DESC = "Page number (1-indexed)"
+PAGE_SIZE_DESC = "Number of items per page"
+ORDER_BY_DESC = "Field to order by"
+ORDER_DIR_DESC = "Order direction (asc|desc)"
+PROJ_NO_DESC = "Project number (required)"
+
+router = APIRouter(prefix="/api/v1/bidders", tags=["bidders"])
+
+@router.get(
+    "/",
+    response_model=PaginatedResponse[BidderOut],
+    summary="List bidders by project",
+    response_description="Paginated list of bidders for a specific project"
+)
+def list_bidders(
+    proj_no: str = Query(..., description=PROJ_NO_DESC),
+    page: int = Query(1, ge=1, description=PAGE_DESC),
+    page_size: int = Query(10, ge=1, le=100, description=PAGE_SIZE_DESC),
+    order_by: Optional[str] = Query("Id", description=ORDER_BY_DESC),
+    order_dir: Optional[str] = Query("asc", description=ORDER_DIR_DESC),
+    db: Session = Depends(get_db)
+):
+    """Get all bidders for a specific project with pagination and ordering"""
+    try:
+        logger.info(f"Listing bidders for project {proj_no}: page={page}, page_size={page_size}")
+        bidder_service = BidderService(db)
+        result = bidder_service.get_by_project_no(
+            proj_no=proj_no,
+            page=page, 
+            page_size=page_size, 
+            order_by=order_by, 
+            order_dir=order_dir.upper()
+        )
+        logger.info(f"Successfully retrieved {len(result.items)} bidders for project {proj_no}")
+        return result
+    except Exception as e:
+        logger.error(f"Error listing bidders for project {proj_no}: {e}")
+        return PaginatedResponse[BidderOut](
+            items=[],
+            page=page,
+            page_size=page_size,
+            total=0
+        )
+
+@router.get(
+    "/project/{proj_no}",
+    response_model=PaginatedResponse[BidderOut],
+    summary="List bidders by project path parameter",
+    response_description="Paginated list of bidders for a specific project"
+)
+def list_bidders_by_project(
+    proj_no: str,
+    page: int = Query(1, ge=1, description=PAGE_DESC),
+    page_size: int = Query(10, ge=1, le=100, description=PAGE_SIZE_DESC),
+    order_by: Optional[str] = Query("Id", description=ORDER_BY_DESC),
+    order_dir: Optional[str] = Query("asc", description=ORDER_DIR_DESC),
+    db: Session = Depends(get_db)
+):
+    """Get all bidders for a specific project with pagination and ordering (using path parameter)"""
+    try:
+        logger.info(f"Listing bidders for project {proj_no}: page={page}, page_size={page_size}")
+        bidder_service = BidderService(db)
+        result = bidder_service.get_by_project_no(
+            proj_no=proj_no, 
+            page=page, 
+            page_size=page_size, 
+            order_by=order_by, 
+            order_dir=order_dir.upper()
+        )
+        logger.info(f"Successfully retrieved {len(result.items)} bidders for project {proj_no}")
+        return result
+    except Exception as e:
+        logger.error(f"Error listing bidders for project {proj_no}: {e}")
+        return PaginatedResponse[BidderOut](
+            items=[],
+            page=page,
+            page_size=page_size,
+            total=0
+        )
+
+@router.get(
+    "/customer/{cust_id}",
+    response_model=PaginatedResponse[BidderOut],
+    summary="List bidders by customer",
+    response_description="Paginated list of bidders for a specific customer"
+)
+def list_bidders_by_customer(
+    cust_id: int,
+    page: int = Query(1, ge=1, description=PAGE_DESC),
+    page_size: int = Query(10, ge=1, le=100, description=PAGE_SIZE_DESC),
+    order_by: Optional[str] = Query("Id", description=ORDER_BY_DESC),
+    order_dir: Optional[str] = Query("asc", description=ORDER_DIR_DESC),
+    db: Session = Depends(get_db)
+):
+    """Get all bidders for a specific customer with pagination and ordering"""
+    try:
+        logger.info(f"Listing bidders for customer {cust_id}: page={page}, page_size={page_size}")
+        bidder_service = BidderService(db)
+        result = bidder_service.get_by_customer_id(
+            cust_id=cust_id, 
+            page=page, 
+            page_size=page_size, 
+            order_by=order_by, 
+            order_dir=order_dir.upper()
+        )
+        logger.info(f"Successfully retrieved {len(result.items)} bidders for customer {cust_id}")
+        return result
+    except Exception as e:
+        logger.error(f"Error listing bidders for customer {cust_id}: {e}")
+        return PaginatedResponse[BidderOut](
+            items=[],
+            page=page,
+            page_size=page_size,
+            total=0
+        )
+
+@router.get(
+    "/{bidder_id}",
+    response_model=BidderOut,
+    summary="Get a bidder by ID",
+    response_description="Bidder details"
+)
+def get_bidder(bidder_id: int, db: Session = Depends(get_db)):
+    """Get a specific bidder by ID"""
+    try:
+        bidder_service = BidderService(db)
+        return bidder_service.get(bidder_id)
+    except Exception as e:
+        logger.error(f"Error getting bidder {bidder_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Bidder {bidder_id} not found"
+        )
+
+@router.post(
+    "/",
+    response_model=BidderOut,
+    status_code=status.HTTP_201_CREATED,
+    summary="Create a new bidder",
+    response_description="Created bidder details"
+)
+def create_bidder(
+    bidder_in: BidderCreate,
+    proj_no: str = Query(..., description=PROJ_NO_DESC),
+    db: Session = Depends(get_db)
+):
+    """Create a new bidder"""
+    try:
+        bidder_service = BidderService(db)
+        logger.info(f"Creating new bidder for project {proj_no}")
+        
+        # Update the bidder data with the project number
+        bidder_data = bidder_in.dict()
+        bidder_data["proj_no"] = proj_no
+        
+        result = bidder_service.create(bidder_data)
+        logger.info(f"Successfully created bidder {result.id} for project {proj_no}")
+        return result
+    except ValueError as e:
+        logger.error(f"Validation error creating bidder: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(f"Error creating bidder: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create bidder"
+        )
+
+@router.put(
+    "/{bidder_id}",
+    response_model=BidderOut,
+    summary="Update a bidder",
+    response_description="Updated bidder details"
+)
+def update_bidder(
+    bidder_id: int,
+    bidder_in: BidderCreate,
+    proj_no: str = Query(..., description=PROJ_NO_DESC),
+    db: Session = Depends(get_db)
+):
+    """Update an existing bidder"""
+    try:
+        bidder_service = BidderService(db)
+        logger.info(f"Updating bidder {bidder_id} for project {proj_no}")
+        
+        # Update the bidder data with the project number
+        bidder_data = bidder_in.dict()
+        bidder_data["proj_no"] = proj_no
+        
+        result = bidder_service.update(bidder_id, bidder_data)
+        logger.info(f"Successfully updated bidder {bidder_id} for project {proj_no}")
+        return result
+    except ValueError as e:
+        logger.error(f"Validation error updating bidder {bidder_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        logger.error(f"Error updating bidder {bidder_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update bidder"
+        )
+
+@router.delete(
+    "/{bidder_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Delete a bidder",
+    response_description="Bidder deleted successfully"
+)
+def delete_bidder(
+    bidder_id: int,
+    proj_no: str = Query(..., description=PROJ_NO_DESC),
+    db: Session = Depends(get_db)
+):
+    """Delete a bidder"""
+    try:
+        bidder_service = BidderService(db)
+        logger.info(f"Deleting bidder {bidder_id} for project {proj_no}")
+        
+        # First verify the bidder belongs to the specified project
+        bidder = bidder_service.get(bidder_id)
+        if bidder.proj_no != proj_no:
+            raise ValueError(f"Bidder {bidder_id} does not belong to project {proj_no}")
+            
+        bidder_service.delete(bidder_id)
+        logger.info(f"Successfully deleted bidder {bidder_id} for project {proj_no}")
+        return None
+    except Exception as e:
+        logger.error(f"Error deleting bidder {bidder_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to delete bidder"
+        )

app/db/models/bidder.py

@@ -0,0 +1,29 @@
+from sqlalchemy import Column, Integer, String, Boolean, Float, DateTime, ForeignKey
+from app.db.base import Base
+
+class Bidder(Base):
+    __tablename__ = "Bidders"
+    
+    Id = Column(Integer, primary_key=True, index=True)
+    ProjNo = Column(String(50), nullable=True)
+    CustId = Column(Integer, nullable=True)
+    Quote = Column(Float, nullable=True)
+    Contact = Column(String(200), nullable=True)
+    Phone = Column(String(50), nullable=True)
+    Notes = Column(String(500), nullable=True)
+    DateLastContact = Column(DateTime, nullable=True)
+    DateFollowup = Column(DateTime, nullable=True)
+    Primary = Column(Boolean, nullable=True, default=False)
+    CustType = Column(String(50), nullable=True)
+    EmailAddress = Column(String(255), nullable=True)
+    Fax = Column(String(50), nullable=True)
+    OrderNr = Column(String(50), nullable=True)
+    CustomerPO = Column(String(50), nullable=True)
+    ShipDate = Column(DateTime, nullable=True)
+    DeliverDate = Column(DateTime, nullable=True)
+    ReplacementCost = Column(Float, nullable=True)
+    QuoteDate = Column(DateTime, nullable=True)
+    InvoiceDate = Column(DateTime, nullable=True)
+    LessPayment = Column(Float, nullable=True)
+    Enabled = Column(Boolean, nullable=False, default=True)
+    EmployeeId = Column(Integer, nullable=True)

app/db/repositories/bidder_repo.py

@@ -0,0 +1,274 @@
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from app.db.models.bidder import Bidder
+from app.schemas.bidder import BidderCreate, BidderOut
+from app.schemas.paginated_response import PaginatedResponse
+from app.core.exceptions import NotFoundException
+from typing import List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class BidderRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get(self, bidder_id: int) -> Optional[BidderOut]:
+        """Get a single bidder by ID using Bidders table directly."""
+        try:
+            bidder = self.db.query(Bidder).filter(Bidder.Id == bidder_id).first()
+            if bidder:
+                return self._map_bidder_data(bidder.__dict__)
+            return None
+        except SQLAlchemyError as e:
+            logger.error(f"Database error getting bidder {bidder_id}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error getting bidder {bidder_id}: {e}")
+            raise
+
+    def list(self, page: int = 1, page_size: int = 10, order_by: str = "Id", order_direction: str = "ASC") -> PaginatedResponse[BidderOut]:
+        """Get paginated list of all bidders using Bidders table directly with order by."""
+        try:
+            query = self.db.query(Bidder)
+            # Validate order_by field
+            if not hasattr(Bidder, order_by):
+                order_by = "Id"
+            order_col = getattr(Bidder, order_by)
+            if order_direction.upper() == "DESC":
+                order_col = order_col.desc()
+            else:
+                order_col = order_col.asc()
+            query = query.order_by(order_col)
+            total_records = query.count()
+            bidders = query.offset((page - 1) * page_size).limit(page_size).all()
+            bidder_out_list = [self._map_bidder_data(bidder.__dict__) for bidder in bidders]
+            return PaginatedResponse[BidderOut](
+                items=bidder_out_list,
+                page=page,
+                page_size=page_size,
+                total=total_records
+            )
+        except Exception as e:
+            logger.error(f"Error listing bidders: {e}")
+            return PaginatedResponse[BidderOut](
+                items=[],
+                page=page,
+                page_size=page_size,
+                total=0
+            )
+
+    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."""
+        try:
+            # Handle string or integer proj_no values
+            # Try both the original value and converted value to handle both cases
+            original_proj_no = proj_no
+            
+            # Try to handle numeric project numbers stored in database as int or string
+            try:
+                numeric_proj_no = int(proj_no)
+                query = self.db.query(Bidder).filter(
+                    (Bidder.ProjNo == original_proj_no) | 
+                    (Bidder.ProjNo == str(numeric_proj_no)) |
+                    (Bidder.ProjNo == numeric_proj_no)
+                )
+            except (ValueError, TypeError):
+                # If conversion to int fails, just use the original string
+                query = self.db.query(Bidder).filter(Bidder.ProjNo == original_proj_no)
+            # Validate order_by field
+            if not hasattr(Bidder, order_by):
+                order_by = "Id"
+            order_col = getattr(Bidder, order_by)
+            if order_dir.upper() == "DESC":
+                order_col = order_col.desc()
+            else:
+                order_col = order_col.asc()
+            query = query.order_by(order_col)
+            total_records = query.count()
+            bidders = query.offset((page - 1) * page_size).limit(page_size).all()
+            bidder_out_list = [self._map_bidder_data(bidder.__dict__) for bidder in bidders]
+            return PaginatedResponse[BidderOut](
+                items=bidder_out_list,
+                page=page,
+                page_size=page_size,
+                total=total_records
+            )
+        except Exception as e:
+            logger.error(f"Error getting bidders for project {proj_no}: {e}")
+            return PaginatedResponse[BidderOut](
+                items=[],
+                page=page,
+                page_size=page_size,
+                total=0
+            )
+
+    def get_by_customer_id(self, cust_id: int, page: int = 1, page_size: int = 10, 
+                          order_by: str = "Id", order_dir: str = "ASC") -> PaginatedResponse[BidderOut]:
+        """Get bidders for a specific customer using Bidders table directly."""
+        try:
+            query = self.db.query(Bidder).filter(Bidder.CustId == cust_id)
+            # Validate order_by field
+            if not hasattr(Bidder, order_by):
+                order_by = "Id"
+            order_col = getattr(Bidder, order_by)
+            if order_dir.upper() == "DESC":
+                order_col = order_col.desc()
+            else:
+                order_col = order_col.asc()
+            query = query.order_by(order_col)
+            total_records = query.count()
+            bidders = query.offset((page - 1) * page_size).limit(page_size).all()
+            bidder_out_list = [self._map_bidder_data(bidder.__dict__) for bidder in bidders]
+            return PaginatedResponse[BidderOut](
+                items=bidder_out_list,
+                page=page,
+                page_size=page_size,
+                total=total_records
+            )
+        except Exception as e:
+            logger.error(f"Error getting bidders for customer {cust_id}: {e}")
+            return PaginatedResponse[BidderOut](
+                items=[],
+                page=page,
+                page_size=page_size,
+                total=0
+            )
+
+    def create(self, bidder_data: BidderCreate) -> BidderOut:
+        """Create a new bidder using Bidders table directly."""
+        try:
+            new_bidder = Bidder(
+                ProjNo=bidder_data.proj_no,
+                CustId=bidder_data.cust_id,
+                Quote=bidder_data.quote,
+                Contact=bidder_data.contact,
+                Phone=bidder_data.phone,
+                Notes=bidder_data.notes,
+                DateLastContact=bidder_data.date_last_contact,
+                DateFollowup=bidder_data.date_followup,
+                Primary=bidder_data.primary or False,
+                CustType=bidder_data.cust_type,
+                EmailAddress=bidder_data.email_address,
+                Fax=bidder_data.fax,
+                OrderNr=bidder_data.order_nr,
+                CustomerPO=bidder_data.customer_po,
+                ShipDate=bidder_data.ship_date,
+                DeliverDate=bidder_data.deliver_date,
+                ReplacementCost=bidder_data.replacement_cost,
+                QuoteDate=bidder_data.quote_date,
+                InvoiceDate=bidder_data.invoice_date,
+                LessPayment=bidder_data.less_payment,
+                Enabled=bidder_data.enabled or True,
+                EmployeeId=bidder_data.employee_id
+            )
+            self.db.add(new_bidder)
+            self.db.commit()
+            self.db.refresh(new_bidder)
+            return self._map_bidder_data(new_bidder.__dict__)
+        except SQLAlchemyError as e:
+            logger.error(f"Database error creating bidder: {e}")
+            self.db.rollback()
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error creating bidder: {e}")
+            self.db.rollback()
+            raise
+
+    def update(self, bidder_id: int, bidder_data: BidderCreate) -> BidderOut:
+        """Update a bidder using Bidders table directly."""
+        try:
+            bidder = self.db.query(Bidder).filter(Bidder.Id == bidder_id).first()
+            if not bidder:
+                raise NotFoundException("Bidder not found for update")
+            
+            bidder.ProjNo = bidder_data.proj_no
+            bidder.CustId = bidder_data.cust_id
+            bidder.Quote = bidder_data.quote
+            bidder.Contact = bidder_data.contact
+            bidder.Phone = bidder_data.phone
+            bidder.Notes = bidder_data.notes
+            bidder.DateLastContact = bidder_data.date_last_contact
+            bidder.DateFollowup = bidder_data.date_followup
+            bidder.Primary = bidder_data.primary or False
+            bidder.CustType = bidder_data.cust_type
+            bidder.EmailAddress = bidder_data.email_address
+            bidder.Fax = bidder_data.fax
+            bidder.OrderNr = bidder_data.order_nr
+            bidder.CustomerPO = bidder_data.customer_po
+            bidder.ShipDate = bidder_data.ship_date
+            bidder.DeliverDate = bidder_data.deliver_date
+            bidder.ReplacementCost = bidder_data.replacement_cost
+            bidder.QuoteDate = bidder_data.quote_date
+            bidder.InvoiceDate = bidder_data.invoice_date
+            bidder.LessPayment = bidder_data.less_payment
+            bidder.Enabled = bidder_data.enabled
+            bidder.EmployeeId = bidder_data.employee_id
+            
+            self.db.commit()
+            self.db.refresh(bidder)
+            return self._map_bidder_data(bidder.__dict__)
+        except SQLAlchemyError as e:
+            logger.error(f"Database error updating bidder {bidder_id}: {e}")
+            self.db.rollback()
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error updating bidder {bidder_id}: {e}")
+            self.db.rollback()
+            raise
+
+    def delete(self, bidder_id: int) -> bool:
+        """Delete a bidder using Bidders table directly."""
+        try:
+            bidder = self.db.query(Bidder).filter(Bidder.Id == bidder_id).first()
+            if not bidder:
+                raise NotFoundException("Bidder not found for delete")
+            self.db.delete(bidder)
+            self.db.commit()
+            return True
+        except SQLAlchemyError as e:
+            logger.error(f"Database error deleting bidder {bidder_id}: {e}")
+            self.db.rollback()
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error deleting bidder {bidder_id}: {e}")
+            self.db.rollback()
+            raise
+
+    def _map_bidder_data(self, bidder_data: dict) -> BidderOut:
+        """Map database bidder data to BidderOut schema"""
+        # Handle type conversions for proj_no and cust_type
+        proj_no_value = bidder_data.get('ProjNo')
+        if proj_no_value is not None and not isinstance(proj_no_value, str):
+            proj_no_value = str(proj_no_value)
+            
+        cust_type_value = bidder_data.get('CustType')
+        if cust_type_value is not None and not isinstance(cust_type_value, str):
+            cust_type_value = str(cust_type_value)
+            
+        return BidderOut(
+            id=bidder_data.get('Id'),
+            proj_no=proj_no_value,
+            cust_id=bidder_data.get('CustId'),
+            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('DateLastContact'),
+            date_followup=bidder_data.get('DateFollowup'),
+            primary=bidder_data.get('Primary'),
+            cust_type=cust_type_value,
+            email_address=bidder_data.get('EmailAddress'),
+            fax=bidder_data.get('Fax'),
+            order_nr=bidder_data.get('OrderNr'),
+            customer_po=bidder_data.get('CustomerPO'),
+            ship_date=bidder_data.get('ShipDate'),
+            deliver_date=bidder_data.get('DeliverDate'),
+            replacement_cost=bidder_data.get('ReplacementCost'),
+            quote_date=bidder_data.get('QuoteDate'),
+            invoice_date=bidder_data.get('InvoiceDate'),
+            less_payment=bidder_data.get('LessPayment'),
+            enabled=bidder_data.get('Enabled'),
+            employee_id=bidder_data.get('EmployeeId')
+        )

app/db/repositories/contact_repo.py

@@ -1,5 +1,5 @@
+
 from sqlalchemy.orm import Session
-from sqlalchemy import text
 from sqlalchemy.exc import SQLAlchemyError
 from app.db.models.contact import Contact
 from app.schemas.contact import ContactCreate, ContactOut
@@ -15,18 +15,12 @@ class ContactRepository:
         self.db = db
 
     def get(self, contact_id: int) -> Optional[ContactOut]:
-        """Get a single contact by ID using stored procedure"""
+        """Get a single contact by ID using Contacts table directly."""
         try:
-            with self.db.get_bind().connect() as conn:
-                result = conn.execute(text("EXEC spContactsGet @ContactID = :contact_id"), 
-                                    {"contact_id": contact_id})
-                row = result.fetchone()
-                
-                if row:
-                    columns = result.keys()
-                    contact_data = dict(zip(columns, row))
-                    return self._map_contact_data(contact_data)
-                return None
+            contact = self.db.query(Contact).filter(Contact.ContactID == contact_id).first()
+            if contact:
+                return self._map_contact_data(contact.__dict__)
+            return None
         except SQLAlchemyError as e:
             logger.error(f"Database error getting contact {contact_id}: {e}")
             raise
@@ -34,138 +28,54 @@ class ContactRepository:
             logger.error(f"Unexpected error getting contact {contact_id}: {e}")
             raise
 
-    def list(self, page: int = 1, page_size: int = 10, 
-             order_by: str = "ContactID", order_direction: str = "ASC") -> PaginatedResponse[ContactOut]:
-        """Get paginated list of all contacts using stored procedure"""
-        try:
-            contacts = []
-            total_records = 0
-            
-            with self.db.get_bind().connect() as conn:
-                # Based on DATABASE_DOCUMENTATION.md, using spContactsGetList
-                result = conn.execute(
-                    text("""DECLARE @TotalRecords INT;
-                            EXEC spContactsGetList 
-                            @OrderBy = :order_by, 
-                            @OrderDirection = :order_dir, 
-                            @Page = :page, 
-                            @PageSize = :page_size, 
-                            @TotalRecords = @TotalRecords OUTPUT;
-                            SELECT @TotalRecords as TotalRecords;"""), 
-                    {
-                        "order_by": order_by,
-                        "order_dir": order_direction,
-                        "page": page,
-                        "page_size": page_size
-                    }
-                )
-                
-                # Process the result sets
-                if result.returns_rows:
-                    # First result set contains the contacts
-                    rows = result.fetchall()
-                    columns = result.keys()
-                    
-                    for row in rows:
-                        contact_data = dict(zip(columns, row))
-                        contact = self._map_contact_data(contact_data)
-                        contacts.append(contact)
-                    
-                    # Move to next result set for total count
-                    if result.nextset():
-                        total_row = result.fetchone()
-                        if total_row:
-                            total_records = total_row[0] if total_row[0] is not None else len(contacts)
-                        else:
-                            total_records = len(contacts)
-                    else:
-                        total_records = len(contacts)
-                
-            return PaginatedResponse[ContactOut](
-                items=contacts,
-                page=page,
-                page_size=page_size,
-                total=total_records
-            )
-            
-        except SQLAlchemyError as e:
-            logger.error(f"Database error getting contacts list: {e}")
-            # Return empty result instead of raising exception for list operations
-            return PaginatedResponse[ContactOut](
-                items=[],
-                page=page,
-                page_size=page_size,
-                total=0
-            )
-        except Exception as e:
-            logger.error(f"Unexpected error getting contacts list: {e}")
-            # Return empty result instead of raising exception for list operations
-            return PaginatedResponse[ContactOut](
-                items=[],
-                page=page,
-                page_size=page_size,
-                total=0
-            )
+    def list(self, page: int = 1, page_size: int = 10, order_by: str = "ContactID", order_direction: str = "ASC", customer_id: int = None) -> PaginatedResponse[ContactOut]:
+        """Get paginated list of all contacts using Contacts table directly, with optional customer_id filter and order by."""
+        query = self.db.query(Contact)
+        if customer_id is not None:
+            query = query.filter(Contact.CustomerID == customer_id)
+        # Validate order_by field
+        if not hasattr(Contact, order_by):
+            order_by = "ContactID"
+        order_col = getattr(Contact, order_by)
+        if order_direction.upper() == "DESC":
+            order_col = order_col.desc()
+        else:
+            order_col = order_col.asc()
+        query = query.order_by(order_col)
+        total_records = query.count()
+        contacts = query.offset((page - 1) * page_size).limit(page_size).all()
+        contact_out_list = [self._map_contact_data(contact.__dict__) for contact in contacts]
+        return PaginatedResponse[ContactOut](
+            items=contact_out_list,
+            page=page,
+            page_size=page_size,
+            total=total_records
+        )
 
-    def get_by_customer_id(self, customer_id: int, page: int = 1, page_size: int = 10, 
-                          order_by: str = "ContactID", order_dir: str = "ASC") -> PaginatedResponse[ContactOut]:
-        """Get contacts for a specific customer using stored procedure"""
+    def get_by_customer_id(self, customer_id: int, page: int = 1, page_size: int = 10, order_by: str = "ContactID", order_dir: str = "ASC") -> PaginatedResponse[ContactOut]:
+        """Get contacts for a specific customer using Contacts table directly."""
         try:
-            contacts = []
-            total_records = 0
-            
-            with self.db.get_bind().connect() as conn:
-                # Using spContactsGetListByParam with CustomerID filter
-                result = conn.execute(
-                    text("""DECLARE @TotalRecords INT;
-                            EXEC spContactsGetListByParam 
-                            @CustomerTypeID = NULL, 
-                            @CustomerID = :customer_id,
-                            @OrderBy = :order_by, 
-                            @OrderDirection = :order_dir, 
-                            @Page = :page, 
-                            @PageSize = :page_size, 
-                            @TotalRecords = @TotalRecords OUTPUT;
-                            SELECT @TotalRecords as TotalRecords;"""), 
-                    {
-                        "customer_id": customer_id,
-                        "order_by": order_by,
-                        "order_dir": order_dir,
-                        "page": page,
-                        "page_size": page_size
-                    }
-                )
-                
-                if result.returns_rows:
-                    # First result set contains the contacts
-                    rows = result.fetchall()
-                    columns = result.keys()
-                    
-                    for row in rows:
-                        contact_data = dict(zip(columns, row))
-                        contact = self._map_contact_data(contact_data)
-                        contacts.append(contact)
-                    
-                    # Move to next result set for total count
-                    if result.nextset():
-                        total_row = result.fetchone()
-                        if total_row:
-                            total_records = total_row[0] if total_row[0] is not None else len(contacts)
-                        else:
-                            total_records = len(contacts)
-                    else:
-                        total_records = len(contacts)
-                
+            query = self.db.query(Contact).filter(Contact.CustomerID == customer_id)
+            # Validate order_by field
+            if not hasattr(Contact, order_by):
+                order_by = "ContactID"
+            order_col = getattr(Contact, order_by)
+            if order_dir.upper() == "DESC":
+                order_col = order_col.desc()
+            else:
+                order_col = order_col.asc()
+            query = query.order_by(order_col)
+            total_records = query.count()
+            contacts = query.offset((page - 1) * page_size).limit(page_size).all()
+            contact_out_list = [self._map_contact_data(contact.__dict__) for contact in contacts]
             return PaginatedResponse[ContactOut](
-                items=contacts,
+                items=contact_out_list,
                 page=page,
                 page_size=page_size,
                 total=total_records
             )
-            
         except Exception as e:
             logger.error(f"Error getting contacts for customer {customer_id}: {e}")
-            # Return empty result instead of raising exception
             return PaginatedResponse[ContactOut](
                 items=[],
                 page=page,
@@ -174,167 +84,97 @@ class ContactRepository:
             )
 
     def create(self, contact_data: ContactCreate) -> ContactOut:
-        """Create a new contact using stored procedure"""
+        """Create a new contact using Contacts table directly."""
         try:
-            with self.db.get_bind().connect() as conn:
-                # Based on DATABASE_DOCUMENTATION.md, using proper output parameter handling
-                result = conn.execute(
-                    text("""DECLARE @NewContactID INT;
-                            EXEC spContactsInsert 
-                            @CustomerID = :customer_id,
-                            @FirstName = :first_name,
-                            @LastName = :last_name,
-                            @Title = :title,
-                            @Address = :address,
-                            @City = :city,
-                            @PostalCode = :postal_code,
-                            @WorkPhone = :work_phone,
-                            @WorkExtension = :work_extension,
-                            @FaxNumber = :fax_number,
-                            @ReferredTo = :referred_to,
-                            @MobilePhone = :mobile_phone,
-                            @ChristmasCard = :christmas_card,
-                            @EmailAddress = :email_address,
-                            @WebAddress = :web_address,
-                            @CustomerTypeID = :customer_type_id,
-                            @StateID = :state_id,
-                            @CountryID = :country_id,
-                            @TempAddress = :temp_address,
-                            @Exported = :exported,
-                            @ContactID = @NewContactID OUTPUT;
-                            SELECT @NewContactID as ContactID;"""),
-                    {
-                        "customer_id": contact_data.customer_id,
-                        "first_name": contact_data.first_name,
-                        "last_name": contact_data.last_name,
-                        "title": contact_data.title,
-                        "address": contact_data.address,
-                        "city": contact_data.city,
-                        "postal_code": contact_data.postal_code,
-                        "work_phone": contact_data.work_phone,
-                        "work_extension": contact_data.work_extension,
-                        "fax_number": contact_data.fax_number,
-                        "referred_to": contact_data.referred_to,
-                        "mobile_phone": contact_data.mobile_phone,
-                        "christmas_card": contact_data.christmas_card or False,
-                        "email_address": contact_data.email_address,
-                        "web_address": contact_data.web_address,
-                        "customer_type_id": contact_data.customer_type_id,
-                        "state_id": contact_data.state_id,
-                        "country_id": contact_data.country_id,
-                        "temp_address": contact_data.temp_address or False,
-                        "exported": contact_data.exported or False
-                    }
-                )
-                
-                # Get the new contact ID from the output
-                new_contact_id = None
-                if result.returns_rows:
-                    row = result.fetchone()
-                    if row:
-                        new_contact_id = row[0]
-                
-                conn.commit()
-                
-                if new_contact_id:
-                    # Retrieve the newly created contact
-                    created_contact = self.get(new_contact_id)
-                    if created_contact:
-                        return created_contact
-                
-                raise ValueError("Failed to retrieve created contact")
-                
+            new_contact = Contact(
+                CustomerID=contact_data.customer_id,
+                FirstName=contact_data.first_name,
+                LastName=contact_data.last_name,
+                Title=contact_data.title,
+                Address=contact_data.address,
+                City=contact_data.city,
+                PostalCode=contact_data.postal_code,
+                WorkPhone=contact_data.work_phone,
+                WorkExtension=contact_data.work_extension,
+                FaxNumber=contact_data.fax_number,
+                ReferredTo=contact_data.referred_to,
+                MobilePhone=contact_data.mobile_phone,
+                ChristmasCard=contact_data.christmas_card or False,
+                EmailAddress=contact_data.email_address,
+                WebAddress=contact_data.web_address,
+                CustomerTypeID=contact_data.customer_type_id,
+                StateID=contact_data.state_id,
+                CountryID=contact_data.country_id,
+                TempAddress=contact_data.temp_address or False,
+                Exported=contact_data.exported or False
+            )
+            self.db.add(new_contact)
+            self.db.commit()
+            self.db.refresh(new_contact)
+            return self._map_contact_data(new_contact.__dict__)
         except SQLAlchemyError as e:
             logger.error(f"Database error creating contact: {e}")
+            self.db.rollback()
             raise
         except Exception as e:
             logger.error(f"Unexpected error creating contact: {e}")
+            self.db.rollback()
             raise
 
     def update(self, contact_id: int, contact_data: ContactCreate) -> ContactOut:
-        """Update a contact using stored procedure"""
+        """Update a contact using Contacts table directly."""
         try:
-            with self.db.get_bind().connect() as conn:
-                # Execute the update stored procedure
-                conn.execute(
-                    text("""EXEC spContactsUpdate 
-                            @ContactID = :contact_id,
-                            @CustomerID = :customer_id,
-                            @FirstName = :first_name,
-                            @LastName = :last_name,
-                            @Title = :title,
-                            @Address = :address,
-                            @City = :city,
-                            @PostalCode = :postal_code,
-                            @WorkPhone = :work_phone,
-                            @WorkExtension = :work_extension,
-                            @FaxNumber = :fax_number,
-                            @ReferredTo = :referred_to,
-                            @MobilePhone = :mobile_phone,
-                            @ChristmasCard = :christmas_card,
-                            @EmailAddress = :email_address,
-                            @WebAddress = :web_address,
-                            @CustomerTypeID = :customer_type_id,
-                            @StateID = :state_id,
-                            @CountryID = :country_id,
-                            @TempAddress = :temp_address,
-                            @Exported = :exported"""),
-                    {
-                        "contact_id": contact_id,
-                        "customer_id": contact_data.customer_id,
-                        "first_name": contact_data.first_name,
-                        "last_name": contact_data.last_name,
-                        "title": contact_data.title,
-                        "address": contact_data.address,
-                        "city": contact_data.city,
-                        "postal_code": contact_data.postal_code,
-                        "work_phone": contact_data.work_phone,
-                        "work_extension": contact_data.work_extension,
-                        "fax_number": contact_data.fax_number,
-                        "referred_to": contact_data.referred_to,
-                        "mobile_phone": contact_data.mobile_phone,
-                        "christmas_card": contact_data.christmas_card or False,
-                        "email_address": contact_data.email_address,
-                        "web_address": contact_data.web_address,
-                        "customer_type_id": contact_data.customer_type_id,
-                        "state_id": contact_data.state_id,
-                        "country_id": contact_data.country_id,
-                        "temp_address": contact_data.temp_address or False,
-                        "exported": contact_data.exported or False,
-                    }
-                )
-                conn.commit()
-                
-                # Get the updated contact
-                updated_contact = self.get(contact_id)
-                if not updated_contact:
-                    raise NotFoundException("Contact not found after update")
-                
-                return updated_contact
-                
+            contact = self.db.query(Contact).filter(Contact.ContactID == contact_id).first()
+            if not contact:
+                raise NotFoundException("Contact not found for update")
+            contact.CustomerID = contact_data.customer_id
+            contact.FirstName = contact_data.first_name
+            contact.LastName = contact_data.last_name
+            contact.Title = contact_data.title
+            contact.Address = contact_data.address
+            contact.City = contact_data.city
+            contact.PostalCode = contact_data.postal_code
+            contact.WorkPhone = contact_data.work_phone
+            contact.WorkExtension = contact_data.work_extension
+            contact.FaxNumber = contact_data.fax_number
+            contact.ReferredTo = contact_data.referred_to
+            contact.MobilePhone = contact_data.mobile_phone
+            contact.ChristmasCard = contact_data.christmas_card or False
+            contact.EmailAddress = contact_data.email_address
+            contact.WebAddress = contact_data.web_address
+            contact.CustomerTypeID = contact_data.customer_type_id
+            contact.StateID = contact_data.state_id
+            contact.CountryID = contact_data.country_id
+            contact.TempAddress = contact_data.temp_address or False
+            contact.Exported = contact_data.exported or False
+            self.db.commit()
+            self.db.refresh(contact)
+            return self._map_contact_data(contact.__dict__)
         except SQLAlchemyError as e:
             logger.error(f"Database error updating contact {contact_id}: {e}")
+            self.db.rollback()
             raise
         except Exception as e:
             logger.error(f"Unexpected error updating contact {contact_id}: {e}")
+            self.db.rollback()
             raise
 
     def delete(self, contact_id: int) -> bool:
-        """Delete a contact using stored procedure"""
+        """Delete a contact using Contacts table directly."""
         try:
-            with self.db.get_bind().connect() as conn:
-                conn.execute(
-                    text("EXEC spContactsDelete @ContactID = :contact_id"),
-                    {"contact_id": contact_id}
-                )
-                conn.commit()
-                return True
-                
+            contact = self.db.query(Contact).filter(Contact.ContactID == contact_id).first()
+            if not contact:
+                raise NotFoundException("Contact not found for delete")
+            self.db.delete(contact)
+            self.db.commit()
+            return True
         except SQLAlchemyError as e:
             logger.error(f"Database error deleting contact {contact_id}: {e}")
+            self.db.rollback()
             raise
         except Exception as e:
             logger.error(f"Unexpected error deleting contact {contact_id}: {e}")
+            self.db.rollback()
             raise
 
     def _map_contact_data(self, contact_data: dict) -> ContactOut:

app/prompts/SELECT TOP (1000) [CustomerID].sql

@@ -1,19 +1,2 @@
-SELECT TOP (1000) [CustomerID]
-      ,[CompanyName]
-      ,[Address]
-      ,[City]
-      ,[PostalCode]
-      ,[WebAddress]
-      ,[Referral]
-      ,[CompanyTypeID]
-      ,[StateID]
-      ,[CountryID]
-      ,[LeadGeneratedFromID]
-      ,[SpecificSource]
-      ,[PriorityID]
-      ,[FollowupDate]
-      ,[Purchase]
-      ,[VendorID]
-      ,[Enabled]
-      ,[RentalType]
-  FROM [hs-prod3].[dbo].[Customers]
+-- Replace 'Bidders' with an existing table name, for example 'Customers'
+select * from dbo.Customers;

app/schemas/bidder.py

@@ -0,0 +1,55 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime
+
+class BidderCreate(BaseModel):
+    proj_no: Optional[str] = Field(None, description="Project number")
+    cust_id: Optional[int] = Field(None, description="Customer ID")
+    quote: Optional[float] = Field(None, description="Quote amount")
+    contact: Optional[str] = Field(None, description="Contact name")
+    phone: Optional[str] = Field(None, description="Phone number")
+    notes: Optional[str] = Field(None, description="Notes")
+    date_last_contact: Optional[datetime] = Field(None, description="Date of last contact")
+    date_followup: Optional[datetime] = Field(None, description="Date of follow up")
+    primary: Optional[bool] = Field(False, description="Primary bidder flag")
+    cust_type: Optional[str] = Field(None, description="Customer type")
+    email_address: Optional[str] = Field(None, description="Email address")
+    fax: Optional[str] = Field(None, description="Fax number")
+    order_nr: Optional[str] = Field(None, description="Order number")
+    customer_po: Optional[str] = Field(None, description="Customer purchase order")
+    ship_date: Optional[datetime] = Field(None, description="Ship date")
+    deliver_date: Optional[datetime] = Field(None, description="Delivery date")
+    replacement_cost: Optional[float] = Field(None, description="Replacement cost")
+    quote_date: Optional[datetime] = Field(None, description="Quote date")
+    invoice_date: Optional[datetime] = Field(None, description="Invoice date")
+    less_payment: Optional[float] = Field(None, description="Less payment")
+    enabled: Optional[bool] = Field(True, description="Enabled status")
+    employee_id: Optional[int] = Field(None, description="Employee ID")
+
+class BidderOut(BaseModel):
+    id: int = Field(..., description="Bidder ID")
+    proj_no: Optional[str] = Field(None, description="Project number")
+    cust_id: Optional[int] = Field(None, description="Customer ID")
+    quote: Optional[float] = Field(None, description="Quote amount")
+    contact: Optional[str] = Field(None, description="Contact name")
+    phone: Optional[str] = Field(None, description="Phone number")
+    notes: Optional[str] = Field(None, description="Notes")
+    date_last_contact: Optional[datetime] = Field(None, description="Date of last contact")
+    date_followup: Optional[datetime] = Field(None, description="Date of follow up")
+    primary: Optional[bool] = Field(None, description="Primary bidder flag")
+    cust_type: Optional[str] = Field(None, description="Customer type")
+    email_address: Optional[str] = Field(None, description="Email address")
+    fax: Optional[str] = Field(None, description="Fax number")
+    order_nr: Optional[str] = Field(None, description="Order number")
+    customer_po: Optional[str] = Field(None, description="Customer purchase order")
+    ship_date: Optional[datetime] = Field(None, description="Ship date")
+    deliver_date: Optional[datetime] = Field(None, description="Delivery date")
+    replacement_cost: Optional[float] = Field(None, description="Replacement cost")
+    quote_date: Optional[datetime] = Field(None, description="Quote date")
+    invoice_date: Optional[datetime] = Field(None, description="Invoice date")
+    less_payment: Optional[float] = Field(None, description="Less payment")
+    enabled: Optional[bool] = Field(None, description="Enabled status")
+    employee_id: Optional[int] = Field(None, description="Employee ID")
+
+    class Config:
+        from_attributes = True  # Updated for Pydantic v2

app/services/bidder_service.py

@@ -0,0 +1,96 @@
+from sqlalchemy.orm import Session
+from app.db.repositories.bidder_repo import BidderRepository
+from app.schemas.bidder import BidderCreate, BidderOut
+from app.schemas.paginated_response import PaginatedResponse
+from app.core.exceptions import NotFoundException
+from typing import List, Optional
+
+# Constants
+BIDDER_NOT_FOUND_MSG = "Bidder not found"
+
+class BidderService:
+    def __init__(self, db: Session):
+        self.repo = BidderRepository(db)
+
+    def get(self, bidder_id: int) -> BidderOut:
+        """Get a single bidder by ID"""
+        bidder = self.repo.get(bidder_id)
+        if not bidder:
+            raise NotFoundException(BIDDER_NOT_FOUND_MSG)
+        return bidder
+
+    def list(self, page: int = 1, page_size: int = 10, order_by: str = "Id", 
+             order_direction: str = "ASC") -> PaginatedResponse[BidderOut]:
+        """Get a paginated list of all bidders"""
+        return self.repo.list(page, page_size, order_by, order_direction)
+
+    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 all bidders for a specific project"""
+        return self.repo.get_by_project_no(proj_no, page, page_size, order_by, order_dir)
+
+    def get_by_customer_id(self, cust_id: int, page: int = 1, page_size: int = 10, 
+                          order_by: str = "Id", order_dir: str = "ASC") -> PaginatedResponse[BidderOut]:
+        """Get all bidders for a specific customer"""
+        return self.repo.get_by_customer_id(cust_id, page, page_size, order_by, order_dir)
+
+    def create(self, data: dict) -> BidderOut:
+        """Create a new bidder"""
+        # Validate and clean data
+        validated_data = self._validate_bidder_data(data)
+        
+        # Convert dict to BidderCreate for validation
+        bidder_data = BidderCreate(**validated_data)
+        
+        return self.repo.create(bidder_data)
+
+    def update(self, bidder_id: int, data: dict) -> BidderOut:
+        """Update an existing bidder"""
+        # Check if bidder exists
+        existing_bidder = self.repo.get(bidder_id)
+        if not existing_bidder:
+            raise NotFoundException(BIDDER_NOT_FOUND_MSG)
+        
+        # Validate and clean data
+        validated_data = self._validate_bidder_data(data)
+        
+        # Convert dict to BidderCreate for validation
+        bidder_data = BidderCreate(**validated_data)
+        
+        return self.repo.update(bidder_id, bidder_data)
+
+    def delete(self, bidder_id: int):
+        """Delete a bidder"""
+        # Check if bidder exists
+        existing_bidder = self.repo.get(bidder_id)
+        if not existing_bidder:
+            raise NotFoundException(BIDDER_NOT_FOUND_MSG)
+        
+        self.repo.delete(bidder_id)
+
+    def _validate_bidder_data(self, data: dict) -> dict:
+        """Internal method to validate and clean bidder data"""
+        # Ensure project number is provided (required)
+        if not data.get('proj_no'):
+            raise ValueError("Project number is required")
+            
+        # Clean email format
+        if data.get('email_address'):
+            email = data['email_address'].strip().lower()
+            if '@' not in email:
+                raise ValueError("Invalid email address format")
+            data['email_address'] = email
+
+        # Clean phone numbers
+        phone_fields = ['phone', 'fax']
+        for field in phone_fields:
+            if data.get(field):
+                # Basic phone number cleaning - keep only allowed characters
+                cleaned_phone = ''.join(c for c in data[field] if c.isdigit() or c in '+()-. ')
+                data[field] = cleaned_phone.strip()
+        
+        # Ensure quote is a positive number if provided
+        if data.get('quote') is not None and data.get('quote') < 0:
+            raise ValueError("Quote amount must be a positive number")
+            
+        return data