feat(barrier-sizes): implement SQL-like insertion for barrier sizes and bidder associations, including new API endpoint and service methods

BARRIER_INSERTION_IMPLEMENTATION.md

@@ -0,0 +1,263 @@
+# Barrier Size Insertion Implementation
+
+## Overview
+
+This implementation provides the SQL INSERT-like functionality for creating barrier sizes and their associations with bidders, as requested:
+
+```sql
+-- Step 1: Insert into BarrierSizes (Id auto-generated, increment by 1)
+INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+
+-- Step 2: Insert into BiddersBarrierSizes using the generated BarrierSizeId
+INSERT INTO BiddersBarrierSizes (id,inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+```
+
+## Key Features
+
+1. **Auto-generated IDs**: Both `BarrierSizes.Id` and `BiddersBarrierSizes.Id` are auto-increment fields
+2. **ID Relationship**: The generated `BarrierSizes.Id` is automatically used as `BiddersBarrierSizes.BarrierSizeId`
+3. **Transaction Safety**: Both inserts happen in a single database transaction
+4. **Flexible Parameters**: All barrier size parameters are optional except `bidder_id`
+
+## Implementation Structure
+
+### 1. Database Models
+
+#### BarrierSizes Model (`app/db/models/barrier_size.py`)
+```python
+class BarrierSizes(Base):
+    __tablename__ = "BarrierSizes"
+    
+    Id = Column(Integer, primary_key=True, index=True, autoincrement=True)  # Auto-increment
+    Height = Column(Float, nullable=True)
+    Width = Column(Float, nullable=True)
+    Lenght = Column(Float, nullable=True)  # Note: original DB spelling
+    CableUnits = Column(Integer, nullable=True)
+    Price = Column(Float, nullable=True)
+    IsStandard = Column(Boolean, nullable=True)
+```
+
+#### BiddersBarrierSizes Model (`app/db/models/bidders_barrier_sizes.py`)
+```python
+class BiddersBarrierSizes(Base):
+    __tablename__ = "BiddersBarrierSizes"
+    
+    Id = Column(Integer, primary_key=True, index=True, autoincrement=True)  # Auto-increment
+    InventoryId = Column(Integer, nullable=True)
+    BidderId = Column(Integer, ForeignKey("Bidders.Id"), nullable=False)
+    BarrierSizeId = Column(Integer, ForeignKey("BarrierSizes.Id"), nullable=False)
+    IsStandard = Column(Boolean, nullable=True)
+```
+
+### 2. Repository Layer
+
+#### Core Method (`app/db/repositories/bidders_barrier_sizes_repo.py`)
+```python
+def create_barrier_size_with_association(
+    self,
+    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,
+    bidder_id: int = None
+) -> tuple[int, int]:
+    """
+    Implementation as requested:
+    1. Insert into BarrierSizes (id is auto-generated, increment by 1)
+    2. Insert into BiddersBarrierSizes using the generated BarrierSizeId
+    
+    Returns: (barrier_size_id, bidders_barrier_sizes_id)
+    """
+```
+
+### 3. Service Layer
+
+#### Service Function (`app/services/barrier_size_service.py`)
+```python
+def create_barrier_with_association(
+    db: Session,
+    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,
+    bidder_id: int = None
+):
+    """Create barrier size and bidder association using SQL INSERT-like approach"""
+```
+
+### 4. API Layer
+
+#### REST Endpoint (`app/controllers/bidders.py`)
+```python
+@router.post("/barrier-sizes-sql")
+def create_barrier_size_sql_like(
+    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,
+    bidder_id: int = None,
+    db: Session = Depends(get_db)
+):
+```
+
+## Usage Examples
+
+### 1. Direct Repository Usage
+```python
+from app.db.repositories.bidders_barrier_sizes_repo import BiddersBarrierSizesRepository
+from app.db.session import SessionLocal
+
+db = SessionLocal()
+repo = BiddersBarrierSizesRepository(db)
+
+barrier_size_id, association_id = repo.create_barrier_size_with_association(
+    height=6.0,
+    width=4.0,
+    length=12.0,
+    cable_units=10,
+    price=1500.00,
+    is_standard=True,
+    inventory_id=12345,
+    bidder_id=1
+)
+
+print(f"BarrierSize ID: {barrier_size_id} (auto-generated)")
+print(f"BiddersBarrierSizes ID: {association_id} (auto-generated)")
+```
+
+### 2. Service Layer Usage
+```python
+from app.services.barrier_size_service import create_barrier_with_association
+from app.db.session import SessionLocal
+
+db = SessionLocal()
+
+result = create_barrier_with_association(
+    db=db,
+    height=6.0,
+    width=4.0,
+    length=12.0,
+    cable_units=10,
+    price=1500.00,
+    is_standard=True,
+    inventory_id=12345,
+    bidder_id=1
+)
+
+# Returns: {"barrier_size_id": 123, "bidder_barrier_size_id": 456, "message": "..."}
+```
+
+### 3. API Usage
+```bash
+curl -X POST "http://localhost:8000/bidders/barrier-sizes-sql" \
+  -G \
+  -d "height=6.0" \
+  -d "width=4.0" \
+  -d "length=12.0" \
+  -d "cable_units=10" \
+  -d "price=1500.00" \
+  -d "is_standard=true" \
+  -d "inventory_id=12345" \
+  -d "bidder_id=1"
+```
+
+### 4. Python Requests
+```python
+import requests
+
+response = requests.post(
+    "http://localhost:8000/bidders/barrier-sizes-sql",
+    params={
+        "height": 6.0,
+        "width": 4.0,
+        "length": 12.0,
+        "cable_units": 10,
+        "price": 1500.00,
+        "is_standard": True,
+        "inventory_id": 12345,
+        "bidder_id": 1
+    }
+)
+
+result = response.json()
+print(f"Created BarrierSize ID: {result['barrier_size_id']}")
+print(f"Created BiddersBarrierSizes ID: {result['bidder_barrier_size_id']}")
+```
+
+## Testing
+
+### Test Scripts Provided
+
+1. **`test_barrier_insertion.py`**: Direct database testing
+2. **`demo_barrier_insertion_api.py`**: API endpoint testing with full examples
+
+### Running Tests
+
+```bash
+# Direct database test
+python test_barrier_insertion.py
+
+# API demo (requires running FastAPI server)
+python demo_barrier_insertion_api.py
+```
+
+## Database Schema Mapping
+
+| SQL Field | BarrierSizes Model | BiddersBarrierSizes Model |
+|-----------|-------------------|---------------------------|
+| `height` | `Height` | - |
+| `width` | `Width` | - |
+| `length` | `Lenght` | - |
+| `cableunits` | `CableUnits` | - |
+| `price` | `Price` | - |
+| `isstandard` | `IsStandard` | `IsStandard` |
+| `id` (auto) | `Id` | `Id` |
+| - | - | `InventoryId` |
+| - | - | `BidderId` |
+| - | - | `BarrierSizeId` (from BarrierSizes.Id) |
+
+## Implementation Notes
+
+1. **Auto-increment IDs**: Both tables use auto-increment primary keys
+2. **Foreign Key Relationship**: `BiddersBarrierSizes.BarrierSizeId` references `BarrierSizes.Id`
+3. **Transaction Safety**: All operations are wrapped in database transactions
+4. **Error Handling**: Comprehensive error handling with rollback on failure
+5. **Logging**: Detailed logging for debugging and monitoring
+6. **Flexibility**: All parameters except `bidder_id` are optional
+
+## Files Modified/Created
+
+### Modified Files
+- `app/db/models/barrier_size.py` - Added autoincrement=True to Id field
+- `app/db/models/bidders_barrier_sizes.py` - Added InventoryId and IsStandard fields
+- `app/db/repositories/bidders_barrier_sizes_repo.py` - Added insertion methods
+- `app/services/barrier_size_service.py` - Added service layer function
+- `app/controllers/bidders.py` - Added API endpoint
+- `app/schemas/barrier_size.py` - Added inventory_id field
+
+### New Files
+- `app/schemas/bidders_barrier_sizes.py` - Schema definitions
+- `test_barrier_insertion.py` - Direct database test
+- `demo_barrier_insertion_api.py` - API demo script
+- `BARRIER_INSERTION_IMPLEMENTATION.md` - This documentation
+
+## API Response Format
+
+```json
+{
+  "barrier_size_id": 123,
+  "bidder_barrier_size_id": 456,
+  "message": "Successfully inserted barrier size (ID: 123) and bidder association (ID: 456)"
+}
+```
+
+This implementation exactly matches the requested SQL INSERT behavior while providing a clean, maintainable API interface.

