Clean up

Ensure data management page grabs progress of any running scripts on load, clean up unneeded console logs, restyle login page
More data management page tweaks, ensure reusable images don't get deleted automatically
2025-03-28 19:35:23 -04:00 · 2025-03-28 19:26:52 -04:00 · 2025-03-27 19:31:11 -04:00 · 2025-03-27 17:09:06 -04:00 · 2025-03-27 16:27:13 -04:00 · 2025-03-26 21:53:33 -04:00
37 changed files with 3176 additions and 913 deletions
--- a/docs/inventory-calculation-reference.md
+++ b/docs/inventory-calculation-reference.md
--- a/inventory-server/db/config-schema.sql
+++ b/inventory-server/db/config-schema.sql
@@ -154,6 +154,24 @@ CREATE TRIGGER update_sales_seasonality_updated
    FOR EACH ROW
    EXECUTE FUNCTION update_updated_at_column();

+-- Create table for financial calculation parameters
+CREATE TABLE financial_calc_config (
+    id INTEGER NOT NULL PRIMARY KEY,
+    order_cost DECIMAL(10,2) NOT NULL DEFAULT 25.00, -- The fixed cost per purchase order (used in EOQ)
+    holding_rate DECIMAL(10,4) NOT NULL DEFAULT 0.25, -- The annual inventory holding cost as a percentage of unit cost (used in EOQ)
+    service_level_z_score DECIMAL(10,4) NOT NULL DEFAULT 1.96, -- Z-score for ~95% service level (used in Safety Stock)
+    min_reorder_qty INTEGER NOT NULL DEFAULT 1, -- Minimum reorder quantity 
+    default_reorder_qty INTEGER NOT NULL DEFAULT 5, -- Default reorder quantity when sales data is insufficient
+    default_safety_stock INTEGER NOT NULL DEFAULT 5, -- Default safety stock when sales data is insufficient
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TRIGGER update_financial_calc_config_updated
+    BEFORE UPDATE ON financial_calc_config
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
 -- Insert default global thresholds
 INSERT INTO stock_thresholds (id, category_id, vendor, critical_days, reorder_days, overstock_days)
 VALUES (1, NULL, NULL, 7, 14, 90)
@@ -203,6 +221,17 @@ VALUES
 ON CONFLICT (month) DO UPDATE SET
    last_updated = CURRENT_TIMESTAMP;

+-- Insert default values
+INSERT INTO financial_calc_config (id, order_cost, holding_rate, service_level_z_score, min_reorder_qty, default_reorder_qty, default_safety_stock)
+VALUES (1, 25.00, 0.25, 1.96, 1, 5, 5)
+ON CONFLICT (id) DO UPDATE SET
+    order_cost = EXCLUDED.order_cost,
+    holding_rate = EXCLUDED.holding_rate,
+    service_level_z_score = EXCLUDED.service_level_z_score,
+    min_reorder_qty = EXCLUDED.min_reorder_qty,
+    default_reorder_qty = EXCLUDED.default_reorder_qty,
+    default_safety_stock = EXCLUDED.default_safety_stock;
+
 -- View to show thresholds with category names
 CREATE OR REPLACE VIEW stock_thresholds_view AS
 SELECT 
--- a/inventory-server/db/metrics-schema.sql
+++ b/inventory-server/db/metrics-schema.sql
@@ -11,15 +11,17 @@ CREATE TABLE temp_sales_metrics (
    avg_margin_percent DECIMAL(10,3),
    first_sale_date DATE,
    last_sale_date DATE,
+    stddev_daily_sales DECIMAL(10,3),
    PRIMARY KEY (pid)
 );

 CREATE TABLE temp_purchase_metrics (
    pid BIGINT NOT NULL,
-    avg_lead_time_days INTEGER,
+    avg_lead_time_days DECIMAL(10,2),
    last_purchase_date DATE,
    first_received_date DATE,
    last_received_date DATE,
+    stddev_lead_time_days DECIMAL(10,2),
    PRIMARY KEY (pid)
 );

@@ -50,7 +52,7 @@ CREATE TABLE product_metrics (
    gross_profit DECIMAL(10,3),
    gmroi DECIMAL(10,3),
    -- Purchase metrics
-    avg_lead_time_days INTEGER,
+    avg_lead_time_days DECIMAL(10,2),
    last_purchase_date DATE,
    first_received_date DATE,
    last_received_date DATE,
--- a/inventory-server/db/schema.sql
+++ b/inventory-server/db/schema.sql
@@ -7,7 +7,7 @@ BEGIN
    -- Check which table is being updated and use the appropriate column
    IF TG_TABLE_NAME = 'categories' THEN
        NEW.updated_at = CURRENT_TIMESTAMP;
-    ELSE
+    ELSIF TG_TABLE_NAME IN ('products', 'orders', 'purchase_orders') THEN
        NEW.updated = CURRENT_TIMESTAMP;
    END IF;
    RETURN NEW;
@@ -91,6 +91,7 @@ CREATE TABLE categories (
    description TEXT,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    status VARCHAR(20) DEFAULT 'active',
    FOREIGN KEY (parent_id) REFERENCES categories(cat_id)
 );
--- a/inventory-server/scripts/calculate-metrics.js
+++ b/inventory-server/scripts/calculate-metrics.js
@@ -57,25 +57,16 @@ const TEMP_TABLES = [
    'temp_daily_sales',
    'temp_product_stats',
    'temp_category_sales',
-    'temp_category_stats'
+    'temp_category_stats',
+    'temp_beginning_inventory',
+    'temp_monthly_inventory'
 ];

 // Add cleanup function for temporary tables
 async function cleanupTemporaryTables(connection) {
-    // List of possible temporary tables that might exist
-    const tempTables = [
-        'temp_sales_metrics',
-        'temp_purchase_metrics',
-        'temp_forecast_dates',
-        'temp_daily_sales',
-        'temp_product_stats',
-        'temp_category_sales',
-        'temp_category_stats'
-    ];
-    
    try {
        // Drop each temporary table if it exists
-        for (const table of tempTables) {
+        for (const table of TEMP_TABLES) {
            await connection.query(`DROP TABLE IF EXISTS ${table}`);
        }
    } catch (err) {
@@ -534,7 +525,7 @@ async function calculateMetrics() {
                await connection.query(`
                    UPDATE calculate_history 
                    SET 
-                        status = 'error',
+                        status = 'failed',
                        end_time = NOW(),
                        duration_seconds = EXTRACT(EPOCH FROM (NOW() - start_time))::INTEGER,
                        error_message = $1
--- a/inventory-server/scripts/import-from-prod.js
+++ b/inventory-server/scripts/import-from-prod.js
@@ -10,9 +10,9 @@ const importPurchaseOrders = require('./import/purchase-orders');
 dotenv.config({ path: path.join(__dirname, "../.env") });

 // Constants to control which imports run
-const IMPORT_CATEGORIES = false;
-const IMPORT_PRODUCTS = false;
-const IMPORT_ORDERS = false;
+const IMPORT_CATEGORIES = true;
+const IMPORT_PRODUCTS = true;
+const IMPORT_ORDERS = true;
 const IMPORT_PURCHASE_ORDERS = true;

 // Add flag for incremental updates
@@ -169,8 +169,8 @@ async function main() {
      if (isImportCancelled) throw new Error("Import cancelled");
      completedSteps++;
      console.log('Categories import result:', results.categories);
-      totalRecordsAdded += parseInt(results.categories?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.categories?.recordsUpdated || 0) || 0;
+      totalRecordsAdded += parseInt(results.categories?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.categories?.recordsUpdated || 0);
    }

    if (IMPORT_PRODUCTS) {
@@ -178,8 +178,8 @@ async function main() {
      if (isImportCancelled) throw new Error("Import cancelled");
      completedSteps++;
      console.log('Products import result:', results.products);
-      totalRecordsAdded += parseInt(results.products?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.products?.recordsUpdated || 0) || 0;
+      totalRecordsAdded += parseInt(results.products?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.products?.recordsUpdated || 0);
    }

    if (IMPORT_ORDERS) {
@@ -187,8 +187,8 @@ async function main() {
      if (isImportCancelled) throw new Error("Import cancelled");
      completedSteps++;
      console.log('Orders import result:', results.orders);
-      totalRecordsAdded += parseInt(results.orders?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.orders?.recordsUpdated || 0) || 0;
+      totalRecordsAdded += parseInt(results.orders?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.orders?.recordsUpdated || 0);
    }

    if (IMPORT_PURCHASE_ORDERS) {
@@ -202,8 +202,8 @@ async function main() {
        if (results.purchaseOrders?.status === 'error') {
          console.error('Purchase orders import had an error:', results.purchaseOrders.error);
        } else {
-          totalRecordsAdded += parseInt(results.purchaseOrders?.recordsAdded || 0) || 0;
-          totalRecordsUpdated += parseInt(results.purchaseOrders?.recordsUpdated || 0) || 0;
+          totalRecordsAdded += parseInt(results.purchaseOrders?.recordsAdded || 0);
+          totalRecordsUpdated += parseInt(results.purchaseOrders?.recordsUpdated || 0);
        }
      } catch (error) {
        console.error('Error during purchase orders import:', error);
@@ -242,8 +242,8 @@ async function main() {
      WHERE id = $12
    `, [
      totalElapsedSeconds,
-      parseInt(totalRecordsAdded) || 0,
-      parseInt(totalRecordsUpdated) || 0,
+      parseInt(totalRecordsAdded),
+      parseInt(totalRecordsUpdated),
      IMPORT_CATEGORIES,
      IMPORT_PRODUCTS,
      IMPORT_ORDERS,
--- a/inventory-server/scripts/import/categories.js
+++ b/inventory-server/scripts/import/categories.js
@@ -15,6 +15,9 @@ async function importCategories(prodConnection, localConnection) {
  try {
    // Start a single transaction for the entire import
    await localConnection.query('BEGIN');
+    
+    // Temporarily disable the trigger that's causing problems
+    await localConnection.query('ALTER TABLE categories DISABLE TRIGGER update_categories_updated_at');

    // Process each type in order with its own savepoint
    for (const type of typeOrder) {
@@ -149,6 +152,9 @@ async function importCategories(prodConnection, localConnection) {
      ON CONFLICT (table_name) DO UPDATE SET
        last_sync_timestamp = NOW()
    `);
+    
+    // Re-enable the trigger
+    await localConnection.query('ALTER TABLE categories ENABLE TRIGGER update_categories_updated_at');

    outputProgress({
      status: "complete",
@@ -178,6 +184,9 @@ async function importCategories(prodConnection, localConnection) {
    // Only rollback if we haven't committed yet
    try {
      await localConnection.query('ROLLBACK');
+      
+      // Make sure we re-enable the trigger even if there was an error
+      await localConnection.query('ALTER TABLE categories ENABLE TRIGGER update_categories_updated_at');
    } catch (rollbackError) {
      console.error("Error during rollback:", rollbackError);
    }
--- a/inventory-server/scripts/import/purchase-orders.js
+++ b/inventory-server/scripts/import/purchase-orders.js
@@ -590,7 +590,7 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
            ordered, po_cost_price, supplier_id, date_created, date_ordered
          )
          SELECT 
-            'R' || r.receiving_id as po_id,
+            r.receiving_id::text as po_id,
            r.pid,
            COALESCE(p.sku, 'NO-SKU') as sku,
            COALESCE(p.name, 'Unknown Product') as name,
@@ -626,7 +626,7 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
            po_id, pid, receiving_id, allocated_qty, cost_each, received_date, received_by
          )
          SELECT 
-            'R' || r.receiving_id as po_id,
+            r.receiving_id::text as po_id,
            r.pid,
            r.receiving_id,
            r.qty_each as allocated_qty,
--- a/inventory-server/scripts/metrics/financial-metrics.js
+++ b/inventory-server/scripts/metrics/financial-metrics.js
@@ -56,36 +56,94 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
            }
        });

-        // Calculate financial metrics with optimized query
+        // First, calculate beginning inventory values (12 months ago)
+        await connection.query(`
+            CREATE TEMPORARY TABLE IF NOT EXISTS temp_beginning_inventory AS
+            WITH beginning_inventory_calc AS (
+                SELECT 
+                    p.pid,
+                    p.stock_quantity as current_quantity,
+                    COALESCE(SUM(o.quantity), 0) as sold_quantity,
+                    COALESCE(SUM(po.received), 0) as received_quantity,
+                    GREATEST(0, (p.stock_quantity + COALESCE(SUM(o.quantity), 0) - COALESCE(SUM(po.received), 0))) as beginning_quantity,
+                    p.cost_price
+                FROM 
+                    products p
+                LEFT JOIN 
+                    orders o ON p.pid = o.pid 
+                    AND o.canceled = false 
+                    AND o.date >= CURRENT_DATE - INTERVAL '12 months'::interval
+                LEFT JOIN 
+                    purchase_orders po ON p.pid = po.pid 
+                    AND po.received_date IS NOT NULL 
+                    AND po.received_date >= CURRENT_DATE - INTERVAL '12 months'::interval
+                GROUP BY 
+                    p.pid, p.stock_quantity, p.cost_price
+            )
+            SELECT 
+                pid,
+                beginning_quantity,
+                beginning_quantity * cost_price as beginning_value,
+                current_quantity * cost_price as current_value,
+                ((beginning_quantity * cost_price) + (current_quantity * cost_price)) / 2 as average_inventory_value
+            FROM 
+                beginning_inventory_calc
+        `);
+
+        processedCount = Math.floor(totalProducts * 0.60);
+        outputProgress({
+            status: 'running',
+            operation: 'Beginning inventory values calculated, computing financial metrics',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
+            timing: {
+                start_time: new Date(startTime).toISOString(),
+                end_time: new Date().toISOString(),
+                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+            }
+        });
+
+        // Calculate financial metrics with optimized query and standard formulas
        await connection.query(`
            WITH product_financials AS (
                SELECT 
                    p.pid,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    SUM(o.quantity * p.cost_price) as cost_of_goods_sold,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
+                    COALESCE(bi.average_inventory_value, p.cost_price * p.stock_quantity) as avg_inventory_value,
+                    p.cost_price * p.stock_quantity as current_inventory_value,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0))) as total_revenue,
+                    SUM(o.quantity * COALESCE(o.costeach, 0)) as cost_of_goods_sold,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0) - COALESCE(o.costeach, 0))) as gross_profit,
                    MIN(o.date) as first_sale_date,
                    MAX(o.date) as last_sale_date,
                    EXTRACT(DAY FROM (MAX(o.date)::timestamp with time zone - MIN(o.date)::timestamp with time zone)) + 1 as calculation_period_days,
                    COUNT(DISTINCT DATE(o.date)) as active_days
                FROM products p
                LEFT JOIN orders o ON p.pid = o.pid
+                LEFT JOIN temp_beginning_inventory bi ON p.pid = bi.pid
                WHERE o.canceled = false
-                    AND DATE(o.date) >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.pid, p.cost_price, p.stock_quantity
+                    AND DATE(o.date) >= CURRENT_DATE - INTERVAL '12 months'::interval
+                GROUP BY p.pid, p.cost_price, p.stock_quantity, bi.average_inventory_value
            )
            UPDATE product_metrics pm
            SET 
-                inventory_value = COALESCE(pf.inventory_value, 0),
-                total_revenue = COALESCE(pf.total_revenue, 0),
-                cost_of_goods_sold = COALESCE(pf.cost_of_goods_sold, 0),
-                gross_profit = COALESCE(pf.gross_profit, 0),
-                gmroi = CASE 
-                    WHEN COALESCE(pf.inventory_value, 0) > 0 AND pf.active_days > 0 THEN 
-                        (COALESCE(pf.gross_profit, 0) * (365.0 / pf.active_days)) / COALESCE(pf.inventory_value, 0)
+                inventory_value = COALESCE(pf.current_inventory_value, 0)::decimal(10,3),
+                total_revenue = COALESCE(pf.total_revenue, 0)::decimal(10,3),
+                cost_of_goods_sold = COALESCE(pf.cost_of_goods_sold, 0)::decimal(10,3),
+                gross_profit = COALESCE(pf.gross_profit, 0)::decimal(10,3),
+                turnover_rate = CASE 
+                    WHEN COALESCE(pf.avg_inventory_value, 0) > 0 THEN 
+                        COALESCE(pf.cost_of_goods_sold, 0) / NULLIF(pf.avg_inventory_value, 0)
                    ELSE 0 
-                END,
+                END::decimal(12,3),
+                gmroi = CASE 
+                    WHEN COALESCE(pf.avg_inventory_value, 0) > 0 THEN 
+                        COALESCE(pf.gross_profit, 0) / NULLIF(pf.avg_inventory_value, 0)
+                    ELSE 0 
+                END::decimal(10,3),
                last_calculated_at = CURRENT_TIMESTAMP
            FROM product_financials pf
            WHERE pm.pid = pf.pid
@@ -115,53 +173,8 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
            success
        };

-        // Update time-based aggregates with optimized query
-        await connection.query(`
-            WITH monthly_financials AS (
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
-                    COUNT(DISTINCT DATE(o.date)) as active_days,
-                    MIN(o.date) as period_start,
-                    MAX(o.date) as period_end
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
-            )
-            UPDATE product_time_aggregates pta
-            SET 
-                inventory_value = COALESCE(mf.inventory_value, 0),
-                gmroi = CASE 
-                    WHEN COALESCE(mf.inventory_value, 0) > 0 AND mf.active_days > 0 THEN 
-                        (COALESCE(mf.gross_profit, 0) * (365.0 / mf.active_days)) / COALESCE(mf.inventory_value, 0)
-                    ELSE 0 
-                END
-            FROM monthly_financials mf
-            WHERE pta.pid = mf.pid 
-                AND pta.year = mf.year 
-                AND pta.month = mf.month
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.70);
-        outputProgress({
-            status: 'running',
-            operation: 'Time-based aggregates updated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
+        // Clean up temporary tables
+        await connection.query('DROP TABLE IF EXISTS temp_beginning_inventory');

        // If we get here, everything completed successfully
        success = true;
@@ -187,6 +200,12 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
        throw error;
    } finally {
        if (connection) {
+            try {
+                // Make sure temporary tables are always cleaned up
+                await connection.query('DROP TABLE IF EXISTS temp_beginning_inventory');
+            } catch (err) {
+                console.error('Error cleaning up temp tables:', err);
+            }
            connection.release();
        }
    }
--- a/inventory-server/scripts/metrics/product-metrics.js
+++ b/inventory-server/scripts/metrics/product-metrics.js
@@ -66,8 +66,36 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
            WHERE category_id IS NULL AND vendor IS NULL
            LIMIT 1
        `);
+        
+        // Check if threshold data was returned
+        if (!thresholds.rows || thresholds.rows.length === 0) {
+            console.warn('No default thresholds found in the database. Using explicit type casting in the query.');
+        }
+        
        const defaultThresholds = thresholds.rows[0];

+        // Get financial calculation configuration parameters
+        const financialConfig = await connection.query(`
+            SELECT 
+                order_cost, 
+                holding_rate, 
+                service_level_z_score,
+                min_reorder_qty,
+                default_reorder_qty,
+                default_safety_stock
+            FROM financial_calc_config 
+            WHERE id = 1
+            LIMIT 1
+        `);
+        const finConfig = financialConfig.rows[0] || { 
+            order_cost: 25.00, 
+            holding_rate: 0.25, 
+            service_level_z_score: 1.96,
+            min_reorder_qty: 1,
+            default_reorder_qty: 5,
+            default_safety_stock: 5
+        };
+
        // Calculate base product metrics
        if (!SKIP_PRODUCT_BASE_METRICS) {
            outputProgress({
@@ -109,6 +137,7 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                    avg_margin_percent DECIMAL(10,3),
                    first_sale_date DATE,
                    last_sale_date DATE,
+                    stddev_daily_sales DECIMAL(10,3),
                    PRIMARY KEY (pid)
                )
            `);
@@ -117,10 +146,11 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
            await connection.query(`
                CREATE TEMPORARY TABLE temp_purchase_metrics (
                    pid BIGINT NOT NULL,
-                    avg_lead_time_days DOUBLE PRECISION,
+                    avg_lead_time_days DECIMAL(10,2),
                    last_purchase_date DATE,
                    first_received_date DATE,
                    last_received_date DATE,
+                    stddev_lead_time_days DECIMAL(10,2),
                    PRIMARY KEY (pid)
                )
            `);
@@ -140,11 +170,22 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        ELSE 0 
                    END as avg_margin_percent,
                    MIN(o.date) as first_sale_date,
-                    MAX(o.date) as last_sale_date
+                    MAX(o.date) as last_sale_date,
+                    COALESCE(STDDEV_SAMP(daily_qty.quantity), 0) as stddev_daily_sales
                FROM products p
                LEFT JOIN orders o ON p.pid = o.pid 
                    AND o.canceled = false
                    AND o.date >= CURRENT_DATE - INTERVAL '90 days'
+                LEFT JOIN (
+                    SELECT 
+                        pid, 
+                        DATE(date) as sale_date, 
+                        SUM(quantity) as quantity
+                    FROM orders
+                    WHERE canceled = false
+                    AND date >= CURRENT_DATE - INTERVAL '90 days'
+                    GROUP BY pid, DATE(date)
+                ) daily_qty ON p.pid = daily_qty.pid
                GROUP BY p.pid
            `);

@@ -163,7 +204,14 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        ) as avg_lead_time_days,
                        MAX(po.date) as last_purchase_date,
                        MIN(po.received_date) as first_received_date,
-                        MAX(po.received_date) as last_received_date
+                        MAX(po.received_date) as last_received_date,
+                        STDDEV_SAMP(
+                            CASE 
+                                WHEN po.received_date IS NOT NULL AND po.date IS NOT NULL 
+                                THEN EXTRACT(EPOCH FROM (po.received_date::timestamp with time zone - po.date::timestamp with time zone)) / 86400.0
+                                ELSE NULL
+                            END
+                        ) as stddev_lead_time_days
                    FROM products p
                    LEFT JOIN purchase_orders po ON p.pid = po.pid 
                        AND po.received_date IS NOT NULL
@@ -184,7 +232,8 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        30.0 as avg_lead_time_days,
                        NULL as last_purchase_date,
                        NULL as first_received_date,
-                        NULL as last_received_date
+                        NULL as last_received_date,
+                        0.0 as stddev_lead_time_days
                    FROM products p
                    LEFT JOIN temp_purchase_metrics tpm ON p.pid = tpm.pid
                    WHERE tpm.pid IS NULL
@@ -208,6 +257,17 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                if (batch.rows.length === 0) break;

                // Process the entire batch in a single efficient query
+                const lowStockThreshold = parseInt(defaultThresholds?.low_stock_threshold) || 5;
+                const criticalDays = parseInt(defaultThresholds?.critical_days) || 7;
+                const reorderDays = parseInt(defaultThresholds?.reorder_days) || 14;
+                const overstockDays = parseInt(defaultThresholds?.overstock_days) || 90;
+                const serviceLevel = parseFloat(finConfig?.service_level_z_score) || 1.96;
+                const defaultSafetyStock = parseInt(finConfig?.default_safety_stock) || 5;
+                const defaultReorderQty = parseInt(finConfig?.default_reorder_qty) || 5;
+                const orderCost = parseFloat(finConfig?.order_cost) || 25.00;
+                const holdingRate = parseFloat(finConfig?.holding_rate) || 0.25;
+                const minReorderQty = parseInt(finConfig?.min_reorder_qty) || 1;
+
                await connection.query(`
                    UPDATE product_metrics pm
                    SET 
@@ -219,7 +279,7 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        avg_margin_percent = COALESCE(sm.avg_margin_percent, 0),
                        first_sale_date = sm.first_sale_date,
                        last_sale_date = sm.last_sale_date,
-                        avg_lead_time_days = COALESCE(lm.avg_lead_time_days, 30),
+                        avg_lead_time_days = COALESCE(lm.avg_lead_time_days, 30.0),
                        days_of_inventory = CASE 
                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 
                            THEN FLOOR(p.stock_quantity / NULLIF(sm.daily_sales_avg, 0))
@@ -232,57 +292,61 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        END,
                        stock_status = CASE
                            WHEN p.stock_quantity <= 0 THEN 'Out of Stock'
-                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 AND p.stock_quantity <= $1 THEN 'Low Stock'
+                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 AND p.stock_quantity <= ${lowStockThreshold} THEN 'Low Stock'
                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 THEN 'In Stock'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= $2 THEN 'Critical'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= $3 THEN 'Reorder'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > $4 THEN 'Overstocked'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ${criticalDays} THEN 'Critical'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ${reorderDays} THEN 'Reorder'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ${overstockDays} THEN 'Overstocked'
                            ELSE 'Healthy'
                        END,
                        safety_stock = CASE
-                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
-                                CEIL(sm.daily_sales_avg * SQRT(ABS(COALESCE(lm.avg_lead_time_days, 30))) * 1.96)
-                            ELSE $5
+                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 AND COALESCE(lm.avg_lead_time_days, 0) > 0 THEN
+                                CEIL(
+                                    ${serviceLevel} * SQRT(
+                                        GREATEST(0, COALESCE(lm.avg_lead_time_days, 0)) * POWER(COALESCE(sm.stddev_daily_sales, 0), 2) +
+                                        POWER(COALESCE(sm.daily_sales_avg, 0), 2) * POWER(COALESCE(lm.stddev_lead_time_days, 0), 2)
+                                    )
+                                )
+                            ELSE ${defaultSafetyStock}
                        END,
                        reorder_point = CASE
                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
-                                CEIL(sm.daily_sales_avg * COALESCE(lm.avg_lead_time_days, 30)) + 
-                                CEIL(sm.daily_sales_avg * SQRT(ABS(COALESCE(lm.avg_lead_time_days, 30))) * 1.96)
-                            ELSE $6
+                                CEIL(sm.daily_sales_avg * GREATEST(0, COALESCE(lm.avg_lead_time_days, 30.0))) + 
+                                (CASE
+                                    WHEN COALESCE(sm.daily_sales_avg, 0) > 0 AND COALESCE(lm.avg_lead_time_days, 0) > 0 THEN
+                                        CEIL(
+                                            ${serviceLevel} * SQRT(
+                                                GREATEST(0, COALESCE(lm.avg_lead_time_days, 0)) * POWER(COALESCE(sm.stddev_daily_sales, 0), 2) +
+                                                POWER(COALESCE(sm.daily_sales_avg, 0), 2) * POWER(COALESCE(lm.stddev_lead_time_days, 0), 2)
+                                            )
+                                        )
+                                    ELSE ${defaultSafetyStock}
+                                END)
+                            ELSE ${lowStockThreshold}
                        END,
                        reorder_qty = CASE
                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 AND NULLIF(p.cost_price, 0) IS NOT NULL AND NULLIF(p.cost_price, 0) > 0 THEN
                                GREATEST(
-                                    CEIL(SQRT(ABS((2 * (sm.daily_sales_avg * 365) * 25) / (NULLIF(p.cost_price, 0) * 0.25)))),
-                                    $7
+                                    CEIL(SQRT(
+                                        (2 * (sm.daily_sales_avg * 365) * ${orderCost}) / 
+                                        NULLIF(p.cost_price * ${holdingRate}, 0) 
+                                    )),
+                                    ${minReorderQty}
                                )
-                            ELSE $8
+                            ELSE ${defaultReorderQty}
                        END,
                        overstocked_amt = CASE
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > $9 
-                            THEN GREATEST(0, p.stock_quantity - CEIL(sm.daily_sales_avg * $10))
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ${overstockDays} 
+                            THEN GREATEST(0, p.stock_quantity - CEIL(sm.daily_sales_avg * ${overstockDays}))
                            ELSE 0
                        END,
                        last_calculated_at = NOW()
                    FROM products p
                    LEFT JOIN temp_sales_metrics sm ON p.pid = sm.pid
                    LEFT JOIN temp_purchase_metrics lm ON p.pid = lm.pid
-                    WHERE p.pid = ANY($11::bigint[])
+                    WHERE p.pid = ANY($1::BIGINT[])
                    AND pm.pid = p.pid
-                `,
-                [
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.critical_days,
-                    defaultThresholds.reorder_days,
-                    defaultThresholds.overstock_days,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.overstock_days,
-                    defaultThresholds.overstock_days,
-                    batch.rows.map(row => row.pid)
-                ]);
+                `, [batch.rows.map(row => row.pid)]);

                lastPid = batch.rows[batch.rows.length - 1].pid;
                processedCount += batch.rows.length;
@@ -311,25 +375,22 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
        }

        // Calculate forecast accuracy and bias in batches
-        lastPid = 0;
+        let forecastPid = 0;
        while (true) {
            if (isCancelled) break;

-            const batch = await connection.query(
+            const forecastBatch = await connection.query(
                'SELECT pid FROM products WHERE pid > $1 ORDER BY pid LIMIT $2',
-                [lastPid, BATCH_SIZE]
+                [forecastPid, BATCH_SIZE]
            );

-            if (batch.rows.length === 0) break;
+            if (forecastBatch.rows.length === 0) break;

+            const forecastPidArray = forecastBatch.rows.map(row => row.pid);
+
+            // Use array_to_string to convert the array to a string of comma-separated values
            await connection.query(`
-                UPDATE product_metrics pm
-                SET 
-                    forecast_accuracy = GREATEST(0, 100 - LEAST(fa.avg_forecast_error, 100)),
-                    forecast_bias = GREATEST(-100, LEAST(fa.avg_forecast_bias, 100)),
-                    last_forecast_date = fa.last_forecast_date,
-                    last_calculated_at = NOW()
-                FROM (
+                WITH forecast_metrics AS (
                    SELECT 
                        sf.pid,
                        AVG(CASE 
@@ -348,13 +409,20 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                        AND DATE(o.date) = sf.forecast_date
                    WHERE o.canceled = false
                        AND sf.forecast_date >= CURRENT_DATE - INTERVAL '90 days'
-                        AND sf.pid = ANY($1::bigint[])
+                        AND sf.pid = ANY('{${forecastPidArray.join(',')}}'::BIGINT[])
                    GROUP BY sf.pid
-                ) fa
-                WHERE pm.pid = fa.pid
-            `, [batch.rows.map(row => row.pid)]);
+                )
+                UPDATE product_metrics pm
+                SET 
+                    forecast_accuracy = GREATEST(0, 100 - LEAST(fm.avg_forecast_error, 100)),
+                    forecast_bias = GREATEST(-100, LEAST(fm.avg_forecast_bias, 100)),
+                    last_forecast_date = fm.last_forecast_date,
+                    last_calculated_at = NOW()
+                FROM forecast_metrics fm
+                WHERE pm.pid = fm.pid
+            `);

-            lastPid = batch.rows[batch.rows.length - 1].pid;
+            forecastPid = forecastBatch.rows[forecastBatch.rows.length - 1].pid;
        }

        // Calculate product time aggregates
@@ -375,61 +443,12 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                }
            });

-            // Calculate time-based aggregates
-            await connection.query(`
-                INSERT INTO product_time_aggregates (
-                    pid,
-                    year,
-                    month,
-                    total_quantity_sold,
-                    total_revenue,
-                    total_cost,
-                    order_count,
-                    avg_price,
-                    profit_margin,
-                    inventory_value,
-                    gmroi
-                )
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    SUM(o.quantity) as total_quantity_sold,
-                    SUM(o.price * o.quantity) as total_revenue,
-                    SUM(p.cost_price * o.quantity) as total_cost,
-                    COUNT(DISTINCT o.order_number) as order_count,
-                    AVG(o.price) as avg_price,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 
-                        THEN ((SUM(o.quantity * o.price) - SUM(o.quantity * p.cost_price)) / SUM(o.quantity * o.price)) * 100
-                        ELSE 0 
-                    END as profit_margin,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    CASE 
-                        WHEN p.cost_price * p.stock_quantity > 0 
-                        THEN (SUM(o.quantity * (o.price - p.cost_price))) / (p.cost_price * p.stock_quantity)
-                        ELSE 0 
-                    END as gmroi
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
-                WHERE o.date >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
-                ON CONFLICT (pid, year, month) DO UPDATE
-                SET
-                    total_quantity_sold = EXCLUDED.total_quantity_sold,
-                    total_revenue = EXCLUDED.total_revenue,
-                    total_cost = EXCLUDED.total_cost,
-                    order_count = EXCLUDED.order_count,
-                    avg_price = EXCLUDED.avg_price,
-                    profit_margin = EXCLUDED.profit_margin,
-                    inventory_value = EXCLUDED.inventory_value,
-                    gmroi = EXCLUDED.gmroi
-            `);
-
+            // Note: The time-aggregates calculation has been moved to time-aggregates.js
+            // This module will not duplicate that functionality
            processedCount = Math.floor(totalProducts * 0.6);
            outputProgress({
                status: 'running',
-                operation: 'Product time aggregates calculated',
+                operation: 'Product time aggregates calculation delegated to time-aggregates module',
                current: processedCount || 0,
                total: totalProducts || 0,
                elapsed: formatElapsedTime(startTime),
@@ -487,6 +506,10 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount

        const abcConfig = await connection.query('SELECT a_threshold, b_threshold FROM abc_classification_config WHERE id = 1');
        const abcThresholds = abcConfig.rows[0] || { a_threshold: 20, b_threshold: 50 };
+        
+        // Extract values and ensure they are valid numbers
+        const aThreshold = parseFloat(abcThresholds.a_threshold) || 20;
+        const bThreshold = parseFloat(abcThresholds.b_threshold) || 50;

        // First, create and populate the rankings table with an index
        await connection.query('DROP TABLE IF EXISTS temp_revenue_ranks');
@@ -557,13 +580,13 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                    OR pm.abc_class != 
                        CASE 
                            WHEN tr.pid IS NULL THEN 'C'
-                            WHEN tr.percentile <= $2 THEN 'A'
-                            WHEN tr.percentile <= $3 THEN 'B'
+                            WHEN tr.percentile <= ${aThreshold} THEN 'A'
+                            WHEN tr.percentile <= ${bThreshold} THEN 'B'
                            ELSE 'C'
                        END)
                ORDER BY pm.pid
-                LIMIT $4
-            `, [abcProcessedCount, abcThresholds.a_threshold, abcThresholds.b_threshold, batchSize]);
+                LIMIT $2
+            `, [abcProcessedCount, batchSize]);

            if (pids.rows.length === 0) break;

@@ -574,15 +597,15 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                SET abc_class = 
                    CASE 
                        WHEN tr.pid IS NULL THEN 'C'
-                        WHEN tr.percentile <= $1 THEN 'A'
-                        WHEN tr.percentile <= $2 THEN 'B'
+                        WHEN tr.percentile <= ${aThreshold} THEN 'A'
+                        WHEN tr.percentile <= ${bThreshold} THEN 'B'
                        ELSE 'C'
                    END,
                    last_calculated_at = NOW()
                FROM (SELECT pid, percentile FROM temp_revenue_ranks) tr
-                WHERE pm.pid = tr.pid AND pm.pid = ANY($3::bigint[])
-                OR (pm.pid = ANY($3::bigint[]) AND tr.pid IS NULL)
-            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, pidValues]);
+                WHERE pm.pid = tr.pid AND pm.pid = ANY($1::BIGINT[])
+                OR (pm.pid = ANY($1::BIGINT[]) AND tr.pid IS NULL)
+            `, [pidValues]);

            // Now update turnover rate with proper handling of zero inventory periods
            await connection.query(`
