Update app.py

app.py

@@ -2,14 +2,44 @@ import pandas as pd
 from itertools import permutations, combinations
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import List, Dict, Any
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
 import uuid
 import requests
 import json
 
+from fastapi.responses import RedirectResponse
+import pyodbc
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Fetch credentials from environment variables
+DB_DRIVER = os.getenv('DB_DRIVER')
+DB_SERVER = os.getenv('DB_SERVER')
+DB_DATABASE = os.getenv('DB_DATABASE')
+DB_UID = os.getenv('DB_UID')
+DB_PWD = os.getenv('DB_PWD')
+DB_ENCRYPT = os.getenv('DB_ENCRYPT')
+DB_NAME = os.getenv('DB_name')
+DB_TABLE_NAME = os.getenv('DB_tableName')
+frontend_url = os.getenv('FRONTEND_URL')
+# Define connection string
+conn_str = (
+    f"Driver={DB_DRIVER};"
+    f"Server={DB_SERVER};"
+    f"Database={DB_NAME};"  # Use the target database
+    f"UID={DB_UID};"
+    f"PWD={DB_PWD};"
+    f"Encrypt={DB_ENCRYPT};"
+)
+
 app = FastAPI()
 stored_combinations = {}
+destination_mapping_global = {}
 processed_data_store: Dict[str, Dict[str, Any]] = {}  # Store processed data with session_id
 
 app.add_middleware(
@@ -31,12 +61,13 @@ async def preflight_handler(request: Request, rest_of_path: str) -> Response:
 
 # Box and Truck classes
 class Box:
-    def __init__(self, length, width, height, quantity, box_type):
+    def __init__(self, length, width, height, quantity, box_type, destination):
         self.length = length
         self.width = width
         self.height = height
         self.quantity = quantity if quantity > 0 else 1
         self.type = box_type
+        self.destination = destination  # Added Destination
 
     def rotated_dimensions(self):
         possible_rotations = [
@@ -158,6 +189,10 @@ def find_max_consignments_combinations(truck, consignments, combination_limit=10
     for r in range(1, len(consignments_sorted) + 1):
         for combo in combinations(consignments_sorted, r):
             combo_count += 1
+            # Corrected line: Access the first box's type
+            if len(combo) == 0 or any(len(consignment[0]) == 0 for consignment in combo):
+                # Skip if any consignment has no boxes
+                continue
             print(f"Checking combination {combo_count}: {[f'Consignment {boxes[0].type}' for boxes, _ in combo]}")
 
             if combo_count > combination_limit:
@@ -236,17 +271,19 @@ def suggest_truck(consignments):
     return None
 
 
-# Models
+# Updated Pydantic Models with Destination Fields
 class BoxData(BaseModel):
     PieceLength: float
     PieceBreadth: float
     PieceHeight: float
     Priority: int
+    Destination: str  # Added Destination
 
 
 class ConsignmentData(BaseModel):
     ConsignmentNo: str
     Priority: int
+    Destination: str  # Added Destination
     boxes: List[BoxData]
 
 
@@ -254,30 +291,36 @@ class SubmitDataRequest(BaseModel):
     truck_name: str
     autoSuggest: bool
     consignments_data: List[ConsignmentData]
+    destination_mapping: Dict[str, int]  # Added destination_mapping
 
-from fastapi.responses import RedirectResponse
 
 @app.post("/submit_data/")
 async def submit_data(request: SubmitDataRequest):
     """
     Endpoint to receive data from the client via API.
     """
+    
+    frontend_url = os.getenv('FRONTEND_URL')
     truck_name = request.truck_name
     autoSuggest = request.autoSuggest
     consignments_data = request.consignments_data  # This is already parsed from JSON
+    destination_mapping = request.destination_mapping  # Received destination_mapping
 
-    global stored_combinations, processed_data_store
+    global stored_combinations, processed_data_store, destination_mapping_global
+    
+    destination_mapping_global = destination_mapping
 
     # Parse consignments and calculate total quantity based on box dimensions
     consignments = []
     for consignment_data in consignments_data:
         consignment_no = consignment_data.ConsignmentNo  # ConsignmentNo is now accessible as a string
         is_priority = consignment_data.Priority
+        consignment_destination = consignment_data.Destination  # Get Destination for Consignment
 
-        # Aggregate the boxes with same dimensions
+        # Aggregate the boxes with same dimensions and destination
         box_aggregation = {}
         for box_data in consignment_data.boxes:
-            dimensions = (box_data.PieceLength, box_data.PieceBreadth, box_data.PieceHeight)
+            dimensions = (box_data.PieceLength, box_data.PieceBreadth, box_data.PieceHeight, box_data.Destination)
 
             if dimensions in box_aggregation:
                 box_aggregation[dimensions]['Quantity'] += 1  # Increment the count if dimensions are the same
@@ -286,6 +329,7 @@ async def submit_data(request: SubmitDataRequest):
                     'PieceLength': box_data.PieceLength,
                     'PieceBreadth': box_data.PieceBreadth,
                     'PieceHeight': box_data.PieceHeight,
+                    'Destination': box_data.Destination,  # Include Destination
                     'Quantity': 1  # Initialize count to 1
                 }
 
@@ -296,7 +340,8 @@ async def submit_data(request: SubmitDataRequest):
                 box['PieceBreadth'] / 2.54,
                 box['PieceHeight'] / 2.54,
                 box['Quantity'],
-                f"Consignment {consignment_no} ({'Priority' if is_priority else 'Non-Priority'})"
+                f"Consignment {consignment_no} ({'Priority' if is_priority else 'Non-Priority'})",
+                box['Destination']  # Pass Destination to Box
             )
             for box in box_aggregation.values()
         ]
