feat(barrier-sizes): add CRUD operations and update associations for barrier sizes

.env.example

@@ -0,0 +1,22 @@
+# AquaBarrier Core API Environment Configuration Template
+# Copy this file to .env and update the values
+
+# Security Settings (REQUIRED)
+SECRET_KEY=your-secret-key-here
+JWT_ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=15
+REFRESH_TOKEN_EXPIRE_DAYS=7
+
+# SQL Server Database Configuration (REQUIRED)
+SQLSERVER_USER=your-db-username
+SQLSERVER_PASSWORD=your-db-password
+SQLSERVER_HOST=localhost
+SQLSERVER_PORT=1433
+SQLSERVER_DB=your-database-name
+SQLSERVER_DRIVER=ODBC Driver 18 for SQL Server
+
+# Application Settings (OPTIONAL)
+APP_NAME=AquaBarrier Core API
+API_V1_STR=/api/v1
+CORS_ORIGINS=*
+LOG_LEVEL=INFO

app/controllers/bidders.py

@@ -205,6 +205,47 @@ def create_barrier_size(
 
 
 
+@router.get(
+    "/barrier-sizes/all",
+    response_model=List[BarrierSizesOut],
+    summary="Get all barrier sizes (for debugging)",
+    response_description="List of all barrier sizes in the system"
+)
+def get_all_barrier_sizes(db: Session = Depends(get_db)):
+    """Get all barrier sizes in the system (for debugging purposes)"""
+    try:
+        barrier_sizes = barrier_size_service.get_all(db, skip=0, limit=50)
+        logger.info(f"Found {len(barrier_sizes)} barrier sizes in database")
+        return barrier_sizes
+    except Exception as e:
+        logger.error(f"Error getting all barrier sizes: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to get barrier sizes"
+        )
+
+@router.get(
+    "/barrier-sizes/{barrier_size_id}",
+    response_model=BarrierSizesOut,
+    summary="Get a specific barrier size by ID (for debugging)",
+    response_description="Specific barrier size details"
+)
+def get_barrier_size_by_id(barrier_size_id: int, db: Session = Depends(get_db)):
+    """Get a specific barrier size by ID (for debugging purposes)"""
+    try:
+        barrier_size = barrier_size_service.get(db, barrier_size_id)
+        if not barrier_size:
+            raise HTTPException(status_code=404, detail=f"Barrier size {barrier_size_id} not found")
+        return barrier_size
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting barrier size {barrier_size_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to get barrier size"
+        )
+
 @router.get(
     "/{bidder_id}/barrier-sizes",
     response_model=List[BidderBarrierSizeDetail],
@@ -344,19 +385,22 @@ def update_barrier_size(
         result = barrier_size_service.update_barrier_with_association(
             db=db,
             barrier_size_id=id,
-            height=barrier_update.height,
-            width=barrier_update.width,
-            length=barrier_update.length,
-            cable_units=barrier_update.cable_units,
-            price=barrier_update.price,
-            is_standard=barrier_update.is_standard,
+            height=barrier_update.Height,
+            width=barrier_update.Width,
+            length=barrier_update.Lenght,
+            cable_units=barrier_update.CableUnits,
+            price=barrier_update.Price,
+            is_standard=barrier_update.IsStandard,
             inventory_id=barrier_update.inventory_id,
             install_advisor_fees=barrier_update.install_advisor_fees,
             bidder_id=barrier_update.bidder_id
         )
         
         if not result:
-            raise HTTPException(status_code=404, detail="Barrier size not found")
+            raise HTTPException(
+                status_code=404, 
+                detail=f"Barrier size {id} not found. Please create the barrier size first using POST /api/v1/bidders/barrier-sizes"
+            )
             
         logger.info(f"Successfully updated barrier size {id}")
         return result

app/db/repositories/bidders_barrier_sizes_repo.py

@@ -180,4 +180,98 @@ class BiddersBarrierSizesRepository:
             "barrier_size_id": barrier_size_id,
             "bidder_barrier_size_id": bidder_barrier_size_id,
             "message": f"Successfully inserted barrier size (ID: {barrier_size_id}) and bidder association (ID: {bidder_barrier_size_id})"
-        }
+        }
+    
+    def get_by_barrier_size_and_bidder(self, barrier_size_id: int, bidder_id: int) -> List[dict]:
+        """Get association details for a specific barrier size and bidder combination"""
+        associations = (
+            self.db.query(BiddersBarrierSizes)
+            .filter(
+                BiddersBarrierSizes.BarrierSizeId == barrier_size_id,
+                BiddersBarrierSizes.BidderId == bidder_id
+            )
+            .all()
+        )
+        
+        # Convert to dict format for easier consumption
+        return [
+            {
+                "Id": assoc.Id,
+                "InventoryId": assoc.InventoryId,
+                "BidderId": assoc.BidderId,
+                "BarrierSizeId": assoc.BarrierSizeId,
+                "InstallAdvisorFees": assoc.InstallAdvisorFees,
+                "IsStandard": assoc.IsStandard
+            }
+            for assoc in associations
+        ]
+    
+    def update_or_create_association(
+        self,
+        barrier_size_id: int,
+        bidder_id: int,
+        inventory_id: Optional[int] = None,
+        install_advisor_fees: Optional[float] = None,
+        is_standard: Optional[bool] = None
+    ) -> BiddersBarrierSizes:
+        """Update existing association or create new one if it doesn't exist"""
+        # Try to find existing association
+        association = (
+            self.db.query(BiddersBarrierSizes)
+            .filter(
+                BiddersBarrierSizes.BarrierSizeId == barrier_size_id,
+                BiddersBarrierSizes.BidderId == bidder_id
+            )
+            .first()
+        )
+        
+        if association:
+            # Update existing association
+            if inventory_id is not None:
+                association.InventoryId = inventory_id
+            if install_advisor_fees is not None:
+                association.InstallAdvisorFees = install_advisor_fees
+            if is_standard is not None:
+                association.IsStandard = is_standard
+            
+            self.db.commit()
+            self.db.refresh(association)
+            return association
+        else:
+            # Create new association
+            return self.create_association(
+                bidder_id=bidder_id,
+                barrier_size_id=barrier_size_id,
+                inventory_id=inventory_id,
+                install_advisor_fees=install_advisor_fees,
+                is_standard=is_standard
+            )
+    
+    def update_association_fields(
+        self,
+        barrier_size_id: int,
+        inventory_id: Optional[int] = None,
+        install_advisor_fees: Optional[float] = None,
+        is_standard: Optional[bool] = None
+    ) -> int:
+        """Update fields for all associations with a specific barrier size"""
+        associations = (
+            self.db.query(BiddersBarrierSizes)
+            .filter(BiddersBarrierSizes.BarrierSizeId == barrier_size_id)
+            .all()
+        )
+        
+        updated_count = 0
+        for association in associations:
+            if inventory_id is not None:
+                association.InventoryId = inventory_id
+            if install_advisor_fees is not None:
+                association.InstallAdvisorFees = install_advisor_fees
+            if is_standard is not None:
+                association.IsStandard = is_standard
+            updated_count += 1
+        
+        if updated_count > 0:
+            self.db.commit()
+        
+        return updated_count

app/schemas/barrier_size.py

@@ -18,7 +18,10 @@ class BarrierSizesCreate(BarrierSizesBase):
 
 class BarrierSizesUpdate(BarrierSizesBase):
     """Schema for updating a barrier size. All fields are optional."""
-    pass
+    # Additional fields for updating bidder associations
+    bidder_id: Optional[int] = None  # Optional bidder ID for association updates
+    inventory_id: Optional[int] = None  # Optional inventory ID for BiddersBarrierSizes
+    install_advisor_fees: Optional[float] = None  # Optional install advisor fees
 
 class BarrierSizesOut(BarrierSizesBase):
     """Schema for barrier size output. Id is always present from database."""

app/services/barrier_size_service.py

@@ -188,3 +188,118 @@ def create_barrier_with_association(
         logger.error(f"Error creating barrier size with association: {e}")
         db.rollback()
         raise
+
+def update_barrier_with_association(
+    db: Session,
+    barrier_size_id: int,
+    height: Optional[float] = None,
+    width: Optional[float] = None,
+    length: Optional[float] = None,
+    cable_units: Optional[int] = None,
+    price: Optional[float] = None,
+    is_standard: Optional[bool] = None,
+    inventory_id: Optional[int] = None,
+    install_advisor_fees: Optional[float] = None,
+    bidder_id: Optional[int] = None
+):
+    """
+    Update barrier size and/or bidder association.
+    
+    Updates both BarrierSizes table and BiddersBarrierSizes table if bidder_id is provided.
+    Only updates the fields that are provided (non-None values).
+    
+    Args:
+        db: Database session
+        barrier_size_id: ID of the barrier size to update
+        height: New height value (optional)
+        width: New width value (optional)
+        length: New length value (optional)
+        cable_units: New cable units value (optional)
+        price: New price value (optional)
+        is_standard: New is_standard flag (optional)
+        inventory_id: New inventory ID for the bidder association (optional)
+        install_advisor_fees: New install advisor fees for the bidder association (optional)
+        bidder_id: Bidder ID for the association update (optional)
+    
+    Returns:
+        dict: Updated barrier size information
+    """
+    try:
+        # First check if barrier size exists
+        logger.info(f"Checking if barrier size {barrier_size_id} exists in database")
+        barrier_size = get_barrier_size(db, barrier_size_id)
+        logger.info(f"Barrier size query result: {barrier_size}")
+        
+        if not barrier_size:
+            logger.warning(f"Barrier size {barrier_size_id} not found in database")
+            # Get some sample barrier size IDs to help with debugging
+            sample_barrier_sizes = get_barrier_sizes(db, skip=0, limit=5)
+            sample_ids = [bs.Id for bs in sample_barrier_sizes] if sample_barrier_sizes else []
+            logger.info(f"Available barrier size IDs (sample): {sample_ids}")
+            return None
+        
+        # Prepare update data for BarrierSizes table using correct schema field names
+        barrier_update_data = {}
+        if height is not None:
+            barrier_update_data['Height'] = height
+        if width is not None:
+            barrier_update_data['Width'] = width
+        if length is not None:
+            barrier_update_data['Lenght'] = length  # Note: keeping the misspelled column name
+        if cable_units is not None:
+            barrier_update_data['CableUnits'] = cable_units
+        if price is not None:
+            barrier_update_data['Price'] = price
+        if is_standard is not None:
+            barrier_update_data['IsStandard'] = is_standard
+        
+        # Update BarrierSizes table if there are fields to update
+        if barrier_update_data:
+            from app.schemas.barrier_size import BarrierSizesUpdate
+            barrier_update_obj = BarrierSizesUpdate(**barrier_update_data)
+            update_barrier_size(db, barrier_size_id, barrier_update_obj)
+        
+        # Update BiddersBarrierSizes association if bidder-related fields are provided
+        if bidder_id is not None or inventory_id is not None or install_advisor_fees is not None:
+            bidders_barrier_repo = BiddersBarrierSizesRepository(db)
+            
+            if bidder_id is not None:
+                # Update or create association for this bidder
+                bidders_barrier_repo.update_or_create_association(
+                    barrier_size_id=barrier_size_id,
+                    bidder_id=bidder_id,
+                    inventory_id=inventory_id,
+                    install_advisor_fees=install_advisor_fees
+                )
+            else:
+                # Update existing associations with new inventory_id or install_advisor_fees
+                bidders_barrier_repo.update_association_fields(
+                    barrier_size_id=barrier_size_id,
+                    inventory_id=inventory_id,
+                    install_advisor_fees=install_advisor_fees
+                )
+        
+        # Return updated barrier size information
+        updated_barrier = get_barrier_size(db, barrier_size_id)
+        
+        # Get association details if bidder_id was provided
+        association_details = {}
+        if bidder_id is not None:
+            bidders_barrier_repo = BiddersBarrierSizesRepository(db)
+            associations = bidders_barrier_repo.get_by_barrier_size_and_bidder(barrier_size_id, bidder_id)
+            if associations:
+                association_details = associations[0]  # Get the first/only association
+        
+        result = {
+            "barrier_size": updated_barrier.__dict__ if updated_barrier else None,
+            "association": association_details,
+            "updated_fields": list(barrier_update_data.keys()) + (["bidder_association"] if bidder_id is not None else [])
+        }
+        
+        logger.info(f"Successfully updated barrier size {barrier_size_id}: {result}")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error updating barrier size with association: {e}")
+        db.rollback()
+        raise

test_barrier_update.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Script to test barrier size creation and update functionality
+"""
+import requests
+import json
+
+BASE_URL = "http://127.0.0.1:9291/api/v1"
+
+def create_barrier_size():
+    """Create a new barrier size and return its ID"""
+    print("Creating a new barrier size...")
+    
+    # First, let's check what barrier sizes already exist
+    try:
+        response = requests.get(f"{BASE_URL}/bidders/barrier-sizes/all")
+        if response.status_code == 200:
+            existing_barriers = response.json()
+            print(f"Found {len(existing_barriers)} existing barrier sizes:")
+            for barrier in existing_barriers[:5]:  # Show first 5
+                print(f"  - ID: {barrier['Id']}, Height: {barrier.get('Height')}, Price: {barrier.get('Price')}")
+            
+            if existing_barriers:
+                # Use the first existing barrier size for testing
+                barrier_id = existing_barriers[0]['Id']
+                print(f"Using existing barrier size ID: {barrier_id}")
+                return barrier_id
+        else:
+            print(f"Could not fetch existing barriers: {response.status_code}")
+    except Exception as e:
+        print(f"Error fetching existing barriers: {e}")
+    
+    # Create a new barrier size
+    barrier_data = {
+        "Height": 10.0,
+        "Width": 12.0,
+        "Lenght": 25.0,
+        "CableUnits": 3,
+        "Price": 1500.00,
+        "IsStandard": True,
+        "bidder_id": 21378,  # Using the same bidder ID from the original request
+        "inventory_id": 1
+    }
+    
+    try:
+        response = requests.post(f"{BASE_URL}/bidders/barrier-sizes", json=barrier_data)
+        if response.status_code == 201:
+            result = response.json()
+            barrier_id = result['Id']
+            print(f"Successfully created barrier size with ID: {barrier_id}")
+            return barrier_id
+        else:
+            print(f"Failed to create barrier size: {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error creating barrier size: {e}")
+        return None
+
+def update_barrier_size(barrier_id):
+    """Update the barrier size"""
+    print(f"\\nUpdating barrier size {barrier_id}...")
+    
+    update_data = {
+        "Height": 12,
+        "Width": 15, 
+        "Lenght": 20,
+        "CableUnits": 1500,
+        "Price": 2500,
+        "IsStandard": True,
+        "bidder_id": 21378,
+        "inventory_id": 1
+    }
+    
+    try:
+        response = requests.put(f"{BASE_URL}/bidders/barrier-sizes/{barrier_id}", json=update_data)
+        print(f"Update response status: {response.status_code}")
+        print(f"Update response: {response.text}")
+        
+        if response.status_code == 200:
+            print("✅ Barrier size updated successfully!")
+            return True
+        else:
+            print("❌ Failed to update barrier size")
+            return False
+    except Exception as e:
+        print(f"Error updating barrier size: {e}")
+        return False
+
+def test_specific_barrier_id():
+    """Test the specific barrier ID 32739 that was failing"""
+    print(f"\\nTesting specific barrier ID 32739...")
+    
+    # First check if it exists
+    try:
+        response = requests.get(f"{BASE_URL}/bidders/barrier-sizes/32739")
+        print(f"Check response status: {response.status_code}")
+        if response.status_code == 200:
+            print("✅ Barrier size 32739 exists!")
+            return update_barrier_size(32739)
+        else:
+            print(f"❌ Barrier size 32739 does not exist: {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error checking barrier size 32739: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Testing Barrier Size Update Functionality")
+    print("=" * 50)
+    
+    # Test the specific barrier ID that was failing
+    if not test_specific_barrier_id():
+        # If 32739 doesn't exist, create/use another barrier size
+        barrier_id = create_barrier_size()
+        if barrier_id:
+            update_barrier_size(barrier_id)
+        else:
+            print("❌ Could not create or find a barrier size to test with")