app/controllers/bidders.py

@@ -200,6 +200,70 @@ def create_barrier_size(
             detail=f"Failed to create barrier size: {str(e)}"
         )
 
+@router.post(
+    "/barrier-sizes-sql",
+    response_model=dict,
+    status_code=status.HTTP_201_CREATED,
+    summary="Create barrier size with SQL-like INSERT approach",
+    response_description="Created barrier size and bidder association IDs"
+)
+def create_barrier_size_sql_like(
+    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,
+    bidder_id: int = None,
+    db: Session = Depends(get_db)
+):
+    """
+    Create barrier size and bidder association using SQL INSERT-like approach.
+    
+    Implements:
+    INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+    - The Id in BarrierSizes is auto generated in the table increment by 1
+    
+    INSERT INTO BiddersBarrierSizes (id,inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+    - The id that got generated in BarrierSizes is stored in BiddersBarrierSizes BarrierSizeId field
+    - The id field in BiddersBarrierSizes is auto increment field
+    """
+    try:
+        if bidder_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="bidder_id is required"
+            )
+            
+        logger.info(f"Creating barrier size with SQL-like approach for bidder {bidder_id}")
+        
+        result = barrier_size_service.create_barrier_with_association(
+            db=db,
+            height=height,
+            width=width,
+            length=length,
+            cable_units=cable_units,
+            price=price,
+            is_standard=is_standard,
+            inventory_id=inventory_id,
+            bidder_id=bidder_id
+        )
+        
+        logger.info(f"Successfully created barrier size and association: {result}")
+        return result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating barrier size with SQL-like approach: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create barrier size: {str(e)}"
+        )
+
 
 
 