@@ -610,7 +633,7 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                    JOIN products p ON o.pid = p.pid
                    WHERE o.canceled = false 
                    AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-                    AND o.pid = ANY($1::bigint[])
+                    AND o.pid = ANY($1::BIGINT[])
                    GROUP BY o.pid
                ) sales
                WHERE pm.pid = sales.pid
@@ -707,40 +730,7 @@ function calculateStockStatus(stock, config, daily_sales_avg, weekly_sales_avg,
    return 'Healthy';
 }

-function calculateReorderQuantities(stock, stock_status, daily_sales_avg, avg_lead_time, config) {
-    // Calculate safety stock based on service level and lead time
-    const z_score = 1.96; // 95% service level
-    const lead_time = avg_lead_time || config.target_days;
-    const safety_stock = Math.ceil(daily_sales_avg * Math.sqrt(lead_time) * z_score);
-
-    // Calculate reorder point
-    const lead_time_demand = daily_sales_avg * lead_time;
-    const reorder_point = Math.ceil(lead_time_demand + safety_stock);
-
-    // Calculate reorder quantity using EOQ formula if we have the necessary data
-    let reorder_qty = 0;
-    if (daily_sales_avg > 0) {
-        const annual_demand = daily_sales_avg * 365;
-        const order_cost = 25; // Fixed cost per order
-        const holding_cost = config.cost_price * 0.25; // 25% of unit cost as annual holding cost
-        
-        reorder_qty = Math.ceil(Math.sqrt((2 * annual_demand * order_cost) / holding_cost));
-    } else {
-        // If no sales data, use a basic calculation
-        reorder_qty = Math.max(safety_stock, config.low_stock_threshold);
-    }
-
-    // Calculate overstocked amount
-    const overstocked_amt = stock_status === 'Overstocked' ? 
-        stock - Math.ceil(daily_sales_avg * config.overstock_days) : 
-        0;
-
-    return {
-        safety_stock,
-        reorder_point,
-        reorder_qty,
-        overstocked_amt
-    };
-}
+// Note: calculateReorderQuantities function has been removed as its logic has been incorporated 
+// in the main SQL query with configurable parameters

 module.exports = calculateProductMetrics; 
