Fix o3 issues on time-aggregates script

docs/calculate-issues.md

@@ -0,0 +1,185 @@
+1. **Missing Updates for Reorder Point and Safety Stock** [RESOLVED - product-metrics.js]
+- **Problem:** In the **product_metrics** table (used by the inventory health view), the fields **reorder_point** and **safety_stock** are never updated in the product metrics calculations. Although a helper function (`calculateReorderQuantities`) exists and computes these values, the update query in the `calculateProductMetrics` function does not assign any values to these columns.
+- **Effect:** The inventory health view relies on these fields (using COALESCE to default them to 0), which means that stock might never be classified as "Reorder" or "Healthy" based on the proper reorder point or safety stock calculations.
+- **Example:** Even if a product's base metrics would require a reorder (for example, if its days of inventory are low), the view always shows a value of 0 for reorder_point and safety_stock.
+- **Fix:** Update the product metrics query (or add a subsequent update) so that **pm.reorder_point** and **pm.safety_stock** are calculated (for instance, by integrating the logic from `calculateReorderQuantities`) and stored in the table.
+
+2. **Overwritten Module Exports When Combining Scripts** [RESOLVED - calculate-metrics.js]
+- **Problem:** The code provided shows two distinct exports. The main metrics calculation module exports `calculateMetrics` (along with cancel and getProgress helpers), but later in the same concatenated file the module exports are overwritten.
+- **Effect:** If these two code sections end up in a single module file, the export for the main calculation will be lost. This would break any code that calls the overall metrics calculation.
+- **Example:** An external caller expecting to run `calculateMetrics` would instead receive the `calculateProductMetrics` function.
+- **Fix:** Make sure each script resides in its own module file. Verify that the module boundaries and exports are not accidentally merged or overwritten when deployed.
+
+3. **Potential Formula Issue in EOQ Calculation (Reorder Qty)** [RESOLVED - product-metrics.js]
+- **Problem:** The helper function `calculateReorderQuantities` uses an EOQ formula with a holding cost expressed as a percentage (0.25) rather than a per‐unit cost.
+- **Effect:** If the intent was to use the traditional EOQ formula (which expects a holding cost per unit rather than a percentage), this could lead to an incorrect reorder quantity.
+- **Example:** For a given annual demand and fixed order cost, the computed reorder quantity might be higher or lower than expected.
+- **Fix:** Double-check the EOQ formula. If the intention is to compute based on a percentage, then document that clearly; otherwise, adjust the formula to use the proper holding cost value.
+
+4. **Potential Overlap or Redundancy in GMROI Calculation** [RESOLVED - time-aggregates.js]
+- **Problem:** In the time aggregates function, GMROI is calculated in two steps. The initial INSERT query computes GMROI as
+
+	`CASE WHEN s.inventory_value > 0 THEN (s.total_revenue - s.total_cost) / s.inventory_value ELSE 0 END`
+
+	and then a subsequent UPDATE query recalculates it as an annualized value using gross profit and active days.
+
+
+- **Effect:** Overwriting a computed value may be intentional to refine the metric, but if not coordinated it can cause confusion or unexpected output in the `product_time_aggregates` table.
+- **Example:** A product's GMROI might first appear as a simple ratio but then be updated to a scaled value based on the number of active days, which could lead to inconsistent reporting if not documented.
+- **Fix:** Consolidated the GMROI calculation into a single step in the initial INSERT query, properly handling annualization and NULL values.
+
+5. **Handling of Products Without Orders or Purchase Data** [RESOLVED - time-aggregates.js]
+- **Problem:** In the INSERT query of the time aggregates function, the UNION covers two cases: one for products with order data (from `monthly_sales`) and one for products that have entries in `monthly_stock` but no matching order data.
+- **Effect:** If a product has neither orders nor purchase orders, it won't get an entry in `product_time_aggregates`. Depending on business rules, this might be acceptable or might mean missing data.
+- **Example:** A product that's new or rarely ordered might not appear in the time aggregates view, potentially affecting downstream calculations.
+- **Fix:** Added an `all_products` CTE and modified the JOIN structure to ensure every product gets an entry with appropriate default values, even if it has no orders or purchase orders.
+
+6. **Redundant Recalculation of Vendor Metrics**
+- **Problem:** Similar concepts from prior scripts where cumulative metrics (like **total_revenue** and **total_cost**) are calculated in multiple query steps without necessary validation or optimization. In the vendor metrics script, calculations for total revenue and margin are performed within a `WITH` clause, which is then used in other parts of the process, making it more complex than needed.
+- **Effect:** There's unnecessary duplication in querying the same data multiple times across subqueries. It could result in decreased performance and may even lead to excess computation if the subqueries are not optimized or correctly indexed.
+- **Example:** Vendor sales and vendor purchase orders (PO) metrics are calculated in separate `WITH` clauses, leading to repeated calculations.
+- **Fix:** Synthesize the required metrics into fewer queries or reuse the results within the `WITH` clause itself. Avoid redundant calculations of **revenue** and **cost** unless truly necessary.
+
+7. **Handling Products Without Orders or Purchase Orders**
+- **Problem:** In your `calculateVendorMetrics` script, the initial insert for vendor sales doesn't fully address the products that might not have matching orders or purchase orders. If a vendor has products without any sales within the last 12 months, the results may not be fully accurate unless handled explicitly.
+- **Effect:** If no orders exist for a product associated with a particular vendor, that product will not contribute to the vendor's metrics, potentially omitting important data when calculating **total_orders** or **total_revenue**.
+- **Example:** The scripted statistics fill gaps, but products with no recent purchase or sales orders might not be counted accurately.
+- **Fix:** Include logic to handle scenarios where these products still need to be part of the vendor calculation. Use a `LEFT JOIN` wherever possible to account for cases without sales or purchase orders.
+
+8. **Redundant `ON DUPLICATE KEY UPDATE`**
+- **Problem:** Multiple queries in the `calculateVendorMetrics` script use `ON DUPLICATE KEY UPDATE` clauses to handle repeated metrics updates. This is useful for ensuring the most up-to-date calculations but can cause inconsistencies if multiple calculations happen for the same product or vendor simultaneously.
+- **Effect:** This approach can lead to an inaccurate update of brand-specific data when insertion and update overlap. Each time you add a new batch, an existing entry could be overwritten if not handled correctly.
+- **Example:** Vendor country, category, or sales-related metrics could unintentionally update during processing.
+- **Fix:** Match on current status more robustly in case of existing rows to avoid unnecessary updates. Ensure that the key used for `ON DUPLICATE KEY` aligns with any foreign key relationships that might indicate an already processed entry.
+
+9. **SQL Query Performance with Multiple Nested `WITH` Clauses**
+- **Problem:** Heavily nested queries (especially **WITH** clauses) may lead to slow performance depending on the size of the dataset.
+- **Effect:** Computational burden could be high when the database is large, e.g., querying **purchase orders**, **vendor sales**, and **product info** simultaneously. Even with proper indexes, the deployment might struggle in production environments.
+- **Example:** Multiple `WITH` clauses in the vendor and brand metrics calculation scripts might work fine in small datasets but degrade performance in production.
+- **Fix:** Combine some subqueries and reduce the layer of computations needed for calculating final metrics. Test performance on a production-sized dataset to see how nested queries are handled.
+
+10. **Missing Updates for Reorder Metrics (Vendor/Brand)**
+- **Previously Identified Issue:** Inconsistent updates for **reorder_point** and **safety_stock** across earlier scripts.
+- **Current Impact on This Script:** The vendor and brand metrics do not have explicit updates for reorder point or safety stock, which are essential for inventory evaluation.
+- **Effect:** The correct thresholds and reorder logic for vendor product inventory aren't fully accounted for in these scripts.
+- **Fix:** Integrate relevant logic to update **reorder_point** or **safety_stock** within the vendor and brand metrics calculations. Ensure that it's consistently computed and stored.
+
+11. **Data Integrity and Consistency** 
+
+**w**hen tracking sales growth or performance
+
+
+- **Problem:** Brand metrics include a sales growth clause where negative results can sometimes be skewed severely if period data varies considerably.
+- **Effect:** If period boundaries are incorrect or records are missing, this can create drastic growth rate calculations.
+- **Example:** If the "previous" period has no sales but "current" has a substantial increase, the growth rate will show as **100%**.
+- **Fix:** Implement checks that ensure both periods are valid and that the system calculates growth accurately, avoiding growth rates based solely on potential outliers. Replace consistent gaps with a no-growth rate or a meaningful zero.
+
+12. **Exclusion of Vendors With No Sales**
+
+	The vendor metrics query is driven by the `vendor_sales` CTE, which aggregates data only for vendors that have orders in the past 12 months.
+
+
+	- **Impact:** Vendors that have purchase activity (or simply exist in vendor_details) but no recent sales won't show up in vendor_metrics. This could cause the frontend to miss metrics for vendors that might still be important.
+	- **Fix:** Consider adding a UNION or changing the driving set so that all vendors (for example, from vendor_details) are included—even if they have zero sales.
+13. **Identical Formulas for On-Time Delivery and Order Fill Rates**
+
+	Both metrics are calculated as `(received_orders / total_orders) * 100`.
+
+
+	- **Impact:** If the business expects these to be distinct (for example, one might factor in on-time receipt versus mere receipt), then showing identical values on the frontend could be misleading.
+	- **Fix:** Verify and adjust the formulas if on-time delivery and order fill rates should be computed differently.
+14. **Handling Nulls and Defaults in Aggregations**
+
+	The query uses COALESCE in most places, but be sure that every aggregated value (like average lead time) correctly defaults when no data is present.
+
+
+	- **Impact:** Incorrect defaults might cause odd or missing numbers on the production interface.
+	- **Fix:** Double-check that all numeric aggregates reliably default to 0 where needed.
+
+15. **Inconsistent Stock Filtering Conditions**
+
+	In the main brand metrics query the CTE filters products with the condition
+
+	`p.stock_quantity <= 5000 AND p.stock_quantity >= 0`
+
+	whereas in the brand time-based metrics query the condition is only `p.stock_quantity <= 5000`.
+
+
+	- **Impact:** This discrepancy may lead to inconsistent numbers (for example, if any products have negative stock, which might be due to data issues) between overall brand metrics and time-based metrics on the frontend.
+	- **Fix:** Standardize the filtering criteria so that both queries treat out-of-range stock values in the same way.
+16. **Growth Rate Calculation Periods**
+
+	The growth rate is computed by comparing revenue from the last 3 months ("current") against a period from 15–12 months ago ("previous").
+
+
+	- **Impact:** This narrow window may not reflect typical year-over-year performance and could lead to volatile or unexpected growth percentages on the frontend.
+	- **Fix:** Revisit the business logic for growth—if a longer or different comparison period is preferred, adjust the date intervals accordingly.
+17. **Potential NULLs in Aggregated Time-Based Metrics**
+
+	In the brand time-based metrics query, aggregate expressions such as `SUM(o.quantity * o.price)` aren't wrapped with COALESCE.
+
+
+	- **Impact:** If there are no orders for a given brand/month, these sums might return NULL rather than 0, which could propagate into the frontend display.
+	- **Fix:** Wrap such aggregates in COALESCE (e.g. `COALESCE(SUM(o.quantity * o.price), 0)`) to ensure a default numeric value.
+
+18. **Grouping by Category Status in Base Metrics Insert**
+	- **Problem:** The INSERT for base category metrics groups by both `c.cat_id` and `c.status` even though the table's primary key is just `category_id`.
+	- **Effect:** If a category's status changes over time, the grouping may produce unexpected updates (or even multiple groups before the duplicate key update kicks in), possibly causing the wrong status or aggregated figures to be stored.
+	- **Example:** A category that toggles between "active" and "inactive" might have its metrics calculated differently on different runs.
+	- **Fix:** Ensure that the grouping keys match the primary key (or that the status update logic is exactly as intended) so that a single row per category is maintained.
+19. **Potential Null Handling in Margin Calculations**
+	- **Problem:** In the query for category time metrics, the calculation of average margin uses expressions such as `SUM(o.quantity * (o.price - GREATEST(p.cost_price, 0)))` without using `COALESCE` on `p.cost_price`.
+	- **Effect:** If any product's `cost_price` is `NULL`, then `GREATEST(p.cost_price, 0)` returns `NULL` and the resulting sum (and thus the margin) could become `NULL` rather than defaulting to 0. This might lead to missing or misleading margin figures on the frontend.
+	- **Example:** A product with a missing cost price would make the entire margin expression evaluate to `NULL` even when sales exist.
+	- **Fix:** Replace `GREATEST(p.cost_price, 0)` with `GREATEST(COALESCE(p.cost_price, 0), 0)` (or simply use `COALESCE(p.cost_price, 0)`) to ensure that missing values are handled.
+20. **Data Coverage in Growth Rate Calculation**
+	- **Problem:** The growth rate update depends on multiple CTEs (current period, previous period, and trend analysis) that require a minimum amount of data (for instance, `HAVING COUNT(*) >= 6` in the trend_stats CTE).
+	- **Effect:** Categories with insufficient historical data will fall into the "ELSE" branch (or may even be skipped if no revenue is present), which might result in a growth rate of 0.0 or an unexpected value.
+	- **Example:** A newly created category that has only two months of data won't have trend analysis, so its growth rate will be calculated solely by the simple difference, which might not reflect true performance.
+	- **Fix:** Confirm that this fallback behavior is acceptable for production; if not, adjust the logic so that every category receives a consistent growth rate even with sparse data.
+21. **Omission of Forecasts for Zero–Sales Categories**
+	- **Observation:** The category–sales metrics query uses a `HAVING AVG(cs.daily_quantity) > 0` clause.
+	- **Effect:** Categories without any average daily sales will not receive a forecast record in `category_sales_metrics`. If the frontend expects a row (even with zeros) for every category, this will lead to missing data.
+	- **Fix:** Verify that it's acceptable for categories with no sales to have no forecast entry. If not, adjust the query so that a default forecast (with zeros) is inserted.
+
+22. **Randomness in Category-Level Forecast Revenue Calculation**
+	- **Problem:** In the category-level forecasts query, the forecast revenue is multiplied by a factor of `(0.95 + (RAND() * 0.1))`.
+	- **Effect:** This introduces randomness into the forecast figures so that repeated runs could yield slightly different values. If deterministic forecasts are expected on the production frontend, this could lead to inconsistent displays.
+	- **Example:** The same category might show a 5% higher forecast on one run and 3% on another because of the random multiplier.
+	- **Fix:** Confirm that this randomness is intentional for your forecasting model; if forecasts are meant to be reproducible, remove or replace the `RAND()` factor with a fixed multiplier.
+23. **Multi-Statement Cleanup of Temporary Tables**
+	- **Problem:** The cleanup query drops multiple temporary tables in one call (separated by semicolons).
+	- **Effect:** If your Node.js MySQL driver isn't configured to allow multi-statement execution, this query may fail, leaving temporary tables behind. Leftover temporary tables might eventually cause conflicts or resource issues.
+	- **Example:** Running the cleanup query could produce an error like "multi-statement queries not enabled," preventing proper cleanup.
+	- **Fix:** Either configure your database connection to allow multi-statements or issue separate queries for each temporary table drop to ensure that the cleanup runs successfully.
+24. **Handling Products with No Sales Data**
+	- **Problem:** In the product-level forecast calculation, the CTE `daily_stats` includes a `HAVING AVG(ds.daily_quantity) > 0` clause.
+	- **Effect:** Products that have no sales (or a zero average daily quantity) will be excluded from the forecasts. This means the frontend won't show forecasts for non–selling products, which might be acceptable but could also be a completeness issue.
+	- **Example:** A product that has never sold will not appear in the `sales_forecasts` table.
+	- **Fix:** Confirm that it is intended for forecasts to be generated only for products with some sales activity. If forecasts are required for all products, adjust the query to insert default forecast records for products with zero sales.
+25. **Complexity of the Forecast Formula Involving the Seasonality Factor**
+- **Issue:**
+
+	The sales forecast calculations incorporate an adjustment factor using `COALESCE(sf.seasonality_factor, 0)` to modify forecast units and revenue. This means that if the seasonality data is missing (or not populated), the factor defaults to 0.
+
+
+- **Potential Problem:**
+
+	A default value of 0 will drastically alter the forecast calculations—often leading to a forecast of 0 or an overly dampened forecast—when in reality the intended behavior might be to use a neutral multiplier (typically 1.0). This could result in forecasts that are not reflective of the actual seasonal impact, thereby skewing the figures that reach the frontend.
+
+
+- **Fix:**
+
+	Review your data source for seasonality (the `sales_seasonality` table) and ensure it's consistently populated. Alternatively, if missing seasonality data is possible, consider using a more neutral default (such as 1.0) in your COALESCE. This change would prevent the forecast formulas from over-simplifying (or even nullifying) the forecast output due to missing seasonality factors.
+
+
+26. **Group By with Seasonality Factor Variability**
+	- **Observation:** In the forecast insertion query, the GROUP BY clause includes `sf.seasonality_factor` along with other fields.
+	- **Effect:** If the seasonality factor differs (or is `NULL` versus a value) for different forecast dates, this might result in multiple rows for the same product and forecast date. However, the `ON DUPLICATE KEY UPDATE` clause will merge them—but only if the primary key (pid, forecast_date) is truly unique.
+	- **Fix:** Verify that the grouping produces exactly one row per product per forecast date. If there's potential for multiple rows due to seasonality variability, consider applying a COALESCE or an aggregation on the seasonality factor so that it does not affect grouping.
+
+27. **Memory Management for Temporary Tables** [RESOLVED - calculate-metrics.js]
+- **Problem:** In metrics calculations, temporary tables aren't always properly cleaned up if the process fails between creation and the DROP statement.
+- **Effect:** If a process fails after creating temporary tables but before dropping them, these tables remain in memory until the connection is closed. In a production environment with multiple calculation runs, this could lead to memory leaks or table name conflicts.
+- **Example:** The `temp_revenue_ranks` table creation in ABC classification could remain if the process fails before reaching the DROP statement.
+- **Fix:** Implement proper cleanup in a finally block or use transaction management that ensures temporary tables are always cleaned up, even in failure scenarios.