app/db/models/barrier_size.py

@@ -5,7 +5,7 @@ class BarrierSizes(Base):
     __tablename__ = "BarrierSizes"
     __table_args__ = {'extend_existing': True}
 
-    Id = Column(Integer, primary_key=True, index=True)
+    Id = Column(Integer, primary_key=True, index=True, autoincrement=True)
     Height = Column(Float, nullable=True)
     Width = Column(Float, nullable=True)
     Lenght = Column(Float, nullable=True)  # Note: keeping the original spelling "Lenght" from the database

app/db/models/bidders_barrier_sizes.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, ForeignKey
+from sqlalchemy import Column, Integer, ForeignKey, Boolean
 from sqlalchemy.orm import relationship
 from app.db.base import Base
 
@@ -7,8 +7,10 @@ class BiddersBarrierSizes(Base):
     __table_args__ = {'extend_existing': True}
 
     Id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    InventoryId = Column(Integer, nullable=True)  # Added InventoryId field
     BidderId = Column(Integer, ForeignKey("Bidders.Id"), nullable=False)
     BarrierSizeId = Column(Integer, ForeignKey("BarrierSizes.Id"), nullable=False)
+    IsStandard = Column(Boolean, nullable=True)  # Added IsStandard field
     
     # Optional: Add relationships for easier navigation
     # bidder = relationship("Bidder", back_populates="barrier_sizes")

app/db/repositories/bidders_barrier_sizes_repo.py

@@ -8,11 +8,19 @@ class BiddersBarrierSizesRepository:
     def __init__(self, db: Session):
         self.db = db
     
-    def create_association(self, bidder_id: int, barrier_size_id: int) -> BiddersBarrierSizes:
+    def create_association(
+        self, 
+        bidder_id: int, 
+        barrier_size_id: int, 
+        inventory_id: Optional[int] = None,
+        is_standard: Optional[bool] = None
+    ) -> BiddersBarrierSizes:
         """Create a new association between a bidder and barrier size"""
         db_obj = BiddersBarrierSizes(
             BidderId=bidder_id,
-            BarrierSizeId=barrier_size_id
+            BarrierSizeId=barrier_size_id,
+            InventoryId=inventory_id,
+            IsStandard=is_standard
         )
         self.db.add(db_obj)
         self.db.commit()