@@ -370,8 +415,9 @@ async def submit_data(request: SubmitDataRequest):
                     "combination_number": index + 1,
                     "consignments": [
                         {
-                            "consignment_number": f"{boxes[0].type.split(' ')[1]}",
-                            "priority_status": boxes[0].type.split('(')[1].strip(')')
+                            "consignment_number": f"{boxes[0].type.split(' ')[1]}",  # Corrected access
+                            "priority_status": boxes[0].type.split('(')[1].strip(')'),
+                            "destination": boxes[0].destination  # Include Destination
                         }
                         for boxes, _ in combo
                     ],
@@ -392,11 +438,12 @@ async def submit_data(request: SubmitDataRequest):
                         "height": height
                     }
                 },
-                "consignments_data": [consignment.dict() for consignment in consignments_data]  # **Added**
+                "consignments_data": [consignment.dict() for consignment in consignments_data],  # **Includes Destination**
+                "destination_mapping": destination_mapping  # Include destination_mapping
             }
 
             # Redirect to the visualization page
-            return RedirectResponse(url=f"https://66eafada5f1ccb4a5f161808--quiet-nougat-e4fc4b.netlify.app?session_id={session_id}", status_code=302)
+            return RedirectResponse(url=f"{frontend_url}?session_id={session_id}", status_code=302)
 
     # Prepare box data for visualization
     box_data = []
@@ -411,7 +458,8 @@ async def submit_data(request: SubmitDataRequest):
             'height': box.height,
             'type': box.type,
             'quantity': 1,  # Since we're iterating over each individual box
-            'position': position
+            'position': position,
+            'destination': box.destination  # Include Destination
         })
 
     # Generate a unique session_id
@@ -425,83 +473,201 @@ async def submit_data(request: SubmitDataRequest):
                 "width": width,
                 "height": height
             }
-        }
+        },
+        "destination_mapping": destination_mapping  # Include destination_mapping
     }
+    
+    print(" auto suggest data ", processed_data_store[session_id])
 
     # Redirect to the visualization page
-    return RedirectResponse(url=f"https://66eafada5f1ccb4a5f161808--quiet-nougat-e4fc4b.netlify.app?session_id={session_id}", status_code=302)
-
+    return RedirectResponse(url=f"{frontend_url}?session_id={session_id}", status_code=302)
 
