taw bch yekhdem

app.py

@@ -18,12 +18,13 @@ Version: 1.0.0
 
 import os
 import sys
+import base64
 from datetime import datetime
 from typing import Optional, List, Dict, Any, Union
 import logging
 
 # FastAPI imports
-from fastapi import FastAPI, HTTPException, status
+from fastapi import FastAPI, HTTPException, status, UploadFile, File
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 
@@ -37,17 +38,8 @@ from bson import ObjectId
 # Environment variables
 from dotenv import load_dotenv
 
-# Load environment variables from .env file (if available)
-# For Hugging Face Spaces, environment variables are set in the Space settings
-try:
-    load_dotenv('mongodb.env')
-    print("✅ Loaded environment variables from mongodb.env")
-except:
-    try:
-        load_dotenv('.env')
-        print("✅ Loaded environment variables from .env")
-    except:
-        print("ℹ️  No .env file found, using system environment variables")
+# Load environment variables from .env file
+load_dotenv('mongodb.env')
 
 # Configure logging
 logging.basicConfig(
@@ -65,16 +57,6 @@ MONGODB_URI = os.getenv('MONGODB_URI', 'mongodb://localhost:27017/audit_checklis
 PORT = int(os.getenv('PORT', 8000))  # Hugging Face Spaces uses port 8000
 CORS_ORIGIN = os.getenv('CORS_ORIGIN', '*')  # Allow all origins by default for mobile apps
 
-# Debug logging for environment variables
-logger.info(f"MONGODB_URI: {'*' * 50 if MONGODB_URI.startswith('mongodb+srv://') else MONGODB_URI}")
-logger.info(f"PORT: {PORT}")
-logger.info(f"CORS_ORIGIN: {CORS_ORIGIN}")
-
-# Check if we're using the default MongoDB URI (which means env var is not set)
-if MONGODB_URI == 'mongodb://localhost:27017/audit_checklist':
-    logger.warning("⚠️  MONGODB_URI environment variable not set! Using default localhost connection.")
-    logger.warning("⚠️  Please set MONGODB_URI environment variable in Hugging Face Space settings.")
-
 # Initialize FastAPI application
 app = FastAPI(
     title="Audit Checklist API",
@@ -214,6 +196,8 @@ class ChecklistData(BaseModel):
         verificationDate: Date when the checklist was verified
         createdAt: Timestamp when the checklist was created
         updatedAt: Timestamp when the checklist was last updated
+        imageData: Base64 encoded image data (stored when compliance < 100%)
+        imageType: MIME type of the image (e.g., image/jpeg, image/png)
     """
     userId: str = Field(..., description="Unique identifier for the user")
     title: str = Field(..., description="Title of the checklist")
@@ -226,6 +210,8 @@ class ChecklistData(BaseModel):
     createdAt: Optional[datetime] = Field(default=None, description="Creation timestamp")
     updatedAt: Optional[datetime] = Field(default=None, description="Last update timestamp")
     metadata: Optional[Metadata] = Field(default=None, description="Additional metadata including user information")
+    imageData: Optional[str] = Field(default=None, description="Base64 encoded image data for non-compliant checklists")
+    imageType: Optional[str] = Field(default=None, description="MIME type of the image")
     
     class Config:
         # Allow extra fields that might be sent from frontend
@@ -304,30 +290,25 @@ def serialize_checklist(checklist_doc: Dict[str, Any]) -> Dict[str, Any]:
     Returns:
         Dictionary with ObjectId converted to string
     """
-    import copy
-    import json
-    from bson import ObjectId
-    
-    # Make a deep copy to avoid modifying the original document
-    serialized = copy.deepcopy(checklist_doc)
-    
-    # Convert ObjectId to string recursively
-    def convert_objectid(obj):
-        if isinstance(obj, ObjectId):
-            return str(obj)
-        elif isinstance(obj, dict):
-            return {key: convert_objectid(value) for key, value in obj.items()}
-        elif isinstance(obj, list):
-            return [convert_objectid(item) for item in obj]
-        elif hasattr(obj, 'isoformat'):  # datetime objects
-            return obj.isoformat()
-        else:
-            return obj
+    if checklist_doc and '_id' in checklist_doc:
+        checklist_doc['_id'] = str(checklist_doc['_id'])
     
-    # Apply ObjectId conversion to the entire document
-    serialized = convert_objectid(serialized)
+    # Convert datetime objects to ISO strings
+    for field in ['createdAt', 'updatedAt', 'verificationDate']:
+        if field in checklist_doc and checklist_doc[field]:
+            # Only convert if it's a datetime object, not a string
+            if hasattr(checklist_doc[field], 'isoformat'):
+                checklist_doc[field] = checklist_doc[field].isoformat()
     
-    return serialized
+    # Convert datetime objects in items
+    for section in checklist_doc.get('sections', []):
+        for item in section.get('items', []):
+            if 'checkedAt' in item and item['checkedAt']:
+                # Only convert if it's a datetime object, not a string
+                if hasattr(item['checkedAt'], 'isoformat'):
+                    item['checkedAt'] = item['checkedAt'].isoformat()
+    
+    return checklist_doc
 
 # =============================================================================
 # API ENDPOINTS
@@ -425,8 +406,8 @@ async def get_checklist(user_id: str):
         )
         
         if not checklist_doc:
-            # Return default checklist structure without saving to database
-            logger.info(f"No checklist found for user {user_id}, returning default structure")
+            # Create new checklist if none exists
+            logger.info(f"No checklist found for user {user_id}, creating new one")
             
             # Default checklist structure - Complete 38-item audit checklist
             default_checklist = {
@@ -530,8 +511,10 @@ async def get_checklist(user_id: str):
                 "updatedAt": datetime.utcnow()
             }
             
-            # Return the default checklist without saving to database
-            checklist_doc = default_checklist
+            # Insert the new checklist
+            result = await db.checklists.insert_one(default_checklist)
+            checklist_doc = await db.checklists.find_one({"_id": result.inserted_id})
+            logger.info(f"Created new checklist for user {user_id}")
         
         # Serialize the document
         serialized_checklist = serialize_checklist(checklist_doc)
@@ -577,45 +560,76 @@ async def save_checklist(user_id: str, checklist_data: dict):
         metrics = calculate_checklist_metrics(checklist_dict)
         checklist_dict.update(metrics)
         
+        # Handle image data for non-compliant checklists
+        compliance_score = metrics.get('complianceScore', 0.0)
+        if compliance_score < 100.0 and 'collectedImages' in checklist_dict and checklist_dict['collectedImages']:
+            # Process collected images from individual items
+            collected_images = checklist_dict['collectedImages']
+            logger.info(f"Storing {len(collected_images)} images for non-compliant checklist (score: {compliance_score}%)")
+            
+            # Store the collected images in the checklist data
+            checklist_dict['imageData'] = collected_images
+            checklist_dict['imageType'] = 'multiple_items'
+        elif compliance_score < 100.0:
+            logger.info(f"No image data provided for non-compliant checklist (score: {compliance_score}%)")
+        
         # Update timestamps
         checklist_dict['updatedAt'] = datetime.utcnow()
         
-        # Always create a new checklist session (don't update existing)
-        # Add a unique session ID to make each save unique
-        session_id = f"{user_id}-{datetime.utcnow().strftime('%Y%m%d-%H%M%S')}"
-        checklist_dict['sessionId'] = session_id
+        # Check if this is an update to existing checklist or new save
+        existing_checklist = await db.checklists.find_one({"userId": user_id})
         
-        # Ensure metadata exists and contains user information
-        if 'metadata' not in checklist_dict:
-            checklist_dict['metadata'] = {}
-        
-        # Preserve existing userName or set default
-        if 'userName' not in checklist_dict['metadata']:
-            checklist_dict['metadata']['userName'] = 'Unknown User'
-        checklist_dict['metadata']['userId'] = user_id
-        checklist_dict['metadata']['savedAt'] = datetime.utcnow().isoformat()
-        checklist_dict['metadata']['savedAtFormatted'] = datetime.utcnow().strftime('%d/%m/%Y, %H:%M:%S')
-        
-        # Remove _id if it exists to let MongoDB generate a new one
-        if '_id' in checklist_dict:
-            del checklist_dict['_id']
-        
-        # Insert as a new document (always create new session)
-        result = await db.checklists.insert_one(checklist_dict)
-        
-        if result.inserted_id:
-            logger.info(f"Created new checklist session for user {user_id}")
-            message = "Checklist session created successfully"
-        else:
-            logger.error(f"Failed to create checklist for user {user_id}")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to save checklist"
+        if existing_checklist:
+            # Update existing checklist
+            checklist_dict['createdAt'] = existing_checklist.get('createdAt', datetime.utcnow())
+            
+            # Remove _id if it exists to prevent immutable field error
+            if '_id' in checklist_dict:
+                del checklist_dict['_id']
+            
+            result = await db.checklists.update_one(
+                {"userId": user_id},
+                {"$set": checklist_dict}
             )
+            
+            if result.modified_count > 0:
+                logger.info(f"Updated existing checklist for user {user_id}")
+                message = "Checklist updated successfully"
+            else:
+                logger.error(f"Failed to update checklist for user {user_id}")
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to update checklist"
+                )
+        else:
+            # Create new checklist
+            checklist_dict['createdAt'] = datetime.utcnow()
+            
+            # Remove _id if it exists to let MongoDB generate a new one
+            if '_id' in checklist_dict:
+                del checklist_dict['_id']
+            
+            result = await db.checklists.insert_one(checklist_dict)
+            
+            if result.inserted_id:
+                logger.info(f"Created new checklist for user {user_id}")
+                message = "Checklist created successfully"
+            else:
+                logger.error(f"Failed to create checklist for user {user_id}")
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to save checklist"
+                )
         