@@ -65,4 +73,89 @@ class BiddersBarrierSizesRepository:
                 self.db.delete(association)
             self.db.commit()
             return True
-        return False
+        return False
+    
+    def create_barrier_size_with_association(
+        self,
+        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,
+        bidder_id: int = None
+    ) -> tuple[int, int]:
+        """
+        Create a barrier size and then create the bidder association.
+        Returns tuple of (barrier_size_id, bidders_barrier_sizes_id)
+        
+        Implementation as requested:
+        1. Insert into BarrierSizes (id is auto-generated, increment by 1)
+        2. Insert into BiddersBarrierSizes using the generated BarrierSizeId
+        """
+        from app.db.models.barrier_size import BarrierSizes
+        
+        # Step 1: Insert into BarrierSizes (Id is auto-generated)
+        barrier_size = BarrierSizes(
+            Height=height,
+            Width=width,
+            Lenght=length,  # Note: keeping original spelling from DB
+            CableUnits=cable_units,
+            Price=price,
+            IsStandard=is_standard
+        )
+        
+        self.db.add(barrier_size)
+        self.db.commit()
+        self.db.refresh(barrier_size)
+        
+        # Step 2: Insert into BiddersBarrierSizes using the generated Id
+        bidder_barrier_size = BiddersBarrierSizes(
+            InventoryId=inventory_id,
+            BidderId=bidder_id,
+            BarrierSizeId=barrier_size.Id,  # Use the auto-generated Id from step 1
+            IsStandard=is_standard
+        )
+        
+        self.db.add(bidder_barrier_size)
+        self.db.commit()
+        self.db.refresh(bidder_barrier_size)
+        
+        return (barrier_size.Id, bidder_barrier_size.Id)
+    
+    def create_with_sql_like_params(
+        self,
+        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,
+        bidder_id: int = None
+    ) -> dict:
+        """
+        Create barrier size and bidder association like SQL INSERT statements.
+        Mimics:
+        INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+        INSERT INTO BiddersBarrierSizes (inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+        
+        Returns dict with both created record IDs and details
+        """
+        barrier_size_id, bidder_barrier_size_id = self.create_barrier_size_with_association(
+            height=height,
+            width=width,
+            length=length,
+            cable_units=cable_units,
+            price=price,
+            is_standard=is_standard,
+            inventory_id=inventory_id,
+            bidder_id=bidder_id
+        )
+        
+        return {
+            "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})"
+        }

app/schemas/barrier_size.py

@@ -14,6 +14,7 @@ class BarrierSizesCreate(BarrierSizesBase):
     """Schema for creating a new barrier size. bidder_id is required."""
     # Id is auto-generated, so we don't require it for creation
     bidder_id: int  # Required to associate barrier size with bidder
+    inventory_id: Optional[int] = None  # Optional inventory ID for BiddersBarrierSizes
 
 class BarrierSizesUpdate(BarrierSizesBase):
     """Schema for updating a barrier size. All fields are optional."""

app/schemas/bidders_barrier_sizes.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class BiddersBarrierSizesBase(BaseModel):
+    """Base schema for BiddersBarrierSizes"""
+    InventoryId: Optional[int] = None
+    BidderId: int
+    BarrierSizeId: int
+    IsStandard: Optional[bool] = None
+
+class BiddersBarrierSizesCreate(BiddersBarrierSizesBase):
+    """Schema for creating a new bidder-barrier size association"""
+    # Id is auto-generated, so we don't require it for creation
+    pass
+
+class BiddersBarrierSizesUpdate(BaseModel):
+    """Schema for updating a bidder-barrier size association"""
+    InventoryId: Optional[int] = None
+    IsStandard: Optional[bool] = None
+
+class BiddersBarrierSizesOut(BiddersBarrierSizesBase):
+    """Schema for bidder-barrier size association output"""
+    Id: int  # Always present from database
+
+    class Config:
+        orm_mode = True
+
+class BiddersBarrierSizesCreateRequest(BaseModel):
+    """Schema for creating barrier size with bidder association in one request"""
+    # Barrier size fields
+    Height: Optional[float] = None
+    Width: Optional[float] = None
+    Lenght: Optional[float] = None  # Note: keeping original spelling from database
+    CableUnits: Optional[int] = None
+    Price: Optional[float] = None
+    IsStandard: Optional[bool] = None
+    
+    # Association fields
+    BidderId: int
+    InventoryId: Optional[int] = None
+
+class BiddersBarrierSizesCreateResponse(BaseModel):
+    """Response schema for creating barrier size with bidder association"""
+    barrier_size_id: int
+    bidder_barrier_size_id: int
+    message: str

