digikhata-mashreq-sdk 1.0.0 → 1.1.0

package/src/app/database/stock.js

@@ -0,0 +1,724 @@
+import db from './database';
+
+
+export const addItem = (
+    name,          // 🏷️ Item name
+    bId,           // 🏢 Business ID
+    unit,          // ⚖️ Unit of measurement (e.g. pcs, kg)
+    qty,           // 📦 Quantity in stock
+    lowStock,      // ⚠️ Minimum stock alert threshold
+    costPrice,     // 💰 Cost price per unit
+    sellingPrice,  // 💵 Selling price per unit
+    local_path,    // 📂 Optional image or file path
+    catId,         // 🗂️ Category ID
+    barcode        // 🔢 Barcode number or string
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+  INSERT INTO Items 
+  (name, bId, unit, qty, lowStock, costPrice, sellingPrice, local_path, catId, barcode, created_at, updated_at)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now', 'localtime'), datetime('now', 'localtime'))
+`;
+
+
+                const params = [
+                    name,
+                    bId,
+                    unit,
+                    qty,
+                    lowStock,
+                    costPrice,
+                    sellingPrice,
+                    local_path,
+                    catId,
+                    barcode,
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ Item added successfully:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (Item):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (Item):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const editItem = (
+    id,           // 🆔 Item ID to update
+    name,         // 🏷️ Item name
+    bId,          // 🏢 Business ID
+    unit,         // ⚖️ Unit of measurement (e.g. pcs, kg)
+    qty,          // 📦 Quantity in stock
+    lowStock,     // ⚠️ Minimum stock alert threshold
+    costPrice,    // 💰 Cost price per unit
+    sellingPrice, // 💵 Selling price per unit
+    local_path,   // 📂 Optional image or file path
+    catId,        // 🗂️ Category ID
+    barcode       // 🔢 Barcode number or string
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          UPDATE Items
+          SET
+            name = ?,
+            bId = ?,
+            unit = ?,
+            qty = ?,
+            lowStock = ?,
+            costPrice = ?,
+            sellingPrice = ?,
+            local_path = ?,
+            catId = ?,
+            barcode = ?,
+            updated_at = datetime('now', 'localtime')
+          WHERE id = ?;
+        `;
+
+                const params = [
+                    name,
+                    bId,
+                    unit,
+                    qty,
+                    lowStock,
+                    costPrice,
+                    sellingPrice,
+                    local_path,
+                    catId,
+                    barcode,
+                    id,
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ Item updated successfully:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (editItem):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (editItem):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const getItemCategories = () => {
+    return new Promise((resolve, reject) => {
+        db.transaction(tx => {
+            tx.executeSql(
+                "SELECT * FROM ItemCategory ORDER BY created_at DESC",
+                [],
+                (txObj, resultSet) => {
+                    let results = [];
+                    for (let i = 0; i < resultSet.rows.length; i++) {
+                        results.push(resultSet.rows.item(i));
+                    }
+                    resolve(results);
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (ItemCategory):", error);
+                    reject(error);
+                }
+            );
+        },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ItemCategory):", transactionError);
+                reject(transactionError);
+            });
+    });
+};
+
+export const addItemCategory = (name, businessId) => {
+    const timestamp = new Date().toISOString();
+
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                tx.executeSql(
+                    "INSERT INTO ItemCategory (name, created_at, updated_at,businessId) VALUES (?, ?, ?,?)",
+                    [name, timestamp, timestamp, Number(businessId)],
+                    (txObj, resultSet) => {
+                        console.log("✅ Inserted item category:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (ItemCategory):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ItemCategory):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const updateItemCategory = (id, newName) => {
+    const timestamp = new Date().toISOString(); // 🕒 Current time for updated_at
+
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                tx.executeSql(
+                    "UPDATE ItemCategory SET name = ?, updated_at = ? WHERE id = ?",
+                    [newName, timestamp, id],
+                    (txObj, resultSet) => {
+                        console.log("✅ Updated item category:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (ItemCategory):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ItemCategory):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const getItemsByBusiness = (
+    bId,
+    filter = "most_recent",
+    lowStock = false,
+    catId = null // 🆕 Optional category filter
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                // Base query
+                let query = "SELECT * FROM Items WHERE bId = ? AND isDeleted = 0";
+                const params = [bId];
+
+                // Add category filter if provided
+                if (catId !== null && catId !== "") {
+                    query += " AND catId = ?";
+                    params.push(catId);
+                }
+
+                // Add low stock condition if true
+                if (lowStock) {
+                    query += " AND qty <= 0";
+                }
+
+                // Sorting logic
+                switch (filter) {
+                    case "most_recent":
+                        query += " ORDER BY datetime(created_at) DESC";
+                        break;
+                    case "oldest":
+                        query += " ORDER BY datetime(created_at) ASC";
+                        break;
+                    case "high_quantity":
+                        query += " ORDER BY qty DESC";
+                        break;
+                    case "low_quantity":
+                        query += " ORDER BY qty ASC";
+                        break;
+                    case "a-z":
+                        query += " ORDER BY name COLLATE NOCASE ASC";
+                        break;
+                    case "z-a":
+                        query += " ORDER BY name COLLATE NOCASE DESC";
+                        break;
+                    default:
+                        query += " ORDER BY datetime(created_at) DESC";
+                }
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        const results = [];
+                        for (let i = 0; i < resultSet.rows.length; i++) {
+                            results.push(resultSet.rows.item(i));
+                        }
+                        console.log(
+                            `✅ Fetched items for bId=${bId}${catId ? `, catId=${catId}` : ""} (${filter}${lowStock ? ", lowStock" : ""
+                            }):`,
+                            results.length
+                        );
+                        resolve(results);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (getItemsByBusiness):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (getItemsByBusiness):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const addItemDetails = (
+    itemId,
+    stockIN,
+    stockOUT,
+    amount,
+    subamount,
+    details,
+    local_path,
+    entryDate,
+    fbId,
+    bill = "",
+    customerId = null
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+                    INSERT INTO ItemsDetail
+                    (itemId, stockIN, stockOUT, amount, subamount, details, local_path, entryDate, fbId, bill, customerId, created_at, updated_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now', 'localtime'), datetime('now', 'localtime'))
+                `;
+
+                const params = [
+                    itemId,
+                    stockIN,
+                    stockOUT,
+                    amount,
+                    subamount,
+                    String(details),
+                    local_path,
+                    entryDate,
+                    fbId,
+                    bill,
+                    customerId
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ ItemDetails inserted successfully:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (ItemDetails):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ItemDetails):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const updateItemDetails = (
+    id,            // 🆔 ID of the record to update
+    itemId,        // 🆔 Item ID (foreign key)
+    stockIN,       // 📦 Stock added
+    stockOUT,      // 📤 Stock removed
+    amount,        // 💰 Total amount after tax/discount
+    subamount,     // 💵 Subtotal before tax/discount
+    details,       // 📝 Notes or description
+    local_path,    // 📂 Optional file path or attachment
+    entryDate,     // 📅 Transaction/entry date
+    fbId,          // 🏢 Business ID
+    bill = ""      // 🧾 Bill number or reference
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+                    UPDATE ItemsDetail
+                    SET 
+                        itemId = ?, 
+                        stockIN = ?, 
+                        stockOUT = ?, 
+                        amount = ?, 
+                        subamount = ?, 
+                        details = ?, 
+                        local_path = ?, 
+                        entryDate = ?, 
+                        fbId = ?, 
+                        bill = ?, 
+                        updated_at = datetime('now', 'localtime')
+                    WHERE id = ?;
+                `;
+
+                const params = [
+                    itemId,
+                    stockIN,
+                    stockOUT,
+                    amount,
+                    subamount,
+                    String(details),
+                    local_path,
+                    entryDate,
+                    fbId,
+                    bill,
+                    id, // WHERE condition
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ ItemDetails updated successfully:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (updateItemDetails):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (updateItemDetails):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const addItemImages = (itemId, local_path) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `INSERT INTO ItemImages (itemId, local_path, created_at, updated_at)
+         VALUES (?, ?, datetime('now', 'localtime'), datetime('now', 'localtime'))`,
+                [itemId, local_path],
+                (txObj, resultSet) => {
+                    console.log("✅ Item image inserted:", resultSet);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (addItemImages):", error);
+                    reject(error);
+                }
+            );
+        },
+            (transactionError) => {
+                console.log("❌ Transaction Error (addItemImages):", transactionError);
+                reject(transactionError);
+            });
+    });
+};
+
+export const deleteItemImagesByItemId = (itemId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `DELETE FROM ItemImages WHERE itemId = ?`,
+                [itemId],
+                (txObj, resultSet) => {
+                    console.log("🗑️ deleteItemImagesByItemId rowsAffected:", resultSet.rowsAffected);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (deleteItemImagesByItemId):", error);
+                    reject(error);
+                }
+            );
+        },
+            (transactionError) => {
+                console.log("❌ Transaction Error (deleteItemImagesByItemId):", transactionError);
+                reject(transactionError);
+            });
+    });
+};
+
+export const updateItemQty = (itemId, newQty) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          UPDATE Items
+          SET qty = ?, updated_at = datetime('now', 'localtime')
+          WHERE id = ?
+        `;
+
+                tx.executeSql(
+                    query,
+                    [newQty, itemId],
+                    (txObj, resultSet) => {
+                        console.log("✅ Quantity updated successfully:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (updateItemQty):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (updateItemQty):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const getItemDetailsByItemId = (itemId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            // Step 1: Fetch item details (these rows have their own id)
+            tx.executeSql(
+                `SELECT * 
+         FROM ItemsDetail 
+         WHERE itemId = ? AND isDeleted = 0 
+         ORDER BY datetime(created_at) DESC`,
+                [itemId],
+                (txObj, resultSet) => {
+                    const details = [];
+                    for (let i = 0; i < resultSet.rows.length; i++) {
+                        details.push({
+                            ...resultSet.rows.item(i),
+                            attachments: [],
+                        });
+                    }
+
+                    if (details.length === 0) {
+                        // nothing to look up images for
+                        console.log("ℹ️ No ItemsDetail rows found for itemId:", itemId);
+                        resolve([]);
+                        return;
+                    }
+
+                    // IMPORTANT: images are saved against the ItemsDetail's `id` (detail row id)
+                    const detailIds = details.map((d) => d.id); // <-- use detail row id
+                    const placeholders = detailIds.map(() => "?").join(",");
+
+                    // Step 2: Fetch images where ItemImages.itemId is actually the ItemsDetail.id
+                    tx.executeSql(
+                        `SELECT * FROM ItemImages WHERE itemId IN (${placeholders})`,
+                        detailIds,
+                        (txObj2, resultSet2) => {
+                            const images = [];
+                            for (let i = 0; i < resultSet2.rows.length; i++) {
+                                images.push(resultSet2.rows.item(i));
+                            }
+
+                            // Step 3: merge images into details by matching img.itemId === detail.id
+                            const detailMap = {};
+                            details.forEach((d) => {
+                                detailMap[d.id] = d; // use detail.id as key
+                            });
+
+                            images.forEach((img) => {
+                                // safety: ensure the mapping exists
+                                if (detailMap[img.itemId]) {
+                                    detailMap[img.itemId].attachments.push(img);
+                                } else {
+                                    // optional: log unexpected image that doesn't match any detail id
+                                    console.warn("⚠️ Image has no matching ItemsDetail row:", img);
+                                }
+                            });
+
+                            console.log("✅ ItemDetails with images fetched successfully:", details);
+                            resolve(details);
+                        },
+                        (txObj2, error) => {
+                            console.log("❌ SQL Error (ItemImages):", error);
+                            reject(error);
+                        }
+                    );
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (ItemsDetail):", error);
+                    reject(error);
+                }
+            );
+        },
+            (transactionError) => {
+                console.log("❌ Transaction Error (getItemDetailsByItemId):", transactionError);
+                reject(transactionError);
+            });
+    });
+};
+
+export const softDeleteItem = (itemId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          UPDATE Items 
+          SET isDeleted = 1, updated_at = datetime('now', 'localtime')
+          WHERE id = ?
+        `;
+
+                tx.executeSql(
+                    query,
+                    [itemId],
+                    (txObj, resultSet) => {
+                        if (resultSet.rowsAffected > 0) {
+                            console.log(`🗑️ Item soft deleted successfully (id: ${itemId})`);
+                            resolve(resultSet);
+                        } else {
+                            console.log(`⚠️ No item found with id: ${itemId}`);
+                            resolve(null);
+                        }
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (softDeleteItem):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (softDeleteItem):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const getStockEntries = (
+    fbId,
+    type = null,
+    startDate = null,
+    endDate = null,
+    lowStockOnly = false,
+    itemId = null
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                let query = `
+          SELECT ItemsDetail.*, Items.qty
+          FROM ItemsDetail
+          JOIN Items ON ItemsDetail.itemId = Items.id
+          WHERE ItemsDetail.fbId = ?
+            AND ItemsDetail.isDeleted = 0
+            AND Items.isDeleted = 0
+        `;
+                const params = [fbId];
+
+                // ✅ Filter by itemId
+                if (itemId) {
+                    query += " AND ItemsDetail.itemId = ?";
+                    params.push(itemId);
+                }
+
+                // ✅ Filter by type (IN or OUT)
+                if (type === "IN") {
+                    query += " AND ItemsDetail.stockIN > 0";
+                } else if (type === "OUT") {
+                    query += " AND ItemsDetail.stockOUT > 0";
+                }
+
+                // ✅ Filter by date range (ignore time)
+                if (startDate && endDate) {
+                    query +=
+                        " AND date(ItemsDetail.entryDate) BETWEEN date(?) AND date(?)";
+                    params.push(startDate, endDate);
+                }
+
+                // ✅ Low Stock check (qty = 0 or less OR qty < lowStock if lowStock exists)
+                if (lowStockOnly) {
+                    query += `
+    AND (
+      Items.qty < IFNULL(Items.lowStock, 0)
+    )
+  `;
+                }
+
+
+
+
+                // ✅ Sort by latest first
+                query += " ORDER BY datetime(ItemsDetail.created_at) DESC";
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        const results = [];
+                        for (let i = 0; i < resultSet.rows.length; i++) {
+                            results.push(resultSet.rows.item(i));
+                        }
+                        console.log(
+                            `✅ Stock entries fetched for fbId=${fbId} (type=${type || "ALL"}, itemId=${itemId || "ALL"}, lowStockOnly=${lowStockOnly}):`,
+                            results.length
+                        );
+                        resolve(results);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (getStockEntries):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (getStockEntries):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const softDeleteItemDetail = (detailId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `
+        UPDATE ItemsDetail
+        SET isDeleted = 1
+        WHERE id = ?;
+        `,
+                [detailId],
+                (txObj, resultSet) => {
+                    console.log("Rows affected (soft delete ItemsDetail):", resultSet.rowsAffected);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("❌ Error soft deleting ItemsDetail entry:", error);
+                    reject(error);
+                }
+            );
+        });
+    });
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+