Implemented improved inventory requirements system with API endpoints, validation, and comprehensive documentation.

docs/examples/inventory_requirements_setup.py

@@ -0,0 +1,346 @@
+"""
+Example: Setting up Inventory Requirements for a Project
+
+This script demonstrates how to configure inventory requirements
+for a typical FTTH (Fiber to the Home) installation project.
+"""
+
+# Example 1: FTTH Installation Project
+ftth_inventory_requirements = {
+    # Equipment - Installed at customer sites
+    "ONT-ZTE-F670L": {
+        "code": "ONT-ZTE-F670L",
+        "name": "ZTE F670L ONT Device",
+        "description": "Fiber optic network terminal with 4 GE ports and WiFi",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": True,
+        "category": "Equipment",
+        "include_in_completion": True,
+        "completion_field_label": "ONT Serial Number",
+        "completion_required": True
+    },
+    "ONT-HUAWEI-HG8546M": {
+        "code": "ONT-HUAWEI-HG8546M",
+        "name": "Huawei HG8546M ONT",
+        "description": "GPON ONT with 4 GE ports, 2 POTS, WiFi",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": True,
+        "category": "Equipment",
+        "include_in_completion": True,
+        "completion_field_label": "ONT Serial Number",
+        "completion_required": True
+    },
+    "ROUTER-TP-C6": {
+        "code": "ROUTER-TP-C6",
+        "name": "TP-Link Archer C6 Router",
+        "description": "AC1200 Dual-band wireless router",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": True,
+        "category": "Equipment",
+        "include_in_completion": True,
+        "completion_field_label": "Router Serial Number",
+        "completion_required": False  # Optional if ONT has WiFi
+    },
+    
+    # Cables - Consumed during installation
+    "CABLE-FIBER-SM-DROP": {
+        "code": "CABLE-FIBER-SM-DROP",
+        "name": "Single Mode Fiber Drop Cable",
+        "description": "Outdoor drop cable from pole to customer premises",
+        "usage_type": "consumed",
+        "unit": "meters",
+        "requires_serial_number": False,
+        "category": "Cable",
+        "include_in_completion": False
+    },
+    "CABLE-FIBER-SM-INDOOR": {
+        "code": "CABLE-FIBER-SM-INDOOR",
+        "name": "Single Mode Indoor Fiber Cable",
+        "description": "Indoor fiber cable for in-home routing",
+        "usage_type": "consumed",
+        "unit": "meters",
+        "requires_serial_number": False,
+        "category": "Cable",
+        "include_in_completion": False
+    },
+    "CABLE-CAT6": {
+        "code": "CABLE-CAT6",
+        "name": "Cat6 Ethernet Cable",
+        "description": "Category 6 UTP cable for LAN connections",
+        "usage_type": "consumed",
+        "unit": "meters",
+        "requires_serial_number": False,
+        "category": "Cable",
+        "include_in_completion": False
+    },
+    
+    # Connectors & Consumables
+    "CONNECTOR-SC-APC": {
+        "code": "CONNECTOR-SC-APC",
+        "name": "SC/APC Fiber Connector",
+        "description": "Single mode SC/APC connector for termination",
+        "usage_type": "consumed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Consumables",
+        "include_in_completion": False
+    },
+    "CONNECTOR-LC-UPC": {
+        "code": "CONNECTOR-LC-UPC",
+        "name": "LC/UPC Fiber Connector",
+        "description": "Single mode LC/UPC connector",
+        "usage_type": "consumed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Consumables",
+        "include_in_completion": False
+    },
+    "CONNECTOR-RJ45": {
+        "code": "CONNECTOR-RJ45",
+        "name": "RJ45 Ethernet Connector",
+        "description": "Cat6 RJ45 connector for termination",
+        "usage_type": "consumed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Consumables",
+        "include_in_completion": False
+    },
+    
+    # Installation Materials
+    "FASTENER-CABLE-CLIP": {
+        "code": "FASTENER-CABLE-CLIP",
+        "name": "Cable Clips",
+        "description": "Plastic clips for securing drop cable",
+        "usage_type": "consumed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Installation Materials",
+        "include_in_completion": False
+    },
+    "FASTENER-WALL-ANCHOR": {
+        "code": "FASTENER-WALL-ANCHOR",
+        "name": "Wall Anchors",
+        "description": "Plastic wall anchors for mounting",
+        "usage_type": "consumed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Installation Materials",
+        "include_in_completion": False
+    },
+    "TAPE-DUCT": {
+        "code": "TAPE-DUCT",
+        "name": "Duct Tape",
+        "description": "Heavy-duty duct tape for cable management",
+        "usage_type": "consumed",
+        "unit": "rolls",
+        "requires_serial_number": False,
+        "category": "Installation Materials",
+        "include_in_completion": False
+    },
+    
+    # Power & Protection
+    "ADAPTER-POWER-12V": {
+        "code": "ADAPTER-POWER-12V",
+        "name": "12V Power Adapter",
+        "description": "12V DC power adapter for ONT",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Power",
+        "include_in_completion": False
+    },
+    "PROTECTOR-SURGE": {
+        "code": "PROTECTOR-SURGE",
+        "name": "Surge Protector",
+        "description": "Electrical surge protector",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Protection",
+        "include_in_completion": False
+    }
+}
+
+
+# Example 2: Fixed Wireless Project
+fixed_wireless_inventory_requirements = {
+    "CPE-UBIQUITI-LITEBEAM": {
+        "code": "CPE-UBIQUITI-LITEBEAM",
+        "name": "Ubiquiti LiteBeam AC Gen2",
+        "description": "5GHz airMAX CPE with integrated antenna",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": True,
+        "category": "Equipment",
+        "include_in_completion": True,
+        "completion_field_label": "CPE Serial Number",
+        "completion_required": True
+    },
+    "ROUTER-MIKROTIK-RB750": {
+        "code": "ROUTER-MIKROTIK-RB750",
+        "name": "MikroTik hEX RB750Gr3",
+        "description": "5-port Gigabit router",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": True,
+        "category": "Equipment",
+        "include_in_completion": True,
+        "completion_field_label": "Router Serial Number",
+        "completion_required": True
+    },
+    "CABLE-CAT6-OUTDOOR": {
+        "code": "CABLE-CAT6-OUTDOOR",
+        "name": "Cat6 Outdoor Cable",
+        "description": "Outdoor-rated Cat6 cable for CPE connection",
+        "usage_type": "consumed",
+        "unit": "meters",
+        "requires_serial_number": False,
+        "category": "Cable",
+        "include_in_completion": False
+    },
+    "POE-INJECTOR-24V": {
+        "code": "POE-INJECTOR-24V",
+        "name": "24V PoE Injector",
+        "description": "Power over Ethernet injector for CPE",
+        "usage_type": "installed",
+        "unit": "pieces",
+        "requires_serial_number": False,
+        "category": "Power",
+        "include_in_completion": False
+    }
+}
+
+
+# Example 3: API Request to Create Project with Inventory Requirements
+import requests
+
+def create_project_with_inventory_requirements():
+    """
+    Example API call to create a project with inventory requirements
+    """
+    api_url = "https://api.example.com/api/v1/projects"
+    headers = {
+        "Authorization": "Bearer YOUR_TOKEN_HERE",
+        "Content-Type": "application/json"
+    }
+    
+    project_data = {
+        "title": "Nairobi FTTH Rollout Phase 1",
+        "description": "Fiber to the home installations in Nairobi suburbs",
+        "project_type": "customer_service",
+        "service_type": "ftth",
+        "client_id": "client-uuid-here",
+        "contractor_id": "contractor-uuid-here",
+        "planned_start_date": "2025-01-01",
+        "planned_end_date": "2025-12-31",
+        
+        # Inventory requirements
+        "inventory_requirements": ftth_inventory_requirements,
+        
+        # Photo requirements
+        "photo_requirements": [
+            {
+                "type": "before_installation",
+                "required": True,
+                "min_photos": 1,
+                "max_photos": 3,
+                "description": "Photo of installation site before work"
+            },
+            {
+                "type": "ont_installation",
+                "required": True,
+                "min_photos": 1,
+                "max_photos": 2,
+                "description": "Photo of installed ONT device"
+            },
+            {
+                "type": "speedtest",
+                "required": True,
+                "min_photos": 1,
+                "max_photos": 1,
+                "description": "Screenshot of speed test results"
+            }
+        ],
+        
+        # Activation requirements
+        "activation_requirements": [
+            {
+                "field": "customer_phone",
+                "label": "Customer Phone Number",
+                "type": "text",
+                "required": True,
+                "placeholder": "+254..."
+            },
+            {
+                "field": "speed_test_download_mbps",
+                "label": "Download Speed (Mbps)",
+                "type": "number",
+                "required": True
+            },
+            {
+                "field": "speed_test_upload_mbps",
+                "label": "Upload Speed (Mbps)",
+                "type": "number",
+                "required": True
+            }
+        ]
+    }
+    
+    response = requests.post(api_url, json=project_data, headers=headers)
+    return response.json()
+
+
+# Example 4: Receiving Inventory Batch
+def receive_inventory_batch():
+    """
+    Example API call to receive inventory batch
+    The equipment_type must match a code from inventory_requirements
+    """
+    api_url = "https://api.example.com/api/v1/inventory"
+    headers = {
+        "Authorization": "Bearer YOUR_TOKEN_HERE",
+        "Content-Type": "application/json"
+    }
+    
+    inventory_data = {
+        "project_id": "project-uuid-here",
+        "equipment_type": "ONT-ZTE-F670L",  # Must match inventory requirement code
+        "equipment_name": "ZTE F670L ONT Device",  # Auto-populated from requirement
+        "description": "Batch received from supplier",
+        "quantity_received": 100,
+        "unit": "pieces",
+        "item_type": "equipment",
+        "has_serial_numbers": True,
+        "serial_numbers": [
+            {"serial": "HW12345001", "status": "available"},
+            {"serial": "HW12345002", "status": "available"},
+            # ... more serials
+        ],
+        "received_date": "2025-01-15",
+        "unit_cost": 2500.00,
+        "total_cost": 250000.00,
+        "currency": "KES"
+    }
+    
+    response = requests.post(api_url, json=inventory_data, headers=headers)
+    return response.json()
+
+
+if __name__ == "__main__":
+    print("FTTH Inventory Requirements:")
+    print(f"Total items: {len(ftth_inventory_requirements)}")
+    
+    installed_items = [k for k, v in ftth_inventory_requirements.items() if v['usage_type'] == 'installed']
+    consumed_items = [k for k, v in ftth_inventory_requirements.items() if v['usage_type'] == 'consumed']
+    
+    print(f"Installed items: {len(installed_items)}")
+    print(f"Consumed items: {len(consumed_items)}")
+    
+    print("\nInstalled items (will appear in ticket completion):")
+    for code in installed_items:
+        item = ftth_inventory_requirements[code]
+        if item.get('include_in_completion'):
+            print(f"  - {item['name']} ({code})")