-
-@app.post("/load_combination/")
-async def load_combination(
-    index: int = Form(...),
-    truck_length: float = Form(...),
-    truck_width: float = Form(...),
-    truck_height: float = Form(...),
-    truck_name: str = Form(...)
-):
+@app.get("/get_visualization/{session_id}/")
+async def get_visualization(session_id: str):
     """
-    Endpoint to visualize the selected combination.
+    Endpoint for the frontend to fetch processed data using session_id.
     """
-    print(f"Received index: {index}")
-    print(f"Received truck details: {truck_length}L x {truck_width}W x {truck_height}H, Name: {truck_name}")
-
-    # Ensure the index is within the valid range
-    if index >= len(stored_combinations):
-        raise HTTPException(status_code=400, detail="Invalid combination index")
-
-    selected_combination = stored_combinations[index]
-
-    # Create a Truck object using the received truck dimensions
-    truck = Truck(truck_length * 12, truck_width * 12, truck_height * 12)  # Convert feet to inches
-
-    # Unpack and structure the combination data for the pack_boxes_ffd function
-    consignments = [
-        (boxes, priority) for boxes, priority in selected_combination  # Unpack the combination as expected
-    ]
+    if session_id not in processed_data_store:
+        raise HTTPException(status_code=404, detail="Session ID not found")
 
-    # Generate the box data for this combination
-    packed_positions = pack_boxes_ffd(truck, consignments)
+    return processed_data_store[session_id]
 
-    # Prepare the box data
+    
+class SaveCombinationRequest(BaseModel):
+    combination_number: int
+    truck: str
+    truck_length: float
+    truck_width: float
+    truck_height: float
+    consignments: List[ConsignmentData]
+    total_quantity: int
+    utilization_percentage: Optional[float]
+
+# Endpoint to save combination data
+@app.post("/save_combination/", summary="Save a truck loading combination")
+async def save_combination(data: SaveCombinationRequest):
+    try:
+        
+        global destination_mapping_global
+        # Establish a connection
+        conn = pyodbc.connect(conn_str)
+        cursor = conn.cursor()
+        
+        # Prepare data for insertion
+        current_date = datetime.now().strftime("%d-%m-%Y") 
+        truck_name = data.truck
+        # Truck dimensions are now captured separately
+        truck_length = data.truck_length
+        truck_width = data.truck_width
+        truck_height = data.truck_height
+        total_consignments = len(data.consignments)
+        total_boxes = sum(len(consignment.boxes) for consignment in data.consignments)
+
+        # Prepare box data as payload for storage
+        box_data = []
+        for consignment in data.consignments:
+            for box in consignment.boxes:
+                box_entry = {
+                    'length': box.PieceLength,
+                    'width': box.PieceBreadth,
+                    'height': box.PieceHeight,
+                    'type': consignment.ConsignmentNo,
+                    'quantity': 1,  # Assuming the quantity is handled individually in frontend
+                    'position': "None",
+                    'destination': box.Destination
+                }
+                box_data.append(box_entry)
+
+        payload = {
+            "boxes": box_data,
+            "truck": {
+                "name": truck_name,
+                "dimensions": {
+                    "length": truck_length,
+                    "width": truck_width,
+                    "height": truck_height
+                }
+            },
+            "destination_mapping": destination_mapping_global,
+            "total_boxes": total_boxes,
+            "total_consignments": total_consignments
+        }
+        
+        # print("payload ", payload)
+
+        # Insert data into the table
+        insert_query = f"""
+        INSERT INTO {DB_TABLE_NAME} (Date, truckName, truckDimensions, totalConsignment, totalBoxes, payload)
+        VALUES (?, ?, ?, ?, ?, ?)
+        """
+        cursor.execute(insert_query, (
+            current_date,
+            truck_name,
+            f"{truck_length}L x {truck_width}W x {truck_height}H Feet",
+            total_consignments,
+            total_boxes,  # Total number of boxes calculated
+            json.dumps(payload)  # Store the payload as a JSON string
+        ))
+        
+        # Commit the transaction
+        conn.commit()
+        
+        # Close the connection
+        cursor.close()
+        conn.close()
+        
+        return {"message": "Combination saved successfully.", "Date": current_date}
+    except pyodbc.Error as e:
+        error_message = str(e)
+        raise HTTPException(status_code=500, detail=f"Database error: {error_message}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/visualize_payload/")
+async def visualize_payload(payload: Dict[str, Any]):
+    """
+    API to receive a payload and return the processed data to the frontend via session ID.
+    """
+    global processed_data_store
+    
+    frontend_url = os.getenv('FRONTEND_URL')
+    destination_mapping = payload.get('destination_mapping')
+    
+    
+    # Extract truck details from payload
+    truck = payload.get('truck')
+    if not truck or 'dimensions' not in truck:
+        raise HTTPException(status_code=400, detail="Truck information or dimensions missing.")
+    
+    truck_name = truck.get('name')
+    truck_dimensions = truck.get('dimensions')
+    if not truck_dimensions:
+        raise HTTPException(status_code=400, detail="Truck dimensions missing.")
+    
+    # Extract boxes from payload
+    boxes = payload.get('boxes', [])
+    if not boxes:
+        raise HTTPException(status_code=400, detail="No boxes found in payload.")
+    
+    # Extract and process truck dimensions
+    length = truck_dimensions.get('length')
+    width = truck_dimensions.get('width')
+    height = truck_dimensions.get('height')
+    if not length or not width or not height:
+        raise HTTPException(status_code=400, detail="Incomplete truck dimensions.")
+    
+    # Initialize Truck object
+    truck_obj = Truck(length * 12, width * 12, height * 12)  # Convert feet to inches
+    
+    # Process the boxes for FFD packing
+    packed_positions = []
+    consignments = []
+    
+    for box in boxes:
+        # Convert box dimensions to inches (assuming they are given in feet or inches depending on your context)
+        box_obj = Box(
+            length=box['length'], 
+            width=box['width'], 
+            height=box['height'], 
+            quantity=box.get('quantity', 1),
+            box_type=box['type'],
+            destination=box['destination']
+        )
+        # Use pack_boxes_ffd method to find positions for boxes in truck
+        position = truck_obj.add_box_ffd(box_obj)
+        packed_positions.append((box_obj, position))
+    
+    # Prepare the box data for visualization
     box_data = []