inventory-server/db/config-schema.sql

@@ -171,6 +171,39 @@ ORDER BY
     c.name,
     st.vendor;
 
+CREATE TABLE IF NOT EXISTS calculate_history (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    start_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    end_time TIMESTAMP NULL,
+    duration_seconds INT,
+    duration_minutes DECIMAL(10,2) GENERATED ALWAYS AS (duration_seconds / 60.0) STORED,
+    total_products INT DEFAULT 0,
+    total_orders INT DEFAULT 0,
+    total_purchase_orders INT DEFAULT 0,
+    processed_products INT DEFAULT 0,
+    processed_orders INT DEFAULT 0,
+    processed_purchase_orders INT DEFAULT 0,
+    status ENUM('running', 'completed', 'failed', 'cancelled') DEFAULT 'running',
+    error_message TEXT,
+    additional_info JSON,
+    INDEX idx_status_time (status, start_time)
+);
+
+CREATE TABLE IF NOT EXISTS calculate_status (
+    module_name ENUM(
+        'product_metrics',
+        'time_aggregates',
+        'financial_metrics',
+        'vendor_metrics',
+        'category_metrics',
+        'brand_metrics',
+        'sales_forecasts',
+        'abc_classification'
+    ) PRIMARY KEY,
+    last_calculation_timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    INDEX idx_last_calc (last_calculation_timestamp)
+);
+
 CREATE TABLE IF NOT EXISTS sync_status (
     table_name VARCHAR(50) PRIMARY KEY,
     last_sync_timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,

inventory-server/db/metrics-schema.sql

@@ -102,19 +102,17 @@ CREATE TABLE IF NOT EXISTS product_time_aggregates (
     INDEX idx_date (year, month)
 );
 
--- Create vendor details table
-CREATE TABLE IF NOT EXISTS vendor_details (
-    vendor VARCHAR(100) NOT NULL,
+-- Create vendor_details table
+CREATE TABLE vendor_details (
+    vendor VARCHAR(100) PRIMARY KEY,
     contact_name VARCHAR(100),
-    email VARCHAR(100),
-    phone VARCHAR(20),
+    email VARCHAR(255),
+    phone VARCHAR(50),
     status VARCHAR(20) DEFAULT 'active',
-    notes TEXT,
-    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    PRIMARY KEY (vendor),
-    INDEX idx_vendor_status (status)
-);
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    INDEX idx_status (status)
+) ENGINE=InnoDB;
 
 -- New table for vendor metrics
 CREATE TABLE IF NOT EXISTS vendor_metrics (
@@ -411,20 +409,3 @@ LEFT JOIN
 
 -- Re-enable foreign key checks
 SET FOREIGN_KEY_CHECKS = 1;
-
--- Create table for sales seasonality factors
-CREATE TABLE IF NOT EXISTS sales_seasonality (
-    month INT NOT NULL,
-    seasonality_factor DECIMAL(5,3) DEFAULT 0,
-    last_updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (month),
-    CHECK (month BETWEEN 1 AND 12),
-    CHECK (seasonality_factor BETWEEN -1.0 AND 1.0)
-);
-
--- Insert default seasonality factors (neutral)
-INSERT INTO sales_seasonality (month, seasonality_factor)
-VALUES 
-    (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0),
-    (7, 0), (8, 0), (9, 0), (10, 0), (11, 0), (12, 0)
-ON DUPLICATE KEY UPDATE last_updated = CURRENT_TIMESTAMP; 

inventory-server/db/schema.sql

@@ -51,13 +51,15 @@ CREATE TABLE products (
     baskets INT UNSIGNED DEFAULT 0,
     notifies INT UNSIGNED DEFAULT 0,
     date_last_sold DATE,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (pid),
     INDEX idx_sku (SKU),
     INDEX idx_vendor (vendor),
     INDEX idx_brand (brand),
     INDEX idx_location (location),
     INDEX idx_total_sold (total_sold),
-    INDEX idx_date_last_sold (date_last_sold)
+    INDEX idx_date_last_sold (date_last_sold),
+    INDEX idx_updated (updated)
 ) ENGINE=InnoDB;
 
 -- Create categories table with hierarchy support
@@ -77,18 +79,6 @@ CREATE TABLE categories (
     INDEX idx_name_type (name, type)
 ) ENGINE=InnoDB;
 
--- Create vendor_details table
-CREATE TABLE vendor_details (
-    vendor VARCHAR(100) PRIMARY KEY,
-    contact_name VARCHAR(100),
-    email VARCHAR(255),
-    phone VARCHAR(50),
-    status VARCHAR(20) DEFAULT 'active',
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    INDEX idx_status (status)
-) ENGINE=InnoDB;
-
 -- Create product_categories junction table
 CREATE TABLE product_categories (
     cat_id BIGINT NOT NULL,
@@ -118,6 +108,7 @@ CREATE TABLE IF NOT EXISTS orders (
     customer_name VARCHAR(100),
     status VARCHAR(20) DEFAULT 'pending',
     canceled TINYINT(1) DEFAULT 0,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     UNIQUE KEY unique_order_line (order_number, pid),
     KEY order_number (order_number),
@@ -125,7 +116,8 @@ CREATE TABLE IF NOT EXISTS orders (
     KEY customer (customer),
     KEY date (date),
     KEY status (status),
-    INDEX idx_orders_metrics (pid, date, canceled)
+    INDEX idx_orders_metrics (pid, date, canceled),
+    INDEX idx_updated (updated)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- Create purchase_orders table with its indexes
@@ -148,8 +140,9 @@ CREATE TABLE purchase_orders (
     received INT DEFAULT 0,
     received_date DATE COMMENT 'Date of first receiving',
     last_received_date DATE COMMENT 'Date of most recent receiving',
-    received_by INT,
+    received_by VARCHAR(100) COMMENT 'Name of person who first received this PO line',
     receiving_history JSON COMMENT 'Array of receiving records with qty, date, cost, receiving_id, and alt_po flag',
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     FOREIGN KEY (pid) REFERENCES products(pid),
     INDEX idx_po_id (po_id),
     INDEX idx_vendor (vendor),
@@ -159,6 +152,7 @@ CREATE TABLE purchase_orders (
     INDEX idx_po_metrics (pid, date, receiving_status, received_date),
     INDEX idx_po_product_date (pid, date),
     INDEX idx_po_product_status (pid, status),
+    INDEX idx_updated (updated),
     UNIQUE KEY unique_po_product (po_id, pid)
 ) ENGINE=InnoDB;
 

inventory-server/scripts/calculate-metrics.js

@@ -7,13 +7,13 @@ require('dotenv').config({ path: path.resolve(__dirname, '..', '.env') });
 
 // Configuration flags for controlling which metrics to calculate
 // Set to 1 to skip the corresponding calculation, 0 to run it
-const SKIP_PRODUCT_METRICS = 1;          // Skip all product metrics
-const SKIP_TIME_AGGREGATES = 1;          // Skip time aggregates
-const SKIP_FINANCIAL_METRICS = 1;        // Skip financial metrics
-const SKIP_VENDOR_METRICS = 1;           // Skip vendor metrics
-const SKIP_CATEGORY_METRICS = 1;         // Skip category metrics
-const SKIP_BRAND_METRICS = 1;            // Skip brand metrics
-const SKIP_SALES_FORECASTS = 1;          // Skip sales forecasts
+const SKIP_PRODUCT_METRICS = 0;
+const SKIP_TIME_AGGREGATES = 0;
+const SKIP_FINANCIAL_METRICS = 0;
+const SKIP_VENDOR_METRICS = 0;
+const SKIP_CATEGORY_METRICS = 0;
+const SKIP_BRAND_METRICS = 0;
+const SKIP_SALES_FORECASTS = 0;
 
 // Add error handler for uncaught exceptions
 process.on('uncaughtException', (error) => {
@@ -44,6 +44,34 @@ global.clearProgress = progress.clearProgress;
 global.getProgress = progress.getProgress;
 global.logError = progress.logError;
 
+// List of temporary tables used in the calculation process
+const TEMP_TABLES = [
+    'temp_revenue_ranks',
+    'temp_sales_metrics',
+    'temp_purchase_metrics',
+    'temp_product_metrics',
+    'temp_vendor_metrics',
+    'temp_category_metrics',
+    'temp_brand_metrics',
+    'temp_forecast_dates',
+    'temp_daily_sales',
+    'temp_product_stats',
+    'temp_category_sales',
+    'temp_category_stats'
+];
+
+// Add cleanup function for temporary tables
+async function cleanupTemporaryTables(connection) {
+    try {
+        for (const table of TEMP_TABLES) {
+            await connection.query(`DROP TEMPORARY TABLE IF EXISTS ${table}`);
+        }
+    } catch (error) {
+        logError(error, 'Error cleaning up temporary tables');
+        throw error; // Re-throw to be handled by the caller
+    }
+}
+
 const { getConnection, closePool } = require('./metrics/utils/db');
 const calculateProductMetrics = require('./metrics/product-metrics');
 const calculateTimeAggregates = require('./metrics/time-aggregates');
@@ -83,10 +111,78 @@ process.on('SIGTERM', cancelCalculation);
 async function calculateMetrics() {
     let connection;
     const startTime = Date.now();
-    let processedCount = 0;
+    let processedProducts = 0;
+    let processedOrders = 0;
+    let processedPurchaseOrders = 0;
     let totalProducts = 0;
+    let totalOrders = 0;
+    let totalPurchaseOrders = 0;
+    let calculateHistoryId;
     
     try {
+        // Clean up any previously running calculations
+        connection = await getConnection();
+        await connection.query(`
+            UPDATE calculate_history 
+            SET 
+                status = 'cancelled',
+                end_time = NOW(),
+                duration_seconds = TIMESTAMPDIFF(SECOND, start_time, NOW()),
+                error_message = 'Previous calculation was not completed properly'
+            WHERE status = 'running'
+        `);
+
+        // Get counts from all relevant tables
+        const [[productCount], [orderCount], [poCount]] = await Promise.all([
+            connection.query('SELECT COUNT(*) as total FROM products'),
+            connection.query('SELECT COUNT(*) as total FROM orders'),
+            connection.query('SELECT COUNT(*) as total FROM purchase_orders')
+        ]);
+
+        totalProducts = productCount.total;
+        totalOrders = orderCount.total;
+        totalPurchaseOrders = poCount.total;
+
+        // Create history record for this calculation
+        const [historyResult] = await connection.query(`
+            INSERT INTO calculate_history (
+                start_time,
+                status,
+                total_products,
+                total_orders,
+                total_purchase_orders,
+                additional_info
+            ) VALUES (
+                NOW(),
+                'running',
+                ?,
+                ?,
+                ?,
+                JSON_OBJECT(
+                    'skip_product_metrics', ?,
+                    'skip_time_aggregates', ?,
+                    'skip_financial_metrics', ?,
+                    'skip_vendor_metrics', ?,
+                    'skip_category_metrics', ?,
+                    'skip_brand_metrics', ?,
+                    'skip_sales_forecasts', ?
+                )
+            )
+        `, [
+            totalProducts,
+            totalOrders,
+            totalPurchaseOrders,
+            SKIP_PRODUCT_METRICS,
+            SKIP_TIME_AGGREGATES,
+            SKIP_FINANCIAL_METRICS, 
+            SKIP_VENDOR_METRICS,
+            SKIP_CATEGORY_METRICS,
+            SKIP_BRAND_METRICS,
+            SKIP_SALES_FORECASTS
+        ]);
+        calculateHistoryId = historyResult.insertId;
+        connection.release();
+
         // Add debug logging for the progress functions
         console.log('Debug - Progress functions:', {
             formatElapsedTime: typeof global.formatElapsedTime,
@@ -115,72 +211,150 @@ async function calculateMetrics() {
                 elapsed: '0s',
                 remaining: 'Calculating...',
                 rate: 0,
-                percentage: '0'
+                percentage: '0',
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
 
-            // Get total number of products
-            const [countResult] = await connection.query('SELECT COUNT(*) as total FROM products')
-                .catch(err => {
-                    global.logError(err, 'Failed to count products');
-                    throw err;
+            // Update progress periodically
+            const updateProgress = async (products = null, orders = null, purchaseOrders = null) => {
+                // Ensure all values are valid numbers or default to previous value
+                if (products !== null) processedProducts = Number(products) || processedProducts || 0;
+                if (orders !== null) processedOrders = Number(orders) || processedOrders || 0;
+                if (purchaseOrders !== null) processedPurchaseOrders = Number(purchaseOrders) || processedPurchaseOrders || 0;
+
+                // Ensure we never send NaN to the database
+                const safeProducts = Number(processedProducts) || 0;
+                const safeOrders = Number(processedOrders) || 0;
+                const safePurchaseOrders = Number(processedPurchaseOrders) || 0;
+
+                await connection.query(`
+                    UPDATE calculate_history 
+                    SET 
+                        processed_products = ?,
+                        processed_orders = ?,
+                        processed_purchase_orders = ?
+                    WHERE id = ?
+                `, [safeProducts, safeOrders, safePurchaseOrders, calculateHistoryId]);
+            };
+
+            // Helper function to ensure valid progress numbers
+            const ensureValidProgress = (current, total) => ({
+                current: Number(current) || 0,
+                total: Number(total) || 1,  // Default to 1 to avoid division by zero
+                percentage: (((Number(current) || 0) / (Number(total) || 1)) * 100).toFixed(1)
+            });
+
+            // Initial progress
+            const initialProgress = ensureValidProgress(0, totalProducts);
+            global.outputProgress({
+                status: 'running',
+                operation: 'Starting metrics calculation',
+                current: initialProgress.current,
+                total: initialProgress.total,
+                elapsed: '0s',
+                remaining: 'Calculating...',
+                rate: 0,
+                percentage: initialProgress.percentage,
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
-            totalProducts = countResult[0].total;
 
             if (!SKIP_PRODUCT_METRICS) {
-                processedCount = await calculateProductMetrics(startTime, totalProducts);
+                const result = await calculateProductMetrics(startTime, totalProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Product metrics calculation failed');
+                }
             } else {
                 console.log('Skipping product metrics calculation...');
-                processedCount = Math.floor(totalProducts * 0.6);
+                processedProducts = Math.floor(totalProducts * 0.6);
+                await updateProgress(processedProducts);
                 global.outputProgress({
                     status: 'running',
                     operation: 'Skipping product metrics calculation',
-                    current: processedCount,
+                    current: processedProducts,
                     total: totalProducts,
                     elapsed: global.formatElapsedTime(startTime),
-                    remaining: global.estimateRemaining(startTime, processedCount, totalProducts),
-                    rate: global.calculateRate(startTime, processedCount),
-                    percentage: '60'
+                    remaining: global.estimateRemaining(startTime, processedProducts, totalProducts),
+                    rate: global.calculateRate(startTime, processedProducts),
+                    percentage: '60',
+                    timing: {
+                        start_time: new Date(startTime).toISOString(),
+                        end_time: new Date().toISOString(),
+                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                    }
                 });
             }
 
             // Calculate time-based aggregates
             if (!SKIP_TIME_AGGREGATES) {
-                processedCount = await calculateTimeAggregates(startTime, totalProducts, processedCount);
+                const result = await calculateTimeAggregates(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Time aggregates calculation failed');
+                }
             } else {
                 console.log('Skipping time aggregates calculation');
             }
 
             // Calculate financial metrics
             if (!SKIP_FINANCIAL_METRICS) {
-                processedCount = await calculateFinancialMetrics(startTime, totalProducts, processedCount);
+                const result = await calculateFinancialMetrics(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Financial metrics calculation failed');
+                }
             } else {
                 console.log('Skipping financial metrics calculation');
             }
             
             // Calculate vendor metrics
             if (!SKIP_VENDOR_METRICS) {
-                processedCount = await calculateVendorMetrics(startTime, totalProducts, processedCount);
+                const result = await calculateVendorMetrics(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Vendor metrics calculation failed');
+                }
             } else {
                 console.log('Skipping vendor metrics calculation');
             }
 
             // Calculate category metrics
             if (!SKIP_CATEGORY_METRICS) {
-                processedCount = await calculateCategoryMetrics(startTime, totalProducts, processedCount);
+                const result = await calculateCategoryMetrics(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Category metrics calculation failed');
+                }
             } else {
                 console.log('Skipping category metrics calculation');
             }
 
             // Calculate brand metrics
             if (!SKIP_BRAND_METRICS) {
-                processedCount = await calculateBrandMetrics(startTime, totalProducts, processedCount);
+                const result = await calculateBrandMetrics(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Brand metrics calculation failed');
+                }
             } else {
                 console.log('Skipping brand metrics calculation');
             }
 
             // Calculate sales forecasts
             if (!SKIP_SALES_FORECASTS) {
-                processedCount = await calculateSalesForecasts(startTime, totalProducts, processedCount);
+                const result = await calculateSalesForecasts(startTime, totalProducts, processedProducts);
+                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
+                if (!result.success) {
+                    throw new Error('Sales forecasts calculation failed');
+                }
             } else {
                 console.log('Skipping sales forecasts calculation');
             }
@@ -189,15 +363,25 @@ async function calculateMetrics() {
             outputProgress({
                 status: 'running',
                 operation: 'Starting ABC classification',
-                current: processedCount,
-                total: totalProducts,
+                current: processedProducts || 0,
+                total: totalProducts || 0,
                 elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                remaining: estimateRemaining(startTime, processedProducts || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedProducts || 0),
+                percentage: (((processedProducts || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
 
-            if (isCancelled) return processedCount;
+            if (isCancelled) return {
+                processedProducts: processedProducts || 0,
+                processedOrders: processedOrders || 0,
+                processedPurchaseOrders: 0,
+                success: false
+            };
 
             const [abcConfig] = await connection.query('SELECT a_threshold, b_threshold FROM abc_classification_config WHERE id = 1');
             const abcThresholds = abcConfig[0] || { a_threshold: 20, b_threshold: 50 };
@@ -218,15 +402,25 @@ async function calculateMetrics() {
             outputProgress({
                 status: 'running',
                 operation: 'Creating revenue rankings',
-                current: processedCount,
-                total: totalProducts,
+                current: processedProducts || 0,
+                total: totalProducts || 0,
                 elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                remaining: estimateRemaining(startTime, processedProducts || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedProducts || 0),
+                percentage: (((processedProducts || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
 
-            if (isCancelled) return processedCount;
+            if (isCancelled) return {
+                processedProducts: processedProducts || 0,
+                processedOrders: processedOrders || 0,
+                processedPurchaseOrders: 0,
+                success: false
+            };
 
             await connection.query(`
                 INSERT INTO temp_revenue_ranks
@@ -247,26 +441,44 @@ async function calculateMetrics() {
             // Get total count for percentage calculation
             const [rankingCount] = await connection.query('SELECT MAX(rank_num) as total_count FROM temp_revenue_ranks');
             const totalCount = rankingCount[0].total_count || 1;
+            const max_rank = totalCount; // Store max_rank for use in classification
 
             outputProgress({
                 status: 'running',
                 operation: 'Updating ABC classifications',
-                current: processedCount,
-                total: totalProducts,
+                current: processedProducts || 0,
+                total: totalProducts || 0,
                 elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                remaining: estimateRemaining(startTime, processedProducts || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedProducts || 0),
+                percentage: (((processedProducts || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
 
-            if (isCancelled) return processedCount;
+            if (isCancelled) return {
+                processedProducts: processedProducts || 0,
+                processedOrders: processedOrders || 0,
+                processedPurchaseOrders: 0,
+                success: false
+            };
 
-            // Process updates in batches
+            // ABC classification progress tracking
             let abcProcessedCount = 0;
             const batchSize = 5000;
+            let lastProgressUpdate = Date.now();
+            const progressUpdateInterval = 1000; // Update every second
 
             while (true) {
-                if (isCancelled) return processedCount;
+                if (isCancelled) return {
+                    processedProducts: Number(processedProducts) || 0,
+                    processedOrders: Number(processedOrders) || 0,
+                    processedPurchaseOrders: 0,
+                    success: false
+                };
 
                 // First get a batch of PIDs that need updating
                 const [pids] = await connection.query(`
@@ -282,8 +494,8 @@ async function calculateMetrics() {
                             ELSE 'C'
                         END
                     LIMIT ?
-                `, [totalCount, abcThresholds.a_threshold,
-                    totalCount, abcThresholds.b_threshold,
+                `, [max_rank, abcThresholds.a_threshold,
+                    max_rank, abcThresholds.b_threshold,
                     batchSize]);
 
                 if (pids.length === 0) {
@@ -303,24 +515,43 @@ async function calculateMetrics() {
                         END,
                         pm.last_calculated_at = NOW()
                     WHERE pm.pid IN (?)
-                `, [totalCount, abcThresholds.a_threshold,
-                    totalCount, abcThresholds.b_threshold,
+                `, [max_rank, abcThresholds.a_threshold,
+                    max_rank, abcThresholds.b_threshold,
                     pids.map(row => row.pid)]);
 
                 abcProcessedCount += result.affectedRows;
-                processedCount = Math.floor(totalProducts * (0.99 + (abcProcessedCount / totalCount) * 0.01));
+                
+                // Calculate progress ensuring valid numbers
+                const currentProgress = Math.floor(totalProducts * (0.99 + (abcProcessedCount / (totalCount || 1)) * 0.01));
+                processedProducts = Number(currentProgress) || processedProducts || 0;
+
+                // Only update progress at most once per second
+                const now = Date.now();
+                if (now - lastProgressUpdate >= progressUpdateInterval) {
+                    const progress = ensureValidProgress(processedProducts, totalProducts);
                     
                     outputProgress({
                         status: 'running',
                         operation: 'ABC classification progress',
-                    current: processedCount,
-                    total: totalProducts,
+                        current: progress.current,
+                        total: progress.total,
                         elapsed: formatElapsedTime(startTime),
-                    remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                    rate: calculateRate(startTime, processedCount),
-                    percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                        remaining: estimateRemaining(startTime, progress.current, progress.total),
+                        rate: calculateRate(startTime, progress.current),
+                        percentage: progress.percentage,
+                        timing: {
+                            start_time: new Date(startTime).toISOString(),
+                            end_time: new Date().toISOString(),
+                            elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                        }
                     });
                     
+                    lastProgressUpdate = now;
+                }
+
+                // Update database progress
+                await updateProgress(processedProducts, processedOrders, processedPurchaseOrders);
+
                 // Small delay between batches to allow other transactions
                 await new Promise(resolve => setTimeout(resolve, 100));
             }
@@ -328,61 +559,145 @@ async function calculateMetrics() {
             // Clean up
             await connection.query('DROP TEMPORARY TABLE IF EXISTS temp_revenue_ranks');
 
+            const endTime = Date.now();
+            const totalElapsedSeconds = Math.round((endTime - startTime) / 1000);
+
+            // Update calculate_status for ABC classification
+            await connection.query(`
+                INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+                VALUES ('abc_classification', NOW())
+                ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+            `);
+
+            // Final progress update with guaranteed valid numbers
+            const finalProgress = ensureValidProgress(totalProducts, totalProducts);
+            
             // Final success message
             outputProgress({
                 status: 'complete',
                 operation: 'Metrics calculation complete',
-                current: totalProducts,
-                total: totalProducts,
+                current: finalProgress.current,
+                total: finalProgress.total,
                 elapsed: formatElapsedTime(startTime),
                 remaining: '0s',
-                rate: calculateRate(startTime, totalProducts),
-                percentage: '100'
+                rate: calculateRate(startTime, finalProgress.current),
+                percentage: '100',
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: totalElapsedSeconds
+                }
             });
 
+            // Ensure all values are valid numbers before final update
+            const finalStats = {
+                processedProducts: Number(processedProducts) || 0,
+                processedOrders: Number(processedOrders) || 0,
+                processedPurchaseOrders: Number(processedPurchaseOrders) || 0
+            };
+
+            // Update history with completion
+            await connection.query(`
+                UPDATE calculate_history 
+                SET 
+                    end_time = NOW(),
+                    duration_seconds = ?,
+                    processed_products = ?,
+                    processed_orders = ?,
+                    processed_purchase_orders = ?,
+                    status = 'completed'
+                WHERE id = ?
+            `, [totalElapsedSeconds, 
+                finalStats.processedProducts,
+                finalStats.processedOrders, 
+                finalStats.processedPurchaseOrders,
+                calculateHistoryId]);
+
             // Clear progress file on successful completion
             global.clearProgress();
 
         } catch (error) {
+            const endTime = Date.now();
+            const totalElapsedSeconds = Math.round((endTime - startTime) / 1000);
+
+            // Update history with error
+            await connection.query(`
+                UPDATE calculate_history 
+                SET 
+                    end_time = NOW(),
+                    duration_seconds = ?,
+                    processed_products = ?,
+                    processed_orders = ?,
+                    processed_purchase_orders = ?,
+                    status = ?,
+                    error_message = ?
+                WHERE id = ?
+            `, [
+                totalElapsedSeconds,
+                processedProducts || 0,  // Ensure we have a valid number
+                processedOrders || 0,    // Ensure we have a valid number
+                processedPurchaseOrders || 0,  // Ensure we have a valid number
+                isCancelled ? 'cancelled' : 'failed',
+                error.message,
+                calculateHistoryId
+            ]);
+
             if (isCancelled) {
                 global.outputProgress({
                     status: 'cancelled',
                     operation: 'Calculation cancelled',
-                    current: processedCount,
+                    current: processedProducts,
                     total: totalProducts || 0,
                     elapsed: global.formatElapsedTime(startTime),
                     remaining: null,
-                    rate: global.calculateRate(startTime, processedCount),
-                    percentage: ((processedCount / (totalProducts || 1)) * 100).toFixed(1)
+                    rate: global.calculateRate(startTime, processedProducts),
+                    percentage: ((processedProducts / (totalProducts || 1)) * 100).toFixed(1),
+                    timing: {
+                        start_time: new Date(startTime).toISOString(),
+                        end_time: new Date().toISOString(),
+                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                    }
                 });
             } else {
                 global.outputProgress({
                     status: 'error',
                     operation: 'Error: ' + error.message,
-                    current: processedCount,
+                    current: processedProducts,
                     total: totalProducts || 0,
                     elapsed: global.formatElapsedTime(startTime),
                     remaining: null,
-                    rate: global.calculateRate(startTime, processedCount),
-                    percentage: ((processedCount / (totalProducts || 1)) * 100).toFixed(1)
+                    rate: global.calculateRate(startTime, processedProducts),
+                    percentage: ((processedProducts / (totalProducts || 1)) * 100).toFixed(1),
+                    timing: {
+                        start_time: new Date(startTime).toISOString(),
+                        end_time: new Date().toISOString(),
+                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                    }
                 });
             }
             throw error;
         } finally {
             if (connection) {
+                // Ensure temporary tables are cleaned up
+                await cleanupTemporaryTables(connection);
                 connection.release();
             }
-        }
-    } finally {
             // Close the connection pool when we're done
             await closePool();
         }
+    } catch (error) {
+        success = false;
+        logError(error, 'Error in metrics calculation');
+        throw error;
+    }
 }
 
-// Export both functions and progress checker
-module.exports = calculateMetrics;
-module.exports.cancelCalculation = cancelCalculation;
-module.exports.getProgress = global.getProgress;
+// Export as a module with all necessary functions
+module.exports = {
+    calculateMetrics,
+    cancelCalculation,
+    getProgress: global.getProgress
+};
 
 // Run directly if called from command line
 if (require.main === module) {

inventory-server/scripts/full-reset.js

@@ -0,0 +1,107 @@
+const path = require('path');
+const { spawn } = require('child_process');
+
+function outputProgress(data) {
+    if (!data.status) {
+        data = {
+            status: 'running',
+            ...data
+        };
+    }
+    console.log(JSON.stringify(data));
+}
+
+function runScript(scriptPath) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', [scriptPath], {
+            stdio: ['inherit', 'pipe', 'pipe']
+        });
+
+        let output = '';
+
+        child.stdout.on('data', (data) => {
+            const lines = data.toString().split('\n');
+            lines.filter(line => line.trim()).forEach(line => {
+                try {
+                    console.log(line); // Pass through the JSON output
+                    output += line + '\n';
+                } catch (e) {
+                    console.log(line); // If not JSON, just log it directly
+                }
+            });
+        });
+
+        child.stderr.on('data', (data) => {
+            console.error(data.toString());
+        });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Script ${scriptPath} exited with code ${code}`));
+            } else {
+                resolve(output);
+            }
+        });
+
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+async function fullReset() {
+    try {
+        // Step 1: Reset Database
+        outputProgress({
+            operation: 'Starting full reset',
+            message: 'Step 1/3: Resetting database...'
+        });
+        await runScript(path.join(__dirname, 'reset-db.js'));
+        outputProgress({
+            status: 'complete',
+            operation: 'Database reset step complete',
+            message: 'Database reset finished, moving to import...'
+        });
+
+        // Step 2: Import from Production
+        outputProgress({
+            operation: 'Starting import',
+            message: 'Step 2/3: Importing from production...'
+        });
+        await runScript(path.join(__dirname, 'import-from-prod.js'));
+        outputProgress({
+            status: 'complete',
+            operation: 'Import step complete',
+            message: 'Import finished, moving to metrics calculation...'
+        });
+
+        // Step 3: Calculate Metrics
+        outputProgress({
+            operation: 'Starting metrics calculation',
+            message: 'Step 3/3: Calculating metrics...'
+        });
+        await runScript(path.join(__dirname, 'calculate-metrics.js'));
+        
+        // Final completion message
+        outputProgress({
+            status: 'complete',
+            operation: 'Full reset complete',
+            message: 'Successfully completed all steps: database reset, import, and metrics calculation'
+        });
+    } catch (error) {
+        outputProgress({
+            status: 'error',
+            operation: 'Full reset failed',
+            error: error.message,
+            stack: error.stack
+        });
+        process.exit(1);
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    fullReset();
+}
+
+module.exports = fullReset; 

inventory-server/scripts/full-update.js

@@ -0,0 +1,100 @@
+const path = require('path');
+const { spawn } = require('child_process');
+
+function outputProgress(data) {
+    if (!data.status) {
+        data = {
+            status: 'running',
+            ...data
+        };
+    }
+    console.log(JSON.stringify(data));
+}
+
+function runScript(scriptPath) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', [scriptPath], {
+            stdio: ['inherit', 'pipe', 'pipe']
+        });
+
+        let output = '';
+
+        child.stdout.on('data', (data) => {
+            const lines = data.toString().split('\n');
+            lines.filter(line => line.trim()).forEach(line => {
+                try {
+                    console.log(line); // Pass through the JSON output
+                    output += line + '\n';
+                } catch (e) {
+                    console.log(line); // If not JSON, just log it directly
+                }
+            });
+        });
+
+        child.stderr.on('data', (data) => {
+            console.error(data.toString());
+        });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Script ${scriptPath} exited with code ${code}`));
+            } else {
+                resolve(output);
+            }
+        });
+
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+async function fullUpdate() {
+    try {
+        // Step 1: Import from Production
+        outputProgress({
+            operation: 'Starting full update',
+            message: 'Step 1/2: Importing from production...'
+        });
+        await runScript(path.join(__dirname, 'import-from-prod.js'));
+        outputProgress({
+            status: 'complete',
+            operation: 'Import step complete',
+            message: 'Import finished, moving to metrics calculation...'
+        });
+
+        // Step 2: Calculate Metrics
+        outputProgress({
+            operation: 'Starting metrics calculation',
+            message: 'Step 2/2: Calculating metrics...'
+        });
+        await runScript(path.join(__dirname, 'calculate-metrics.js'));
+        outputProgress({
+            status: 'complete',
+            operation: 'Metrics step complete',
+            message: 'Metrics calculation finished'
+        });
+
+        // Final completion message
+        outputProgress({
+            status: 'complete',
+            operation: 'Full update complete',
+            message: 'Successfully completed all steps: import and metrics calculation'
+        });
+    } catch (error) {
+        outputProgress({
+            status: 'error',
+            operation: 'Full update failed',
+            error: error.message,
+            stack: error.stack
+        });
+        process.exit(1);
+    }
+}
+
+// Run if called directly
+if (require.main === module) {
+    fullUpdate();
+}
+
+module.exports = fullUpdate; 

inventory-server/scripts/import/orders.js

@@ -28,9 +28,18 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
   let cumulativeProcessedOrders = 0;
 
   try {
-    // Insert temporary table creation queries
+    // Clean up any existing temp tables first
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_order_items (
+      DROP TEMPORARY TABLE IF EXISTS temp_order_items;
+      DROP TEMPORARY TABLE IF EXISTS temp_order_meta;
+      DROP TEMPORARY TABLE IF EXISTS temp_order_discounts;
+      DROP TEMPORARY TABLE IF EXISTS temp_order_taxes;
+      DROP TEMPORARY TABLE IF EXISTS temp_order_costs;
+    `);
+
+    // Create all temp tables with correct schema
+    await localConnection.query(`
+      CREATE TEMPORARY TABLE temp_order_items (
         order_id INT UNSIGNED NOT NULL,
         pid INT UNSIGNED NOT NULL,
         SKU VARCHAR(50) NOT NULL,
@@ -40,35 +49,41 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         PRIMARY KEY (order_id, pid)
       ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
     `);
+
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_order_meta (
+      CREATE TEMPORARY TABLE temp_order_meta (
         order_id INT UNSIGNED NOT NULL,
         date DATE NOT NULL,
         customer VARCHAR(100) NOT NULL,
         customer_name VARCHAR(150) NOT NULL,
         status INT,
         canceled TINYINT(1),
+        summary_discount DECIMAL(10,2) DEFAULT 0.00,
+        summary_subtotal DECIMAL(10,2) DEFAULT 0.00,
         PRIMARY KEY (order_id)
       ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
     `);
+
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_order_discounts (
+      CREATE TEMPORARY TABLE temp_order_discounts (
         order_id INT UNSIGNED NOT NULL,
         pid INT UNSIGNED NOT NULL,
         discount DECIMAL(10,2) NOT NULL,
         PRIMARY KEY (order_id, pid)
       ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
     `);
+
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_order_taxes (
+      CREATE TEMPORARY TABLE temp_order_taxes (
         order_id INT UNSIGNED NOT NULL,
         pid INT UNSIGNED NOT NULL,
         tax DECIMAL(10,2) NOT NULL,
         PRIMARY KEY (order_id, pid)
       ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
     `);
+
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_order_costs (
+      CREATE TEMPORARY TABLE temp_order_costs (
         order_id INT UNSIGNED NOT NULL,
         pid INT UNSIGNED NOT NULL,
         costeach DECIMAL(10,3) DEFAULT 0.000,
@@ -81,6 +96,7 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
       SELECT COLUMN_NAME 
       FROM INFORMATION_SCHEMA.COLUMNS 
       WHERE TABLE_NAME = 'orders'
+        AND COLUMN_NAME != 'updated'  -- Exclude the updated column
       ORDER BY ORDINAL_POSITION
     `);
     const columnNames = columns.map(col => col.COLUMN_NAME);
@@ -212,7 +228,9 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
           o.order_cid as customer,
           CONCAT(COALESCE(u.firstname, ''), ' ', COALESCE(u.lastname, '')) as customer_name,
           o.order_status as status,
-          CASE WHEN o.date_cancelled != '0000-00-00 00:00:00' THEN 1 ELSE 0 END as canceled
+          CASE WHEN o.date_cancelled != '0000-00-00 00:00:00' THEN 1 ELSE 0 END as canceled,
+          o.summary_discount,
+          o.summary_subtotal
         FROM _order o
         LEFT JOIN users u ON o.order_cid = u.cid
         WHERE o.order_id IN (?)
@@ -226,19 +244,37 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         console.log('Found duplicates:', duplicates);
       }
 
-      const placeholders = orders.map(() => "(?, ?, ?, ?, ?, ?)").join(",");
+      const placeholders = orders.map(() => "(?, ?, ?, ?, ?, ?, ?, ?)").join(",");
       const values = orders.flatMap(order => [
-        order.order_id, order.date, order.customer, order.customer_name, order.status, order.canceled
+        order.order_id, 
+        order.date, 
+        order.customer, 
+        order.customer_name, 
+        order.status, 
+        order.canceled,
+        order.summary_discount,
+        order.summary_subtotal
       ]);
 
       await localConnection.query(`
-        INSERT INTO temp_order_meta VALUES ${placeholders}
+        INSERT INTO temp_order_meta (
+          order_id, 
+          date, 
+          customer, 
+          customer_name, 
+          status, 
+          canceled,
+          summary_discount,
+          summary_subtotal
+        ) VALUES ${placeholders}
         ON DUPLICATE KEY UPDATE
           date = VALUES(date),
           customer = VALUES(customer),
           customer_name = VALUES(customer_name),
           status = VALUES(status),
-          canceled = VALUES(canceled)
+          canceled = VALUES(canceled),
+          summary_discount = VALUES(summary_discount),
+          summary_subtotal = VALUES(summary_subtotal)
       `, values);
 
       processedCount = i + orders.length;
@@ -317,14 +353,25 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
     for (let i = 0; i < orderIds.length; i += 5000) {
       const batchIds = orderIds.slice(i, i + 5000);
       const [costs] = await prodConnection.query(`
-        SELECT orderid as order_id, pid, costeach
-        FROM order_costs
-        WHERE orderid IN (?)
+        SELECT 
+          oc.orderid as order_id, 
+          oc.pid,
+          COALESCE(
+            oc.costeach,
+            (SELECT pi.costeach 
+             FROM product_inventory pi 
+             WHERE pi.pid = oc.pid 
+             AND pi.daterec <= o.date_placed
+             ORDER BY pi.daterec DESC LIMIT 1)
+          ) as costeach
+        FROM order_costs oc
+        JOIN _order o ON oc.orderid = o.order_id
+        WHERE oc.orderid IN (?)
       `, [batchIds]);
 
       if (costs.length > 0) {
         const placeholders = costs.map(() => '(?, ?, ?)').join(",");
-        const values = costs.flatMap(c => [c.order_id, c.pid, c.costeach]);
+        const values = costs.flatMap(c => [c.order_id, c.pid, c.costeach || 0]);
         await localConnection.query(`
           INSERT INTO temp_order_costs (order_id, pid, costeach)
           VALUES ${placeholders}
@@ -355,7 +402,13 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
           om.date,
           oi.price,
           oi.quantity,
-          oi.base_discount + COALESCE(od.discount, 0) as discount,
+          oi.base_discount + COALESCE(od.discount, 0) + 
+          CASE 
+            WHEN om.summary_discount > 0 THEN 
+              ROUND((om.summary_discount * (oi.price * oi.quantity)) / 
+                NULLIF(om.summary_subtotal, 0), 2)
+            ELSE 0 
+          END as discount,
           COALESCE(ot.tax, 0) as tax,
           0 as tax_included,
           0 as shipping,
@@ -455,7 +508,13 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
             om.date,
             oi.price,
             oi.quantity,
-            oi.base_discount + COALESCE(od.discount, 0) as discount,
+            oi.base_discount + COALESCE(od.discount, 0) + 
+            CASE 
+              WHEN o.summary_discount > 0 THEN 
+                ROUND((o.summary_discount * (oi.price * oi.quantity)) / 
+                  NULLIF(o.summary_subtotal, 0), 2)
+              ELSE 0 
+            END as discount,
             COALESCE(ot.tax, 0) as tax,
             0 as tax_included,
             0 as shipping,
@@ -466,6 +525,7 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
             COALESCE(tc.costeach, 0) as costeach
           FROM temp_order_items oi
           JOIN temp_order_meta om ON oi.order_id = om.order_id
+          LEFT JOIN _order o ON oi.order_id = o.order_id
           LEFT JOIN temp_order_discounts od ON oi.order_id = od.order_id AND oi.pid = od.pid
           LEFT JOIN temp_order_taxes ot ON oi.order_id = ot.order_id AND oi.pid = ot.pid
           LEFT JOIN temp_order_costs tc ON oi.order_id = tc.order_id AND oi.pid = tc.pid

inventory-server/scripts/import/products.js

@@ -339,6 +339,7 @@ async function importProducts(prodConnection, localConnection, incrementalUpdate
       SELECT COLUMN_NAME 
       FROM INFORMATION_SCHEMA.COLUMNS 
       WHERE TABLE_NAME = 'products'
+        AND COLUMN_NAME != 'updated'  -- Exclude the updated column
       ORDER BY ORDINAL_POSITION
     `);
     const columnNames = columns.map(col => col.COLUMN_NAME);
@@ -470,7 +471,9 @@ async function importProducts(prodConnection, localConnection, incrementalUpdate
 
         // Process category relationships
         if (batch.some(p => p.category_ids)) {
-          const categoryRelationships = batch
+            // First get all valid categories
+            const allCategoryIds = [...new Set(
+                batch
                     .filter(p => p.category_ids)
                     .flatMap(product => 
                         product.category_ids
@@ -479,33 +482,92 @@ async function importProducts(prodConnection, localConnection, incrementalUpdate
                             .filter(id => id)
                             .map(Number)
                             .filter(id => !isNaN(id))
-                .map(catId => [catId, product.pid])
-            );
+                    )
+            )];
+
+            // Verify categories exist and get their hierarchy
+            const [categories] = await localConnection.query(`
+                WITH RECURSIVE category_hierarchy AS (
+                    SELECT 
+                        cat_id,
+                        parent_id,
+                        type,
+                        1 as level,
+                        CAST(cat_id AS CHAR(200)) as path
+                    FROM categories
+                    WHERE cat_id IN (?)
+                    UNION ALL
+                    SELECT 
+                        c.cat_id,
+                        c.parent_id,
+                        c.type,
+                        ch.level + 1,
+                        CONCAT(ch.path, ',', c.cat_id)
+                    FROM categories c
+                    JOIN category_hierarchy ch ON c.parent_id = ch.cat_id
+                    WHERE ch.level < 10  -- Prevent infinite recursion
+                )
+                SELECT 
+                    h.cat_id,
+                    h.parent_id,
+                    h.type,
+                    h.path,
+                    h.level
+                FROM (
+                    SELECT DISTINCT cat_id, parent_id, type, path, level
+                    FROM category_hierarchy
+                    WHERE cat_id IN (?)
+                ) h
+                ORDER BY h.level DESC
+            `, [allCategoryIds, allCategoryIds]);
+
+            const validCategories = new Map(categories.map(c => [c.cat_id, c]));
+            const validCategoryIds = new Set(categories.map(c => c.cat_id));
+
+            // Build category relationships ensuring proper hierarchy
+            const categoryRelationships = [];
+            batch
+                .filter(p => p.category_ids)
+                .forEach(product => {
+                    const productCategories = product.category_ids
+                        .split(',')
+                        .map(id => id.trim())
+                        .filter(id => id)
+                        .map(Number)
+                        .filter(id => !isNaN(id))
+                        .filter(id => validCategoryIds.has(id))
+                        .map(id => validCategories.get(id))
+                        .sort((a, b) => a.type - b.type);  // Sort by type to ensure proper hierarchy
+
+                    // Only add relationships that maintain proper hierarchy
+                    productCategories.forEach(category => {
+                        if (category.path.split(',').every(parentId => 
+                            validCategoryIds.has(Number(parentId))
+                        )) {
+                            categoryRelationships.push([category.cat_id, product.pid]);
+                        }
+                    });
+                });
 
             if (categoryRelationships.length > 0) {
-            // Verify categories exist before inserting relationships
-            const uniqueCatIds = [...new Set(categoryRelationships.map(([catId]) => catId))];
-            const [existingCats] = await localConnection.query(
-              "SELECT cat_id FROM categories WHERE cat_id IN (?)",
-              [uniqueCatIds]
-            );
-            const existingCatIds = new Set(existingCats.map(c => c.cat_id));
+                // First remove any existing relationships that will be replaced
+                await localConnection.query(`
+                    DELETE FROM product_categories 
+                    WHERE pid IN (?) AND cat_id IN (?)
+                `, [
+                    [...new Set(categoryRelationships.map(([_, pid]) => pid))],
+                    [...new Set(categoryRelationships.map(([catId, _]) => catId))]
+                ]);
 
-            // Filter relationships to only include existing categories
-            const validRelationships = categoryRelationships.filter(([catId]) => 
-              existingCatIds.has(catId)
-            );
-
-            if (validRelationships.length > 0) {
-              const catPlaceholders = validRelationships
+                // Then insert the new relationships
+                const placeholders = categoryRelationships
                     .map(() => "(?, ?)")
                     .join(",");
-              await localConnection.query(
-                `INSERT IGNORE INTO product_categories (cat_id, pid)
-                 VALUES ${catPlaceholders}`,
-                validRelationships.flat()
-              );
-            }
+
+                await localConnection.query(`
+                    INSERT INTO product_categories (cat_id, pid)
+                    VALUES ${placeholders}
+                `, categoryRelationships.flat());
             }
         }
       }
@@ -554,6 +616,7 @@ async function importMissingProducts(prodConnection, localConnection, missingPid
       SELECT COLUMN_NAME 
       FROM INFORMATION_SCHEMA.COLUMNS 
       WHERE TABLE_NAME = 'products'
+        AND COLUMN_NAME != 'updated'  -- Exclude the updated column
       ORDER BY ORDINAL_POSITION
     `);
     const columnNames = columns.map((col) => col.COLUMN_NAME);

inventory-server/scripts/import/purchase-orders.js

@@ -33,16 +33,15 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
       status: "running",
     });
 
-    // Get column names for the insert
+    // Get column names first
     const [columns] = await localConnection.query(`
       SELECT COLUMN_NAME 
       FROM INFORMATION_SCHEMA.COLUMNS 
       WHERE TABLE_NAME = 'purchase_orders'
+        AND COLUMN_NAME != 'updated'  -- Exclude the updated column
       ORDER BY ORDINAL_POSITION
     `);
-    const columnNames = columns
-      .map((col) => col.COLUMN_NAME)
-      .filter((name) => name !== "id");
+    const columnNames = columns.map(col => col.COLUMN_NAME);
 
     // Build incremental conditions
     const incrementalWhereClause = incrementalUpdate
@@ -321,10 +320,16 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
             let lastFulfillmentReceiving = null;
 
             for (const receiving of allReceivings) {
-              const qtyToApply = Math.min(remainingToFulfill, receiving.qty_each);
+                // Convert quantities to base units using supplier data
+                const baseQtyReceived = receiving.qty_each * (
+                    receiving.type === 'original' ? 1 : 
+                    Math.max(1, product.supplier_qty_per_unit || 1)
+                );
+                const qtyToApply = Math.min(remainingToFulfill, baseQtyReceived);
+                
                 if (qtyToApply > 0) {
                     // If this is the first receiving being applied, use its cost
-                if (actualCost === null) {
+                    if (actualCost === null && receiving.cost_each > 0) {
                         actualCost = receiving.cost_each;
                         firstFulfillmentReceiving = receiving;
                     }
@@ -332,13 +337,13 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
                     fulfillmentTracking.push({
                         receiving_id: receiving.receiving_id,
                         qty_applied: qtyToApply,
-                  qty_total: receiving.qty_each,
-                  cost: receiving.cost_each,
+                        qty_total: baseQtyReceived,
+                        cost: receiving.cost_each || actualCost || product.cost_each,
                         date: receiving.received_date,
                         received_by: receiving.received_by,
                         received_by_name: receiving.received_by_name || 'Unknown',
                         type: receiving.type,
-                  remaining_qty: receiving.qty_each - qtyToApply
+                        remaining_qty: baseQtyReceived - qtyToApply
                     });
                     remainingToFulfill -= qtyToApply;
                 } else {
@@ -346,8 +351,8 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
                     fulfillmentTracking.push({
                         receiving_id: receiving.receiving_id,
                         qty_applied: 0,
-                  qty_total: receiving.qty_each,
-                  cost: receiving.cost_each,
+                        qty_total: baseQtyReceived,
+                        cost: receiving.cost_each || actualCost || product.cost_each,
                         date: receiving.received_date,
                         received_by: receiving.received_by,
                         received_by_name: receiving.received_by_name || 'Unknown',
@@ -355,7 +360,7 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
                         is_excess: true
                     });
                 }
-              totalReceived += receiving.qty_each;
+                totalReceived += baseQtyReceived;
             }
 
             const receiving_status = !totalReceived ? 1 : // created

inventory-server/scripts/import/purchase_orders.js

@@ -1,82 +0,0 @@
-// Split into inserts and updates
-const insertsAndUpdates = batch.reduce((acc, po) => {
-  const key = `${po.po_id}-${po.pid}`;
-  if (existingPOMap.has(key)) {
-    const existing = existingPOMap.get(key);
-    // Check if any values are different
-    const hasChanges = columnNames.some(col => {
-      const newVal = po[col] ?? null;
-      const oldVal = existing[col] ?? null;
-      // Special handling for numbers to avoid type coercion issues
-      if (typeof newVal === 'number' && typeof oldVal === 'number') {
-        return Math.abs(newVal - oldVal) > 0.00001; // Allow for tiny floating point differences
-      }
-      // Special handling for receiving_history JSON
-      if (col === 'receiving_history') {
-        return JSON.stringify(newVal) !== JSON.stringify(oldVal);
-      }
-      return newVal !== oldVal;
-    });
-
-    if (hasChanges) {
-      console.log(`PO line changed: ${key}`, {
-        po_id: po.po_id,
-        pid: po.pid,
-        changes: columnNames.filter(col => {
-          const newVal = po[col] ?? null;
-          const oldVal = existing[col] ?? null;
-          if (typeof newVal === 'number' && typeof oldVal === 'number') {
-            return Math.abs(newVal - oldVal) > 0.00001;
-          }
-          if (col === 'receiving_history') {
-            return JSON.stringify(newVal) !== JSON.stringify(oldVal);
-          }
-          return newVal !== oldVal;
-        })
-      });
-      acc.updates.push({
-        po_id: po.po_id,
-        pid: po.pid,
-        values: columnNames.map(col => po[col] ?? null)
-      });
-    }
-  } else {
-    console.log(`New PO line: ${key}`);
-    acc.inserts.push({
-      po_id: po.po_id,
-      pid: po.pid,
-      values: columnNames.map(col => po[col] ?? null)
-    });
-  }
-  return acc;
-}, { inserts: [], updates: [] });
-
-// Handle inserts
-if (insertsAndUpdates.inserts.length > 0) {
-  const insertPlaceholders = Array(insertsAndUpdates.inserts.length).fill(placeholderGroup).join(",");
-  
-  const insertResult = await localConnection.query(`
-    INSERT INTO purchase_orders (${columnNames.join(",")})
-    VALUES ${insertPlaceholders}
-  `, insertsAndUpdates.inserts.map(i => i.values).flat());
-  
-  recordsAdded += insertResult[0].affectedRows;
-}
-
-// Handle updates
-if (insertsAndUpdates.updates.length > 0) {
-  const updatePlaceholders = Array(insertsAndUpdates.updates.length).fill(placeholderGroup).join(",");
-  
-  const updateResult = await localConnection.query(`
-    INSERT INTO purchase_orders (${columnNames.join(",")})
-    VALUES ${updatePlaceholders}
-    ON DUPLICATE KEY UPDATE
-      ${columnNames
-        .filter(col => col !== "po_id" && col !== "pid")
-        .map(col => `${col} = VALUES(${col})`)
-        .join(",")};
-  `, insertsAndUpdates.updates.map(u => u.values).flat());
-  
-  // Each update affects 2 rows in affectedRows, so we divide by 2 to get actual count
-  recordsUpdated += insertsAndUpdates.updates.length;
-} 

inventory-server/scripts/metrics/brand-metrics.js

@@ -1,8 +1,11 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateBrandMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateBrandMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +16,28 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders: 0,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // Get order count that will be processed
+        const [orderCount] = await connection.query(`
+            SELECT COUNT(*) as count 
+            FROM orders o 
+            WHERE o.canceled = false
+        `);
+        processedOrders = orderCount[0].count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +47,12 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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 brand metrics with optimized queries
@@ -45,10 +71,21 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
             WITH filtered_products AS (
                 SELECT 
                     p.*,
-                    CASE WHEN p.stock_quantity <= 5000 THEN p.pid END as valid_pid,
-                    CASE WHEN p.visible = true AND p.stock_quantity <= 5000 THEN p.pid END as active_pid,
                     CASE 
-                        WHEN p.stock_quantity IS NULL OR p.stock_quantity < 0 OR p.stock_quantity > 5000 THEN 0 
+                        WHEN p.stock_quantity <= 5000 AND p.stock_quantity >= 0 
+                        THEN p.pid 
+                    END as valid_pid,
+                    CASE 
+                        WHEN p.visible = true 
+                        AND p.stock_quantity <= 5000 
+                        AND p.stock_quantity >= 0 
+                        THEN p.pid 
+                    END as active_pid,
+                    CASE 
+                        WHEN p.stock_quantity IS NULL 
+                        OR p.stock_quantity < 0 
+                        OR p.stock_quantity > 5000 
+                        THEN 0 
                         ELSE p.stock_quantity 
                     END as valid_stock
                 FROM products p
@@ -57,10 +94,13 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
             sales_periods AS (
                 SELECT 
                     p.brand,
-                    SUM(o.quantity * o.price) as period_revenue,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0))) as period_revenue,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0) - p.cost_price)) as period_margin,
+                    COUNT(DISTINCT DATE(o.date)) as period_days,
                     CASE 
                         WHEN o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 3 MONTH) THEN 'current'
-                        WHEN o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 15 MONTH) AND DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH) THEN 'previous'
+                        WHEN o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 15 MONTH) 
+                            AND DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH) THEN 'previous'
                     END as period_type
                 FROM filtered_products p
                 JOIN orders o ON p.pid = o.pid 
@@ -76,10 +116,20 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
                     SUM(p.valid_stock) as total_stock_units,
                     SUM(p.valid_stock * p.cost_price) as total_stock_cost,
                     SUM(p.valid_stock * p.price) as total_stock_retail,
-                    COALESCE(SUM(o.quantity * o.price), 0) as total_revenue,
+                    COALESCE(SUM(o.quantity * (o.price - COALESCE(o.discount, 0))), 0) as total_revenue,
                     CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 THEN 
-                            (SUM((o.price - p.cost_price) * o.quantity) * 100.0) / SUM(o.price * o.quantity)
+                        WHEN SUM(o.quantity * o.price) > 0 
+                        THEN GREATEST(
+                            -100.0,
+                            LEAST(
+                                100.0,
+                                (
+                                    SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
+                                    SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
+                                ) * 100.0 / 
+                                NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
+                            )
+                        )
                         ELSE 0 
                     END as avg_margin
                 FROM filtered_products p
@@ -97,17 +147,19 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
                 bd.avg_margin,
                 CASE
                     WHEN MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END) = 0 
-                         AND MAX(CASE WHEN sp.period_type = 'current' THEN sp.period_revenue END) > 0 THEN 100.0
-                    WHEN MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END) = 0 THEN 0.0
-                    ELSE LEAST(
-                        GREATEST(
+                         AND MAX(CASE WHEN sp.period_type = 'current' THEN sp.period_revenue END) > 0 
+                    THEN 100.0
+                    WHEN MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END) = 0 
+                    THEN 0.0
+                    ELSE GREATEST(
+                        -100.0,
+                        LEAST(
                             ((MAX(CASE WHEN sp.period_type = 'current' THEN sp.period_revenue END) - 
                               MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END)) / 
-                             NULLIF(MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END), 0)) * 100.0,
-                            -100.0
-                        ),
+                             NULLIF(ABS(MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END)), 0)) * 100.0,
                             999.99
                         )
+                    )
                 END as growth_rate
             FROM brand_data bd
             LEFT JOIN sales_periods sp ON bd.brand = sp.brand
@@ -134,10 +186,20 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Calculate brand time-based metrics with optimized query
         await connection.query(`
@@ -177,8 +239,18 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
                     SUM(p.valid_stock * p.price) as total_stock_retail,
                     SUM(o.quantity * o.price) as total_revenue,
                     CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 THEN 
-                            (SUM((o.price - p.cost_price) * o.quantity) * 100.0) / SUM(o.price * o.quantity)
+                        WHEN SUM(o.quantity * o.price) > 0 
+                        THEN GREATEST(
+                            -100.0,
+                            LEAST(
+                                100.0,
+                                (
+                                    SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
+                                    SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
+                                ) * 100.0 / 
+                                NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
+                            )
+                        )
                         ELSE 0 
                     END as avg_margin
                 FROM filtered_products p
@@ -207,11 +279,33 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount, i
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('brand_metrics', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating brand metrics');
         throw error;
     } finally {

inventory-server/scripts/metrics/category-metrics.js

@@ -1,8 +1,11 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateCategoryMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateCategoryMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +16,28 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders: 0,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // Get order count that will be processed
+        const [orderCount] = await connection.query(`
+            SELECT COUNT(*) as count 
+            FROM orders o 
+            WHERE o.canceled = false
+        `);
+        processedOrders = orderCount[0].count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +47,12 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
         
         // First, calculate base category metrics
@@ -67,10 +93,20 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Then update with margin and turnover data
         await connection.query(`
@@ -80,19 +116,35 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                     SUM(o.quantity * o.price) as total_sales,
                     SUM(o.quantity * (o.price - p.cost_price)) as total_margin,
                     SUM(o.quantity) as units_sold,
-                    AVG(GREATEST(p.stock_quantity, 0)) as avg_stock
+                    AVG(GREATEST(p.stock_quantity, 0)) as avg_stock,
+                    COUNT(DISTINCT DATE(o.date)) as active_days
                 FROM product_categories pc
                 JOIN products p ON pc.pid = p.pid
                 JOIN orders o ON p.pid = o.pid
+                LEFT JOIN turnover_config tc ON 
+                    (tc.category_id = pc.cat_id AND tc.vendor = p.vendor) OR
+                    (tc.category_id = pc.cat_id AND tc.vendor IS NULL) OR
+                    (tc.category_id IS NULL AND tc.vendor = p.vendor) OR
+                    (tc.category_id IS NULL AND tc.vendor IS NULL)
                 WHERE o.canceled = false 
-                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR)
+                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL COALESCE(tc.calculation_period_days, 30) DAY)
                 GROUP BY pc.cat_id
             )
             UPDATE category_metrics cm
             JOIN category_sales cs ON cm.category_id = cs.cat_id
+            LEFT JOIN turnover_config tc ON 
+                (tc.category_id = cm.category_id AND tc.vendor IS NULL) OR
+                (tc.category_id IS NULL AND tc.vendor IS NULL)
             SET 
                 cm.avg_margin = COALESCE(cs.total_margin * 100.0 / NULLIF(cs.total_sales, 0), 0),
-                cm.turnover_rate = LEAST(COALESCE(cs.units_sold / NULLIF(cs.avg_stock, 0), 0), 999.99),
+                cm.turnover_rate = CASE 
+                    WHEN cs.avg_stock > 0 AND cs.active_days > 0 
+                    THEN LEAST(
+                        (cs.units_sold / cs.avg_stock) * (365.0 / cs.active_days),
+                        999.99
+                    )
+                    ELSE 0 
+                END,
                 cm.last_calculated_at = NOW()
         `);
 
@@ -105,20 +157,34 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Finally update growth rates
         await connection.query(`
             WITH current_period AS (
                 SELECT 
                     pc.cat_id,
-                    SUM(o.quantity * o.price) as revenue
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
+                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0) - p.cost_price)) as gross_profit,
+                    COUNT(DISTINCT DATE(o.date)) as days
                 FROM product_categories pc
                 JOIN products p ON pc.pid = p.pid
                 JOIN orders o ON p.pid = o.pid
+                LEFT JOIN sales_seasonality ss ON MONTH(o.date) = ss.month
                 WHERE o.canceled = false 
                     AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 3 MONTH)
                 GROUP BY pc.cat_id
@@ -126,30 +192,106 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
             previous_period AS (
                 SELECT 
                     pc.cat_id,
-                    SUM(o.quantity * o.price) as revenue
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
+                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
+                    COUNT(DISTINCT DATE(o.date)) as days
+                FROM product_categories pc
+                JOIN products p ON pc.pid = p.pid
+                JOIN orders o ON p.pid = o.pid
+                LEFT JOIN sales_seasonality ss ON MONTH(o.date) = ss.month
+                WHERE o.canceled = false 
+                    AND o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 15 MONTH) 
+                    AND DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+                GROUP BY pc.cat_id
+            ),
+            trend_data AS (
+                SELECT 
+                    pc.cat_id,
+                    MONTH(o.date) as month,
+                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
+                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
+                    COUNT(DISTINCT DATE(o.date)) as days_in_month
+                FROM product_categories pc
+                JOIN products p ON pc.pid = p.pid
+                JOIN orders o ON p.pid = o.pid
+                LEFT JOIN sales_seasonality ss ON MONTH(o.date) = ss.month
+                WHERE o.canceled = false 
+                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 15 MONTH)
+                GROUP BY pc.cat_id, MONTH(o.date)
+            ),
+            trend_stats AS (
+                SELECT 
+                    cat_id,
+                    COUNT(*) as n,
+                    AVG(month) as avg_x,
+                    AVG(revenue / NULLIF(days_in_month, 0)) as avg_y,
+                    SUM(month * (revenue / NULLIF(days_in_month, 0))) as sum_xy,
+                    SUM(month * month) as sum_xx
+                FROM trend_data
+                GROUP BY cat_id
+                HAVING COUNT(*) >= 6
+            ),
+            trend_analysis AS (
+                SELECT 
+                    cat_id,
+                    ((n * sum_xy) - (avg_x * n * avg_y)) / 
+                        NULLIF((n * sum_xx) - (n * avg_x * avg_x), 0) as trend_slope,
+                    avg_y as avg_daily_revenue
+                FROM trend_stats
+            ),
+            margin_calc AS (
+                SELECT 
+                    pc.cat_id,
+                    CASE 
+                        WHEN SUM(o.quantity * o.price) > 0 THEN
+                            GREATEST(
+                                -100.0,
+                                LEAST(
+                                    100.0,
+                                    (
+                                        SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
+                                        SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
+                                    ) * 100.0 / 
+                                    NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
+                                )
+                            )
+                        ELSE NULL
+                    END as avg_margin
                 FROM product_categories pc
                 JOIN products p ON pc.pid = p.pid
                 JOIN orders o ON p.pid = o.pid
                 WHERE o.canceled = false 
-                    AND o.date BETWEEN DATE_SUB(CURRENT_DATE, INTERVAL 15 MONTH) 
-                    AND DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 3 MONTH)
                 GROUP BY pc.cat_id
             )
             UPDATE category_metrics cm
             LEFT JOIN current_period cp ON cm.category_id = cp.cat_id
             LEFT JOIN previous_period pp ON cm.category_id = pp.cat_id
+            LEFT JOIN trend_analysis ta ON cm.category_id = ta.cat_id
+            LEFT JOIN margin_calc mc ON cm.category_id = mc.cat_id
             SET 
                 cm.growth_rate = CASE
                     WHEN pp.revenue = 0 AND COALESCE(cp.revenue, 0) > 0 THEN 100.0
-                    WHEN pp.revenue = 0 THEN 0.0
-                    ELSE LEAST(
+                    WHEN pp.revenue = 0 OR cp.revenue IS NULL THEN 0.0
+                    WHEN ta.trend_slope IS NOT NULL THEN
                         GREATEST(
-                            ((COALESCE(cp.revenue, 0) - pp.revenue) / pp.revenue) * 100.0,
-                            -100.0
-                        ),
+                            -100.0,
+                            LEAST(
+                                (ta.trend_slope / NULLIF(ta.avg_daily_revenue, 0)) * 365 * 100,
                                 999.99
                             )
+                        )
+                    ELSE
+                        GREATEST(
+                            -100.0,
+                            LEAST(
+                                ((COALESCE(cp.revenue, 0) - pp.revenue) / 
+                                    NULLIF(ABS(pp.revenue), 0)) * 100.0,
+                                999.99
+                            )
+                        )
                 END,
+                cm.avg_margin = COALESCE(mc.avg_margin, cm.avg_margin),
                 cm.last_calculated_at = NOW()
             WHERE cp.cat_id IS NOT NULL OR pp.cat_id IS NOT NULL
         `);
@@ -163,10 +305,20 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Calculate time-based metrics
         await connection.query(`
@@ -189,13 +341,23 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                 COUNT(DISTINCT CASE WHEN p.visible = true THEN p.pid END) as active_products,
                 SUM(p.stock_quantity * p.cost_price) as total_value,
                 SUM(o.quantity * o.price) as total_revenue,
+                CASE
+                    WHEN SUM(o.quantity * o.price) > 0 THEN
+                        LEAST(
+                            GREATEST(
+                                SUM(o.quantity * (o.price - GREATEST(p.cost_price, 0))) * 100.0 / 
+                                SUM(o.quantity * o.price),
+                                -100
+                            ),
+                            100
+                        )
+                    ELSE 0
+                END as avg_margin,
                 COALESCE(
-                    SUM(o.quantity * (o.price - p.cost_price)) * 100.0 / 
-                    NULLIF(SUM(o.quantity * o.price), 0),
-                    0
-                ) as avg_margin,
-                COALESCE(
+                    LEAST(
                         SUM(o.quantity) / NULLIF(AVG(GREATEST(p.stock_quantity, 0)), 0),
+                        999.99
+                    ),
                     0
                 ) as turnover_rate
             FROM product_categories pc
@@ -216,17 +378,138 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
         processedCount = Math.floor(totalProducts * 0.99);
         outputProgress({
             status: 'running',
-            operation: 'Time-based metrics calculated',
+            operation: 'Time-based metrics calculated, updating category-sales metrics',
             current: processedCount,
             total: totalProducts,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
+        // Calculate category-sales metrics
+        await connection.query(`
+            INSERT INTO category_sales_metrics (
+                category_id,
+                brand,
+                period_start,
+                period_end,
+                avg_daily_sales,
+                total_sold,
+                num_products,
+                avg_price,
+                last_calculated_at
+            )
+            WITH date_ranges AS (
+                SELECT 
+                    DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY) as period_start,
+                    CURRENT_DATE as period_end
+                UNION ALL
+                SELECT 
+                    DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY),
+                    DATE_SUB(CURRENT_DATE, INTERVAL 31 DAY)
+                UNION ALL
+                SELECT 
+                    DATE_SUB(CURRENT_DATE, INTERVAL 180 DAY),
+                    DATE_SUB(CURRENT_DATE, INTERVAL 91 DAY)
+                UNION ALL
+                SELECT 
+                    DATE_SUB(CURRENT_DATE, INTERVAL 365 DAY),
+                    DATE_SUB(CURRENT_DATE, INTERVAL 181 DAY)
+            ),
+            sales_data AS (
+                SELECT 
+                    pc.cat_id,
+                    COALESCE(p.brand, 'Unknown') as brand,
+                    dr.period_start,
+                    dr.period_end,
+                    COUNT(DISTINCT p.pid) as num_products,
+                    SUM(o.quantity) as total_sold,
+                    SUM(o.quantity * o.price) as total_revenue,
+                    COUNT(DISTINCT DATE(o.date)) as num_days
+                FROM products p
+                JOIN product_categories pc ON p.pid = pc.pid
+                JOIN orders o ON p.pid = o.pid
+                CROSS JOIN date_ranges dr
+                WHERE o.canceled = false
+                    AND o.date BETWEEN dr.period_start AND dr.period_end
+                GROUP BY pc.cat_id, p.brand, dr.period_start, dr.period_end
+            )
+            SELECT 
+                cat_id as category_id,
+                brand,
+                period_start,
+                period_end,
+                CASE 
+                    WHEN num_days > 0 
+                    THEN total_sold / num_days 
+                    ELSE 0 
+                END as avg_daily_sales,
+                total_sold,
+                num_products,
+                CASE 
+                    WHEN total_sold > 0 
+                    THEN total_revenue / total_sold 
+                    ELSE 0 
+                END as avg_price,
+                NOW() as last_calculated_at
+            FROM sales_data
+            ON DUPLICATE KEY UPDATE
+                avg_daily_sales = VALUES(avg_daily_sales),
+                total_sold = VALUES(total_sold),
+                num_products = VALUES(num_products),
+                avg_price = VALUES(avg_price),
+                last_calculated_at = VALUES(last_calculated_at)
+        `);
+
+        processedCount = Math.floor(totalProducts * 1.0);
+        outputProgress({
+            status: 'running',
+            operation: 'Category-sales metrics calculated',
+            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)
+            }
+        });
+
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('category_metrics', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating category metrics');
         throw error;
     } finally {

inventory-server/scripts/metrics/financial-metrics.js

@@ -1,8 +1,11 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateFinancialMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateFinancialMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +16,29 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders: 0,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // Get order count that will be processed
+        const [orderCount] = await connection.query(`
+            SELECT COUNT(*) as count 
+            FROM orders o 
+            WHERE o.canceled = false
+                AND DATE(o.date) >= DATE_SUB(CURDATE(), INTERVAL 12 MONTH)
+        `);
+        processedOrders = orderCount[0].count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +48,12 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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
@@ -59,7 +86,8 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
                     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)
                     ELSE 0 
-                END
+                END,
+                pm.last_calculated_at = CURRENT_TIMESTAMP
         `);
 
         processedCount = Math.floor(totalProducts * 0.65);
@@ -71,10 +99,20 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Update time-based aggregates with optimized query
         await connection.query(`
@@ -115,11 +153,33 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('financial_metrics', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating financial metrics');
         throw error;
     } finally {

inventory-server/scripts/metrics/product-metrics.js

@@ -11,11 +11,21 @@ function sanitizeValue(value) {
 
 async function calculateProductMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    const BATCH_SIZE = 5000;
+    
     try {
         // Skip flags are inherited from the parent scope
         const SKIP_PRODUCT_BASE_METRICS = 0;
         const SKIP_PRODUCT_TIME_AGGREGATES = 0;
 
+        // Get total product count if not provided
+        if (!totalProducts) {
+            const [productCount] = await connection.query('SELECT COUNT(*) as count FROM products');
+            totalProducts = productCount[0].count;
+        }
+
         if (isCancelled) {
             outputProgress({
                 status: 'cancelled',
@@ -25,10 +35,36 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // First ensure all products have a metrics record
+        await connection.query(`
+            INSERT IGNORE INTO product_metrics (pid, last_calculated_at)
+            SELECT pid, NOW()
+            FROM products
+        `);
+
+        // Get threshold settings once
+        const [thresholds] = await connection.query(`
+            SELECT critical_days, reorder_days, overstock_days, low_stock_threshold
+            FROM stock_thresholds 
+            WHERE category_id IS NULL AND vendor IS NULL
+            LIMIT 1
+        `);
+        const defaultThresholds = thresholds[0];
 
         // Calculate base product metrics
         if (!SKIP_PRODUCT_BASE_METRICS) {
@@ -40,89 +76,237 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                 elapsed: formatElapsedTime(startTime),
                 remaining: estimateRemaining(startTime, processedCount, totalProducts),
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                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 base metrics
+            // Get order count that will be processed
+            const [orderCount] = await connection.query(`
+                SELECT COUNT(*) as count 
+                FROM orders o 
+                WHERE o.canceled = false
+            `);
+            processedOrders = orderCount[0].count;
+
+            // Clear temporary tables
+            await connection.query('TRUNCATE TABLE temp_sales_metrics');
+            await connection.query('TRUNCATE TABLE temp_purchase_metrics');
+
+            // Populate temp_sales_metrics with base stats and sales averages
+            await connection.query(`
+                INSERT INTO temp_sales_metrics
+                SELECT 
+                    p.pid,
+                    COALESCE(SUM(o.quantity) / NULLIF(COUNT(DISTINCT DATE(o.date)), 0), 0) as daily_sales_avg,
+                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 7), 0), 0) as weekly_sales_avg,
+                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 30), 0), 0) as monthly_sales_avg,
+                    COALESCE(SUM(o.quantity * o.price), 0) as total_revenue,
+                    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 avg_margin_percent,
+                    MIN(o.date) as first_sale_date,
+                    MAX(o.date) as last_sale_date
+                FROM products p
+                LEFT JOIN orders o ON p.pid = o.pid 
+                    AND o.canceled = false
+                    AND o.date >= DATE_SUB(CURDATE(), INTERVAL 90 DAY)
+                GROUP BY p.pid
+            `);
+
+            // Populate temp_purchase_metrics
+            await connection.query(`
+                INSERT INTO temp_purchase_metrics
+                SELECT 
+                    p.pid,
+                    AVG(DATEDIFF(po.received_date, po.date)) 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
+                FROM products p
+                LEFT JOIN purchase_orders po ON p.pid = po.pid 
+                    AND po.received_date IS NOT NULL
+                    AND po.date >= DATE_SUB(CURDATE(), INTERVAL 365 DAY)
+                GROUP BY p.pid
+            `);
+
+            // Process updates in batches
+            let lastPid = 0;
+            while (true) {
+                if (isCancelled) break;
+
+                const [batch] = await connection.query(
+                    'SELECT pid FROM products WHERE pid > ? ORDER BY pid LIMIT ?',
+                    [lastPid, BATCH_SIZE]
+                );
+
+                if (batch.length === 0) break;
+
+                await connection.query(`
+                    UPDATE product_metrics pm
+                    JOIN products p ON pm.pid = p.pid
+                    LEFT JOIN temp_sales_metrics sm ON pm.pid = sm.pid
+                    LEFT JOIN temp_purchase_metrics lm ON pm.pid = lm.pid
+                    SET 
+                        pm.inventory_value = p.stock_quantity * NULLIF(p.cost_price, 0),
+                        pm.daily_sales_avg = COALESCE(sm.daily_sales_avg, 0),
+                        pm.weekly_sales_avg = COALESCE(sm.weekly_sales_avg, 0),
+                        pm.monthly_sales_avg = COALESCE(sm.monthly_sales_avg, 0),
+                        pm.total_revenue = COALESCE(sm.total_revenue, 0),
+                        pm.avg_margin_percent = COALESCE(sm.avg_margin_percent, 0),
+                        pm.first_sale_date = sm.first_sale_date,
+                        pm.last_sale_date = sm.last_sale_date,
+                        pm.avg_lead_time_days = COALESCE(lm.avg_lead_time_days, 30),
+                        pm.days_of_inventory = CASE 
+                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 
+                            THEN FLOOR(p.stock_quantity / NULLIF(sm.daily_sales_avg, 0))
+                            ELSE NULL 
+                        END,
+                        pm.weeks_of_inventory = CASE 
+                            WHEN COALESCE(sm.weekly_sales_avg, 0) > 0 
+                            THEN FLOOR(p.stock_quantity / NULLIF(sm.weekly_sales_avg, 0))
+                            ELSE NULL 
+                        END,
+                        pm.stock_status = CASE
+                            WHEN p.stock_quantity <= 0 THEN 'Out of Stock'
+                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 AND p.stock_quantity <= ? THEN 'Low Stock'
+                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 THEN 'In Stock'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ? THEN 'Critical'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= ? THEN 'Reorder'
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ? THEN 'Overstocked'
+                            ELSE 'Healthy'
+                        END,
+                        pm.safety_stock = CASE
+                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
+                                CEIL(sm.daily_sales_avg * SQRT(COALESCE(lm.avg_lead_time_days, 30)) * 1.96)
+                            ELSE ?
+                        END,
+                        pm.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(COALESCE(lm.avg_lead_time_days, 30)) * 1.96)
+                            ELSE ?
+                        END,
+                        pm.reorder_qty = CASE
+                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 AND NULLIF(p.cost_price, 0) IS NOT NULL THEN
+                                GREATEST(
+                                    CEIL(SQRT((2 * (sm.daily_sales_avg * 365) * 25) / (NULLIF(p.cost_price, 0) * 0.25))),
+                                    ?
+                                )
+                            ELSE ?
+                        END,
+                        pm.overstocked_amt = CASE
+                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > ? 
+                            THEN GREATEST(0, p.stock_quantity - CEIL(sm.daily_sales_avg * ?))
+                            ELSE 0
+                        END,
+                        pm.last_calculated_at = NOW()
+                    WHERE p.pid IN (${batch.map(() => '?').join(',')})
+                `,
+                [
+                    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.map(row => row.pid)
+                ]
+                );
+
+                lastPid = batch[batch.length - 1].pid;
+                processedCount += batch.length;
+
+                outputProgress({
+                    status: 'running',
+                    operation: 'Processing base metrics batch',
+                    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 forecast accuracy and bias in batches
+            lastPid = 0;
+            while (true) {
+                if (isCancelled) break;
+
+                const [batch] = await connection.query(
+                    'SELECT pid FROM products WHERE pid > ? ORDER BY pid LIMIT ?',
+                    [lastPid, BATCH_SIZE]
+                );
+
+                if (batch.length === 0) break;
+
                 await connection.query(`
                     UPDATE product_metrics pm
                     JOIN (
                         SELECT 
-                        p.pid,
-                        p.cost_price * p.stock_quantity as inventory_value,
-                        SUM(o.quantity) as total_quantity,
-                        COUNT(DISTINCT o.order_number) as number_of_orders,
-                        SUM(o.quantity * o.price) as total_revenue,
-                        SUM(o.quantity * p.cost_price) as cost_of_goods_sold,
-                        AVG(o.price) as avg_price,
-                        STDDEV(o.price) as price_std,
-                        MIN(o.date) as first_sale_date,
-                        MAX(o.date) as last_sale_date,
-                        COUNT(DISTINCT DATE(o.date)) as active_days
-                    FROM products p
-                    LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
-                    GROUP BY p.pid
-                ) stats ON pm.pid = stats.pid
+                            sf.pid,
+                            AVG(CASE 
+                                WHEN o.quantity > 0 
+                                THEN ABS(sf.forecast_units - o.quantity) / o.quantity * 100
+                                ELSE 100 
+                            END) as avg_forecast_error,
+                            AVG(CASE 
+                                WHEN o.quantity > 0 
+                                THEN (sf.forecast_units - o.quantity) / o.quantity * 100
+                                ELSE 0 
+                            END) as avg_forecast_bias,
+                            MAX(sf.forecast_date) as last_forecast_date
+                        FROM sales_forecasts sf
+                        JOIN orders o ON sf.pid = o.pid 
+                            AND DATE(o.date) = sf.forecast_date
+                        WHERE o.canceled = false
+                            AND sf.forecast_date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
+                            AND sf.pid IN (?)
+                        GROUP BY sf.pid
+                    ) fa ON pm.pid = fa.pid
                     SET 
-                    pm.inventory_value = COALESCE(stats.inventory_value, 0),
-                    pm.avg_quantity_per_order = COALESCE(stats.total_quantity / NULLIF(stats.number_of_orders, 0), 0),
-                    pm.number_of_orders = COALESCE(stats.number_of_orders, 0),
-                    pm.total_revenue = COALESCE(stats.total_revenue, 0),
-                    pm.cost_of_goods_sold = COALESCE(stats.cost_of_goods_sold, 0),
-                    pm.gross_profit = COALESCE(stats.total_revenue - stats.cost_of_goods_sold, 0),
-                    pm.avg_margin_percent = CASE 
-                        WHEN COALESCE(stats.total_revenue, 0) > 0 
-                        THEN ((stats.total_revenue - stats.cost_of_goods_sold) / stats.total_revenue) * 100 
-                        ELSE 0 
-                    END,
-                    pm.first_sale_date = stats.first_sale_date,
-                    pm.last_sale_date = stats.last_sale_date,
-                    pm.gmroi = CASE 
-                        WHEN COALESCE(stats.inventory_value, 0) > 0 
-                        THEN (stats.total_revenue - stats.cost_of_goods_sold) / stats.inventory_value
-                        ELSE 0 
-                    END,
+                        pm.forecast_accuracy = GREATEST(0, 100 - LEAST(fa.avg_forecast_error, 100)),
+                        pm.forecast_bias = GREATEST(-100, LEAST(fa.avg_forecast_bias, 100)),
+                        pm.last_forecast_date = fa.last_forecast_date,
                         pm.last_calculated_at = NOW()
-            `);
+                    WHERE pm.pid IN (?)
+                `, [batch.map(row => row.pid), batch.map(row => row.pid)]);
 
-            processedCount = Math.floor(totalProducts * 0.4);
-            outputProgress({
-                status: 'running',
-                operation: 'Base product metrics calculated',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-        } else {
-            processedCount = Math.floor(totalProducts * 0.4);
-            outputProgress({
-                status: 'running',
-                operation: 'Skipping base product metrics calculation',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
+                lastPid = batch[batch.length - 1].pid;
+            }
         }
-
-        if (isCancelled) return processedCount;
 
         // Calculate product time aggregates
         if (!SKIP_PRODUCT_TIME_AGGREGATES) {
             outputProgress({
                 status: 'running',
                 operation: 'Starting product time aggregates calculation',
-                current: processedCount,
-                total: totalProducts,
+                current: processedCount || 0,
+                total: totalProducts || 0,
                 elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedCount || 0),
+                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
 
             // Calculate time-based aggregates
@@ -179,29 +363,206 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
             outputProgress({
                 status: 'running',
                 operation: 'Product time aggregates calculated',
-                current: processedCount,
-                total: totalProducts,
+                current: processedCount || 0,
+                total: totalProducts || 0,
                 elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedCount || 0),
+                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
             });
         } else {
             processedCount = Math.floor(totalProducts * 0.6);
             outputProgress({
                 status: 'running',
                 operation: 'Skipping product time aggregates calculation',
+                current: processedCount || 0,
+                total: totalProducts || 0,
+                elapsed: formatElapsedTime(startTime),
+                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
+                rate: calculateRate(startTime, processedCount || 0),
+                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
+                timing: {
+                    start_time: new Date(startTime).toISOString(),
+                    end_time: new Date().toISOString(),
+                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
+                }
+            });
+        }
+
+        // Calculate ABC classification
+        outputProgress({
+            status: 'running',
+            operation: 'Starting ABC classification',
             current: processedCount,
             total: totalProducts,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
+
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,  // This module doesn't process POs
+            success
+        };
+
+        const [abcConfig] = await connection.query('SELECT a_threshold, b_threshold FROM abc_classification_config WHERE id = 1');
+        const abcThresholds = abcConfig[0] || { a_threshold: 20, b_threshold: 50 };
+
+        // First, create and populate the rankings table with an index
+        await connection.query('DROP TEMPORARY TABLE IF EXISTS temp_revenue_ranks');
+        await connection.query(`
+            CREATE TEMPORARY TABLE temp_revenue_ranks (
+                pid BIGINT NOT NULL,
+                total_revenue DECIMAL(10,3),
+                rank_num INT,
+                dense_rank_num INT,
+                percentile DECIMAL(5,2),
+                total_count INT,
+                PRIMARY KEY (pid),
+                INDEX (rank_num),
+                INDEX (dense_rank_num),
+                INDEX (percentile)
+            ) ENGINE=MEMORY
+        `);
+
+        // Calculate rankings with proper tie handling
+        await connection.query(`
+            INSERT INTO temp_revenue_ranks
+            WITH revenue_data AS (
+                SELECT 
+                    pid,
+                    total_revenue,
+                    COUNT(*) OVER () as total_count,
+                    PERCENT_RANK() OVER (ORDER BY total_revenue DESC) * 100 as percentile,
+                    RANK() OVER (ORDER BY total_revenue DESC) as rank_num,
+                    DENSE_RANK() OVER (ORDER BY total_revenue DESC) as dense_rank_num
+                FROM product_metrics 
+                WHERE total_revenue > 0
+            )
+            SELECT 
+                pid,
+                total_revenue,
+                rank_num,
+                dense_rank_num,
+                percentile,
+                total_count
+            FROM revenue_data
+        `);
+
+        // Get total count for percentage calculation
+        const [rankingCount] = await connection.query('SELECT MAX(rank_num) as total_count FROM temp_revenue_ranks');
+        const totalCount = rankingCount[0].total_count || 1;
+        const max_rank = totalCount;
+
+        // Process updates in batches
+        let abcProcessedCount = 0;
+        const batchSize = 5000;
+
+        while (true) {
+            if (isCancelled) return {
+                processedProducts: processedCount,
+                processedOrders,
+                processedPurchaseOrders: 0,  // This module doesn't process POs
+                success
+            };
+
+            // Get a batch of PIDs that need updating
+            const [pids] = await connection.query(`
+                SELECT pm.pid 
+                FROM product_metrics pm
+                LEFT JOIN temp_revenue_ranks tr ON pm.pid = tr.pid
+                WHERE pm.abc_class IS NULL 
+                OR pm.abc_class != 
+                    CASE 
+                        WHEN tr.pid IS NULL THEN 'C'
+                        WHEN tr.percentile <= ? THEN 'A'
+                        WHEN tr.percentile <= ? THEN 'B'
+                        ELSE 'C'
+                    END
+                LIMIT ?
+            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, batchSize]);
+
+            if (pids.length === 0) break;
+
+            await connection.query(`
+                UPDATE product_metrics pm
+                LEFT JOIN temp_revenue_ranks tr ON pm.pid = tr.pid
+                SET pm.abc_class = 
+                    CASE 
+                        WHEN tr.pid IS NULL THEN 'C'
+                        WHEN tr.percentile <= ? THEN 'A'
+                        WHEN tr.percentile <= ? THEN 'B'
+                        ELSE 'C'
+                    END,
+                    pm.last_calculated_at = NOW()
+                WHERE pm.pid IN (?)
+            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, pids.map(row => row.pid)]);
+
+            // Now update turnover rate with proper handling of zero inventory periods
+            await connection.query(`
+                UPDATE product_metrics pm
+                JOIN (
+                    SELECT 
+                        o.pid,
+                        SUM(o.quantity) as total_sold,
+                        COUNT(DISTINCT DATE(o.date)) as active_days,
+                        AVG(CASE 
+                            WHEN p.stock_quantity > 0 THEN p.stock_quantity 
+                            ELSE NULL 
+                        END) as avg_nonzero_stock
+                    FROM orders o
+                    JOIN products p ON o.pid = p.pid
+                    WHERE o.canceled = false 
+                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
+                    AND o.pid IN (?)
+                    GROUP BY o.pid
+                ) sales ON pm.pid = sales.pid
+                SET 
+                    pm.turnover_rate = CASE 
+                        WHEN sales.avg_nonzero_stock > 0 AND sales.active_days > 0 
+                        THEN LEAST(
+                            (sales.total_sold / sales.avg_nonzero_stock) * (365.0 / sales.active_days),
+                            999.99
+                        )
+                        ELSE 0 
+                    END,
+                    pm.last_calculated_at = NOW()
+                WHERE pm.pid IN (?)
+            `, [pids.map(row => row.pid), pids.map(row => row.pid)]);
         }
 
-        return processedCount;
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('product_metrics', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount || 0,
+            processedOrders: processedOrders || 0,
+            processedPurchaseOrders: 0,  // This module doesn't process POs
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating product metrics');
         throw error;
     } finally {
@@ -257,9 +618,9 @@ function calculateReorderQuantities(stock, stock_status, daily_sales_avg, avg_le
     if (daily_sales_avg > 0) {
         const annual_demand = daily_sales_avg * 365;
         const order_cost = 25; // Fixed cost per order
-        const holding_cost_percent = 0.25; // 25% annual holding cost
+        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_percent));
+        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);

inventory-server/scripts/metrics/sales-forecasts.js

@@ -1,8 +1,11 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateSalesForecasts(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateSalesForecasts(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +16,29 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders: 0,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // Get order count that will be processed
+        const [orderCount] = await connection.query(`
+            SELECT COUNT(*) as count 
+            FROM orders o 
+            WHERE o.canceled = false
+                AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 90 DAY)
+        `);
+        processedOrders = orderCount[0].count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +48,12 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
         // First, create a temporary table for forecast dates
@@ -65,10 +92,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Create temporary table for daily sales stats
         await connection.query(`
@@ -94,10 +131,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Create temporary table for product stats
         await connection.query(`
@@ -119,10 +166,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Calculate product-level forecasts
         await connection.query(`
@@ -134,37 +191,76 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
                 confidence_level,
                 last_calculated_at
             )
+            WITH daily_stats AS (
+                SELECT 
+                    ds.pid,
+                    AVG(ds.daily_quantity) as avg_daily_qty,
+                    STDDEV(ds.daily_quantity) as std_daily_qty,
+                    COUNT(DISTINCT ds.day_count) as data_points,
+                    SUM(ds.day_count) as total_days,
+                    AVG(ds.daily_revenue) as avg_daily_revenue,
+                    STDDEV(ds.daily_revenue) as std_daily_revenue,
+                    MIN(ds.daily_quantity) as min_daily_qty,
+                    MAX(ds.daily_quantity) as max_daily_qty,
+                    -- Calculate variance without using LAG
+                    COALESCE(
+                        STDDEV(ds.daily_quantity) / NULLIF(AVG(ds.daily_quantity), 0),
+                        0
+                    ) as daily_variance_ratio
+                FROM temp_daily_sales ds
+                GROUP BY ds.pid
+                HAVING AVG(ds.daily_quantity) > 0
+            )
             SELECT 
                 ds.pid,
                 fd.forecast_date,
                 GREATEST(0, 
-                    AVG(ds.daily_quantity) * 
-                    (1 + COALESCE(sf.seasonality_factor, 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,
+                        2
+                    )
                 ) as forecast_units,
                 GREATEST(0, 
+                    ROUND(
                         COALESCE(
                             CASE 
-                            WHEN SUM(ds.day_count) >= 4 THEN AVG(ds.daily_revenue)
+                                WHEN ds.data_points >= 4 THEN ds.avg_daily_revenue
                                 ELSE ps.overall_avg_revenue
                             END * 
                             (1 + COALESCE(sf.seasonality_factor, 0)) *
-                        (0.95 + (RAND() * 0.1)),
+                            CASE
+                                WHEN ds.std_daily_revenue / NULLIF(ds.avg_daily_revenue, 0) > 1.5 THEN 0.85
+                                WHEN ds.std_daily_revenue / NULLIF(ds.avg_daily_revenue, 0) > 1.0 THEN 0.9
+                                WHEN ds.std_daily_revenue / NULLIF(ds.avg_daily_revenue, 0) > 0.5 THEN 0.95
+                                ELSE 1.0
+                            END,
                             0
+                        ),
+                        2
                     )
                 ) as forecast_revenue,
                 CASE
-                    WHEN ps.total_days >= 60 THEN 90
-                    WHEN ps.total_days >= 30 THEN 80
-                    WHEN ps.total_days >= 14 THEN 70
+                    WHEN ds.total_days >= 60 AND ds.daily_variance_ratio < 0.5 THEN 90
+                    WHEN ds.total_days >= 60 THEN 85
+                    WHEN ds.total_days >= 30 AND ds.daily_variance_ratio < 0.5 THEN 80
+                    WHEN ds.total_days >= 30 THEN 75
+                    WHEN ds.total_days >= 14 AND ds.daily_variance_ratio < 0.5 THEN 70
+                    WHEN ds.total_days >= 14 THEN 65
                     ELSE 60
                 END as confidence_level,
                 NOW() as last_calculated_at
-            FROM temp_daily_sales ds
+            FROM daily_stats ds
             JOIN temp_product_stats ps ON ds.pid = ps.pid
             CROSS JOIN temp_forecast_dates fd
             LEFT JOIN sales_seasonality sf ON fd.month = sf.month
-            GROUP BY ds.pid, fd.forecast_date, ps.overall_avg_revenue, ps.total_days, sf.seasonality_factor
-            HAVING AVG(ds.daily_quantity) > 0
+            GROUP BY ds.pid, fd.forecast_date, ps.overall_avg_revenue, sf.seasonality_factor
             ON DUPLICATE KEY UPDATE
                 forecast_units = VALUES(forecast_units),
                 forecast_revenue = VALUES(forecast_revenue),
@@ -181,10 +277,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Create temporary table for category stats
         await connection.query(`
@@ -221,10 +327,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Calculate category-level forecasts
         await connection.query(`
@@ -292,11 +408,33 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('sales_forecasts', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating sales forecasts');
         throw error;
     } finally {

inventory-server/scripts/metrics/time-aggregates.js

@@ -1,8 +1,11 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateTimeAggregates(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateTimeAggregates(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +16,28 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders: 0,
+                processedPurchaseOrders: 0,
+                success
+            };
+        }
+
+        // Get order count that will be processed
+        const [orderCount] = await connection.query(`
+            SELECT COUNT(*) as count 
+            FROM orders o 
+            WHERE o.canceled = false
+        `);
+        processedOrders = orderCount[0].count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +47,12 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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
@@ -42,9 +68,11 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                 stock_received,
                 stock_ordered,
                 avg_price,
-                profit_margin
+                profit_margin,
+                inventory_value,
+                gmroi
             )
-            WITH sales_data AS (
+            WITH monthly_sales AS (
                 SELECT 
                     o.pid,
                     YEAR(o.date) as year,
@@ -55,17 +83,19 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                     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 0
-                        ELSE ((SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) - 
-                              SUM(COALESCE(p.cost_price, 0) * o.quantity)) / 
-                              SUM((o.price - COALESCE(o.discount, 0)) * o.quantity)) * 100
-                    END as profit_margin
+                        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)) 
+                            / 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 = 0
+                WHERE o.canceled = false
                 GROUP BY o.pid, YEAR(o.date), MONTH(o.date)
             ),
-            purchase_data AS (
+            monthly_stock AS (
                 SELECT 
                     pid,
                     YEAR(date) as year,
@@ -73,45 +103,100 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                     SUM(received) as stock_received,
                     SUM(ordered) as stock_ordered
                 FROM purchase_orders
-                WHERE status = 50
                 GROUP BY pid, YEAR(date), MONTH(date)
-            )
-            SELECT 
-                s.pid,
-                s.year,
-                s.month,
-                s.total_quantity_sold,
-                s.total_revenue,
-                s.total_cost,
-                s.order_count,
-                COALESCE(p.stock_received, 0) as stock_received,
-                COALESCE(p.stock_ordered, 0) as stock_ordered,
-                s.avg_price,
-                s.profit_margin
-            FROM sales_data s
-            LEFT JOIN purchase_data p 
-                ON s.pid = p.pid 
-                AND s.year = p.year 
-                AND s.month = p.month
-            UNION
+            ),
+            base_products AS (
                 SELECT 
                     p.pid,
-                p.year,
-                p.month,
+                    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,
+                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)
+                    ELSE 0 
+                END as gmroi
+            FROM (
+                SELECT * FROM monthly_sales s
+                UNION ALL
+                SELECT 
+                    ms.pid,
+                    ms.year,
+                    ms.month,
                     0 as total_quantity_sold,
                     0 as total_revenue,
                     0 as total_cost,
                     0 as order_count,
-                p.stock_received,
-                p.stock_ordered,
+                    NULL as avg_price,
+                    0 as profit_margin,
+                    NULL as inventory_value,
+                    0 as active_days
+                FROM monthly_stock ms
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM monthly_sales s2
+                    WHERE s2.pid = ms.pid
+                    AND s2.year = ms.year
+                    AND s2.month = ms.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
-            FROM purchase_data p
-            LEFT JOIN sales_data s
-                ON p.pid = s.pid 
-                AND p.year = s.year 
-                AND p.month = s.month
-            WHERE s.pid IS NULL
+                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
+            )
             ON DUPLICATE KEY UPDATE
                 total_quantity_sold = VALUES(total_quantity_sold),
                 total_revenue = VALUES(total_revenue),
@@ -120,7 +205,9 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                 stock_received = VALUES(stock_received),
                 stock_ordered = VALUES(stock_ordered),
                 avg_price = VALUES(avg_price),
-                profit_margin = VALUES(profit_margin)
+                profit_margin = VALUES(profit_margin),
+                inventory_value = VALUES(inventory_value),
+                gmroi = VALUES(gmroi)
         `);
 
         processedCount = Math.floor(totalProducts * 0.60);
@@ -132,10 +219,20 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
 
         // Update with financial metrics
         await connection.query(`
@@ -147,7 +244,7 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                     MONTH(o.date) 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 days_in_period
+                    COUNT(DISTINCT DATE(o.date)) as active_days
                 FROM products p
                 LEFT JOIN orders o ON p.pid = o.pid
                 WHERE o.canceled = false
@@ -156,12 +253,7 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
                 AND pta.year = fin.year 
                 AND pta.month = fin.month
             SET 
-                pta.inventory_value = COALESCE(fin.inventory_value, 0),
-                pta.gmroi = CASE 
-                    WHEN COALESCE(fin.inventory_value, 0) > 0 AND fin.days_in_period > 0 THEN 
-                        (COALESCE(fin.gross_profit, 0) * (365.0 / fin.days_in_period)) / COALESCE(fin.inventory_value, 0)
-                    ELSE 0 
-                END
+                pta.inventory_value = COALESCE(fin.inventory_value, 0)
         `);
 
         processedCount = Math.floor(totalProducts * 0.65);
@@ -173,11 +265,33 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('time_aggregates', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders: 0,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating time aggregates');
         throw error;
     } finally {

inventory-server/scripts/metrics/vendor-metrics.js

@@ -1,8 +1,12 @@
 const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');
 
-async function calculateVendorMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
+async function calculateVendorMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
     const connection = await getConnection();
+    let success = false;
+    let processedOrders = 0;
+    let processedPurchaseOrders = 0;
+    
     try {
         if (isCancelled) {
             outputProgress({
@@ -13,10 +17,36 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                 elapsed: formatElapsedTime(startTime),
                 remaining: null,
                 rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
-            });
-            return 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)
                 }
+            });
+            return {
+                processedProducts: processedCount,
+                processedOrders,
+                processedPurchaseOrders,
+                success
+            };
+        }
+
+        // Get counts of records that will be processed
+        const [[orderCount], [poCount]] = await Promise.all([
+            connection.query(`
+                SELECT COUNT(*) as count 
+                FROM orders o 
+                WHERE o.canceled = false
+            `),
+            connection.query(`
+                SELECT COUNT(*) as count 
+                FROM purchase_orders po 
+                WHERE po.status != 0
+            `)
+        ]);
+        processedOrders = orderCount.count;
+        processedPurchaseOrders = poCount.count;
 
         outputProgress({
             status: 'running',
@@ -26,7 +56,12 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
         // First ensure all vendors exist in vendor_details
@@ -50,10 +85,20 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        if (isCancelled) return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders,
+            success
+        };
 
         // Now calculate vendor metrics
         await connection.query(`
@@ -68,6 +113,8 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                 avg_order_value,
                 active_products,
                 total_products,
+                total_purchase_value,
+                avg_margin_percent,
                 status,
                 last_calculated_at
             )
@@ -76,7 +123,8 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                     p.vendor,
                     SUM(o.quantity * o.price) as total_revenue,
                     COUNT(DISTINCT o.id) as total_orders,
-                    COUNT(DISTINCT p.pid) as active_products
+                    COUNT(DISTINCT p.pid) as active_products,
+                    SUM(o.quantity * (o.price - p.cost_price)) as total_margin
                 FROM products p
                 JOIN orders o ON p.pid = o.pid
                 WHERE o.canceled = false
@@ -91,7 +139,8 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                     AVG(CASE 
                         WHEN po.receiving_status = 40 
                         THEN DATEDIFF(po.received_date, po.date) 
-                    END) as avg_lead_time_days
+                    END) as avg_lead_time_days,
+                    SUM(po.ordered * po.po_cost_price) as total_purchase_value
                 FROM products p
                 JOIN purchase_orders po ON p.pid = po.pid
                 WHERE po.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
@@ -127,6 +176,12 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                 END as avg_order_value,
                 COALESCE(vs.active_products, 0) as active_products,
                 COALESCE(vpr.total_products, 0) as total_products,
+                COALESCE(vp.total_purchase_value, 0) as total_purchase_value,
+                CASE 
+                    WHEN vs.total_revenue > 0 
+                    THEN (vs.total_margin / vs.total_revenue) * 100 
+                    ELSE 0 
+                END as avg_margin_percent,
                 'active' as status,
                 NOW() as last_calculated_at
             FROM vendor_sales vs
@@ -143,6 +198,8 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
                 avg_order_value = VALUES(avg_order_value),
                 active_products = VALUES(active_products),
                 total_products = VALUES(total_products),
+                total_purchase_value = VALUES(total_purchase_value),
+                avg_margin_percent = VALUES(avg_margin_percent),
                 status = VALUES(status),
                 last_calculated_at = VALUES(last_calculated_at)
         `);
@@ -150,17 +207,155 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount,
         processedCount = Math.floor(totalProducts * 0.9);
         outputProgress({
             status: 'running',
-            operation: 'Vendor metrics calculated',
+            operation: 'Vendor metrics calculated, updating time-based metrics',
             current: processedCount,
             total: totalProducts,
             elapsed: formatElapsedTime(startTime),
             remaining: estimateRemaining(startTime, processedCount, totalProducts),
             rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            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)
+            }
         });
 
-        return processedCount;
+        if (isCancelled) return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders,
+            success
+        };
+
+        // Calculate 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
+            )
+            WITH monthly_orders AS (
+                SELECT 
+                    p.vendor,
+                    YEAR(o.date) as year,
+                    MONTH(o.date) as month,
+                    COUNT(DISTINCT o.id) as total_orders,
+                    SUM(o.quantity * o.price) as total_revenue,
+                    SUM(o.quantity * (o.price - p.cost_price)) as total_margin
+                FROM products p
+                JOIN orders o ON p.pid = o.pid
+                WHERE o.canceled = false
+                    AND o.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+                    AND p.vendor IS NOT NULL
+                GROUP BY p.vendor, YEAR(o.date), MONTH(o.date)
+            ),
+            monthly_po AS (
+                SELECT 
+                    p.vendor,
+                    YEAR(po.date) as year,
+                    MONTH(po.date) as month,
+                    COUNT(DISTINCT po.id) as total_po,
+                    COUNT(DISTINCT CASE 
+                        WHEN po.receiving_status = 40 AND po.received_date > po.expected_date 
+                        THEN po.id 
+                    END) as late_orders,
+                    AVG(CASE 
+                        WHEN po.receiving_status = 40 
+                        THEN DATEDIFF(po.received_date, po.date)
+                    END) as avg_lead_time_days,
+                    SUM(po.ordered * po.po_cost_price) as total_purchase_value
+                FROM products p
+                JOIN purchase_orders po ON p.pid = po.pid
+                WHERE po.date >= DATE_SUB(CURRENT_DATE, INTERVAL 12 MONTH)
+                    AND p.vendor IS NOT NULL
+                GROUP BY p.vendor, YEAR(po.date), MONTH(po.date)
+            )
+            SELECT 
+                mo.vendor,
+                mo.year,
+                mo.month,
+                COALESCE(mp.total_po, 0) as total_orders,
+                COALESCE(mp.late_orders, 0) as late_orders,
+                COALESCE(mp.avg_lead_time_days, 0) as avg_lead_time_days,
+                COALESCE(mp.total_purchase_value, 0) as total_purchase_value,
+                mo.total_revenue,
+                CASE 
+                    WHEN mo.total_revenue > 0 
+                    THEN (mo.total_margin / mo.total_revenue) * 100 
+                    ELSE 0 
+                END as avg_margin_percent
+            FROM monthly_orders mo
+            LEFT JOIN monthly_po mp ON mo.vendor = mp.vendor 
+                AND mo.year = mp.year 
+                AND mo.month = mp.month
+            UNION
+            SELECT 
+                mp.vendor,
+                mp.year,
+                mp.month,
+                mp.total_po as total_orders,
+                mp.late_orders,
+                mp.avg_lead_time_days,
+                mp.total_purchase_value,
+                0 as total_revenue,
+                0 as avg_margin_percent
+            FROM monthly_po mp
+            LEFT JOIN monthly_orders mo ON mp.vendor = mo.vendor 
+                AND mp.year = mo.year 
+                AND mp.month = mo.month
+            WHERE mo.vendor IS NULL
+            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)
+        `);
+
+        processedCount = Math.floor(totalProducts * 0.95);
+        outputProgress({
+            status: 'running',
+            operation: 'Time-based vendor metrics calculated',
+            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)
+            }
+        });
+
+        // If we get here, everything completed successfully
+        success = true;
+        
+        // Update calculate_status
+        await connection.query(`
+            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
+            VALUES ('vendor_metrics', NOW())
+            ON DUPLICATE KEY UPDATE last_calculation_timestamp = NOW()
+        `);
+
+        return {
+            processedProducts: processedCount,
+            processedOrders,
+            processedPurchaseOrders,
+            success
+        };
+
     } catch (error) {
+        success = false;
         logError(error, 'Error calculating vendor metrics');
         throw error;
     } finally {

inventory-server/scripts/reset-db.js

@@ -156,7 +156,7 @@ async function resetDatabase() {
             SELECT GROUP_CONCAT(table_name) as tables 
             FROM information_schema.tables 
             WHERE table_schema = DATABASE()
-            AND table_name NOT IN ('users', 'import_history')
+            AND table_name NOT IN ('users', 'import_history', 'calculate_history')
         `);
 
         if (!tables[0].tables) {
@@ -175,7 +175,7 @@ async function resetDatabase() {
                 DROP TABLE IF EXISTS 
                 ${tables[0].tables
                     .split(',')
-                    .filter(table => table !== 'users')
+                    .filter(table => !['users', 'calculate_history'].includes(table))
                     .map(table => '`' + table + '`')
                     .join(', ')}
             `;
@@ -543,5 +543,15 @@ async function resetDatabase() {
     }
 }
 
-// Run the reset
-resetDatabase(); 
+// Export if required as a module
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = resetDatabase;
+}
+
+// Run if called directly
+if (require.main === module) {
+    resetDatabase().catch(error => {
+        console.error('Error:', error);
+        process.exit(1);
+    });
+} 

inventory-server/src/routes/csv.js

@@ -2,6 +2,7 @@ const express = require('express');
 const router = express.Router();
 const { spawn } = require('child_process');
 const path = require('path');
+const db = require('../utils/db');
 
 // Debug middleware MUST be first
 router.use((req, res, next) => {
@@ -9,9 +10,11 @@ router.use((req, res, next) => {
     next();
 });
 
-// Store active import process and its progress
+// Store active processes and their progress
 let activeImport = null;
 let importProgress = null;
+let activeFullUpdate = null;
+let activeFullReset = null;
 
 // SSE clients for progress updates
 const updateClients = new Set();
@@ -19,17 +22,16 @@ const importClients = new Set();
 const resetClients = new Set();
 const resetMetricsClients = new Set();
 const calculateMetricsClients = new Set();
+const fullUpdateClients = new Set();
+const fullResetClients = new Set();
 
 // Helper to send progress to specific clients
-function sendProgressToClients(clients, progress) {
-    const data = typeof progress === 'string' ? { progress } : progress;
-    
-    // Ensure we have a status field
-    if (!data.status) {
-        data.status = 'running';
-    }
-    
-    const message = `data: ${JSON.stringify(data)}\n\n`;
+function sendProgressToClients(clients, data) {
+    // If data is a string, send it directly
+    // If it's an object, convert it to JSON
+    const message = typeof data === 'string' 
+        ? `data: ${data}\n\n`
+        : `data: ${JSON.stringify(data)}\n\n`;
     
     clients.forEach(client => {
         try {
@@ -45,115 +47,149 @@ function sendProgressToClients(clients, progress) {
     });
 }
 
-// Progress endpoints
-router.get('/update/progress', (req, res) => {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Send an initial message to test the connection
-    res.write('data: {"status":"running","operation":"Initializing connection..."}\n\n');
-
-    // Add this client to the update set
-    updateClients.add(res);
-
-    // Remove client when connection closes
-    req.on('close', () => {
-        updateClients.delete(res);
-    });
-});
-
-router.get('/import/progress', (req, res) => {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Send an initial message to test the connection
-    res.write('data: {"status":"running","operation":"Initializing connection..."}\n\n');
-
-    // Add this client to the import set
-    importClients.add(res);
-
-    // Remove client when connection closes
-    req.on('close', () => {
-        importClients.delete(res);
-    });
-});
-
-router.get('/reset/progress', (req, res) => {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Send an initial message to test the connection
-    res.write('data: {"status":"running","operation":"Initializing connection..."}\n\n');
-
-    // Add this client to the reset set
-    resetClients.add(res);
-
-    // Remove client when connection closes
-    req.on('close', () => {
-        resetClients.delete(res);
-    });
-});
-
-// Add reset-metrics progress endpoint
-router.get('/reset-metrics/progress', (req, res) => {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Send an initial message to test the connection
-    res.write('data: {"status":"running","operation":"Initializing connection..."}\n\n');
-
-    // Add this client to the reset-metrics set
-    resetMetricsClients.add(res);
-
-    // Remove client when connection closes
-    req.on('close', () => {
-        resetMetricsClients.delete(res);
-    });
-});
-
-// Add calculate-metrics progress endpoint
-router.get('/calculate-metrics/progress', (req, res) => {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Send current progress if it exists
-    if (importProgress) {
-        res.write(`data: ${JSON.stringify(importProgress)}\n\n`);
-    } else {
-        res.write('data: {"status":"running","operation":"Initializing connection..."}\n\n');
+// Helper to run a script and stream progress
+function runScript(scriptPath, type, clients) {
+    return new Promise((resolve, reject) => {
+        // Kill any existing process of this type
+        let activeProcess;
+        switch (type) {
+            case 'update':
+                if (activeFullUpdate) {
+                    try { activeFullUpdate.kill(); } catch (e) { }
+                }
+                activeProcess = activeFullUpdate;
+                break;
+            case 'reset':
+                if (activeFullReset) {
+                    try { activeFullReset.kill(); } catch (e) { }
+                }
+                activeProcess = activeFullReset;
+                break;
         }
 
-    // Add this client to the calculate-metrics set
-    calculateMetricsClients.add(res);
+        const child = spawn('node', [scriptPath], {
+            stdio: ['inherit', 'pipe', 'pipe']
+        });
 
-    // Remove client when connection closes
+        switch (type) {
+            case 'update':
+                activeFullUpdate = child;
+                break;
+            case 'reset':
+                activeFullReset = child;
+                break;
+        }
+
+        let output = '';
+
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            
+            // Split by lines to handle multiple JSON outputs
+            const lines = text.split('\n');
+            lines.filter(line => line.trim()).forEach(line => {
+                try {
+                    // Try to parse as JSON but don't let it affect the display
+                    const jsonData = JSON.parse(line);
+                    // Only end the process if we get a final status
+                    if (jsonData.status === 'complete' || jsonData.status === 'error' || jsonData.status === 'cancelled') {
+                        if (jsonData.status === 'complete' && !jsonData.operation?.includes('complete')) {
+                            // Don't close for intermediate completion messages
+                            sendProgressToClients(clients, line);
+                            return;
+                        }
+                        // Close only on final completion/error/cancellation
+                        switch (type) {
+                            case 'update':
+                                activeFullUpdate = null;
+                                break;
+                            case 'reset':
+                                activeFullReset = null;
+                                break;
+                        }
+                        if (jsonData.status === 'error') {
+                            reject(new Error(jsonData.error || 'Unknown error'));
+                        } else {
+                            resolve({ output });
+                        }
+                    }
+                } catch (e) {
+                    // Not JSON, just display as is
+                }
+                // Always send the raw line
+                sendProgressToClients(clients, line);
+            });
+        });
+
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            console.error(text);
+            // Send stderr output directly too
+            sendProgressToClients(clients, text);
+        });
+
+        child.on('close', (code) => {
+            switch (type) {
+                case 'update':
+                    activeFullUpdate = null;
+                    break;
+                case 'reset':
+                    activeFullReset = null;
+                    break;
+            }
+
+            if (code !== 0) {
+                const error = `Script ${scriptPath} exited with code ${code}`;
+                sendProgressToClients(clients, error);
+                reject(new Error(error));
+            }
+            // Don't resolve here - let the completion message from the script trigger the resolve
+        });
+
+        child.on('error', (err) => {
+            switch (type) {
+                case 'update':
+                    activeFullUpdate = null;
+                    break;
+                case 'reset':
+                    activeFullReset = null;
+                    break;
+            }
+            sendProgressToClients(clients, err.message);
+            reject(err);
+        });
+    });
+}
+
+// Progress endpoints
+router.get('/:type/progress', (req, res) => {
+    const { type } = req.params;
+    if (!['update', 'reset'].includes(type)) {
+        return res.status(400).json({ error: 'Invalid operation type' });
+    }
+
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': req.headers.origin || '*',
+        'Access-Control-Allow-Credentials': 'true'
+    });
+
+    // Add this client to the correct set
+    const clients = type === 'update' ? fullUpdateClients : fullResetClients;
+    clients.add(res);
+
+    // Send initial connection message
+    sendProgressToClients(new Set([res]), JSON.stringify({
+        status: 'running',
+        operation: 'Initializing connection...'
+    }));
+
+    // Handle client disconnect
     req.on('close', () => {
-        calculateMetricsClients.delete(res);
+        clients.delete(res);
     });
 });
 
@@ -174,7 +210,6 @@ router.get('/status', (req, res) => {
 
 // Add calculate-metrics status endpoint
 router.get('/calculate-metrics/status', (req, res) => {
-    console.log('Calculate metrics status endpoint hit');
     const calculateMetrics = require('../../scripts/calculate-metrics');
     const progress = calculateMetrics.getProgress();
     
@@ -371,49 +406,35 @@ router.post('/import', async (req, res) => {
 
 // Route to cancel active process
 router.post('/cancel', (req, res) => {
-    if (!activeImport) {
-        return res.status(404).json({ error: 'No active process to cancel' });
-    }
-
-    try {
-        // If it's the prod import module, call its cancel function
-        if (typeof activeImport.cancelImport === 'function') {
-            activeImport.cancelImport();
-        } else {
-            // Otherwise it's a child process
-            activeImport.kill('SIGTERM');
-        }
+    let killed = false;
 
     // Get the operation type from the request
-        const { operation } = req.query;
+    const { type } = req.query;
+    const clients = type === 'update' ? fullUpdateClients : fullResetClients;
+    const activeProcess = type === 'update' ? activeFullUpdate : activeFullReset;
 
-        // Send cancel message only to the appropriate client set
-        const cancelMessage = { 
+    if (activeProcess) {
+        try {
+            activeProcess.kill('SIGTERM');
+            if (type === 'update') {
+                activeFullUpdate = null;
+            } else {
+                activeFullReset = null;
+            }
+            killed = true;
+            sendProgressToClients(clients, JSON.stringify({
                 status: 'cancelled',
                 operation: 'Operation cancelled'
-        };
-
-        switch (operation) {
-            case 'update':
-                sendProgressToClients(updateClients, cancelMessage);
-                break;
-            case 'import':
-                sendProgressToClients(importClients, cancelMessage);
-                break;
-            case 'reset':
-                sendProgressToClients(resetClients, cancelMessage);
-                break;
-            case 'calculate-metrics':
-                sendProgressToClients(calculateMetricsClients, cancelMessage);
-                break;
+            }));
+        } catch (err) {
+            console.error(`Error killing ${type} process:`, err);
+        }
     }
 
+    if (killed) {
         res.json({ success: true });
-    } catch (error) {
-        // Even if there's an error, try to clean up
-        activeImport = null;
-        importProgress = null;
-        res.status(500).json({ error: 'Failed to cancel process' });
+    } else {
+        res.status(404).json({ error: 'No active process to cancel' });
     }
 });
 
@@ -552,20 +573,6 @@ router.post('/reset-metrics', async (req, res) => {
     }
 });
 
-// Add calculate-metrics status endpoint
-router.get('/calculate-metrics/status', (req, res) => {
-    const calculateMetrics = require('../../scripts/calculate-metrics');
-    const progress = calculateMetrics.getProgress();
-    
-    // Only consider it active if both the process is running and we have progress
-    const isActive = !!activeImport && !!progress;
-    
-    res.json({
-        active: isActive,
-        progress: isActive ? progress : null
-    });
-});
-
 // Add calculate-metrics endpoint
 router.post('/calculate-metrics', async (req, res) => {
     if (activeImport) {
@@ -711,4 +718,96 @@ router.post('/import-from-prod', async (req, res) => {
     }
 });
 
+// POST /csv/full-update - Run full update script
+router.post('/full-update', async (req, res) => {
+    try {
+        const scriptPath = path.join(__dirname, '../../scripts/full-update.js');
+        runScript(scriptPath, 'update', fullUpdateClients)
+            .catch(error => {
+                console.error('Update failed:', error);
+            });
+        res.status(202).json({ message: 'Update started' });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// POST /csv/full-reset - Run full reset script
+router.post('/full-reset', async (req, res) => {
+    try {
+        const scriptPath = path.join(__dirname, '../../scripts/full-reset.js');
+        runScript(scriptPath, 'reset', fullResetClients)
+            .catch(error => {
+                console.error('Reset failed:', error);
+            });
+        res.status(202).json({ message: 'Reset started' });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /history/import - Get recent import history
+router.get('/history/import', async (req, res) => {
+    try {
+        const pool = req.app.locals.pool;
+        const [rows] = await pool.query(`
+            SELECT * FROM import_history 
+            ORDER BY start_time DESC 
+            LIMIT 20
+        `);
+        res.json(rows || []);
+    } catch (error) {
+        console.error('Error fetching import history:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /history/calculate - Get recent calculation history
+router.get('/history/calculate', async (req, res) => {
+    try {
+        const pool = req.app.locals.pool;
+        const [rows] = await pool.query(`
+            SELECT * FROM calculate_history 
+            ORDER BY start_time DESC 
+            LIMIT 20
+        `);
+        res.json(rows || []);
+    } catch (error) {
+        console.error('Error fetching calculate history:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /status/modules - Get module calculation status
+router.get('/status/modules', async (req, res) => {
+    try {
+        const pool = req.app.locals.pool;
+        const [rows] = await pool.query(`
+            SELECT module_name, last_calculation_timestamp 
+            FROM calculate_status 
+            ORDER BY module_name
+        `);
+        res.json(rows || []);
+    } catch (error) {
+        console.error('Error fetching module status:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// GET /status/tables - Get table sync status
+router.get('/status/tables', async (req, res) => {
+    try {
+        const pool = req.app.locals.pool;
+        const [rows] = await pool.query(`
+            SELECT table_name, last_sync_timestamp 
+            FROM sync_status 
+            ORDER BY table_name
+        `);
+        res.json(rows || []);
+    } catch (error) {
+        console.error('Error fetching table status:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
 module.exports = router; 

inventory/src/components/settings/PerformanceMetrics.tsx

@@ -133,6 +133,10 @@ export function PerformanceMetrics() {
     }
   };
 
+  function getCategoryName(_cat_id: number): import("react").ReactNode {
+    throw new Error('Function not implemented.');
+  }
+
   return (
     <div className="max-w-[700px] space-y-4">
       {/* Lead Time Thresholds Card */}
@@ -205,11 +209,11 @@ export function PerformanceMetrics() {
             <Table>
               <TableHeader>
                 <TableRow>
-                  <TableHead>Category</TableHead>
-                  <TableHead>Vendor</TableHead>
-                  <TableHead className="text-right">A Threshold</TableHead>
-                  <TableHead className="text-right">B Threshold</TableHead>
-                  <TableHead className="text-right">Period Days</TableHead>
+                  <TableCell>Category</TableCell>
+                  <TableCell>Vendor</TableCell>
+                  <TableCell className="text-right">A Threshold</TableCell>
+                  <TableCell className="text-right">B Threshold</TableCell>
+                  <TableCell className="text-right">Period Days</TableCell>
                 </TableRow>
               </TableHeader>
               <TableBody>
@@ -242,10 +246,10 @@ export function PerformanceMetrics() {
             <Table>
               <TableHeader>
                 <TableRow>
-                  <TableHead>Category</TableHead>
-                  <TableHead>Vendor</TableHead>
-                  <TableHead className="text-right">Period Days</TableHead>
-                  <TableHead className="text-right">Target Rate</TableHead>
+                  <TableCell>Category</TableCell>
+                  <TableCell>Vendor</TableCell>
+                  <TableCell className="text-right">Period Days</TableCell>
+                  <TableCell className="text-right">Target Rate</TableCell>
                 </TableRow>
               </TableHeader>
               <TableBody>

inventory/src/components/settings/StockManagement.tsx

@@ -5,7 +5,6 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { toast } from "sonner";
 import config from '../../config';
-import { Table, TableBody, TableCell, TableHeader, TableRow } from "@/components/ui/table";
 
 interface StockThreshold {
   id: number;
@@ -244,54 +243,6 @@ export function StockManagement() {
           </div>
         </CardContent>
       </Card>
-
-      <Table>
-        <TableHeader>
-          <TableRow>
-            <TableHead>Category</TableHead>
-            <TableHead>Vendor</TableHead>
-            <TableHead className="text-right">Critical Days</TableHead>
-            <TableHead className="text-right">Reorder Days</TableHead>
-            <TableHead className="text-right">Overstock Days</TableHead>
-            <TableHead className="text-right">Low Stock</TableHead>
-            <TableHead className="text-right">Min Reorder</TableHead>
-          </TableRow>
-        </TableHeader>
-        <TableBody>
-          {stockThresholds.map((threshold) => (
-            <TableRow key={`${threshold.cat_id}-${threshold.vendor}`}>
-              <TableCell>{threshold.cat_id ? getCategoryName(threshold.cat_id) : 'Global'}</TableCell>
-              <TableCell>{threshold.vendor || 'All Vendors'}</TableCell>
-              <TableCell className="text-right">{threshold.critical_days}</TableCell>
-              <TableCell className="text-right">{threshold.reorder_days}</TableCell>
-              <TableCell className="text-right">{threshold.overstock_days}</TableCell>
-              <TableCell className="text-right">{threshold.low_stock_threshold}</TableCell>
-              <TableCell className="text-right">{threshold.min_reorder_quantity}</TableCell>
-            </TableRow>
-          ))}
-        </TableBody>
-      </Table>
-
-      <Table>
-        <TableHeader>
-          <TableRow>
-            <TableHead>Category</TableHead>
-            <TableHead>Vendor</TableHead>
-            <TableHead className="text-right">Coverage Days</TableHead>
-            <TableHead className="text-right">Service Level</TableHead>
-          </TableRow>
-        </TableHeader>
-        <TableBody>
-          {safetyStockConfigs.map((config) => (
-            <TableRow key={`${config.cat_id}-${config.vendor}`}>
-              <TableCell>{config.cat_id ? getCategoryName(config.cat_id) : 'Global'}</TableCell>
-              <TableCell>{config.vendor || 'All Vendors'}</TableCell>
-              <TableCell className="text-right">{config.coverage_days}</TableCell>
-              <TableCell className="text-right">{config.service_level}%</TableCell>
-            </TableRow>
-          ))}
-        </TableBody>
-      </Table>
     </div>
   );
 } 

mountremote.command

@@ -1,7 +1,7 @@
 #!/bin/zsh
 
 #Clear previous mount in case it’s still there
-umount ~/Dev/inventory/inventory-server
+umount /Users/matt/Library/Mobile Documents/com~apple~CloudDocs/Dev/inventory/inventory-server
 
 #Mount
-sshfs matt@dashboard.kent.pw:/var/www/html/inventory -p 22122 ~/Dev/inventory/inventory-server/
+sshfs matt@dashboard.kent.pw:/var/www/html/inventory -p 22122 /Users/matt/Library/Mobile Documents/com~apple~CloudDocs/Dev/inventory/inventory-server/