app/services/barrier_size_service.py

@@ -14,7 +14,7 @@ from app.schemas.barrier_size import (
     BarrierSizesUpdate,
     BarrierSizesOut,
 )
-from typing import List
+from typing import List, Optional
 import logging
 
 logger = logging.getLogger(__name__)
@@ -25,35 +25,25 @@ def create(db: Session, obj_in: BarrierSizesCreate):
         # Extract bidder_id before creating the barrier size
         bidder_id = obj_in.bidder_id
         
-        # Create barrier size directly in the database (Id will be auto-generated)
-        from app.db.models.barrier_size import BarrierSizes
-        
-        barrier_size_data = {
-            'Height': obj_in.Height,
-            'Width': obj_in.Width,
-            'Lenght': obj_in.Lenght,
-            'CableUnits': obj_in.CableUnits,
-            'Price': obj_in.Price,
-            'IsStandard': obj_in.IsStandard
-        }
-        
-        # Remove None values
-        barrier_size_data = {k: v for k, v in barrier_size_data.items() if v is not None}
-        
-        # Create the barrier size
-        db_obj = BarrierSizes(**barrier_size_data)
-        db.add(db_obj)
-        db.commit()
-        db.refresh(db_obj)
-        
-        # Create the association in BiddersBarrierSizes table
+        # Use the new method that implements the required workflow:
+        # 1. Insert into BarrierSizes (id auto-generated, increment by 1)
+        # 2. Insert into BiddersBarrierSizes using the generated BarrierSizeId
         bidders_barrier_repo = BiddersBarrierSizesRepository(db)