--- a/inventory-server/scripts/metrics/sales-forecasts.js
+++ b/inventory-server/scripts/metrics/sales-forecasts.js
@@ -216,13 +216,7 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount
                GREATEST(0, 
                    ROUND(
                        ds.avg_daily_qty * 
-                        (1 + COALESCE(sf.seasonality_factor, 0)) *
-                        CASE
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 1.5 THEN 0.85
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 1.0 THEN 0.9
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 0.5 THEN 0.95
-                            ELSE 1.0
-                        END
+                        (1 + COALESCE(sf.seasonality_factor, 0))
                    )
                ) as forecast_quantity,
                CASE
@@ -336,8 +330,8 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount
                cs.cat_id::bigint as category_id,
                fd.forecast_date,
                GREATEST(0, 
-                    AVG(cs.daily_quantity) * 
-                    (1 + COALESCE(sf.seasonality_factor, 0))
+                    ROUND(AVG(cs.daily_quantity) * 
+                    (1 + COALESCE(sf.seasonality_factor, 0)))
                ) as forecast_units,
                GREATEST(0, 
                    COALESCE(
@@ -345,8 +339,7 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount
                            WHEN SUM(cs.day_count) >= 4 THEN AVG(cs.daily_revenue)
                            ELSE ct.overall_avg_revenue
                        END * 
-                        (1 + COALESCE(sf.seasonality_factor, 0)) *
-                        (0.95 + (random() * 0.1)),
+                        (1 + COALESCE(sf.seasonality_factor, 0)),
                        0
                    )
                ) as forecast_revenue,
