Add backend changes and update scripts

inventory-server/scripts/calculate-metrics.js

@@ -547,7 +547,194 @@ async function calculateCategorySalesMetrics(connection, startTime, totalProduct
     `);
 }
 
-// Update the main calculation function to include category sales metrics
+// Add new functions for vendor and category metrics
+async function calculateVendorMetrics(connection) {
+    console.log('Calculating vendor metrics...');
+    
+    // Calculate vendor performance metrics
+    await connection.query(`
+        INSERT INTO vendor_metrics (
+            vendor,
+            avg_lead_time_days,
+            on_time_delivery_rate,
+            order_fill_rate,
+            total_orders,
+            total_late_orders,
+            total_purchase_value,
+            avg_order_value,
+            active_products,
+            total_products,
+            total_revenue,
+            avg_margin_percent,
+            status
+        )
+        SELECT 
+            vd.vendor,
+            -- Lead time metrics
+            AVG(DATEDIFF(po.received_date, po.date)) as avg_lead_time_days,
+            -- On-time delivery rate
+            (COUNT(CASE WHEN po.received_date <= po.expected_date THEN 1 END) / COUNT(*)) * 100 as on_time_delivery_rate,
+            -- Order fill rate
+            (SUM(po.received) / SUM(po.ordered)) * 100 as order_fill_rate,
+            COUNT(DISTINCT po.po_id) as total_orders,
+            COUNT(DISTINCT CASE WHEN po.received_date > po.expected_date THEN po.po_id END) as total_late_orders,
+            SUM(po.cost_price * po.ordered) as total_purchase_value,
+            AVG(po.cost_price * po.ordered) as avg_order_value,
+            -- Product counts
+            COUNT(DISTINCT CASE WHEN p.visible = true THEN p.product_id END) as active_products,
+            COUNT(DISTINCT p.product_id) as total_products,
+            -- Financial metrics
+            SUM(o.price * o.quantity) as total_revenue,
+            AVG(((o.price - p.cost_price) / o.price) * 100) as avg_margin_percent,
+            vd.status
+        FROM vendor_details vd
+        LEFT JOIN products p ON vd.vendor = p.vendor
+        LEFT JOIN purchase_orders po ON p.product_id = po.product_id
+        LEFT JOIN orders o ON p.product_id = o.product_id AND o.canceled = false
+        GROUP BY vd.vendor, vd.status
+        ON DUPLICATE KEY UPDATE
+            avg_lead_time_days = VALUES(avg_lead_time_days),
+            on_time_delivery_rate = VALUES(on_time_delivery_rate),
+            order_fill_rate = VALUES(order_fill_rate),
+            total_orders = VALUES(total_orders),
+            total_late_orders = VALUES(total_late_orders),
+            total_purchase_value = VALUES(total_purchase_value),
+            avg_order_value = VALUES(avg_order_value),
+            active_products = VALUES(active_products),
+            total_products = VALUES(total_products),
+            total_revenue = VALUES(total_revenue),
+            avg_margin_percent = VALUES(avg_margin_percent),
+            status = VALUES(status),
+            last_calculated_at = CURRENT_TIMESTAMP
+    `);
+
+    // Calculate vendor time-based metrics
+    await connection.query(`
+        INSERT INTO vendor_time_metrics (
+            vendor,
+            year,
+            month,
+            total_orders,
+            late_orders,
+            avg_lead_time_days,
+            total_purchase_value,
+            total_revenue,
+            avg_margin_percent
+        )
+        SELECT 
+            vd.vendor,
+            YEAR(po.date) as year,
+            MONTH(po.date) as month,
+            COUNT(DISTINCT po.po_id) as total_orders,
+            COUNT(DISTINCT CASE WHEN po.received_date > po.expected_date THEN po.po_id END) as late_orders,
+            AVG(DATEDIFF(po.received_date, po.date)) as avg_lead_time_days,
+            SUM(po.cost_price * po.ordered) as total_purchase_value,
+            SUM(o.price * o.quantity) as total_revenue,
+            AVG(((o.price - p.cost_price) / o.price) * 100) as avg_margin_percent
+        FROM vendor_details vd
+        LEFT JOIN products p ON vd.vendor = p.vendor
+        LEFT JOIN purchase_orders po ON p.product_id = po.product_id
+        LEFT JOIN orders o ON p.product_id = o.product_id AND o.canceled = false
+        WHERE po.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+        GROUP BY vd.vendor, YEAR(po.date), MONTH(po.date)
+        ON DUPLICATE KEY UPDATE
+            total_orders = VALUES(total_orders),
+            late_orders = VALUES(late_orders),
+            avg_lead_time_days = VALUES(avg_lead_time_days),
+            total_purchase_value = VALUES(total_purchase_value),
+            total_revenue = VALUES(total_revenue),
+            avg_margin_percent = VALUES(avg_margin_percent)
+    `);
+}
+
+async function calculateCategoryMetrics(connection) {
+    console.log('Calculating category metrics...');
+    
+    // Calculate category performance metrics
+    await connection.query(`
+        INSERT INTO category_metrics (
+            category_id,
+            product_count,
+            active_products,
+            total_value,
+            avg_margin,
+            turnover_rate,
+            growth_rate,
+            status
+        )
+        SELECT 
+            c.id as category_id,
+            COUNT(DISTINCT p.product_id) as product_count,
+            COUNT(DISTINCT CASE WHEN p.visible = true THEN p.product_id END) as active_products,
+            SUM(p.stock_quantity * p.cost_price) as total_value,
+            AVG(((p.price - p.cost_price) / p.price) * 100) as avg_margin,
+            -- Turnover rate calculation
+            SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0) as turnover_rate,
+            -- Growth rate calculation (comparing current month to previous month)
+            ((
+                SUM(CASE WHEN o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) THEN o.quantity ELSE 0 END) -
+                SUM(CASE WHEN o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 2 MONTH) AND DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) THEN o.quantity ELSE 0 END)
+            ) / NULLIF(
+                SUM(CASE WHEN o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 2 MONTH) AND DATE_SUB(CURRENT_DATE, INTERVAL 1 MONTH) THEN o.quantity ELSE 0 END),
+                0
+            ) * 100) as growth_rate,
+            c.status
+        FROM categories c
+        LEFT JOIN product_categories pc ON c.id = pc.category_id
+        LEFT JOIN products p ON pc.product_id = p.product_id
+        LEFT JOIN orders o ON p.product_id = o.product_id AND o.canceled = false
+        GROUP BY c.id, c.status
+        ON DUPLICATE KEY UPDATE
+            product_count = VALUES(product_count),
+            active_products = VALUES(active_products),
+            total_value = VALUES(total_value),
+            avg_margin = VALUES(avg_margin),
+            turnover_rate = VALUES(turnover_rate),
+            growth_rate = VALUES(growth_rate),
+            status = VALUES(status),
+            last_calculated_at = CURRENT_TIMESTAMP
+    `);
+
+    // Calculate category time-based metrics
+    await connection.query(`
+        INSERT INTO category_time_metrics (
+            category_id,
+            year,
+            month,
+            product_count,
+            active_products,
+            total_value,
+            total_revenue,
+            avg_margin,
+            turnover_rate
+        )
+        SELECT 
+            c.id as category_id,
+            YEAR(o.date) as year,
+            MONTH(o.date) as month,
+            COUNT(DISTINCT p.product_id) as product_count,
+            COUNT(DISTINCT CASE WHEN p.visible = true THEN p.product_id END) as active_products,
+            SUM(p.stock_quantity * p.cost_price) as total_value,
+            SUM(o.price * o.quantity) as total_revenue,
+            AVG(((p.price - p.cost_price) / p.price) * 100) as avg_margin,
+            SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0) as turnover_rate
+        FROM categories c
+        LEFT JOIN product_categories pc ON c.id = pc.category_id
+        LEFT JOIN products p ON pc.product_id = p.product_id
+        LEFT JOIN orders o ON p.product_id = o.product_id AND o.canceled = false
+        WHERE o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+        GROUP BY c.id, YEAR(o.date), MONTH(o.date)
+        ON DUPLICATE KEY UPDATE
+            product_count = VALUES(product_count),
+            active_products = VALUES(active_products),
+            total_value = VALUES(total_value),
+            total_revenue = VALUES(total_revenue),
+            avg_margin = VALUES(avg_margin),
+            turnover_rate = VALUES(turnover_rate)
+    `);
+}
+
+// Update the main calculation function to include the new metrics
 async function calculateMetrics() {
     let pool;
     const startTime = Date.now();

inventory-server/scripts/reset-metrics.js

@@ -43,179 +43,37 @@ const REQUIRED_CORE_TABLES = [
 ];
 
 async function resetMetrics() {
-    outputProgress({
-        status: 'running',
-        operation: 'Starting metrics reset',
-        percentage: '0'
-    });
-
-    const connection = await mysql.createConnection(dbConfig);
-    
+    let connection;
     try {
-        // First verify that core tables exist
-        outputProgress({
-            status: 'running',
-            operation: 'Verifying core tables exist',
-            percentage: '10'
-        });
+        connection = await mysql.createConnection(dbConfig);
+        await connection.beginTransaction();
 
-        // Use SHOW TABLES to verify core tables exist
-        const [showTables] = await connection.query('SHOW TABLES');
-        const existingTables = showTables.map(t => Object.values(t)[0]);
-
-        outputProgress({
-            operation: 'Core tables verification',
-            message: {
-                found: existingTables,
-                required: REQUIRED_CORE_TABLES
-            }
-        });
-
-        // Check if any core tables are missing
-        const missingCoreTables = REQUIRED_CORE_TABLES.filter(
-            t => !existingTables.includes(t)
-        );
-
-        if (missingCoreTables.length > 0) {
-            throw new Error(
-                `Core tables missing: ${missingCoreTables.join(', ')}. Please run reset-db.js first.`
-            );
-        }
-
-        // Verify all core tables use InnoDB
-        const [engineStatus] = await connection.query('SHOW TABLE STATUS WHERE Name IN (?)', [REQUIRED_CORE_TABLES]);
-        const nonInnoDBTables = engineStatus.filter(t => t.Engine !== 'InnoDB');
+        // Reset existing metrics tables
+        await connection.query('TRUNCATE TABLE temp_sales_metrics');
+        await connection.query('TRUNCATE TABLE temp_purchase_metrics');
+        await connection.query('TRUNCATE TABLE product_metrics');
+        await connection.query('TRUNCATE TABLE product_time_aggregates');
         
-        if (nonInnoDBTables.length > 0) {
-            throw new Error(
-                `Tables using non-InnoDB engine: ${nonInnoDBTables.map(t => t.Name).join(', ')}`
-            );
-        }
+        // Reset vendor metrics tables
+        await connection.query('TRUNCATE TABLE vendor_metrics');
+        await connection.query('TRUNCATE TABLE vendor_time_metrics');
+        
+        // Reset category metrics tables
+        await connection.query('TRUNCATE TABLE category_metrics');
+        await connection.query('TRUNCATE TABLE category_time_metrics');
 
-        // Disable foreign key checks first
-        await connection.query('SET FOREIGN_KEY_CHECKS = 0');
-
-        // Drop the metrics views first
-        outputProgress({
-            status: 'running',
-            operation: 'Dropping metrics views',
-            percentage: '15'
-        });
-        await connection.query('DROP VIEW IF EXISTS inventory_health, product_sales_trends');
-
-        // Drop only the metrics tables if they exist
-        const [existing] = await connection.query(`
-            SELECT GROUP_CONCAT(table_name) as tables 
-            FROM information_schema.tables 
-            WHERE table_schema = DATABASE()
-              AND table_name IN (${METRICS_TABLES.map(table => `'${table}'`).join(',')})
-        `);
-
-        if (existing[0].tables) {
-            outputProgress({
-                status: 'running',
-                operation: 'Dropping existing metrics tables',
-                percentage: '20'
-            });
-            const dropQuery = `
-                DROP TABLE IF EXISTS 
-                ${existing[0].tables
-                    .split(',')
-                    .map(table => '`' + table + '`')
-                    .join(', ')}
-            `;
-            await connection.query(dropQuery);
-        }
-
-        // Read metrics schema in its entirety
-        outputProgress({
-            status: 'running',
-            operation: 'Creating metrics tables',
-            percentage: '40'
-        });
-        const schemaPath = path.join(__dirname, '../db/metrics-schema.sql');
-        const schemaSQL = fs.readFileSync(schemaPath, 'utf8');
-
-        // Run the entire metrics-schema so it creates
-        // the metrics tables and indexes in one shot
-        await connection.query(schemaSQL);
-
-        // Read and execute config schema
-        outputProgress({
-            status: 'running',
-            operation: 'Creating configuration tables',
-            percentage: '60'
-        });
-        const configSchemaPath = path.join(__dirname, '../db/config-schema.sql');
-        const configSchemaSQL = fs.readFileSync(configSchemaPath, 'utf8');
-
-        // Run the config schema
-        await connection.query(configSchemaSQL);
-
-        // Verify all tables were actually created using SHOW TABLES
-        const [verifyTables] = await connection.query('SHOW TABLES');
-        const tablesAfterCreation = verifyTables.map(t => Object.values(t)[0]);
-
-        // First verify metrics tables
-        outputProgress({
-            status: 'running',
-            operation: 'Verifying metrics tables',
-            message: {
-                found: tablesAfterCreation,
-                required: METRICS_TABLES
-            }
-        });
-
-        const missingMetricsTables = METRICS_TABLES.filter(
-            t => !tablesAfterCreation.includes(t)
-        );
-
-        if (missingMetricsTables.length > 0) {
-            throw new Error(
-                `Failed to create metrics tables: ${missingMetricsTables.join(', ')}`
-            );
-        }
-
-        // Then verify config tables
-        outputProgress({
-            status: 'running',
-            operation: 'Verifying config tables',
-            message: {
-                found: tablesAfterCreation,
-                required: CONFIG_TABLES
-            }
-        });
-
-        const missingConfigTables = CONFIG_TABLES.filter(
-            t => !tablesAfterCreation.includes(t)
-        );
-
-        if (missingConfigTables.length > 0) {
-            throw new Error(
-                `Failed to create config tables: ${missingConfigTables.join(', ')}`
-            );
-        }
-
-        // Re-enable foreign key checks
-        await connection.query('SET FOREIGN_KEY_CHECKS = 1');
-
-        outputProgress({
-            status: 'complete',
-            operation: 'Metrics and config tables have been reset',
-            percentage: '100'
-        });
-
-        return { success: true };
+        await connection.commit();
+        console.log('All metrics tables reset successfully');
     } catch (error) {
+        if (connection) {
+            await connection.rollback();
+        }
         console.error('Error resetting metrics:', error);
-        outputProgress({
-            status: 'error',
-            operation: 'Failed to reset metrics',
-            error: error.message
-        });
         throw error;
     } finally {
-        await connection.end();
+        if (connection) {
+            await connection.end();
+        }
     }
 }