-        # Retrieve the newly created checklist
-        created_checklist = await db.checklists.find_one({"_id": result.inserted_id})
-        serialized_checklist = serialize_checklist(created_checklist)
+        # Retrieve the updated/created checklist
+        if existing_checklist:
+            # For updates, get the updated document
+            updated_checklist = await db.checklists.find_one({"userId": user_id})
+            serialized_checklist = serialize_checklist(updated_checklist)
+        else:
+            # For new checklists, get the newly created document
+            created_checklist = await db.checklists.find_one({"_id": result.inserted_id})
+            serialized_checklist = serialize_checklist(created_checklist)
         
         return ChecklistResponse(
             success=True,
@@ -669,6 +683,943 @@ async def get_checklists_by_user_name(user_name: str):
             detail=f"Failed to retrieve checklists for user: {str(e)}"
         )
 
+@app.post("/api/checklist/{user_id}/image")
+async def upload_checklist_image(user_id: str, image: UploadFile = File(...)):
+    """
+    Upload an image for a checklist (for non-compliant cases)
+    
+    Args:
+        user_id: Unique identifier for the user
+        image: The image file to upload
+        
+    Returns:
+        Dictionary containing the base64 encoded image data and metadata
+    """
+    try:
+        logger.info(f"Uploading image for user: {user_id}")
+        
+        # Validate image file type
+        allowed_types = ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"]
+        if image.content_type not in allowed_types:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid image type. Allowed types: {', '.join(allowed_types)}"
+            )
+        
+        # Read image data
+        image_data = await image.read()
+        
+        # Encode to base64
+        base64_data = base64.b64encode(image_data).decode('utf-8')
+        
+        # Create data URL
+        data_url = f"data:{image.content_type};base64,{base64_data}"
+        
+        logger.info(f"Image uploaded successfully for user {user_id}, size: {len(image_data)} bytes")
+        
+        return {
+            "success": True,
+            "data": {
+                "imageData": base64_data,
+                "imageType": image.content_type,
+                "dataUrl": data_url,
+                "size": len(image_data),
+                "filename": image.filename
+            },
+            "message": "Image uploaded successfully"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error uploading image for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to upload image: {str(e)}"
+        )
+
+async def ensure_default_template_exists():
+    """
+    Ensure the default template exists in the database.
+    Creates it if it doesn't exist.
+    """
+    try:
+        logger.info("Checking if default template exists...")
+        # Check if template exists (check both old and new IDs)
+        template = await db.checklist_templates.find_one({
+            "$or": [
+                {"templateId": "default"},
+                {"templateId": "default-audit-checklist"}
+            ]
+        })
+        
+        if not template:
+            logger.info("Default template not found, creating it now...")
+            
+            # Create the default template
+            default_template = {
+                "templateId": "default",
+                "title": "Checklist di Audit Operativo",
+                "sections": [
+                    {
+                        "id": "S1",
+                        "title": "1. PERSONALE E IGIENE",
+                        "icon": "Users",
+                        "items": [
+                            {"id": "I1.1", "requirement": "Indumenti da lavoro puliti (divisa, grembiule)."},
+                            {"id": "I1.2", "requirement": "Scarpe antinfortunistiche / Calzature pulite."},
+                            {"id": "I1.3", "requirement": "Cuffie e/o Retine per capelli indossate correttamente."},
+                            {"id": "I1.4", "requirement": "Assenza di gioielli, piercing visibili, unghie lunghe."},
+                            {"id": "I1.5", "requirement": "Lavaggio mani documentato all'ingresso/reingresso."},
+                            {"id": "I1.6", "requirement": "Assenza di cibo/bevande non autorizzate nelle aree produttive."},
+                        ],
+                    },
+                    {
+                        "id": "S2",
+                        "title": "2. STRUTTURE E IMPIANTI",
+                        "icon": "Building",
+                        "items": [
+                            {"id": "I2.1", "requirement": "Illuminazione adeguata e funzionante in tutte le aree."},
+                            {"id": "I2.2", "requirement": "Porte esterne/interne in buone condizioni e chiuse correttamente (sigillatura)."},
+                            {"id": "I2.3", "requirement": "Integrità di pavimenti, pareti e soffitti (assenza di crepe/danni)."},
+                            {"id": "I2.4", "requirement": "Controllo vetri / lampade protette o anti-frantumazione."},
+                            {"id": "I2.5", "requirement": "Condizioni igieniche dei servizi igienici e spogliatoi (pulizia e dotazioni)."},
+                            {"id": "I2.6", "requirement": "Ventilazione e aspirazione funzionanti, pulite e non ostruite."},
+                        ],
+                    },
+                    {
+                        "id": "S3",
+                        "title": "3. GESTIONE E IGIENE AMBIENTALE",
+                        "icon": "Package",
+                        "items": [
+                            {"id": "I3.1", "requirement": "Contenitori dei rifiuti puliti, chiusi e identificati."},
+                            {"id": "I3.2", "requirement": "Separazione corretta dei rifiuti (es. umido, secco, plastica)."},
+                            {"id": "I3.3", "requirement": "Area di stoccaggio rifiuti (interna ed esterna) ordinata e sanificata."},
+                            {"id": "I3.4", "requirement": "Frequenza di rimozione dei rifiuti adeguata a prevenire accumuli."},
+                        ],
+                    },
+                    {
+                        "id": "S4",
+                        "title": "4. CONTROLLO PROCESSO E QUALITÀ",
+                        "icon": "Settings",
+                        "items": [
+                            {"id": "I4.1", "requirement": "Monitoraggio e registrazione dei Punti Critici di Controllo (CCP)."},
+                            {"id": "I4.2", "requirement": "Procedure di Buona Fabbricazione (GMP) rispettate (es. pulizia prima dell'avvio)."},
+                            {"id": "I4.3", "requirement": "Verifica e calibrazione del Metal Detector eseguita e registrata."},
+                            {"id": "I4.4", "requirement": "Corretta identificazione dei lotti di materie prime e semilavorati."},
+                            {"id": "I4.5", "requirement": "Rispettate le temperature di stoccaggio dei prodotti finiti e intermedi."},
+                            {"id": "I4.6", "requirement": "Corretta gestione, etichettatura e isolamento dei prodotti non conformi."},
+                        ],
+                    },
+                    {
+                        "id": "S5",
+                        "title": "5. CONTROLLO INFESTANTI",
+                        "icon": "Shield",
+                        "items": [
+                            {"id": "I5.1", "requirement": "Assenza di tracce visibili di roditori, insetti o uccelli."},
+                            {"id": "I5.2", "requirement": "Stazioni di monitoraggio/trappole numerate, integre e registrate."},
+                            {"id": "I5.3", "requirement": "Mappe e registri delle trappole aggiornati e disponibili."},
+                            {"id": "I5.4", "requirement": "Barriere fisiche (es. reti, spazzole) anti-intrusione in buone condizioni."},
+                            {"id": "I5.5", "requirement": "Prodotti chimici di controllo infestanti stoccati in modo sicuro e separato."},
+                        ],
+                    },
+                    {
+                        "id": "S6",
+                        "title": "6. MANUTENZIONE E VETRI",
+                        "icon": "Settings",
+                        "items": [
+                            {"id": "I6.1", "requirement": "Piano di manutenzione preventiva e correttiva rispettato e registrato."},
+                            {"id": "I6.2", "requirement": "Lubrificanti e oli utilizzati autorizzati per uso alimentare (se richiesto)."},
+                            {"id": "I6.3", "requirement": "Registri di calibrazione/verifica degli strumenti di misura critici aggiornati."},
+                            {"id": "I6.4", "requirement": "Gestione dei vetri rotti (registri rotture) aggiornata e conforme alla procedura."},
+                            {"id": "I6.5", "requirement": "Assenza di perdite, gocciolamenti o cavi scoperti da impianti/macchinari."},
+                            {"id": "I6.6", "requirement": "Area di deposito utensili e pezzi di ricambio ordinata e pulita."},
+                        ],
+                    },
+                    {
+                        "id": "S7",
+                        "title": "7. DOCUMENTAZIONE E FORMAZIONE",
+                        "icon": "FileText",
+                        "items": [
+                            {"id": "I7.1", "requirement": "Documentazione di processo (procedure, istruzioni) aggiornata e disponibile."},
+                            {"id": "I7.2", "requirement": "Registri di formazione del personale aggiornati e verificabili."},
+                            {"id": "I7.3", "requirement": "Certificazioni e attestati del personale validi e aggiornati."},
+                            {"id": "I7.4", "requirement": "Controllo documenti (versioni, distribuzione, obsolescenza) conforme."},
+                            {"id": "I7.5", "requirement": "Archiviazione e conservazione documenti secondo i requisiti normativi."},
+                        ],
+                    },
+                ],
+                "metadata": {
+                    "createdAt": datetime.utcnow().isoformat(),
+                    "updatedAt": datetime.utcnow().isoformat(),
+                }
+            }
+            
+            result = await db.checklist_templates.insert_one(default_template)
+            logger.info(f"✅ Successfully created default template with ID: {result.inserted_id}")
+            # Fetch the newly created template to return with _id
+            template = await db.checklist_templates.find_one({"templateId": "default"})
+            return template
+        else:
+            logger.info("✅ Default template already exists in database")
+            return template
+            
+    except Exception as e:
+        logger.error(f"❌ Error ensuring default template exists: {e}", exc_info=True)
+        return None
+
+@app.get("/api/checklist-template/default", response_model=Dict[str, Any])
+async def get_default_checklist_template():
+    """
+    Get the default checklist template
+    
+    Returns:
+        Dictionary containing the default checklist template structure
+        
+    Raises:
+        HTTPException: If template not found or database operation fails
+    """
+    try:
+        logger.info("📋 GET /api/checklist-template/default - Retrieving default checklist template")
+        
+        # Ensure template exists (creates if not found)
+        template_doc = await ensure_default_template_exists()
+        logger.info(f"Template check result: {'Found' if template_doc else 'Not Found'}")
+        
+        if not template_doc:
+            # Fallback to looking for old template ID
+            logger.info("Checking for old template ID: default-audit-checklist")
+            template_doc = await db.checklist_templates.find_one({"templateId": "default-audit-checklist"})
+        
+        if not template_doc:
+            # If template doesn't exist, create it from the hardcoded structure
+            logger.info("Default template not found, creating from hardcoded structure")
+            
+            # Use the same structure as in get_checklist but mark as template
+            default_template = {
+                "templateId": "default-audit-checklist",
+                "title": "Checklist di Audit Operativo (38 Controlli)",
+                "description": "Template per audit operativo in ambiente di produzione alimentare",
+                "version": "1.0",
+                "isTemplate": True,
+                "createdAt": datetime.utcnow(),
+                "updatedAt": datetime.utcnow(),
+                "sections": [
+                    {
+                        "id": "S1",
+                        "title": "1. PERSONALE E IGIENE",
+                        "icon": "Users",
+                        "items": [
+                            {"id": "I1.1", "requirement": "Indumenti da lavoro puliti (divisa, grembiule).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I1.2", "requirement": "Scarpe antinfortunistiche / Calzature pulite.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I1.3", "requirement": "Cuffie e/o Retine per capelli indossate correttamente.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I1.4", "requirement": "Assenza di gioielli, piercing visibili, unghie lunghe.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I1.5", "requirement": "Lavaggio mani documentato all'ingresso/reingresso.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I1.6", "requirement": "Assenza di cibo/bevande non autorizzate nelle aree produttive.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S2",
+                        "title": "2. STRUTTURE E IMPIANTI",
+                        "icon": "Building",
+                        "items": [
+                            {"id": "I2.1", "requirement": "Illuminazione adeguata e funzionante in tutte le aree.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I2.2", "requirement": "Porte esterne/interne in buone condizioni e chiuse correttamente (sigillatura).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I2.3", "requirement": "Integrità di pavimenti, pareti e soffitti (assenza di crepe/danni).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I2.4", "requirement": "Controllo vetri / lampade protette o anti-frantumazione.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I2.5", "requirement": "Condizioni igieniche dei servizi igienici e spogliatoi (pulizia e dotazioni).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I2.6", "requirement": "Ventilazione e aspirazione funzionanti, pulite e non ostruite.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S3",
+                        "title": "3. GESTIONE E IGIENE AMBIENTALE",
+                        "icon": "Package",
+                        "items": [
+                            {"id": "I3.1", "requirement": "Contenitori dei rifiuti puliti, chiusi e identificati.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I3.2", "requirement": "Separazione corretta dei rifiuti (es. umido, secco, plastica).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I3.3", "requirement": "Area di stoccaggio rifiuti (interna ed esterna) ordinata e sanificata.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I3.4", "requirement": "Frequenza di rimozione dei rifiuti adeguata a prevenire accumuli.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S4",
+                        "title": "4. CONTROLLO PROCESSO E QUALITÀ",
+                        "icon": "Settings",
+                        "items": [
+                            {"id": "I4.1", "requirement": "Monitoraggio e registrazione dei Punti Critici di Controllo (CCP).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I4.2", "requirement": "Procedure di Buona Fabbricazione (GMP) rispettate (es. pulizia prima dell'avvio).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I4.3", "requirement": "Verifica e calibrazione del Metal Detector eseguita e registrata.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I4.4", "requirement": "Corretta identificazione dei lotti di materie prime e semilavorati.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I4.5", "requirement": "Rispettate le temperature di stoccaggio dei prodotti finiti e intermedi.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I4.6", "requirement": "Corretta gestione, etichettatura e isolamento dei prodotti non conformi.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S5",
+                        "title": "5. CONTROLLO INFESTANTI",
+                        "icon": "Shield",
+                        "items": [
+                            {"id": "I5.1", "requirement": "Assenza di tracce visibili di roditori, insetti o uccelli.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I5.2", "requirement": "Stazioni di monitoraggio/trappole numerate, integre e registrate.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I5.3", "requirement": "Mappe e registri delle trappole aggiornati e disponibili.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I5.4", "requirement": "Barriere fisiche (es. reti, spazzole) anti-intrusione in buone condizioni.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I5.5", "requirement": "Prodotti chimici di controllo infestanti stoccati in modo sicuro e separato.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S6",
+                        "title": "6. MANUTENZIONE E VETRI",
+                        "icon": "Settings",
+                        "items": [
+                            {"id": "I6.1", "requirement": "Piano di manutenzione preventiva e correttiva rispettato e registrato.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I6.2", "requirement": "Lubrificanti e oli utilizzati autorizzati per uso alimentare (se richiesto).", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I6.3", "requirement": "Registri di calibrazione/verifica degli strumenti di misura critici aggiornati.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I6.4", "requirement": "Gestione dei vetri rotti (registri rotture) aggiornata e conforme alla procedura.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I6.5", "requirement": "Assenza di perdite, gocciolamenti o cavi scoperti da impianti/macchinari.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I6.6", "requirement": "Area di deposito utensili e pezzi di ricambio ordinata e pulita.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    },
+                    {
+                        "id": "S7",
+                        "title": "7. DOCUMENTAZIONE E FORMAZIONE",
+                        "icon": "FileText",
+                        "items": [
+                            {"id": "I7.1", "requirement": "Documentazione di processo (procedure, istruzioni) aggiornata e disponibile.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I7.2", "requirement": "Registri di formazione del personale aggiornati e verificabili.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I7.3", "requirement": "Certificazioni e attestati del personale validi e aggiornati.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I7.4", "requirement": "Controllo documenti (versioni, distribuzione, obsolescenza) conforme.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None},
+                            {"id": "I7.5", "requirement": "Archiviazione e conservazione documenti secondo i requisiti normativi.", "compliance": "N/A", "deviation": "", "action": "", "imageData": None}
+                        ]
+                    }
+                ],
+                "totalItems": 38,
+                "completedItems": 0,
+                "nonCompliantItems": 0,
+                "complianceScore": 0.0
+            }
+            
+            # Insert the template
+            await db.checklist_templates.insert_one(default_template)
+            template_doc = default_template
+        
+        # Serialize the document
+        serialized_template = serialize_checklist(template_doc)
+        
+        return {
+            "success": True,
+            "data": serialized_template,
+            "message": "Default checklist template retrieved successfully"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error retrieving default checklist template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to retrieve checklist template: {str(e)}"
+        )
+
+@app.post("/api/checklist-template/item", response_model=Dict[str, Any])
+async def add_template_item(item_data: dict):
+    """
+    Add a new item to the shared checklist template
+    
+    Args:
+        item_data: Dictionary containing item information (sectionId, requirement, etc.)
+        
+    Returns:
+        Dictionary confirming the item was added
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Adding new item to shared template")
+        
+        # Ensure template exists first and get it
+        template = await ensure_default_template_exists()
+        
+        if not template:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Template not found"
+            )
+        
+        template_id = template.get("templateId", "default")
+        
+        # Find the section and add the new item
+        section_id = item_data.get('sectionId')
+        section_index = next((i for i, s in enumerate(template['sections']) if s['id'] == section_id), None)
+        
+        if section_index is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Section {section_id} not found"
+            )
+        
+        new_item = {
+            "id": item_data.get('id', f"I{section_id[-1]}.{len(template['sections'][section_index]['items'])+1}"),
+            "requirement": item_data.get('requirement', ''),
+        }
+        
+        # Update the template
+        result = await db.checklist_templates.update_one(
+            {"templateId": template_id, "sections.id": section_id},
+            {"$push": {"sections.$.items": new_item}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully added item to template")
+            return {
+                "success": True,
+                "message": "Item added successfully",
+                "data": new_item
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to add item"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding item to template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add item: {str(e)}"
+        )
+
+@app.put("/api/checklist-template/item/{item_id}", response_model=Dict[str, Any])
+async def update_template_item(item_id: str, item_data: dict):
+    """
+    Update an existing item in the shared checklist template
+    
+    Args:
+        item_id: ID of the item to update
+        item_data: Dictionary containing updated item information
+        
+    Returns:
+        Dictionary confirming the item was updated
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Updating item {item_id} in shared template")
+        
+        # Ensure template exists first and get it
+        template = await ensure_default_template_exists()
+        template_id = template.get("templateId") if template else "default"
+        
+        # Prepare update fields
+        update_fields = {}
+        if 'requirement' in item_data:
+            update_fields["sections.$[].items.$[item].requirement"] = item_data['requirement']
+        
+        if not update_fields:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="No valid fields to update"
+            )
+        
+        # Update the item in template (use the template ID we found)
+        result = await db.checklist_templates.update_one(
+            {"templateId": template_id},
+            {"$set": update_fields},
+            array_filters=[{"item.id": item_id}]
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully updated item {item_id} in template")
+            return {
+                "success": True,
+                "message": "Item updated successfully",
+                "data": item_data
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Item not found or no changes made"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating item {item_id} in template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update item: {str(e)}"
+        )
+
+@app.delete("/api/checklist-template/item/{item_id}", response_model=Dict[str, Any])
+async def delete_template_item(item_id: str):
+    """
+    Delete an item from the shared checklist template
+    
+    Args:
+        item_id: ID of the item to delete
+        
+    Returns:
+        Dictionary confirming the item was deleted
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Deleting item {item_id} from shared template")
+        
+        # Ensure template exists first and get it
+        template = await ensure_default_template_exists()
+        template_id = template.get("templateId") if template else "default"
+        
+        # Remove the item from the template
+        result = await db.checklist_templates.update_one(
+            {"templateId": template_id},
+            {"$pull": {"sections.$[].items": {"id": item_id}}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully deleted item {item_id} from template")
+            return {
+                "success": True,
+                "message": "Item deleted successfully"
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Item not found"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting item {item_id} from template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete item: {str(e)}"
+        )
+
+@app.post("/api/checklist-template/section", response_model=Dict[str, Any])
+async def add_template_section(section_data: dict):
+    """
+    Add a new section to the shared checklist template
+    
+    Args:
+        section_data: Dictionary containing section information
+        
+    Returns:
+        Dictionary confirming the section was added
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Adding new section to shared template")
+        
+        # Ensure template exists first and get it
+        template = await ensure_default_template_exists()
+        
+        if not template:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Template not found"
+            )
+        
+        template_id = template.get("templateId", "default")
+        
+        # Create new section
+        new_section = {
+            "id": section_data.get('id', f"S{len(template['sections'])+1}"),
+            "title": section_data.get('title', 'New Section'),
+            "icon": section_data.get('icon', 'Settings'),
+            "items": []
+        }
+        
+        # Add the new section
+        result = await db.checklist_templates.update_one(
+            {"templateId": template_id},
+            {"$push": {"sections": new_section}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully added section to template")
+            return {
+                "success": True,
+                "message": "Section added successfully",
+                "data": new_section
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to add section"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding section to template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add section: {str(e)}"
+        )
+
+@app.delete("/api/checklist-template/section/{section_id}", response_model=Dict[str, Any])
+async def delete_template_section(section_id: str):
+    """
+    Delete a section from the shared checklist template
+    
+    Args:
+        section_id: ID of the section to delete
+        
+    Returns:
+        Dictionary confirming the section was deleted
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Deleting section {section_id} from shared template")
+        
+        # Ensure template exists first and get it
+        template = await ensure_default_template_exists()
+        template_id = template.get("templateId") if template else "default"
+        
+        # Remove the section from the template
+        result = await db.checklist_templates.update_one(
+            {"templateId": template_id},
+            {"$pull": {"sections": {"id": section_id}}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully deleted section {section_id} from template")
+            return {
+                "success": True,
+                "message": "Section deleted successfully"
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Section not found"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting section {section_id} from template: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete section: {str(e)}"
+        )
+
+@app.post("/api/checklist/{user_id}/item", response_model=Dict[str, Any])
+async def add_checklist_item(user_id: str, item_data: dict):
+    """
+    Add a new item to a checklist
+    
+    Args:
+        user_id: Unique identifier for the user
+        item_data: Dictionary containing item information (sectionId, requirement, etc.)
+        
+    Returns:
+        Dictionary confirming the item was added
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Adding new item to checklist for user: {user_id}")
+        
+        # Get the user's checklist
+        checklist_doc = await db.checklists.find_one({"userId": user_id})
+        
+        if not checklist_doc:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Checklist not found for user"
+            )
+        
+        # Find the section and add the new item
+        section_id = item_data.get('sectionId')
+        new_item = {
+            "id": item_data.get('id', f"I{section_id}.{len(checklist_doc['sections'][int(section_id[-1])-1]['items'])+1}"),
+            "requirement": item_data.get('requirement', ''),
+            "compliance": "N/A",
+            "deviation": "",
+            "action": "",
+            "imageData": None,
+            "checkedAt": None,
+            "checkedBy": ""
+        }
+        
+        # Update the checklist
+        result = await db.checklists.update_one(
+            {"userId": user_id, "sections.id": section_id},
+            {"$push": {f"sections.$.items": new_item}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully added item to checklist for user {user_id}")
+            return {
+                "success": True,
+                "message": "Item added successfully",
+                "data": new_item
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to add item"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding item for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add item: {str(e)}"
+        )
+
+@app.put("/api/checklist/{user_id}/item/{item_id}", response_model=Dict[str, Any])
+async def update_checklist_item(user_id: str, item_id: str, item_data: dict):
+    """
+    Update an existing checklist item
+    
+    Args:
+        user_id: Unique identifier for the user
+        item_id: ID of the item to update
+        item_data: Dictionary containing updated item information
+        
+    Returns:
+        Dictionary confirming the item was updated
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Updating item {item_id} for user: {user_id}")
+        
+        # Check if checklist exists
+        checklist = await db.checklists.find_one({"userId": user_id})
+        if not checklist:
+            logger.warning(f"No checklist found for user {user_id}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Checklist not found for user {user_id}. Please create a checklist first."
+            )
+        
+        # Prepare update fields
+        update_fields = {}
+        for field in ['requirement', 'compliance', 'deviation', 'action']:
+            if field in item_data:
+                update_fields[f"sections.$[].items.$[item].{field}"] = item_data[field]
+        
+        if not update_fields:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="No valid fields to update"
+            )
+        
+        # Update the item
+        result = await db.checklists.update_one(
+            {"userId": user_id},
+            {"$set": update_fields},
+            array_filters=[{"item.id": item_id}]
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully updated item {item_id} for user {user_id}")
+            return {
+                "success": True,
+                "message": "Item updated successfully",
+                "data": item_data
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Item not found or no changes made"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating item {item_id} for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update item: {str(e)}"
+        )
+
+@app.delete("/api/checklist/{user_id}/item/{item_id}", response_model=Dict[str, Any])
+async def delete_checklist_item(user_id: str, item_id: str):
+    """
+    Delete a checklist item
+    
+    Args:
+        user_id: Unique identifier for the user
+        item_id: ID of the item to delete
+        
+    Returns:
+        Dictionary confirming the item was deleted
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Deleting item {item_id} for user: {user_id}")
+        
+        # Check if checklist exists
+        checklist = await db.checklists.find_one({"userId": user_id})
+        if not checklist:
+            logger.warning(f"No checklist found for user {user_id}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Checklist not found for user {user_id}. Please create a checklist first."
+            )
+        
+        # Remove the item from the checklist
+        result = await db.checklists.update_one(
+            {"userId": user_id},
+            {"$pull": {"sections.$[].items": {"id": item_id}}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully deleted item {item_id} for user {user_id}")
+            return {
+                "success": True,
+                "message": "Item deleted successfully"
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Item not found"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting item {item_id} for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete item: {str(e)}"
+        )
+
+@app.post("/api/checklist/{user_id}/section", response_model=Dict[str, Any])
+async def add_checklist_section(user_id: str, section_data: dict):
+    """
+    Add a new section to a checklist
+    
+    Args:
+        user_id: Unique identifier for the user
+        section_data: Dictionary containing section information
+        
+    Returns:
+        Dictionary confirming the section was added
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Adding new section to checklist for user: {user_id}")
+        
+        # Get the user's checklist
+        checklist_doc = await db.checklists.find_one({"userId": user_id})
+        
+        if not checklist_doc:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Checklist not found for user"
+            )
+        
+        # Create new section
+        new_section = {
+            "id": section_data.get('id', f"S{len(checklist_doc['sections'])+1}"),
+            "title": section_data.get('title', 'New Section'),
+            "icon": section_data.get('icon', 'Settings'),
+            "items": []
+        }
+        
+        # Add the new section
+        result = await db.checklists.update_one(
+            {"userId": user_id},
+            {"$push": {"sections": new_section}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully added section to checklist for user {user_id}")
+            return {
+                "success": True,
+                "message": "Section added successfully",
+                "data": new_section
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to add section"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error adding section for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add section: {str(e)}"
+        )
+
+@app.delete("/api/checklist/{user_id}/section/{section_id}", response_model=Dict[str, Any])
+async def delete_checklist_section(user_id: str, section_id: str):
+    """
+    Delete a checklist section and all its items
+    
+    Args:
+        user_id: Unique identifier for the user
+        section_id: ID of the section to delete
+        
+    Returns:
+        Dictionary confirming the section was deleted
+        
+    Raises:
+        HTTPException: If database operation fails
+    """
+    try:
+        logger.info(f"Deleting section {section_id} for user: {user_id}")
+        
+        # Check if checklist exists
+        checklist = await db.checklists.find_one({"userId": user_id})
+        if not checklist:
+            logger.warning(f"No checklist found for user {user_id}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Checklist not found for user {user_id}. Please create a checklist first."
+            )
+        
+        # Remove the section from the checklist
+        result = await db.checklists.update_one(
+            {"userId": user_id},
+            {"$pull": {"sections": {"id": section_id}}}
+        )
+        
+        if result.modified_count > 0:
+            logger.info(f"Successfully deleted section {section_id} for user {user_id}")
+            return {
+                "success": True,
+                "message": "Section deleted successfully"
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Section not found"
+            )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting section {section_id} for user {user_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete section: {str(e)}"
+        )
+
 @app.get("/api/checklists", response_model=Dict[str, Any])
 async def get_all_checklists():
     """
@@ -756,9 +1707,9 @@ if __name__ == "__main__":
     
     # Run the server
     uvicorn.run(
-        "app:app",  # Changed from "main:app" to "app:app" for HF Spaces
+        "main:app",
         host="0.0.0.0",
         port=PORT,
-        reload=False,  # Disable auto-reload for production deployment
+        reload=True,  # Enable auto-reload for development
         log_level="info"
     )