-        association = bidders_barrier_repo.create_association(
-            bidder_id=bidder_id,
-            barrier_size_id=db_obj.Id
+        barrier_size_id, bidder_barrier_size_id = bidders_barrier_repo.create_barrier_size_with_association(
+            height=obj_in.Height,
+            width=obj_in.Width,
+            length=obj_in.Lenght,
+            cable_units=obj_in.CableUnits,
+            price=obj_in.Price,
+            is_standard=obj_in.IsStandard,
+            inventory_id=obj_in.inventory_id,
+            bidder_id=bidder_id
         )
         
-        logger.info(f"Created barrier size {db_obj.Id} and associated with bidder {bidder_id}")
+        # Retrieve the created barrier size to return
+        db_obj = get_barrier_size(db, barrier_size_id)
+        
+        logger.info(f"Created barrier size {barrier_size_id} and associated with bidder {bidder_id} (association id: {bidder_barrier_size_id})")
         return db_obj
         
     except Exception as e:
@@ -93,3 +83,46 @@ def delete(db: Session, id: int):
         logger.error(f"Error deleting barrier size {id}: {e}")
         db.rollback()
         raise
+
+def create_barrier_with_association(
+    db: Session,
+    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,
+    bidder_id: int = None
+):
+    """
+    Create barrier size and bidder association using SQL INSERT-like approach.
+    
+    Implementation as requested:
+    INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+    - The Id in BarrierSizes is auto generated in the table increment by 1
+    
+    INSERT INTO BiddersBarrierSizes (id,inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+    - The id that got generated in BarrierSizes is stored in BiddersBarrierSizes BarrierSizeId field
+    - The id field in BiddersBarrierSizes is auto increment field
+    """
+    try:
+        bidders_barrier_repo = BiddersBarrierSizesRepository(db)
+        result = bidders_barrier_repo.create_with_sql_like_params(
+            height=height,
+            width=width,
+            length=length,
+            cable_units=cable_units,
+            price=price,
+            is_standard=is_standard,
+            inventory_id=inventory_id,
+            bidder_id=bidder_id
+        )
+        
+        logger.info(f"Successfully created barrier size and association: {result}")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error creating barrier size with association: {e}")
+        db.rollback()
+        raise

demo_barrier_insertion_api.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Demo script showing how to use the barrier size insertion functionality
+that implements the SQL INSERT approach as requested.
+"""
+
+import requests
+import json
+
+# API endpoint
+BASE_URL = "http://localhost:8000"  # Adjust as needed
+ENDPOINT = f"{BASE_URL}/bidders/barrier-sizes-sql"
+
+def demo_barrier_insertion():
+    """
+    Demonstrate the barrier size insertion that mimics SQL INSERT statements:
+    
+    INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+    INSERT INTO BiddersBarrierSizes (id,inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+    """
+    
+    print("🚀 Demonstrating SQL-like barrier size insertion")
+    print("=" * 60)
+    
+    # Test data
+    test_data = {
+        "height": 6.0,
+        "width": 4.0,
+        "length": 12.0,
+        "cable_units": 10,
+        "price": 1500.00,
+        "is_standard": True,
+        "inventory_id": 12345,
+        "bidder_id": 1
+    }
+    
+    print("📊 Test Data:")
+    for key, value in test_data.items():
+        print(f"  {key}: {value}")
+    
+    print(f"\n🌐 Making POST request to: {ENDPOINT}")
+    
+    try:
+        # Make the API request
+        response = requests.post(
+            ENDPOINT,
+            params=test_data,  # Using query parameters as defined in endpoint
+            timeout=30
+        )
+        
+        print(f"📈 Response Status: {response.status_code}")
+        
+        if response.status_code == 201:
+            result = response.json()
+            print("✅ SUCCESS! Barrier size and association created:")
+            print(f"   Barrier Size ID: {result.get('barrier_size_id')} (auto-generated)")
+            print(f"   Bidder-Barrier Association ID: {result.get('bidder_barrier_size_id')} (auto-generated)")
+            print(f"   Message: {result.get('message')}")
+            
+            print("\n🎯 This demonstrates the implementation:")
+            print("   1. INSERT INTO BarrierSizes - ID auto-incremented")
+            print("   2. INSERT INTO BiddersBarrierSizes - uses generated BarrierSizeId")
+            
+        else:
+            print(f"❌ Error: {response.status_code}")
+            try:
+                error_detail = response.json()
+                print(f"   Details: {json.dumps(error_detail, indent=2)}")
+            except:
+                print(f"   Response: {response.text}")
+                
+    except requests.exceptions.ConnectionError:
+        print("❌ Connection Error: Could not connect to the API server")
+        print("   Make sure the FastAPI server is running on the correct port")
+        print("   Try: uvicorn app.app:app --reload --port 8000")
+        
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+
+def show_usage_instructions():
+    """Show how to use the functionality in code"""
+    
+    print("\n📋 Code Usage Instructions")
+    print("=" * 60)
+    
+    print("1. Direct Repository Usage:")
+    print("""
+from app.db.repositories.bidders_barrier_sizes_repo import BiddersBarrierSizesRepository
+from app.db.session import SessionLocal
+
+db = SessionLocal()
+repo = BiddersBarrierSizesRepository(db)
+
+# Create barrier size and association
+barrier_size_id, association_id = repo.create_barrier_size_with_association(
+    height=6.0,
+    width=4.0,
+    length=12.0,
+    cable_units=10,
+    price=1500.00,
+    is_standard=True,
+    inventory_id=12345,
+    bidder_id=1
+)
+
+print(f"Created BarrierSize ID: {barrier_size_id}")
+print(f"Created Association ID: {association_id}")
+""")
+    
+    print("2. Service Layer Usage:")
+    print("""
+from app.services.barrier_size_service import create_barrier_with_association
+from app.db.session import SessionLocal
+
+db = SessionLocal()
+
+result = create_barrier_with_association(
+    db=db,
+    height=6.0,
+    width=4.0,
+    length=12.0,
+    cable_units=10,
+    price=1500.00,
+    is_standard=True,
+    inventory_id=12345,
+    bidder_id=1
+)
+
+print(result)  # Returns dict with IDs and message
+""")
+    
+    print("3. API Usage (curl):")
+    print(f"""
+curl -X POST "{ENDPOINT}" \\
+  -G \\
+  -d "height=6.0" \\
+  -d "width=4.0" \\
+  -d "length=12.0" \\
+  -d "cable_units=10" \\
+  -d "price=1500.00" \\
+  -d "is_standard=true" \\
+  -d "inventory_id=12345" \\
+  -d "bidder_id=1"
+""")
+
+if __name__ == "__main__":
+    demo_barrier_insertion()
+    show_usage_instructions()

test_barrier_insertion.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+Test script demonstrating the barrier size insertion functionality
+as requested in the requirements.
+
+This implements:
+1. INSERT into BarrierSizes (id auto-generated, increment by 1)
+2. INSERT into BiddersBarrierSizes using the generated BarrierSizeId
+"""
+
+from sqlalchemy.orm import Session
+from app.db.session import SessionLocal
+from app.db.repositories.bidders_barrier_sizes_repo import BiddersBarrierSizesRepository
+
+def test_barrier_insertion():
+    """
+    Test the barrier size insertion functionality that mimics:
+    
+    INSERT INTO BarrierSizes (height,width,length,cableunits,price,isstandard) VALUES (...)
+    - The Id in BarrierSizes is auto generated, increments by 1
+    
+    INSERT INTO BiddersBarrierSizes (id,inventoryid,bidderid,barriersizeid,isstandard) VALUES (...)
+    - The id from BarrierSizes is stored in BiddersBarrierSizes.BarrierSizeId
+    - The id field in BiddersBarrierSizes is auto increment
+    """
+    
+    # Get database session
+    db: Session = SessionLocal()
+    
+    try:
+        # Initialize repository
+        repo = BiddersBarrierSizesRepository(db)
+        
+        # Test data - example barrier size
+        test_data = {
+            "height": 6.0,
+            "width": 4.0, 
+            "length": 12.0,
+            "cable_units": 10,
+            "price": 1500.00,
+            "is_standard": True,
+            "inventory_id": 12345,  # Optional inventory ID
+            "bidder_id": 1  # Required bidder ID
+        }
+        
+        print("Creating barrier size with bidder association...")
+        print(f"Input data: {test_data}")
+        
+        # Call the method that implements the required workflow
+        result = repo.create_with_sql_like_params(**test_data)
+        
+        print("\nResults:")
+        print(f"Barrier Size ID (auto-generated): {result['barrier_size_id']}")
+        print(f"Bidder Barrier Size ID (auto-generated): {result['bidder_barrier_size_id']}")
+        print(f"Message: {result['message']}")
+        
+        # Verify the records were created
+        from app.db.models.barrier_size import BarrierSizes
+        from app.db.models.bidders_barrier_sizes import BiddersBarrierSizes
+        
+        # Check BarrierSizes record
+        barrier_size = db.query(BarrierSizes).filter(
+            BarrierSizes.Id == result['barrier_size_id']
+        ).first()
+        
+        print(f"\nCreated BarrierSizes record:")
+        print(f"  Id: {barrier_size.Id} (auto-generated)")
+        print(f"  Height: {barrier_size.Height}")
+        print(f"  Width: {barrier_size.Width}")
+        print(f"  Length: {barrier_size.Lenght}")
+        print(f"  CableUnits: {barrier_size.CableUnits}")
+        print(f"  Price: {barrier_size.Price}")
+        print(f"  IsStandard: {barrier_size.IsStandard}")
+        
+        # Check BiddersBarrierSizes record
+        bidder_barrier = db.query(BiddersBarrierSizes).filter(
+            BiddersBarrierSizes.Id == result['bidder_barrier_size_id']
+        ).first()
+        
+        print(f"\nCreated BiddersBarrierSizes record:")
+        print(f"  Id: {bidder_barrier.Id} (auto-generated)")
+        print(f"  InventoryId: {bidder_barrier.InventoryId}")
+        print(f"  BidderId: {bidder_barrier.BidderId}")
+        print(f"  BarrierSizeId: {bidder_barrier.BarrierSizeId} (from BarrierSizes.Id)")
+        print(f"  IsStandard: {bidder_barrier.IsStandard}")
+        
+        print("\n✅ Successfully implemented the required insertion workflow!")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        db.rollback()
+    finally:
+        db.close()
+
+if __name__ == "__main__":
+    test_barrier_insertion()