docs/features/INVENTORY_REQUIREMENTS.md

@@ -0,0 +1,263 @@
+# Inventory Requirements System
+
+## Overview
+
+The Inventory Requirements system provides a flexible way to define and manage inventory types for projects. It controls what inventory can be received, tracked, and used in ticket completion forms.
+
+## Key Concepts
+
+### 1. Project-Level Configuration
+
+Inventory requirements are defined at the project level in `project.inventory_requirements` (JSONB dictionary). Each requirement defines:
+
+- **code**: Unique identifier (e.g., `ONT-ZTE-F670L`, `CABLE-FIBER-SM`)
+- **name**: Display name (e.g., "ZTE F670L ONT Device")
+- **description**: Detailed description
+- **usage_type**: How the inventory is used
+  - `installed`: Equipment installed at customer sites (appears in ticket completion)
+  - `consumed`: Materials used up during work (tracked but not in completion forms)
+- **unit**: Unit of measurement (pieces, meters, boxes, sets, etc.)
+- **requires_serial_number**: Whether serial number tracking is required
+- **category**: Grouping category (Equipment, Cable, Tools, Consumables, etc.)
+
+### 2. Ticket Completion Integration
+
+For items with `usage_type: "installed"`:
+
+- **include_in_completion**: Whether to include in ticket completion forms (default: true)
+- **completion_field_label**: Custom label for the completion form field
+- **completion_required**: Whether the field is mandatory in ticket completion
+
+## Example Configuration
+
+```json
+{
+  "ONT-ZTE-F670L": {
+    "code": "ONT-ZTE-F670L",
+    "name": "ZTE F670L ONT Device",
+    "description": "Fiber optic network terminal for FTTH installations",
+    "usage_type": "installed",
+    "unit": "pieces",
+    "requires_serial_number": true,
+    "category": "Equipment",
+    "include_in_completion": true,
+    "completion_field_label": "ONT Serial Number",
+    "completion_required": true
+  },
+  "ROUTER-TP-C6": {
+    "code": "ROUTER-TP-C6",
+    "name": "TP-Link Archer C6 Router",
+    "description": "Dual-band wireless router",
+    "usage_type": "installed",
+    "unit": "pieces",
+    "requires_serial_number": true,
+    "category": "Equipment",
+    "include_in_completion": true,
+    "completion_field_label": "Router Serial Number",
+    "completion_required": true
+  },
+  "CABLE-FIBER-SM": {
+    "code": "CABLE-FIBER-SM",
+    "name": "Single Mode Fiber Cable",
+    "description": "Outdoor fiber optic cable for drop installations",
+    "usage_type": "consumed",
+    "unit": "meters",
+    "requires_serial_number": false,
+    "category": "Cable",
+    "include_in_completion": false
+  },
+  "CONNECTOR-SC-APC": {
+    "code": "CONNECTOR-SC-APC",
+    "name": "SC/APC Fiber Connector",
+    "description": "Single mode fiber connector",
+    "usage_type": "consumed",
+    "unit": "pieces",
+    "requires_serial_number": false,
+    "category": "Consumables",
+    "include_in_completion": false
+  }
+}
+```
+
+## Workflow
+
+### 1. Project Setup
+
+When creating or updating a project, define inventory requirements:
+
+```http
+POST /api/v1/projects
+{
+  "title": "Nairobi FTTH Rollout",
+  "inventory_requirements": {
+    "ONT-ZTE-F670L": { ... },
+    "ROUTER-TP-C6": { ... },
+    "CABLE-FIBER-SM": { ... }
+  }
+}
+```
+
+### 2. Receiving Inventory
+
+When receiving inventory batches, the system validates against requirements:
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements/dropdown
+```
+
+Returns dropdown options for inventory receiving:
+
+```json
+{
+  "options": [
+    {
+      "code": "ONT-ZTE-F670L",
+      "name": "ZTE F670L ONT Device",
+      "description": "Fiber optic network terminal",
+      "category": "Equipment",
+      "unit": "pieces",
+      "requires_serial_number": true,
+      "usage_type": "installed"
+    },
+    ...
+  ]
+}
+```
+
+When creating inventory batch:
+
+```http
+POST /api/v1/inventory
+{
+  "project_id": "...",
+  "equipment_type": "ONT-ZTE-F670L",  // Must match a code from requirements
+  "equipment_name": "ZTE F670L ONT Device",  // Auto-populated from requirement
+  "quantity_received": 100,
+  "item_type": "equipment"
+}
+```
+
+The system validates that `equipment_type` matches a code in `project.inventory_requirements`.
+
+### 3. Ticket Completion
+
+When a ticket is being completed, the system dynamically generates completion fields:
+
+```http
+GET /api/v1/tickets/{ticket_id}/completion/checklist
+```
+
+Returns checklist including inventory fields:
+
+```json
+{
+  "field_items": [
+    {
+      "id": "inventory_ONT-ZTE-F670L",
+      "type": "field",
+      "field_name": "inventory_ONT-ZTE-F670L",
+      "label": "ONT Serial Number",
+      "data_type": "text",
+      "required": true,
+      "validation_regex": "^[A-Z0-9\\-]{4,}$",
+      "inventory_code": "ONT-ZTE-F670L",
+      "source": "inventory",
+      "status": "pending"
+    },
+    {
+      "id": "inventory_ROUTER-TP-C6",
+      "type": "field",
+      "field_name": "inventory_ROUTER-TP-C6",
+      "label": "Router Serial Number",
+      "data_type": "text",
+      "required": true,
+      "validation_regex": "^[A-Z0-9\\-]{4,}$",
+      "inventory_code": "ROUTER-TP-C6",
+      "source": "inventory",
+      "status": "pending"
+    }
+  ]
+}
+```
+
+Field agents must provide values for installed inventory items:
+
+```http
+POST /api/v1/tickets/{ticket_id}/completion/data
+{
+  "completion_data": {
+    "inventory_ONT-ZTE-F670L": "HW12345678",
+    "inventory_ROUTER-TP-C6": "TP98765432",
+    "speed_test_download_mbps": 95.5
+  }
+}
+```
+
+## API Endpoints
+
+### Get Inventory Requirements
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements
+```
+
+Query parameters:
+- `usage_type`: Filter by 'installed' or 'consumed'
+- `category`: Filter by category
+
+Returns full inventory requirements dictionary.
+
+### Get Dropdown Options
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements/dropdown
+```
+
+Query parameters:
+- `usage_type`: Filter by 'installed' or 'consumed'
+
+Returns formatted options for dropdown selection (sorted by category and name).
+
+### Get Completion Items
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements/completion-items
+```
+
+Returns only installed items that appear in ticket completion forms.
+
+### Get Categories
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements/categories
+```
+
+Returns list of unique categories for filtering.
+
+## Benefits
+
+1. **Controlled Inventory Types**: Only pre-defined inventory types can be received
+2. **Consistent Naming**: Inventory names are standardized across the project
+3. **Automatic Validation**: System validates inventory codes at receiving time
+4. **Dynamic Completion Forms**: Ticket completion forms automatically include installed items
+5. **Flexible Configuration**: Project managers can define any inventory types needed
+6. **Serial Number Tracking**: Automatic validation for items requiring serial numbers
+7. **Usage Tracking**: Distinguish between installed equipment and consumed materials
+
+## Migration Notes
+
+For existing projects without inventory requirements:
+
+1. Inventory can still be received (backward compatible)
+2. Validation is only enforced if `inventory_requirements` is populated
+3. Recommend defining requirements for new projects
+4. Existing projects can be updated to add requirements
+
+## Related Files
+
+- `src/app/schemas/project.py` - InventoryRequirement schema
+- `src/app/models/project.py` - Project model with inventory_requirements JSONB
+- `src/app/services/inventory_requirements_service.py` - Helper service
+- `src/app/services/inventory_service.py` - Inventory receiving with validation
+- `src/app/services/ticket_completion_service.py` - Dynamic checklist generation
+- `src/app/api/v1/projects.py` - API endpoints for inventory requirements

docs/features/INVENTORY_REQUIREMENTS_CHANGELOG.md

@@ -0,0 +1,166 @@
+# Inventory Requirements System - Implementation Changelog
+
+## Summary
+
+Enhanced the inventory requirements system to be more realistic and integrated with the inventory receiving and ticket completion workflows.
+
+## Changes Made
+
+### 1. Updated InventoryRequirement Schema (`src/app/schemas/project.py`)
+
+**Before:**
+```python
+class InventoryRequirement(BaseModel):
+    item_name: str
+    quantity: int
+    unit: Optional[str]
+    model: Optional[str]
+    notes: Optional[str]
+```
+
+**After:**
+```python
+class InventoryRequirement(BaseModel):
+    code: str  # Unique inventory code (e.g., 'ONT-ZTE-F670L')
+    name: str  # Display name
+    description: Optional[str]  # Detailed description
+    usage_type: Literal["installed", "consumed"]  # How inventory is used
+    unit: str  # Unit of measurement
+    requires_serial_number: bool  # Serial number tracking
+    category: Optional[str]  # Grouping category
+    
+    # Ticket completion integration
+    include_in_completion: bool  # Include in completion forms
+    completion_field_label: Optional[str]  # Custom label
+    completion_required: bool  # Required in completion
+```
+
+**Key Improvements:**
+- Added `code` field as unique identifier
+- Added `usage_type` to distinguish installed vs consumed items
+- Added `requires_serial_number` for tracking
+- Added `category` for grouping
+- Added ticket completion integration fields
+
+### 2. Updated Project Model Comments (`src/app/models/project.py`)
+
+Added comprehensive documentation showing the new JSONB structure with examples.
+
+### 3. Enhanced Ticket Completion Service (`src/app/services/ticket_completion_service.py`)
+
+**Changes:**
+- Modified `_get_project_requirements()` to extract installed inventory items
+- Converts inventory requirements to field requirements dynamically
+- Only includes items with `usage_type='installed'` and `include_in_completion=True`
+- Generates field names like `inventory_ONT-ZTE-F670L`
+- Adds validation regex for items requiring serial numbers
+
+**Result:**
+Installed inventory items now automatically appear in ticket completion checklists.
+
+### 4. Created Inventory Requirements Service (`src/app/services/inventory_requirements_service.py`)
+
+New helper service with methods:
+- `get_project_inventory_requirements()` - Get requirements with filters
+- `get_inventory_requirement_by_code()` - Get specific requirement
+- `validate_inventory_code()` - Validate code exists
+- `get_inventory_dropdown_options()` - Format for dropdowns
+- `get_installed_inventory_for_completion()` - Get completion items
+- `get_inventory_categories()` - Get unique categories
+
+### 5. Enhanced Inventory Service (`src/app/services/inventory_service.py`)
+
+**Changes to `create_inventory()`:**
+- Validates `equipment_type` against `project.inventory_requirements`
+- Only allows receiving inventory types defined in project requirements
+- Auto-populates `equipment_name` from requirement if not provided
+- Provides helpful error messages with available codes
+
+**Result:**
+Controlled inventory receiving - only pre-defined types can be received.
+
+### 6. Added API Endpoints (`src/app/api/v1/projects.py`)
+
+New endpoints:
+- `GET /api/v1/projects/{project_id}/inventory-requirements`
+  - Get all inventory requirements with optional filters
+  
+- `GET /api/v1/projects/{project_id}/inventory-requirements/dropdown`
+  - Get formatted options for dropdown selection
+  - Used when receiving inventory batches
+  
+- `GET /api/v1/projects/{project_id}/inventory-requirements/completion-items`
+  - Get items that appear in ticket completion forms
+  
+- `GET /api/v1/projects/{project_id}/inventory-requirements/categories`
+  - Get list of unique categories
+
+### 7. Documentation
+
+Created comprehensive documentation:
+- `docs/features/INVENTORY_REQUIREMENTS.md` - Full system documentation
+- `docs/examples/inventory_requirements_setup.py` - Example configurations
+
+## Workflow Integration
+
+### 1. Project Setup
+Project managers define inventory requirements when creating/updating projects.
+
+### 2. Inventory Receiving
+When receiving inventory:
+1. Call `GET /inventory-requirements/dropdown` to get valid options
+2. Select inventory type from dropdown
+3. System validates code exists in project requirements
+4. Auto-populates name and metadata from requirements
+
+### 3. Ticket Completion
+When completing tickets:
+1. System generates checklist from project requirements
+2. Installed inventory items automatically included as fields
+3. Field agents must provide values (e.g., serial numbers)
+4. Validation ensures required fields are completed
+
+## Benefits
+
+1. **Controlled Inventory Types** - Only pre-defined types can be received
+2. **Consistent Naming** - Standardized across project
+3. **Automatic Validation** - At receiving and completion time
+4. **Dynamic Forms** - Completion forms adapt to project needs
+5. **Serial Number Tracking** - Automatic for items requiring it
+6. **Usage Tracking** - Distinguish installed vs consumed
+7. **Flexible Configuration** - Project managers control requirements
+
+## Backward Compatibility
+
+- Existing projects without `inventory_requirements` continue to work
+- Validation only enforced when requirements are defined
+- Recommend defining requirements for new projects
+- Existing projects can be updated to add requirements
+
+## Testing Recommendations
+
+1. Create project with inventory requirements
+2. Test receiving inventory with valid codes
+3. Test receiving inventory with invalid codes (should fail)
+4. Test ticket completion checklist generation
+5. Test completing ticket with inventory fields
+6. Test filtering and dropdown endpoints
+
+## Migration Path
+
+For existing projects:
+1. Analyze current inventory types being used
+2. Define inventory requirements based on actual usage
+3. Update project with requirements
+4. Future inventory receiving will be validated
+
+## Related Files
+
+- `src/app/schemas/project.py` - Schema definitions
+- `src/app/models/project.py` - Database model
+- `src/app/services/inventory_requirements_service.py` - Helper service
+- `src/app/services/inventory_service.py` - Inventory receiving
+- `src/app/services/ticket_completion_service.py` - Completion logic
+- `src/app/api/v1/projects.py` - API endpoints
+- `docs/features/INVENTORY_REQUIREMENTS.md` - Documentation
+- `docs/examples/inventory_requirements_setup.py` - Examples

docs/features/INVENTORY_REQUIREMENTS_QUICK_REF.md

@@ -0,0 +1,181 @@
+# Inventory Requirements - Quick Reference
+
+## TL;DR
+
+Inventory requirements define what inventory types can be used in a project. Items marked as "installed" automatically appear in ticket completion forms.
+
+## Quick Setup
+
+### 1. Define Requirements in Project
+
+```json
+{
+  "inventory_requirements": {
+    "ONT-ZTE-F670L": {
+      "code": "ONT-ZTE-F670L",
+      "name": "ZTE F670L ONT Device",
+      "description": "Fiber optic network terminal",
+      "usage_type": "installed",
+      "unit": "pieces",
+      "requires_serial_number": true,
+      "category": "Equipment",
+      "include_in_completion": true,
+      "completion_field_label": "ONT Serial Number",
+      "completion_required": true
+    },
+    "CABLE-FIBER-SM": {
+      "code": "CABLE-FIBER-SM",
+      "name": "Single Mode Fiber Cable",
+      "description": "Outdoor fiber cable",
+      "usage_type": "consumed",
+      "unit": "meters",
+      "requires_serial_number": false,
+      "category": "Cable"
+    }
+  }
+}
+```
+
+### 2. Get Dropdown Options for Receiving
+
+```http
+GET /api/v1/projects/{project_id}/inventory-requirements/dropdown
+```
+
+### 3. Receive Inventory
+
+```http
+POST /api/v1/inventory
+{
+  "project_id": "...",
+  "equipment_type": "ONT-ZTE-F670L",  // Must match a code
+  "quantity_received": 100
+}
+```
+
+### 4. Ticket Completion (Automatic)
+
+Installed items automatically appear in completion checklist:
+
+```json
+{
+  "field_items": [
+    {
+      "field_name": "inventory_ONT-ZTE-F670L",
+      "label": "ONT Serial Number",
+      "required": true
+    }
+  ]
+}
+```
+
+## Field Reference
+
+| Field | Required | Description | Example |
+|-------|----------|-------------|---------|
+| `code` | Yes | Unique identifier | `"ONT-ZTE-F670L"` |
+| `name` | Yes | Display name | `"ZTE F670L ONT Device"` |
+| `description` | No | Detailed description | `"Fiber optic network terminal"` |
+| `usage_type` | Yes | `"installed"` or `"consumed"` | `"installed"` |
+| `unit` | Yes | Unit of measurement | `"pieces"`, `"meters"` |
+| `requires_serial_number` | No | Track serial numbers | `true` |
+| `category` | No | Grouping category | `"Equipment"` |
+| `include_in_completion` | No | Show in completion form | `true` (default) |
+| `completion_field_label` | No | Custom label | `"ONT Serial Number"` |
+| `completion_required` | No | Required in completion | `true` (default) |
+
+## Usage Types
+
+### `installed`
+- Equipment installed at customer sites
+- Appears in ticket completion forms (if `include_in_completion=true`)
+- Examples: ONT devices, routers, CPE equipment
+
+### `consumed`
+- Materials used up during work
+- Does NOT appear in completion forms
+- Examples: cables, connectors, fasteners
+
+## API Endpoints
+
+| Endpoint | Purpose |
+|----------|---------|
+| `GET /projects/{id}/inventory-requirements` | Get all requirements |
+| `GET /projects/{id}/inventory-requirements/dropdown` | Get dropdown options |
+| `GET /projects/{id}/inventory-requirements/completion-items` | Get completion items |
+| `GET /projects/{id}/inventory-requirements/categories` | Get categories |
+
+## Common Patterns
+
+### Equipment with Serial Numbers
+```json
+{
+  "code": "ONT-ZTE-F670L",
+  "usage_type": "installed",
+  "requires_serial_number": true,
+  "include_in_completion": true,
+  "completion_field_label": "ONT Serial Number"
+}
+```
+
+### Consumable Materials
+```json
+{
+  "code": "CABLE-FIBER-SM",
+  "usage_type": "consumed",
+  "requires_serial_number": false,
+  "include_in_completion": false
+}
+```
+
+### Optional Equipment
+```json
+{
+  "code": "ROUTER-TP-C6",
+  "usage_type": "installed",
+  "include_in_completion": true,
+  "completion_required": false  // Optional in completion
+}
+```
+
+## Validation Rules
+
+1. **Receiving Inventory**: `equipment_type` must match a `code` in requirements
+2. **Ticket Completion**: Installed items with `completion_required=true` must be provided
+3. **Serial Numbers**: Items with `requires_serial_number=true` get automatic validation regex
+
+## Tips
+
+- Use descriptive codes: `ONT-ZTE-F670L` not `ONT1`
+- Group by category for better organization
+- Mark optional items with `completion_required: false`
+- Use `consumed` for materials that don't need completion tracking
+- Set `include_in_completion: false` for items that don't need serial tracking
+
+## Example Categories
+
+- Equipment
+- Cable
+- Consumables
+- Tools
+- Installation Materials
+- Power
+- Protection
+- Networking
+
+## Error Messages
+
+**Invalid inventory code:**
+```json
+{
+  "message": "Invalid equipment_type 'INVALID-CODE'. Must match a code from project inventory requirements.",
+  "available_codes": ["ONT-ZTE-F670L", "CABLE-FIBER-SM"],
+  "hint": "Use GET /api/v1/projects/{project_id}/inventory-requirements to see valid inventory types"
+}
+```
+
+## See Also
+
+- Full documentation: `docs/features/INVENTORY_REQUIREMENTS.md`
+- Examples: `docs/examples/inventory_requirements_setup.py`
+- Changelog: `docs/features/INVENTORY_REQUIREMENTS_CHANGELOG.md`

src/app/api/v1/projects.py

@@ -2187,3 +2187,188 @@ async def finalize_project_setup(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="An error occurred while finalizing project setup"
         )
+
+
+# ============================================
+# INVENTORY REQUIREMENTS
+# ============================================
+
+@router.get("/{project_id}/inventory-requirements")
+async def get_project_inventory_requirements(
+    project_id: UUID,
+    usage_type: Optional[str] = Query(None, description="Filter by usage type: 'installed' or 'consumed'"),
+    category: Optional[str] = Query(None, description="Filter by category"),
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Get inventory requirements for a project
+    
+    Returns the inventory types that can be received and tracked for this project.
+    Used when receiving inventory batches to populate dropdown options.
+    
+    **Authorization:**
+    - Any user on the project team can view
+    
+    **Query Parameters:**
+    - usage_type: Filter by 'installed' (equipment installed at customer sites) or 'consumed' (materials used up)
+    - category: Filter by category (e.g., 'Equipment', 'Cable', 'Tools')
+    
+    **Response:**
+    - Dictionary of inventory requirements keyed by code
+    - Each requirement includes: code, name, description, usage_type, unit, requires_serial_number, category
+    """
+    from app.services.inventory_requirements_service import InventoryRequirementsService
+    
+    try:
+        # Get inventory requirements
+        inventory_reqs = InventoryRequirementsService.get_project_inventory_requirements(
+            project_id=project_id,
+            db=db,
+            usage_type=usage_type,
+            category=category
+        )
+        
+        return {
+            "project_id": str(project_id),
+            "inventory_requirements": inventory_reqs,
+            "total_count": len(inventory_reqs)
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting inventory requirements: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve inventory requirements"
+        )
+
+
+@router.get("/{project_id}/inventory-requirements/dropdown")
+async def get_inventory_dropdown_options(
+    project_id: UUID,
+    usage_type: Optional[str] = Query(None, description="Filter by usage type: 'installed' or 'consumed'"),
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Get inventory options formatted for dropdown selection
+    
+    Used when receiving inventory batches - provides a clean list of options
+    with code, name, description, and metadata.
+    
+    **Authorization:**
+    - Any user on the project team can view
+    
+    **Response:**
+    - Array of dropdown options sorted by category and name
+    - Each option includes: code, name, description, category, unit, requires_serial_number, usage_type
+    """
+    from app.services.inventory_requirements_service import InventoryRequirementsService
+    
+    try:
+        options = InventoryRequirementsService.get_inventory_dropdown_options(
+            project_id=project_id,
+            db=db,
+            usage_type=usage_type
+        )
+        
+        return {
+            "project_id": str(project_id),
+            "options": options,
+            "total_count": len(options)
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting inventory dropdown options: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve inventory dropdown options"
+        )
+
+
+@router.get("/{project_id}/inventory-requirements/completion-items")
+async def get_inventory_completion_items(
+    project_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Get inventory items that appear in ticket completion forms
+    
+    Returns only 'installed' items with include_in_completion=True.
+    These items will be dynamically added to ticket completion checklists.
+    
+    **Authorization:**
+    - Any user on the project team can view
+    
+    **Response:**
+    - Array of inventory items that require completion data
+    - Each item includes: code, name, description, requires_serial_number, completion_field_label, completion_required
+    """
+    from app.services.inventory_requirements_service import InventoryRequirementsService
+    
+    try:
+        completion_items = InventoryRequirementsService.get_installed_inventory_for_completion(
+            project_id=project_id,
+            db=db
+        )
+        
+        return {
+            "project_id": str(project_id),
+            "completion_items": completion_items,
+            "total_count": len(completion_items)
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting inventory completion items: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve inventory completion items"
+        )
+
+
+@router.get("/{project_id}/inventory-requirements/categories")
+async def get_inventory_categories(
+    project_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Get list of unique inventory categories in project
+    
+    Useful for filtering and grouping inventory items.
+    
+    **Authorization:**
+    - Any user on the project team can view
+    
+    **Response:**
+    - Array of category names (sorted alphabetically)
+    """
+    from app.services.inventory_requirements_service import InventoryRequirementsService
+    
+    try:
+        categories = InventoryRequirementsService.get_inventory_categories(
+            project_id=project_id,
+            db=db
+        )
+        
+        return {
+            "project_id": str(project_id),
+            "categories": categories,
+            "total_count": len(categories)
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting inventory categories: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve inventory categories"
+        )

src/app/models/project.py

@@ -55,8 +55,31 @@ class Project(BaseModel):
     # Example: {"payroll": 500000, "equipment": 300000, "transport": 100000, "materials": 150000}
     budget = Column(JSONB, default={}, nullable=False)
     
-    # Project Configuration (JSONB)
-    # Example: {"ont_devices": {"quantity": 1000, "model": "ZTE F670L"}, "fiber_cable": {"quantity": 5000, "unit": "meters"}}
+    # Inventory Requirements (JSONB Dictionary) - Defines allowed inventory types for this project
+    # Key: inventory code, Value: inventory requirement object
+    # Example: {
+    #   "ONT-ZTE-F670L": {
+    #     "code": "ONT-ZTE-F670L",
+    #     "name": "ZTE F670L ONT Device",
+    #     "description": "Fiber optic network terminal for FTTH installations",
+    #     "usage_type": "installed",
+    #     "unit": "pieces",
+    #     "requires_serial_number": true,
+    #     "category": "Equipment",
+    #     "include_in_completion": true,
+    #     "completion_field_label": "ONT Serial Number",
+    #     "completion_required": true
+    #   },
+    #   "CABLE-FIBER-SM": {
+    #     "code": "CABLE-FIBER-SM",
+    #     "name": "Single Mode Fiber Cable",
+    #     "description": "Outdoor fiber optic cable",
+    #     "usage_type": "consumed",
+    #     "unit": "meters",
+    #     "requires_serial_number": false,
+    #     "category": "Cable"
+    #   }
+    # }
     inventory_requirements = Column(JSONB, default={}, nullable=False)
     
     # Photo Requirements (JSONB Array)

src/app/schemas/project.py

@@ -78,12 +78,33 @@ class BudgetCategory(BaseModel):
 
 
 class InventoryRequirement(BaseModel):
-    """Schema for inventory requirement (JSONB validation)"""
-    item_name: str = Field(..., min_length=1, max_length=200, description="Item name")
-    quantity: int = Field(..., ge=1, description="Required quantity")
-    unit: Optional[str] = Field(None, max_length=50, description="Unit of measurement")
-    model: Optional[str] = Field(None, max_length=200, description="Model/specification")
-    notes: Optional[str] = Field(None, max_length=500, description="Additional notes")
+    """
+    Schema for inventory requirement (JSONB validation)
+    
+    Defines inventory types that can be used in this project.
+    Controls what inventory types can be received and tracked.
+    If usage_type='installed', this item will appear in ticket completion forms.
+    """
+    code: str = Field(..., min_length=1, max_length=50, description="Unique inventory code (e.g., 'ONT-ZTE-F670L', 'CABLE-FIBER-SM')")
+    name: str = Field(..., min_length=1, max_length=200, description="Inventory item name (e.g., 'ZTE F670L ONT', 'Single Mode Fiber Cable')")
+    description: Optional[str] = Field(None, max_length=500, description="Detailed description of the inventory item")
+    usage_type: Literal["installed", "consumed"] = Field(..., description="How this inventory is used: 'installed' (at customer site) or 'consumed' (used up)")
+    unit: str = Field(default="pieces", max_length=50, description="Unit of measurement (pieces, meters, boxes, sets, etc.)")
+    requires_serial_number: bool = Field(default=False, description="Whether this item requires serial number tracking")
+    category: Optional[str] = Field(None, max_length=100, description="Category for grouping (e.g., 'Equipment', 'Cable', 'Tools', 'Consumables')")
+    
+    # Ticket completion integration (for installed items)
+    include_in_completion: bool = Field(default=True, description="Include in ticket completion form (only applies to installed items)")
+    completion_field_label: Optional[str] = Field(None, max_length=200, description="Custom label for completion form (defaults to name)")
+    completion_required: bool = Field(default=True, description="Whether this field is required in ticket completion")
+    
+    @model_validator(mode='after')
+    def validate_completion_settings(self):
+        """Ensure completion settings only apply to installed items"""
+        if self.usage_type == "consumed" and self.include_in_completion:
+            # Auto-correct: consumed items shouldn't be in completion forms
+            self.include_in_completion = False
+        return self
 
 
 # ============================================

src/app/services/inventory_requirements_service.py

@@ -0,0 +1,209 @@
+"""
+Inventory Requirements Service
+
+Helper service for working with project inventory requirements.
+Used when receiving inventory batches to validate against project requirements.
+"""
+from sqlalchemy.orm import Session
+from fastapi import HTTPException
+from typing import List, Dict, Any, Optional
+from uuid import UUID
+import logging
+
+from app.models.project import Project
+
+logger = logging.getLogger(__name__)
+
+
+class InventoryRequirementsService:
+    """Service for managing project inventory requirements"""
+    
+    @staticmethod
+    def get_project_inventory_requirements(
+        project_id: UUID,
+        db: Session,
+        usage_type: Optional[str] = None,
+        category: Optional[str] = None
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Get inventory requirements for a project
+        
+        Args:
+            project_id: Project ID
+            db: Database session
+            usage_type: Filter by usage type ('installed' or 'consumed')
+            category: Filter by category
+            
+        Returns:
+            Dictionary of inventory requirements keyed by code
+        """
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+        
+        inventory_reqs = project.inventory_requirements or {}
+        
+        # Apply filters if provided
+        if usage_type or category:
+            filtered_reqs = {}
+            for code, req in inventory_reqs.items():
+                if usage_type and req.get('usage_type') != usage_type:
+                    continue
+                if category and req.get('category') != category:
+                    continue
+                filtered_reqs[code] = req
+            return filtered_reqs
+        
+        return inventory_reqs
+    
+    @staticmethod
+    def get_inventory_requirement_by_code(
+        project_id: UUID,
+        inventory_code: str,
+        db: Session
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific inventory requirement by code
+        
+        Args:
+            project_id: Project ID
+            inventory_code: Inventory code to look up
+            db: Database session
+            
+        Returns:
+            Inventory requirement dict or None if not found
+        """
+        inventory_reqs = InventoryRequirementsService.get_project_inventory_requirements(
+            project_id, db
+        )
+        return inventory_reqs.get(inventory_code)
+    
+    @staticmethod
+    def validate_inventory_code(
+        project_id: UUID,
+        inventory_code: str,
+        db: Session
+    ) -> bool:
+        """
+        Validate that an inventory code exists in project requirements
+        
+        Args:
+            project_id: Project ID
+            inventory_code: Inventory code to validate
+            db: Database session
+            
+        Returns:
+            True if valid, raises HTTPException if invalid
+        """
+        req = InventoryRequirementsService.get_inventory_requirement_by_code(
+            project_id, inventory_code, db
+        )
+        
+        if not req:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid inventory code '{inventory_code}'. Not defined in project requirements."
+            )
+        
+        return True
+    
+    @staticmethod
+    def get_inventory_dropdown_options(
+        project_id: UUID,
+        db: Session,
+        usage_type: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get inventory options formatted for dropdown selection
+        Used when receiving inventory batches
+        
+        Args:
+            project_id: Project ID
+            db: Database session
+            usage_type: Filter by usage type
+            
+        Returns:
+            List of dropdown options with code, name, description
+        """
+        inventory_reqs = InventoryRequirementsService.get_project_inventory_requirements(
+            project_id, db, usage_type=usage_type
+        )
+        
+        options = []
+        for code, req in inventory_reqs.items():
+            options.append({
+                'code': code,
+                'name': req.get('name'),
+                'description': req.get('description'),
+                'category': req.get('category'),
+                'unit': req.get('unit', 'pieces'),
+                'requires_serial_number': req.get('requires_serial_number', False),
+                'usage_type': req.get('usage_type')
+            })
+        
+        # Sort by category then name
+        options.sort(key=lambda x: (x.get('category') or '', x.get('name') or ''))
+        
+        return options
+    
+    @staticmethod
+    def get_installed_inventory_for_completion(
+        project_id: UUID,
+        db: Session
+    ) -> List[Dict[str, Any]]:
+        """
+        Get inventory items that should appear in ticket completion forms
+        Only returns 'installed' items with include_in_completion=True
+        
+        Args:
+            project_id: Project ID
+            db: Database session
+            
+        Returns:
+            List of inventory items for completion form
+        """
+        inventory_reqs = InventoryRequirementsService.get_project_inventory_requirements(
+            project_id, db, usage_type='installed'
+        )
+        
+        completion_items = []
+        for code, req in inventory_reqs.items():
+            if req.get('include_in_completion', True):
+                completion_items.append({
+                    'code': code,
+                    'name': req.get('name'),
+                    'description': req.get('description'),
+                    'requires_serial_number': req.get('requires_serial_number', False),
+                    'completion_field_label': req.get('completion_field_label') or req.get('name'),
+                    'completion_required': req.get('completion_required', True),
+                    'category': req.get('category')
+                })
+        
+        return completion_items
+    
+    @staticmethod
+    def get_inventory_categories(
+        project_id: UUID,
+        db: Session
+    ) -> List[str]:
+        """
+        Get list of unique inventory categories in project
+        
+        Args:
+            project_id: Project ID
+            db: Database session
+            
+        Returns:
+            List of category names
+        """
+        inventory_reqs = InventoryRequirementsService.get_project_inventory_requirements(
+            project_id, db
+        )
+        
+        categories = set()
+        for req in inventory_reqs.values():
+            category = req.get('category')
+            if category:
+                categories.add(category)
+        
+        return sorted(list(categories))

src/app/services/inventory_service.py

@@ -130,7 +130,12 @@ class InventoryService:
     
     @staticmethod
     def create_inventory(db: Session, data: ProjectInventoryCreate, current_user: User) -> ProjectInventory:
-        """Create inventory batch at main office"""
+        """
+        Create inventory batch at main office
+        
+        Validates that equipment_type matches a code in project.inventory_requirements.
+        This ensures only pre-defined inventory types can be received.
+        """
         # Authorization
         if not InventoryService.can_user_manage_inventory(current_user, data.project_id, db):
             raise HTTPException(
@@ -146,6 +151,37 @@ class InventoryService:
                 detail=f"Project not found: {data.project_id}"
             )
         
+        # Validate equipment_type against project inventory requirements
+        # equipment_type should match an inventory code from project.inventory_requirements
+        inventory_reqs = project.inventory_requirements or {}
+        
+        if data.equipment_type not in inventory_reqs:
+            # Provide helpful error with available codes
+            available_codes = list(inventory_reqs.keys())
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail={
+                    "message": f"Invalid equipment_type '{data.equipment_type}'. Must match a code from project inventory requirements.",
+                    "available_codes": available_codes,
+                    "hint": "Use GET /api/v1/projects/{project_id}/inventory-requirements to see valid inventory types"
+                }
+            )
+        
+        # Get the requirement details for validation and auto-population
+        inv_req = inventory_reqs[data.equipment_type]
+        
+        # Auto-populate equipment_name from requirement if not provided
+        if not data.equipment_name:
+            data.equipment_name = inv_req.get('name', data.equipment_type)
+        
+        # Validate item_type matches requirement usage_type
+        expected_item_type = 'equipment' if inv_req.get('usage_type') == 'installed' else 'consumable'
+        if data.item_type != expected_item_type:
+            logger.warning(
+                f"Item type mismatch: provided '{data.item_type}' but requirement suggests '{expected_item_type}'. "
+                f"Proceeding with provided value."
+            )
+        
         # Create inventory
         inventory = ProjectInventory(
             **data.model_dump(),
@@ -157,7 +193,10 @@ class InventoryService:
         db.commit()
         db.refresh(inventory)
         
-        logger.info(f"Created inventory: {inventory.id} for project {data.project_id}")
+        logger.info(
+            f"Created inventory: {inventory.id} for project {data.project_id}, "
+            f"type: {data.equipment_type} ({inv_req.get('name')})"
+        )
         return inventory
     
     @staticmethod

src/app/services/ticket_completion_service.py

@@ -65,10 +65,38 @@ class TicketCompletionService:
         # Combine ALL field requirements (activation + inventory)
         # Project manager decides what to populate - we just read and validate
         activation_reqs = project.activation_requirements or []
-        inventory_reqs = project.inventory_requirements or []
         
-        # Merge both lists - project can have both activation AND inventory requirements
-        field_reqs = activation_reqs + inventory_reqs
+        # Extract inventory requirements that should be in completion form
+        # Only "installed" items with include_in_completion=True
+        inventory_dict = project.inventory_requirements or {}
+        inventory_completion_reqs = []
+        
+        for inv_code, inv_req in inventory_dict.items():
+            # Only include installed items that are marked for completion
+            if inv_req.get('usage_type') == 'installed' and inv_req.get('include_in_completion', True):
+                # Convert inventory requirement to field requirement format
+                field_label = inv_req.get('completion_field_label') or inv_req.get('name')
+                field_type = 'text'  # Default to text
+                
+                # If requires serial number, use text with validation
+                validation_regex = None
+                if inv_req.get('requires_serial_number'):
+                    field_label = f"{field_label} (Serial Number)"
+                    validation_regex = r'^[A-Z0-9\-]{4,}$'  # Basic serial number pattern
+                
+                inventory_completion_reqs.append({
+                    'field': f"inventory_{inv_code}",  # Prefix with inventory_ to avoid conflicts
+                    'label': field_label,
+                    'type': field_type,
+                    'required': inv_req.get('completion_required', True),
+                    'placeholder': f"Enter {inv_req.get('name')} details",
+                    'validation_regex': validation_regex,
+                    'inventory_code': inv_code,  # Track which inventory this is for
+                    'source': 'inventory'  # Mark as coming from inventory requirements
+                })
+        
+        # Merge all field requirements: activation + inventory completion fields
+        field_reqs = activation_reqs + inventory_completion_reqs
         
         # Cache for next time
         ProjectRequirementsCache.set(project_id, photo_reqs, field_reqs)