-    for box, pos in packed_positions:
+    for box_obj, pos in packed_positions:
         if pos is not None:
             position = {'x': pos[0], 'y': pos[1], 'z': pos[2]}
         else:
-            position = None
+            position = None  # Box could not be packed
         box_data.append({
-            'length': box.length,
-            'width': box.width,
-            'height': box.height,
-            'type': box.type,
-            'quantity': 1,
-            'position': position
+            'length': box_obj.length / 2.54,
+            'width': box_obj.width / 2.54,
+            'height': box_obj.height / 2.54,
+            'type': box_obj.type,
+            'quantity': box_obj.quantity,
+            'position': position,
+            'destination': box_obj.destination
         })
 
-    print("Data sent to the frontend:", len(box_data))
-
-    # Return the box data and truck information to the frontend
-    return {
+    # Generate a unique session_id for storing the processed data
+    session_id = str(uuid.uuid4())
+    processed_data_store[session_id] = {
         "boxes": box_data,
         "truck": {
             "name": truck_name,
             "dimensions": {
-                "length": truck_length,
-                "width": truck_width,
-                "height": truck_height
+                "length": length,
+                "width": width,
+                "height": height
             }
-        }
+        },
+        "destination_mapping": destination_mapping
     }
 
-
-@app.get("/get_visualization/{session_id}/")
-async def get_visualization(session_id: str):
-    """
-    Endpoint for the frontend to fetch processed data using session_id.
-    """
-    if session_id not in processed_data_store:
-        raise HTTPException(status_code=404, detail="Session ID not found")
-
-    return processed_data_store[session_id]
+    # Return session ID and processed data to the frontend for visualization
+    return {"session_id": session_id, "visualization_url": f"{frontend_url}?session_id={session_id}"}