@@ -427,6 +420,18 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount
        throw error;
    } finally {
        if (connection) {
+            try {
+                // Ensure temporary tables are cleaned up
+                await connection.query(`
+                    DROP TABLE IF EXISTS temp_forecast_dates;
+                    DROP TABLE IF EXISTS temp_daily_sales;
+                    DROP TABLE IF EXISTS temp_product_stats;
+                    DROP TABLE IF EXISTS temp_category_sales;
+                    DROP TABLE IF EXISTS temp_category_stats;
+                `);
+            } catch (err) {
+                console.error('Error cleaning up temporary tables:', err);
+            }
            connection.release();
        }
    }
--- a/inventory-server/scripts/metrics/time-aggregates.js
+++ b/inventory-server/scripts/metrics/time-aggregates.js
@@ -55,6 +55,93 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
            }
        });

+        // Create a temporary table for end-of-month inventory values
+        await connection.query(`
+            CREATE TEMPORARY TABLE IF NOT EXISTS temp_monthly_inventory AS
+            WITH months AS (
+                -- Generate all year/month combinations for the last 12 months
+                SELECT 
+                    EXTRACT(YEAR FROM month_date)::INTEGER as year,
+                    EXTRACT(MONTH FROM month_date)::INTEGER as month,
+                    month_date as start_date,
+                    (month_date + INTERVAL '1 month'::interval - INTERVAL '1 day'::interval)::DATE as end_date
+                FROM (
+                    SELECT generate_series(
+                        DATE_TRUNC('month', CURRENT_DATE - INTERVAL '12 months'::interval)::DATE,
+                        DATE_TRUNC('month', CURRENT_DATE)::DATE,
+                        INTERVAL '1 month'::interval
+                    ) as month_date
+                ) dates
+            ),
+            monthly_inventory_calc AS (
+                SELECT 
+                    p.pid,
+                    m.year,
+                    m.month,
+                    m.end_date,
+                    p.stock_quantity as current_quantity,
+                    -- Calculate sold during period (before end_date)
+                    COALESCE(SUM(
+                        CASE 
+                            WHEN o.date <= m.end_date THEN o.quantity 
+                            ELSE 0 
+                        END
+                    ), 0) as sold_after_end_date,
+                    -- Calculate received during period (before end_date)
+                    COALESCE(SUM(
+                        CASE 
+                            WHEN po.received_date <= m.end_date THEN po.received 
+                            ELSE 0 
+                        END
+                    ), 0) as received_after_end_date,
+                    p.cost_price
+                FROM 
+                    products p
+                CROSS JOIN 
+                    months m
+                LEFT JOIN 
+                    orders o ON p.pid = o.pid 
+                    AND o.canceled = false 
+                    AND o.date > m.end_date
+                    AND o.date <= CURRENT_DATE
+                LEFT JOIN 
+                    purchase_orders po ON p.pid = po.pid 
+                    AND po.received_date IS NOT NULL 
+                    AND po.received_date > m.end_date
+                    AND po.received_date <= CURRENT_DATE
+                GROUP BY 
+                    p.pid, m.year, m.month, m.end_date, p.stock_quantity, p.cost_price
+            )
+            SELECT 
+                pid,
+                year,
+                month,
+                -- End of month quantity = current quantity - sold after + received after
+                GREATEST(0, current_quantity - sold_after_end_date + received_after_end_date) as end_of_month_quantity,
+                -- End of month inventory value
+                GREATEST(0, current_quantity - sold_after_end_date + received_after_end_date) * cost_price as end_of_month_value,
+                cost_price
+            FROM 
+                monthly_inventory_calc
+        `);
+
+        processedCount = Math.floor(totalProducts * 0.40);
+        outputProgress({
+            status: 'running',
+            operation: 'Monthly inventory values calculated, processing time aggregates',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
+            timing: {
+                start_time: new Date(startTime).toISOString(),
+                end_time: new Date().toISOString(),
+                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+            }
+        });
+
        // Initial insert of time-based aggregates
        await connection.query(`
            INSERT INTO product_time_aggregates (
@@ -75,76 +162,67 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
            WITH monthly_sales AS (
                SELECT 
                    o.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
+                    EXTRACT(YEAR FROM o.date::timestamp with time zone)::INTEGER as year,
+                    EXTRACT(MONTH FROM o.date::timestamp with time zone)::INTEGER as month,
                    SUM(o.quantity) as total_quantity_sold,
                    SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) as total_revenue,
-                    SUM(COALESCE(p.cost_price, 0) * o.quantity) as total_cost,
+                    SUM(COALESCE(o.costeach, 0) * o.quantity) as total_cost,
                    COUNT(DISTINCT o.order_number) as order_count,
                    AVG(o.price - COALESCE(o.discount, 0)) as avg_price,
                    CASE 
                        WHEN SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) > 0 
-                        THEN ((SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) - SUM(COALESCE(p.cost_price, 0) * o.quantity)) 
+                        THEN ((SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) - SUM(COALESCE(o.costeach, 0) * o.quantity)) 
                            / SUM((o.price - COALESCE(o.discount, 0)) * o.quantity)) * 100
                        ELSE 0 
                    END as profit_margin,
-                    p.cost_price * p.stock_quantity as inventory_value,
                    COUNT(DISTINCT DATE(o.date)) as active_days
                FROM orders o
                JOIN products p ON o.pid = p.pid
                WHERE o.canceled = false
-                GROUP BY o.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
+                GROUP BY o.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
            ),
            monthly_stock AS (
                SELECT 
                    pid,
-                    EXTRACT(YEAR FROM date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM date::timestamp with time zone) as month,
+                    EXTRACT(YEAR FROM date::timestamp with time zone)::INTEGER as year,
+                    EXTRACT(MONTH FROM date::timestamp with time zone)::INTEGER as month,
                    SUM(received) as stock_received,
                    SUM(ordered) as stock_ordered
                FROM purchase_orders
                GROUP BY pid, EXTRACT(YEAR FROM date::timestamp with time zone), EXTRACT(MONTH FROM date::timestamp with time zone)
-            ),
-            base_products AS (
-                SELECT 
-                    p.pid,
-                    p.cost_price * p.stock_quantity as inventory_value
-                FROM products p
            )
            SELECT 
-                COALESCE(s.pid, ms.pid) as pid,
-                COALESCE(s.year, ms.year) as year,
-                COALESCE(s.month, ms.month) as month,
-                COALESCE(s.total_quantity_sold, 0) as total_quantity_sold,
-                COALESCE(s.total_revenue, 0) as total_revenue,
-                COALESCE(s.total_cost, 0) as total_cost,
-                COALESCE(s.order_count, 0) as order_count,
-                COALESCE(ms.stock_received, 0) as stock_received,
-                COALESCE(ms.stock_ordered, 0) as stock_ordered,
-                COALESCE(s.avg_price, 0) as avg_price,
-                COALESCE(s.profit_margin, 0) as profit_margin,
-                COALESCE(s.inventory_value, bp.inventory_value, 0) as inventory_value,
+                COALESCE(s.pid, ms.pid, mi.pid) as pid,
+                COALESCE(s.year, ms.year, mi.year) as year,
+                COALESCE(s.month, ms.month, mi.month) as month,
+                COALESCE(s.total_quantity_sold, 0)::INTEGER as total_quantity_sold,
+                COALESCE(s.total_revenue, 0)::DECIMAL(10,3) as total_revenue,
+                COALESCE(s.total_cost, 0)::DECIMAL(10,3) as total_cost,
+                COALESCE(s.order_count, 0)::INTEGER as order_count,
+                COALESCE(ms.stock_received, 0)::INTEGER as stock_received,
+                COALESCE(ms.stock_ordered, 0)::INTEGER as stock_ordered,
+                COALESCE(s.avg_price, 0)::DECIMAL(10,3) as avg_price,
+                COALESCE(s.profit_margin, 0)::DECIMAL(10,3) as profit_margin,
+                COALESCE(mi.end_of_month_value, 0)::DECIMAL(10,3) as inventory_value,
                CASE 
-                    WHEN COALESCE(s.inventory_value, bp.inventory_value, 0) > 0 
-                        AND COALESCE(s.active_days, 0) > 0 
-                    THEN (COALESCE(s.total_revenue - s.total_cost, 0) * (365.0 / s.active_days)) 
-                        / COALESCE(s.inventory_value, bp.inventory_value)
+                    WHEN COALESCE(mi.end_of_month_value, 0) > 0 
+                    THEN (COALESCE(s.total_revenue, 0) - COALESCE(s.total_cost, 0)) 
+                        / NULLIF(COALESCE(mi.end_of_month_value, 0), 0)
                    ELSE 0 
-                END as gmroi
+                END::DECIMAL(10,3) as gmroi
            FROM (
                SELECT * FROM monthly_sales s
                UNION ALL
                SELECT 
-                    ms.pid,
-                    ms.year,
-                    ms.month,
+                    pid,
+                    year,
+                    month,
                    0 as total_quantity_sold,
                    0 as total_revenue,
                    0 as total_cost,
                    0 as order_count,
                    NULL as avg_price,
                    0 as profit_margin,
-                    NULL as inventory_value,
                    0 as active_days
                FROM monthly_stock ms
                WHERE NOT EXISTS (
@@ -153,50 +231,40 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
                    AND s2.year = ms.year
                    AND s2.month = ms.month
                )
+                UNION ALL
+                SELECT 
+                    pid,
+                    year,
+                    month,
+                    0 as total_quantity_sold,
+                    0 as total_revenue,
+                    0 as total_cost,
+                    0 as order_count,
+                    NULL as avg_price,
+                    0 as profit_margin,
+                    0 as active_days
+                FROM temp_monthly_inventory mi
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM monthly_sales s3
+                    WHERE s3.pid = mi.pid
+                    AND s3.year = mi.year
+                    AND s3.month = mi.month
+                )
+                AND NOT EXISTS (
+                    SELECT 1 FROM monthly_stock ms3
+                    WHERE ms3.pid = mi.pid
+                    AND ms3.year = mi.year
+                    AND ms3.month = mi.month
+                )
            ) s
            LEFT JOIN monthly_stock ms 
                ON s.pid = ms.pid 
                AND s.year = ms.year 
                AND s.month = ms.month
-            JOIN base_products bp ON COALESCE(s.pid, ms.pid) = bp.pid
-            UNION
-            SELECT 
-                ms.pid,
-                ms.year,
-                ms.month,
-                0 as total_quantity_sold,
-                0 as total_revenue,
-                0 as total_cost,
-                0 as order_count,
-                ms.stock_received,
-                ms.stock_ordered,
-                0 as avg_price,
-                0 as profit_margin,
-                bp.inventory_value,
-                0 as gmroi
-            FROM monthly_stock ms
-            JOIN base_products bp ON ms.pid = bp.pid
-            WHERE NOT EXISTS (
-                SELECT 1 FROM (
-                    SELECT * FROM monthly_sales
-                    UNION ALL
-                    SELECT 
-                        ms2.pid,
-                        ms2.year,
-                        ms2.month,
-                        0, 0, 0, 0, NULL, 0, NULL, 0
-                    FROM monthly_stock ms2
-                    WHERE NOT EXISTS (
-                        SELECT 1 FROM monthly_sales s2
-                        WHERE s2.pid = ms2.pid
-                        AND s2.year = ms2.year
-                        AND s2.month = ms2.month
-                    )
-                ) s
-                WHERE s.pid = ms.pid
-                AND s.year = ms.year
-                AND s.month = ms.month
-            )
+            LEFT JOIN temp_monthly_inventory mi
+                ON s.pid = mi.pid
+                AND s.year = mi.year
+                AND s.month = mi.month
            ON CONFLICT (pid, year, month) DO UPDATE
            SET
                total_quantity_sold = EXCLUDED.total_quantity_sold,
@@ -214,7 +282,7 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
        processedCount = Math.floor(totalProducts * 0.60);
        outputProgress({
            status: 'running',
-            operation: 'Base time aggregates calculated, updating financial metrics',
+            operation: 'Base time aggregates calculated',
            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
@@ -234,45 +302,9 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
            processedPurchaseOrders: 0,
            success
        };
-
-        // Update with financial metrics
-        await connection.query(`
-            UPDATE product_time_aggregates pta
-            SET inventory_value = COALESCE(fin.inventory_value, 0)
-            FROM (
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
-                    COUNT(DISTINCT DATE(o.date)) as active_days
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
-            ) fin
-            WHERE pta.pid = fin.pid 
-                AND pta.year = fin.year 
-                AND pta.month = fin.month
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.65);
-        outputProgress({
-            status: 'running',
-            operation: 'Financial metrics updated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
+        
+        // Clean up temporary tables
+        await connection.query('DROP TABLE IF EXISTS temp_monthly_inventory');

        // If we get here, everything completed successfully
        success = true;
@@ -298,6 +330,12 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount
        throw error;
    } finally {
        if (connection) {
+            try {
+                // Ensure temporary tables are cleaned up
+                await connection.query('DROP TABLE IF EXISTS temp_monthly_inventory');
+            } catch (err) {
+                console.error('Error cleaning up temporary tables:', err);
+            }
            connection.release();
        }
    }
--- a/inventory-server/scripts/reset-db.js
+++ b/inventory-server/scripts/reset-db.js
@@ -184,7 +184,7 @@ async function resetDatabase() {
            SELECT string_agg(tablename, ', ') as tables
            FROM pg_tables
            WHERE schemaname = 'public'
-            AND tablename NOT IN ('users', 'permissions', 'user_permissions', 'calculate_history', 'import_history', 'ai_prompts', 'ai_validation_performance', 'templates');
+            AND tablename NOT IN ('users', 'permissions', 'user_permissions', 'calculate_history', 'import_history', 'ai_prompts', 'ai_validation_performance', 'templates', 'reusable_images');
        `);

        if (!tablesResult.rows[0].tables) {
@@ -204,7 +204,7 @@ async function resetDatabase() {
            // Drop all tables except users
            const tables = tablesResult.rows[0].tables.split(', ');
            for (const table of tables) {
-                if (!['users'].includes(table)) {
+                if (!['users', 'reusable_images'].includes(table)) {
                    await client.query(`DROP TABLE IF EXISTS "${table}" CASCADE`);
                }
            }
--- a/inventory-server/scripts/reset-metrics.js
+++ b/inventory-server/scripts/reset-metrics.js
@@ -39,6 +39,19 @@ const METRICS_TABLES = [
    'vendor_details'
 ];

+// Tables to always protect from being dropped
+const PROTECTED_TABLES = [
+    'users', 
+    'permissions', 
+    'user_permissions', 
+    'calculate_history', 
+    'import_history', 
+    'ai_prompts', 
+    'ai_validation_performance', 
+    'templates', 
+    'reusable_images'
+];
+
 // Split SQL into individual statements
 function splitSQLStatements(sql) {
    sql = sql.replace(/\r\n/g, '\n');
@@ -109,7 +122,8 @@ async function resetMetrics() {
            FROM pg_tables 
            WHERE schemaname = 'public'
            AND tablename = ANY($1)
-        `, [METRICS_TABLES]);
+            AND tablename NOT IN (SELECT unnest($2::text[]))
+        `, [METRICS_TABLES, PROTECTED_TABLES]);

        outputProgress({
            operation: 'Initial state',
@@ -126,6 +140,15 @@ async function resetMetrics() {
        });

        for (const table of [...METRICS_TABLES].reverse()) {
+            // Skip protected tables
+            if (PROTECTED_TABLES.includes(table)) {
+                outputProgress({
+                    operation: 'Protected table',
+                    message: `Skipping protected table: ${table}`
+                });
+                continue;
+            }
+            
            try {
                // Use NOWAIT to avoid hanging if there's a lock
                await client.query(`DROP TABLE IF EXISTS "${table}" CASCADE`);
--- a/inventory-server/src/routes/csv.js
+++ b/inventory-server/src/routes/csv.js
@@ -779,10 +779,16 @@ router.get('/history/calculate', async (req, res) => {
                id,
                start_time,
                end_time,
+                duration_minutes,
                status,
                error_message,
-                modules_processed::integer,
-                total_modules::integer
+                total_products,
+                total_orders,
+                total_purchase_orders,
+                processed_products,
+                processed_orders,
+                processed_purchase_orders,
+                additional_info
            FROM calculate_history 
            ORDER BY start_time DESC 
            LIMIT 20
@@ -830,4 +836,58 @@ router.get('/status/tables', async (req, res) => {
    }
 });

+// GET /status/table-counts - Get record counts for all tables
+router.get('/status/table-counts', async (req, res) => {
+    try {
+        const pool = req.app.locals.pool;
+        const tables = [
+            // Core tables
+            'products', 'categories', 'product_categories', 'orders', 'purchase_orders',
+            // Metrics tables
+            'product_metrics', 'product_time_aggregates', 'vendor_metrics', 'category_metrics',
+            'vendor_time_metrics', 'category_time_metrics', 'category_sales_metrics',
+            'brand_metrics', 'brand_time_metrics', 'sales_forecasts', 'category_forecasts',
+            // Config tables
+            'stock_thresholds', 'lead_time_thresholds', 'sales_velocity_config',
+            'abc_classification_config', 'safety_stock_config', 'turnover_config',
+            'sales_seasonality', 'financial_calc_config'
+        ];
+
+        const counts = await Promise.all(
+            tables.map(table => 
+                pool.query(`SELECT COUNT(*) as count FROM ${table}`)
+                    .then(result => ({
+                        table_name: table,
+                        count: parseInt(result.rows[0].count)
+                    }))
+                    .catch(err => ({
+                        table_name: table,
+                        count: null,
+                        error: err.message
+                    }))
+            )
+        );
+
+        // Group tables by type
+        const groupedCounts = {
+            core: counts.filter(c => ['products', 'categories', 'product_categories', 'orders', 'purchase_orders'].includes(c.table_name)),
+            metrics: counts.filter(c => [
+                'product_metrics', 'product_time_aggregates', 'vendor_metrics', 'category_metrics',
+                'vendor_time_metrics', 'category_time_metrics', 'category_sales_metrics',
+                'brand_metrics', 'brand_time_metrics', 'sales_forecasts', 'category_forecasts'
+            ].includes(c.table_name)),
+            config: counts.filter(c => [
+                'stock_thresholds', 'lead_time_thresholds', 'sales_velocity_config',
+                'abc_classification_config', 'safety_stock_config', 'turnover_config',
+                'sales_seasonality', 'financial_calc_config'
+            ].includes(c.table_name))
+        };
+
+        res.json(groupedCounts);
+    } catch (error) {
+        console.error('Error fetching table counts:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
 module.exports = router; 
--- a/inventory-server/src/routes/import.js
+++ b/inventory-server/src/routes/import.js
@@ -8,7 +8,9 @@ const fs = require('fs');

 // Create uploads directory if it doesn't exist
 const uploadsDir = path.join('/var/www/html/inventory/uploads/products');
+const reusableUploadsDir = path.join('/var/www/html/inventory/uploads/reusable');
 fs.mkdirSync(uploadsDir, { recursive: true });
+fs.mkdirSync(reusableUploadsDir, { recursive: true });

 // Create a Map to track image upload times and their scheduled deletion
 const imageUploadMap = new Map();
@@ -35,6 +37,12 @@ const connectionCache = {

 // Function to schedule image deletion after 24 hours
 const scheduleImageDeletion = (filename, filePath) => {
+  // Only schedule deletion for images in the products folder
+  if (!filePath.includes('/uploads/products/')) {
+    console.log(`Skipping deletion for non-product image: ${filename}`);
+    return;
+  }
+
  // Delete any existing timeout for this file
  if (imageUploadMap.has(filename)) {
    clearTimeout(imageUploadMap.get(filename).timeoutId);
@@ -407,6 +415,14 @@ router.delete('/delete-image', (req, res) => {
      return res.status(404).json({ error: 'File not found' });
    }
    
+    // Only allow deletion of images in the products folder
+    if (!filePath.includes('/uploads/products/')) {
+      return res.status(403).json({ 
+        error: 'Cannot delete images outside the products folder',
+        message: 'This image is in a protected folder and cannot be deleted through this endpoint'
+      });
+    }
+    
    // Delete the file
    fs.unlinkSync(filePath);
    
@@ -641,11 +657,19 @@ router.get('/check-file/:filename', (req, res) => {
    return res.status(400).json({ error: 'Invalid filename' });
  }
  
-  const filePath = path.join(uploadsDir, filename);
+  // First check in products directory
+  let filePath = path.join(uploadsDir, filename);
+  let exists = fs.existsSync(filePath);
+  
+  // If not found in products, check in reusable directory
+  if (!exists) {
+    filePath = path.join(reusableUploadsDir, filename);
+    exists = fs.existsSync(filePath);
+  }
  
  try {
    // Check if file exists
-    if (!fs.existsSync(filePath)) {
+    if (!exists) {
      return res.status(404).json({ 
        error: 'File not found', 
        path: filePath,
@@ -685,13 +709,23 @@ router.get('/check-file/:filename', (req, res) => {
 // List all files in uploads directory
 router.get('/list-uploads', (req, res) => {
  try {
-    if (!fs.existsSync(uploadsDir)) {
-      return res.status(404).json({ error: 'Uploads directory not found', path: uploadsDir });
+    const { directory = 'products' } = req.query;
+    
+    // Determine which directory to list
+    let targetDir;
+    if (directory === 'reusable') {
+      targetDir = reusableUploadsDir;
+    } else {
+      targetDir = uploadsDir; // default to products
    }
    
-    const files = fs.readdirSync(uploadsDir);
+    if (!fs.existsSync(targetDir)) {
+      return res.status(404).json({ error: 'Uploads directory not found', path: targetDir });
+    }
+    
+    const files = fs.readdirSync(targetDir);
    const fileDetails = files.map(file => {
-      const filePath = path.join(uploadsDir, file);
+      const filePath = path.join(targetDir, file);
      try {
        const stats = fs.statSync(filePath);
        return {
@@ -709,12 +743,13 @@ router.get('/list-uploads', (req, res) => {
    });
    
    return res.json({
-      directory: uploadsDir,
+      directory: targetDir,
+      type: directory,
      count: files.length,
      files: fileDetails
    });
  } catch (error) {
-    return res.status(500).json({ error: error.message, path: uploadsDir });
+    return res.status(500).json({ error: error.message });
  }
 });

--- a/inventory-server/src/routes/products.js
+++ b/inventory-server/src/routes/products.js
@@ -65,6 +65,19 @@ router.get('/', async (req, res) => {
      paramCounter++;
    }

+    // Handle text filters for specific fields
+    if (req.query.barcode) {
+      conditions.push(`p.barcode ILIKE $${paramCounter}`);
+      params.push(`%${req.query.barcode}%`);
+      paramCounter++;
+    }
+
+    if (req.query.vendor_reference) {
+      conditions.push(`p.vendor_reference ILIKE $${paramCounter}`);
+      params.push(`%${req.query.vendor_reference}%`);
+      paramCounter++;
+    }
+
    // Handle numeric filters with operators
    const numericFields = {
      stock: 'p.stock_quantity',
@@ -74,11 +87,22 @@ router.get('/', async (req, res) => {
      dailySalesAvg: 'pm.daily_sales_avg',
      weeklySalesAvg: 'pm.weekly_sales_avg',
      monthlySalesAvg: 'pm.monthly_sales_avg',
+      avgQuantityPerOrder: 'pm.avg_quantity_per_order',
+      numberOfOrders: 'pm.number_of_orders',
      margin: 'pm.avg_margin_percent',
      gmroi: 'pm.gmroi',
+      inventoryValue: 'pm.inventory_value',
+      costOfGoodsSold: 'pm.cost_of_goods_sold',
+      grossProfit: 'pm.gross_profit',
+      turnoverRate: 'pm.turnover_rate',
      leadTime: 'pm.current_lead_time',
+      currentLeadTime: 'pm.current_lead_time',
+      targetLeadTime: 'pm.target_lead_time',
      stockCoverage: 'pm.days_of_inventory',
-      daysOfStock: 'pm.days_of_inventory'
+      daysOfStock: 'pm.days_of_inventory',
+      weeksOfStock: 'pm.weeks_of_inventory',
+      reorderPoint: 'pm.reorder_point',
+      safetyStock: 'pm.safety_stock'
    };

    Object.entries(req.query).forEach(([key, value]) => {
@@ -102,6 +126,24 @@ router.get('/', async (req, res) => {
      }
    });

+    // Handle date filters
+    const dateFields = {
+      firstSaleDate: 'pm.first_sale_date',
+      lastSaleDate: 'pm.last_sale_date',
+      lastPurchaseDate: 'pm.last_purchase_date',
+      firstReceivedDate: 'pm.first_received_date',
+      lastReceivedDate: 'pm.last_received_date'
+    };
+
+    Object.entries(req.query).forEach(([key, value]) => {
+      const field = dateFields[key];
+      if (field) {
+        conditions.push(`${field}::TEXT LIKE $${paramCounter}`);
+        params.push(`${value}%`); // Format like '2023-01%' to match by month or '2023-01-01' for exact date
+        paramCounter++;
+      }
+    });
+
    // Handle select filters
    if (req.query.vendor) {
      conditions.push(`p.vendor = $${paramCounter}`);
--- a/inventory/index.html
+++ b/inventory/index.html
@@ -2,9 +2,12 @@
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/box.svg" />
+    <link rel="icon" type="image/x-icon" href="/cherrybottom.ico" />
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap" rel="stylesheet">
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Inventory Manager</title>
+    <title>A Cherry On Bottom</title>
  </head>
  <body>
    <div id="root"></div>
--- a/inventory/public/box.svg
+++ b/inventory/public/box.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7l8.7 5l8.7-5M12 22V12"/></g></svg>
--- a/inventory/public/cherrybottom.ico
+++ b/inventory/public/cherrybottom.ico
--- a/inventory/public/cherrybottom.png
+++ b/inventory/public/cherrybottom.png
--- a/inventory/src/App.css
+++ b/inventory/src/App.css
@@ -1,42 +1,3 @@
 #root {
-  max-width: 1800px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-.logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-  transition: filter 300ms;
-}
-.logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
-}
-.logo.react:hover {
-  filter: drop-shadow(0 0 2em #61dafbaa);
-}
-
-@keyframes logo-spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-@media (prefers-reduced-motion: no-preference) {
-  a:nth-of-type(2) .logo {
-    animation: logo-spin infinite 20s linear;
-  }
-}
-
-.card {
-  padding: 2em;
-}
-
-.read-the-docs {
-  color: #888;
-}
+  font-family: 'Inter', sans-serif;
+}
--- a/inventory/src/components/analytics/VendorPerformance.tsx
+++ b/inventory/src/components/analytics/VendorPerformance.tsx
@@ -1,4 +1,3 @@
-import { useQuery } from '@tanstack/react-query';
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
 import { ResponsiveContainer, BarChart, Bar, XAxis, YAxis, Tooltip, ScatterChart, Scatter, ZAxis } from 'recharts';
 import config from '../../config';
--- a/inventory/src/components/dashboard/Overview.tsx
+++ b/inventory/src/components/dashboard/Overview.tsx
@@ -0,0 +1,66 @@
+import { useQuery } from '@tanstack/react-query';
+import { Line, LineChart, ResponsiveContainer, Tooltip, XAxis, YAxis } from 'recharts';
+import config from '../../config';
+
+interface SalesData {
+  date: string;
+  total: number;
+}
+
+export function Overview() {
+  const { data, isLoading, error } = useQuery<SalesData[]>({
+    queryKey: ['sales-overview'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/dashboard/sales-overview`);
+      if (!response.ok) {
+        throw new Error('Failed to fetch sales overview');
+      }
+      const rawData = await response.json();
+      return rawData.map((item: SalesData) => ({
+        ...item,
+        total: parseFloat(item.total.toString()),
+        date: new Date(item.date).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+      }));
+    },
+  });
+
+  if (isLoading) {
+    return <div>Loading chart...</div>;
+  }
+
+  if (error) {
+    return <div className="text-red-500">Error loading sales overview</div>;
+  }
+
+  return (
+    <ResponsiveContainer width="100%" height={350}>
+      <LineChart data={data}>
+        <XAxis
+          dataKey="date"
+          stroke="#888888"
+          fontSize={12}
+          tickLine={false}
+          axisLine={false}
+        />
+        <YAxis
+          stroke="#888888"
+          fontSize={12}
+          tickLine={false}
+          axisLine={false}
+          tickFormatter={(value) => `$${value.toLocaleString()}`}
+        />
+        <Tooltip 
+          formatter={(value: number) => [`$${value.toLocaleString()}`, 'Sales']}
+          labelFormatter={(label) => `Date: ${label}`}
+        />
+        <Line
+          type="monotone"
+          dataKey="total"
+          stroke="hsl(var(--primary))"
+          strokeWidth={2}
+          dot={false}
+        />
+      </LineChart>
+    </ResponsiveContainer>
+  );
+} 
--- a/inventory/src/components/dashboard/VendorPerformance.tsx
+++ b/inventory/src/components/dashboard/VendorPerformance.tsx
@@ -0,0 +1,79 @@
+import { useQuery } from "@tanstack/react-query"
+import { CardHeader, CardTitle, CardContent } from "@/components/ui/card"
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table"
+import { Progress } from "@/components/ui/progress"
+import config from "@/config"
+
+interface VendorMetrics {
+  vendor: string
+  avg_lead_time: number
+  on_time_delivery_rate: number
+  avg_fill_rate: number
+  total_orders: number
+  active_orders: number
+  overdue_orders: number
+}
+
+export function VendorPerformance() {
+  const { data: vendors } = useQuery<VendorMetrics[]>({
+    queryKey: ["vendor-metrics"],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/dashboard/vendor/performance`)
+      if (!response.ok) {
+        throw new Error("Failed to fetch vendor metrics")
+      }
+      return response.json()
+    },
+  })
+
+  // Sort vendors by on-time delivery rate
+  const sortedVendors = vendors
+    ?.sort((a, b) => b.on_time_delivery_rate - a.on_time_delivery_rate)
+
+  return (
+    <>
+      <CardHeader>
+        <CardTitle className="text-lg font-medium">Top Vendor Performance</CardTitle>
+      </CardHeader>
+      <CardContent className="max-h-[400px] overflow-auto">
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Vendor</TableHead>
+              <TableHead>On-Time</TableHead>
+              <TableHead className="text-right">Fill Rate</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {sortedVendors?.map((vendor) => (
+              <TableRow key={vendor.vendor}>
+                <TableCell className="font-medium">{vendor.vendor}</TableCell>
+                <TableCell>
+                  <div className="flex items-center gap-2">
+                    <Progress
+                      value={vendor.on_time_delivery_rate}
+                      className="h-2"
+                    />
+                    <span className="w-10 text-sm">
+                      {vendor.on_time_delivery_rate.toFixed(0)}%
+                    </span>
+                  </div>
+                </TableCell>
+                <TableCell className="text-right">
+                  {vendor.avg_fill_rate.toFixed(0)}%
+                </TableCell>
+              </TableRow>
+            ))}
+          </TableBody>
+        </Table>
+      </CardContent>
+    </>
+  )
+} 
--- a/inventory/src/components/layout/AppSidebar.tsx
+++ b/inventory/src/components/layout/AppSidebar.tsx
@@ -3,7 +3,6 @@ import {
  Package,
  BarChart2,
  Settings,
-  Box,
  ClipboardList,
  LogOut,
  Users,
@@ -22,6 +21,7 @@ import {
  SidebarMenuButton,
  SidebarMenuItem,
  SidebarSeparator,
+  useSidebar
 } from "@/components/ui/sidebar";
 import { useLocation, useNavigate, Link } from "react-router-dom";
 import { Protected } from "@/components/auth/Protected";
@@ -80,6 +80,7 @@ const items = [
 export function AppSidebar() {
  const location = useLocation();
  const navigate = useNavigate();
+  useSidebar();

  const handleLogout = () => {
    localStorage.removeItem('token');
@@ -90,11 +91,19 @@ export function AppSidebar() {
  return (
    <Sidebar collapsible="icon" variant="sidebar">
      <SidebarHeader>
-        <div className="p-4 flex items-center gap-2 group-data-[collapsible=icon]:justify-center">
-          <Box className="h-6 w-6 shrink-0" />
-          <h2 className="text-lg font-semibold group-data-[collapsible=icon]:hidden">
-            Inventory Manager
-          </h2>
+        <div className="py-1 flex justify-center items-center">
+          <div className="flex items-center">
+            <div className="flex-shrink-0 w-8 h-8 relative flex items-center justify-center">
+              <img 
+                src="/cherrybottom.png" 
+                alt="Cherry Bottom" 
+                className="w-6 h-6 object-contain -rotate-12 transform hover:rotate-0 transition-transform ease-in-out duration-300"
+              />
+            </div>
+            <div className="ml-2 transition-all duration-200 whitespace-nowrap group-[.group[data-state=collapsed]]:hidden">
+              <span className="font-bold text-lg">A Cherry On Bottom</span>
+            </div>
+          </div>
        </div>
      </SidebarHeader>
      <SidebarSeparator />
--- a/inventory/src/components/product-import/steps/ValidationStepNew/components/AiValidationDialogs.tsx
+++ b/inventory/src/components/product-import/steps/ValidationStepNew/components/AiValidationDialogs.tsx
@@ -95,12 +95,8 @@ export const AiValidationDialogs: React.FC<AiValidationDialogsProps> = ({
  isChangeReverted,
  getFieldDisplayValueWithHighlight,
  fields,
-  debugData,
 }) => {
  const [costPerMillionTokens, setCostPerMillionTokens] = useState(2.5); // Default cost
-  const hasCompanyPrompts =
-    currentPrompt.debugData?.promptSources?.companyPrompts &&
-    currentPrompt.debugData.promptSources.companyPrompts.length > 0;

  // Create our own state to track changes
  const [localReversionState, setLocalReversionState] = useState<
@@ -157,17 +153,6 @@ export const AiValidationDialogs: React.FC<AiValidationDialogsProps> = ({
    return !!localReversionState[key];
  };

-  // Use "full" as the default tab
-  const defaultTab = "full";
-  const [activeTab, setActiveTab] = useState(defaultTab);
-
-  // Update activeTab when the dialog is opened with new data
-  React.useEffect(() => {
-    if (currentPrompt.isOpen) {
-      setActiveTab("full");
-    }
-  }, [currentPrompt.isOpen]);
-
  // Format time helper
  const formatTime = (seconds: number): string => {
    if (seconds < 60) {
--- a/inventory/src/components/products/ProductFilters.tsx
+++ b/inventory/src/components/products/ProductFilters.tsx
@@ -51,7 +51,9 @@ const FILTER_OPTIONS: FilterOption[] = [
  // Basic Info Group
  { id: "search", label: "Search", type: "text", group: "Basic Info" },
  { id: "sku", label: "SKU", type: "text", group: "Basic Info" },
+  { id: "barcode", label: "UPC/Barcode", type: "text", group: "Basic Info" },
  { id: "vendor", label: "Vendor", type: "select", group: "Basic Info" },
+  { id: "vendor_reference", label: "Supplier #", type: "text", group: "Basic Info" },
  { id: "brand", label: "Brand", type: "select", group: "Basic Info" },
  { id: "category", label: "Category", type: "select", group: "Basic Info" },

@@ -84,6 +86,27 @@ const FILTER_OPTIONS: FilterOption[] = [
    group: "Inventory",
    operators: ["=", ">", ">=", "<", "<=", "between"],
  },
+  {
+    id: "weeksOfStock",
+    label: "Weeks of Stock",
+    type: "number",
+    group: "Inventory",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "reorderPoint",
+    label: "Reorder Point",
+    type: "number",
+    group: "Inventory",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "safetyStock",
+    label: "Safety Stock",
+    type: "number",
+    group: "Inventory",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
  {
    id: "replenishable",
    label: "Replenishable",
@@ -94,6 +117,17 @@ const FILTER_OPTIONS: FilterOption[] = [
    ],
    group: "Inventory",
  },
+  {
+    id: "abcClass",
+    label: "ABC Class",
+    type: "select",
+    options: [
+      { label: "A", value: "A" },
+      { label: "B", value: "B" },
+      { label: "C", value: "C" },
+    ],
+    group: "Inventory",
+  },

  // Pricing Group
  {
@@ -140,6 +174,32 @@ const FILTER_OPTIONS: FilterOption[] = [
    group: "Sales Metrics",
    operators: ["=", ">", ">=", "<", "<=", "between"],
  },
+  {
+    id: "avgQuantityPerOrder",
+    label: "Avg Qty/Order",
+    type: "number",
+    group: "Sales Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "numberOfOrders",
+    label: "Order Count",
+    type: "number",
+    group: "Sales Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "firstSaleDate",
+    label: "First Sale Date",
+    type: "text",
+    group: "Sales Metrics",
+  },
+  {
+    id: "lastSaleDate",
+    label: "Last Sale Date",
+    type: "text",
+    group: "Sales Metrics",
+  },

  // Financial Metrics Group
  {
@@ -156,6 +216,34 @@ const FILTER_OPTIONS: FilterOption[] = [
    group: "Financial Metrics",
    operators: ["=", ">", ">=", "<", "<=", "between"],
  },
+  {
+    id: "inventoryValue",
+    label: "Inventory Value",
+    type: "number",
+    group: "Financial Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "costOfGoodsSold",
+    label: "COGS",
+    type: "number",
+    group: "Financial Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "grossProfit",
+    label: "Gross Profit",
+    type: "number",
+    group: "Financial Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "turnoverRate",
+    label: "Turnover Rate",
+    type: "number",
+    group: "Financial Metrics",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },

  // Lead Time & Stock Coverage Group
  {
@@ -165,6 +253,20 @@ const FILTER_OPTIONS: FilterOption[] = [
    group: "Lead Time & Coverage",
    operators: ["=", ">", ">=", "<", "<=", "between"],
  },
+  {
+    id: "currentLeadTime",
+    label: "Current Lead Time",
+    type: "number",
+    group: "Lead Time & Coverage",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
+  {
+    id: "targetLeadTime",
+    label: "Target Lead Time",
+    type: "number",
+    group: "Lead Time & Coverage",
+    operators: ["=", ">", ">=", "<", "<=", "between"],
+  },
  {
    id: "leadTimeStatus",
    label: "Lead Time Status",
@@ -183,19 +285,26 @@ const FILTER_OPTIONS: FilterOption[] = [
    group: "Lead Time & Coverage",
    operators: ["=", ">", ">=", "<", "<=", "between"],
  },
-
-  // Classification Group
  {
-    id: "abcClass",
-    label: "ABC Class",
-    type: "select",
-    options: [
-      { label: "A", value: "A" },
-      { label: "B", value: "B" },
-      { label: "C", value: "C" },
-    ],
-    group: "Classification",
+    id: "lastPurchaseDate",
+    label: "Last Purchase Date",
+    type: "text",
+    group: "Lead Time & Coverage",
  },
+  {
+    id: "firstReceivedDate",
+    label: "First Received Date",
+    type: "text",
+    group: "Lead Time & Coverage",
+  },
+  {
+    id: "lastReceivedDate",
+    label: "Last Received Date",
+    type: "text",
+    group: "Lead Time & Coverage",
+  },
+
+  // Classification Group  
  {
    id: "managingStock",
    label: "Managing Stock",
--- a/inventory/src/components/settings/DataManagement.tsx
+++ b/inventory/src/components/settings/DataManagement.tsx
--- a/inventory/src/components/settings/ReusableImageManagement.tsx
+++ b/inventory/src/components/settings/ReusableImageManagement.tsx
@@ -1,4 +1,4 @@
-import { useState, useMemo, useCallback, useRef, useEffect } from "react";
+import { useState, useMemo, useCallback, useEffect } from "react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { Button } from "@/components/ui/button";
 import {
@@ -90,7 +90,7 @@ const ImageForm = ({
 }: {
  editingImage: ReusableImage | null;
  formData: ImageFormData;
-  setFormData: (data: ImageFormData) => void;
+  setFormData: (data: ImageFormData | ((prev: ImageFormData) => ImageFormData)) => void;
  onSubmit: (e: React.FormEvent) => void;
  onCancel: () => void;
  fieldOptions: FieldOptions | undefined;
@@ -99,11 +99,11 @@ const ImageForm = ({
  isDragActive: boolean;
 }) => {
  const handleNameChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
-    setFormData(prev => ({ ...prev, name: e.target.value }));
+    setFormData((prev: ImageFormData) => ({ ...prev, name: e.target.value }));
  }, [setFormData]);

  const handleGlobalChange = useCallback((checked: boolean) => {
-    setFormData(prev => ({ 
+    setFormData((prev: ImageFormData) => ({ 
      ...prev, 
      is_global: checked,
      company: checked ? null : prev.company
@@ -111,7 +111,7 @@ const ImageForm = ({
  }, [setFormData]);

  const handleCompanyChange = useCallback((value: string) => {
-    setFormData(prev => ({ ...prev, company: value }));
+    setFormData((prev: ImageFormData) => ({ ...prev, company: value }));
  }, [setFormData]);

  return (
@@ -738,12 +738,18 @@ export function ReusableImageManagement() {
        </DialogContent>
      </Dialog>

-      <style jsx global>{`
+      {/* Add global styles for this component using regular style tag */}
+      <style>{`
+        .reusable-image-table thead tr th,
+        .reusable-image-table tbody tr td {
+          padding-left: 1rem;
+          padding-right: 1rem;
+        }
        .bg-checkerboard {
          background-image: linear-gradient(45deg, #f0f0f0 25%, transparent 25%),
-                            linear-gradient(-45deg, #f0f0f0 25%, transparent 25%),
-                            linear-gradient(45deg, transparent 75%, #f0f0f0 75%),
-                            linear-gradient(-45deg, transparent 75%, #f0f0f0 75%);
+                          linear-gradient(-45deg, #f0f0f0 25%, transparent 25%),
+                          linear-gradient(45deg, transparent 75%, #f0f0f0 75%),
+                          linear-gradient(-45deg, transparent 75%, #f0f0f0 75%);
          background-size: 20px 20px;
          background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
        }
--- a/inventory/src/index.css
+++ b/inventory/src/index.css
@@ -96,17 +96,15 @@
    @apply border-border;
  }
  body {
-    @apply bg-background text-foreground;
+    @apply bg-background text-foreground font-sans;
  }
 }

-
-
@layer base {
  * {
    @apply border-border outline-ring/50;
  }
  body {
-    @apply bg-background text-foreground;
+    @apply bg-background text-foreground font-sans;
  }
 }
--- a/inventory/src/main.tsx
+++ b/inventory/src/main.tsx
@@ -1,6 +1,7 @@
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
 import './index.css'
+import './App.css'
 import App from './App.tsx'
 import { BrowserRouter as Router } from 'react-router-dom'

--- a/inventory/src/pages/Login.tsx
+++ b/inventory/src/pages/Login.tsx
@@ -1,28 +1,31 @@
 import { useState, useContext } from "react";
 import { useNavigate, useSearchParams } from "react-router-dom";
+import { AuthContext } from "@/contexts/AuthContext";
+import { toast } from "sonner";
+import { cn } from "@/lib/utils";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
-import { toast } from "sonner";
-import { Loader2, Box } from "lucide-react";
-import { motion } from "framer-motion";
-import { AuthContext } from "@/contexts/AuthContext";
+import { Label } from "@/components/ui/label";
+import { motion } from "motion/react";

 export function Login() {
-  const [username, setUsername] = useState("");
-  const [password, setPassword] = useState("");
  const [isLoading, setIsLoading] = useState(false);
  const navigate = useNavigate();
  const [searchParams] = useSearchParams();
  const { login } = useContext(AuthContext);

-  const handleLogin = async (e: React.FormEvent) => {
+  const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    setIsLoading(true);

+    const formData = new FormData(e.currentTarget);
+    const username = formData.get("username") as string;
+    const password = formData.get("password") as string;
+
    try {
      await login(username, password);
-      
+
      // Login successful, redirect to the requested page or home
      const redirectTo = searchParams.get("redirect") || "/";
      navigate(redirectTo);
@@ -36,70 +39,77 @@ export function Login() {
  };

  return (
-    <motion.div
-      layout
-      className="min-h-screen bg-gradient-to-b from-slate-100 to-slate-200 dark:from-slate-900 dark:to-slate-800 antialiased"
-    >
-      <div className="flex flex-col gap-2 p-2 bg-primary">
-        <div className="p-4 flex items-center gap-2 group-data-[collapsible=icon]:justify-center text-white">
-          <Box className="h-6 w-6 shrink-0" />
-          <h2 className="text-lg font-semibold group-data-[collapsible=icon]:hidden">
-            Inventory Manager
-          </h2>
+    <motion.div className="flex min-h-svh flex-row items-center justify-center bg-muted p-6 md:p-10">
+      <div className="fixed top-0 w-full backdrop-blur-sm bg-white/40 border-b shadow-sm z-10">
+        <div className="mx-auto p-4 sm:p-6">
+          <div className="flex items-center gap-2 font-medium text-3xl justify-center sm:justify-start">
+            <div className="relative">
+              <div className="absolute inset-0 "></div>
+              <img 
+                src="/cherrybottom.png" 
+                alt="Cherry Bottom" 
+                className="h-12 w-12 object-contain -rotate-12 transform hover:rotate-0 transition-transform ease-in-out duration-300 relative z-10"
+              />
+            </div>
+            <span className="font-bold font-text-primary">A Cherry On Bottom</span>
+          </div>
+          <p className="text-sm italic text-muted-foreground text-center sm:text-left ml-32 -mt-1">
+            supporting the cherry on top
+          </p>
        </div>
      </div>
-      <motion.div
-        initial={{ opacity: 0, scale: 0.95 }}
-        animate={{ opacity: 1, scale: 1 }}
-        transition={{ duration: 0.3, delay: 0.2 }}
-        className="container relative flex min-h-[calc(100vh-4rem)] flex-col items-center justify-center"
-      >
-        <div className="mx-auto flex w-full flex-col justify-center space-y-6 sm:w-[350px]">
-          <Card className="border-none shadow-xl">
-            <CardHeader className="space-y-1">
-              <div className="flex items-center justify-center mb-2">
-                <Box className="h-10 w-10 text-primary" />
-              </div>
-              <CardTitle className="text-2xl text-center">
-                Log in to continue
-              </CardTitle>
-            </CardHeader>
-            <CardContent>
-              <form onSubmit={handleLogin}>
-                <div className="grid gap-4">
-                  <div className="grid gap-2">
-                    <Input
-                      id="username"
-                      placeholder="Username"
-                      value={username}
-                      onChange={(e) => setUsername(e.target.value)}
-                      disabled={isLoading}
-                      className="w-full"
-                    />
-                  </div>
-                  <div className="grid gap-2">
-                    <Input
-                      id="password"
-                      type="password"
-                      placeholder="Password"
-                      value={password}
-                      onChange={(e) => setPassword(e.target.value)}
-                      disabled={isLoading}
-                      className="w-full"
-                    />
-                  </div>
-                  <Button className="w-full" type="submit" disabled={isLoading}>
-                    {isLoading && (
-                      <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-                    )}
-                    Sign In
-                  </Button>
-                </div>
-              </form>
-            </CardContent>
-          </Card>
-        </div>
-      </motion.div>
+      <div className="w-full sm:w-[80%] max-w-sm mt-20">
+        <LoginForm onSubmit={handleSubmit} isLoading={isLoading} />
+      </div>
+      
+    </motion.div>
+  );
+}
+
+interface LoginFormProps {
+  className?: string;
+  isLoading?: boolean;
+  onSubmit: (e: React.FormEvent<HTMLFormElement>) => void;
+}
+
+function LoginForm({ className, isLoading, onSubmit, ...props }: LoginFormProps) {
+  return (
+    <motion.div className={cn("flex flex-col gap-6", className)} {...props}>
+      <Card className="overflow-hidden rounded-lg shadow-lg">
+        <CardHeader className="pb-0">
+          <CardTitle className="text-2xl font-bold text-center">Log in to your account</CardTitle>
+        </CardHeader>
+        <CardContent className="grid p-0 h-full">
+          <form className="p-6 md:p-8 flex flex-col gap-6" onSubmit={onSubmit}>
+            <div className="grid gap-2">
+              <Label htmlFor="username">Username</Label>
+              <Input
+                id="username"
+                name="username"
+                type="text"
+                required
+                disabled={isLoading}
+              />
+            </div>
+            
+            <div className="grid gap-2">
+              <Label htmlFor="password">Password</Label>
+              <Input 
+                id="password" 
+                name="password" 
+                type="password" 
+                required 
+                disabled={isLoading}
+              />
+            </div>
+            
+            <Button type="submit" className="w-full" disabled={isLoading}>
+              {isLoading ? "Logging in..." : "Log In"}
+            </Button>
+          </form>
+        
+        </CardContent>
+      </Card>
    </motion.div>
  );
 }
--- a/inventory/src/pages/Products.tsx
+++ b/inventory/src/pages/Products.tsx
@@ -55,10 +55,13 @@ const AVAILABLE_COLUMNS: ColumnDef[] = [
  { key: 'stock_quantity', label: 'Shelf Count', group: 'Stock', format: (v) => v?.toString() ?? '-' },
  { key: 'stock_status', label: 'Stock Status', group: 'Stock' },
  { key: 'days_of_inventory', label: 'Days of Stock', group: 'Stock', format: (v) => v?.toFixed(1) ?? '-' },
+  { key: 'weeks_of_inventory', label: 'Weeks of Stock', group: 'Stock', format: (v) => v?.toFixed(1) ?? '-' },
  { key: 'abc_class', label: 'ABC Class', group: 'Stock' },
  { key: 'replenishable', label: 'Replenishable', group: 'Stock' },
  { key: 'moq', label: 'MOQ', group: 'Stock', format: (v) => v?.toString() ?? '-' },
  { key: 'reorder_qty', label: 'Reorder Qty', group: 'Stock', format: (v) => v?.toString() ?? '-' },
+  { key: 'reorder_point', label: 'Reorder Point', group: 'Stock', format: (v) => v?.toString() ?? '-' },
+  { key: 'safety_stock', label: 'Safety Stock', group: 'Stock', format: (v) => v?.toString() ?? '-' },
  { key: 'overstocked_amt', label: 'Overstock Amt', group: 'Stock', format: (v) => v?.toString() ?? '-' },
  { key: 'price', label: 'Price', group: 'Pricing', format: (v) => v?.toFixed(2) ?? '-' },
  { key: 'regular_price', label: 'Default Price', group: 'Pricing', format: (v) => v?.toFixed(2) ?? '-' },
@@ -67,15 +70,22 @@ const AVAILABLE_COLUMNS: ColumnDef[] = [
  { key: 'daily_sales_avg', label: 'Daily Sales', group: 'Sales', format: (v) => v?.toFixed(1) ?? '-' },
  { key: 'weekly_sales_avg', label: 'Weekly Sales', group: 'Sales', format: (v) => v?.toFixed(1) ?? '-' },
  { key: 'monthly_sales_avg', label: 'Monthly Sales', group: 'Sales', format: (v) => v?.toFixed(1) ?? '-' },
+  { key: 'avg_quantity_per_order', label: 'Avg Qty/Order', group: 'Sales', format: (v) => v?.toFixed(1) ?? '-' },
+  { key: 'number_of_orders', label: 'Order Count', group: 'Sales', format: (v) => v?.toString() ?? '-' },
  { key: 'first_sale_date', label: 'First Sale', group: 'Sales' },
  { key: 'last_sale_date', label: 'Last Sale', group: 'Sales' },
  { key: 'gmroi', label: 'GMROI', group: 'Financial', format: (v) => v?.toFixed(2) ?? '-' },
  { key: 'turnover_rate', label: 'Turnover Rate', group: 'Financial', format: (v) => v?.toFixed(2) ?? '-' },
  { key: 'avg_margin_percent', label: 'Margin %', group: 'Financial', format: (v) => v ? `${v.toFixed(1)}%` : '-' },
+  { key: 'inventory_value', label: 'Inventory Value', group: 'Financial', format: (v) => v?.toFixed(2) ?? '-' },
+  { key: 'cost_of_goods_sold', label: 'COGS', group: 'Financial', format: (v) => v?.toFixed(2) ?? '-' },
+  { key: 'gross_profit', label: 'Gross Profit', group: 'Financial', format: (v) => v?.toFixed(2) ?? '-' },
  { key: 'current_lead_time', label: 'Current Lead Time', group: 'Lead Time', format: (v) => v?.toFixed(1) ?? '-' },
  { key: 'target_lead_time', label: 'Target Lead Time', group: 'Lead Time', format: (v) => v?.toFixed(1) ?? '-' },
  { key: 'lead_time_status', label: 'Lead Time Status', group: 'Lead Time' },
  { key: 'last_purchase_date', label: 'Last Purchase', group: 'Lead Time' },
+  { key: 'first_received_date', label: 'First Received', group: 'Lead Time' },
+  { key: 'last_received_date', label: 'Last Received', group: 'Lead Time' },
 ];

 // Define default columns for each view
@@ -93,14 +103,17 @@ const VIEW_COLUMNS: Record<string, ColumnKey[]> = {
    'daily_sales_avg',
    'weekly_sales_avg',
    'monthly_sales_avg',
+    'inventory_value',
  ],
  critical: [
    'image',
    'title',
    'stock_quantity',
+    'safety_stock',
    'daily_sales_avg',
    'weekly_sales_avg',
    'reorder_qty',
+    'reorder_point',
    'vendor',
    'last_purchase_date',
    'current_lead_time',
@@ -109,11 +122,13 @@ const VIEW_COLUMNS: Record<string, ColumnKey[]> = {
    'image',
    'title',
    'stock_quantity',
+    'reorder_point',
    'daily_sales_avg',
    'weekly_sales_avg',
    'reorder_qty',
    'vendor',
    'last_purchase_date',
+    'avg_lead_time_days',
  ],
  overstocked: [
    'image',
@@ -123,15 +138,19 @@ const VIEW_COLUMNS: Record<string, ColumnKey[]> = {
    'weekly_sales_avg',
    'overstocked_amt',
    'days_of_inventory',
+    'inventory_value',
+    'turnover_rate',
  ],
  'at-risk': [
    'image',
    'title',
    'stock_quantity',
+    'safety_stock',
    'daily_sales_avg',
    'weekly_sales_avg',
    'days_of_inventory',
    'last_sale_date',
+    'current_lead_time',
  ],
  new: [
    'image',
@@ -141,6 +160,7 @@ const VIEW_COLUMNS: Record<string, ColumnKey[]> = {
    'brand',
    'price',
    'regular_price',
+    'first_received_date',
  ],
  healthy: [
    'image',
@@ -150,6 +170,8 @@ const VIEW_COLUMNS: Record<string, ColumnKey[]> = {
    'weekly_sales_avg',
    'monthly_sales_avg',
    'days_of_inventory',
+    'gross_profit',
+    'gmroi',
  ],
 };

--- a/inventory/src/types/products.ts
+++ b/inventory/src/types/products.ts
@@ -43,6 +43,7 @@ export interface Product {
  gross_profit?: string;  // numeric(15,3)
  gmroi?: string;  // numeric(15,3)
  avg_lead_time_days?: string;  // numeric(15,3)
+  first_received_date?: string;
  last_received_date?: string;
  abc_class?: string;
  stock_status?: string;
--- a/inventory/tailwind.config.js
+++ b/inventory/tailwind.config.js
@@ -14,6 +14,9 @@ export default {
  		}
  	},
  	extend: {
+      fontFamily: {
+        sans: ['Inter', 'sans-serif'],
+      },
  		colors: {
  			border: 'hsl(var(--border))',
  			input: 'hsl(var(--input))',
--- a/inventory/tsconfig.tsbuildinfo
+++ b/inventory/tsconfig.tsbuildinfo
Author	SHA1	Message	Date
Matt	7aa494aaad	Clean up	2025-03-28 19:35:23 -04:00
Matt	1e0be3f86e	Ensure data management page grabs progress of any running scripts on load, clean up unneeded console logs, restyle login page	2025-03-28 19:26:52 -04:00
Matt	a068a253cd	More data management page tweaks, ensure reusable images don't get deleted automatically	2025-03-27 19:31:11 -04:00
Matt	087ec710f6	Fix/enhance data management page	2025-03-27 17:09:06 -04:00
Matt	957c7b5eb1	Add new filter options and metrics to product filters and pages; enhance SQL schema for financial calculations	2025-03-27 16:27:13 -04:00
Matt	8b8845b423	Clean up build errors	2025-03-26 21:53:33 -04:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7l8.7 5l8.7-5M12 22V12"/></g></svg>`