digikhata-mashreq-sdk 1.0.0 → 1.1.0

package/src/app/database/expense.js

@@ -0,0 +1,439 @@
+import db from './database';
+
+export const createExpenseAccount = (businessId, name) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                "INSERT INTO ExpenseCategory (name, businessId) VALUES (?, ?)",
+                [name, Number(businessId)],
+                (txObj, resultSet) => {
+                    console.log("✅ Inserted Expense category:", resultSet);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (ExpenseCategory):", error);
+                    reject(error);
+                }
+            )
+        },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ExpenseCategory):", transactionError);
+                reject(transactionError);
+            }
+        )
+    })
+}
+
+export const updateExpenseAccountName = (id, newName) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                tx.executeSql(
+                    `UPDATE ExpenseCategory 
+           SET name = ?, updated_at = datetime('now') 
+           WHERE id = ?`,
+                    [newName, id],
+                    (txObj, resultSet) => {
+                        console.log("✅ Expense category updated:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (updateExpenseAccountName):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (updateExpenseAccountName):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const getExpenseCategoriesWithTotals = (
+    businessId,
+    filter = "most_recent",
+    month = null
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            const monthMap = {
+                jan: "01", feb: "02", mar: "03", apr: "04",
+                may: "05", jun: "06", jul: "07", aug: "08",
+                sep: "09", oct: "10", nov: "11", dec: "12",
+            };
+
+            const params = [];
+            let monthCondition = "";
+
+            if (month) {
+                const monthNum = monthMap[month.toLowerCase()];
+                if (monthNum) {
+                    monthCondition = ` AND strftime('%m', et.created_at) = ? `;
+                    params.push(monthNum); // ✅ correct order
+                }
+            }
+
+            params.push(businessId); // ✅ after month
+
+            const sql = `
+        SELECT 
+          ec.*,
+          IFNULL(SUM(et.amount), 0) AS totalAmount
+        FROM ExpenseCategory ec
+        LEFT JOIN ExpenseTransaction et 
+          ON ec.id = et.eId 
+             AND (et.isDeleted IS NULL OR et.isDeleted = 0)
+             ${monthCondition}
+        WHERE 
+          ec.businessId = ? 
+          AND (ec.isDeleted IS NULL OR ec.isDeleted = 0)
+        GROUP BY ec.id
+      `;
+
+            let finalSql = sql;
+            switch (filter) {
+                case "highest_amount":
+                    finalSql += " ORDER BY totalAmount DESC";
+                    break;
+                case "least_amount":
+                    finalSql += " ORDER BY totalAmount ASC";
+                    break;
+                case "oldest":
+                    finalSql += " ORDER BY datetime(ec.created_at) ASC";
+                    break;
+                default:
+                    finalSql += " ORDER BY datetime(ec.created_at) DESC";
+                    break;
+            }
+
+            tx.executeSql(
+                finalSql,
+                params,
+                (txObj, resultSet) => {
+                    const categories = [];
+                    for (let i = 0; i < resultSet.rows.length; i++) {
+                        categories.push(resultSet.rows.item(i));
+                    }
+                    resolve(categories);
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error (getExpenseCategoriesWithTotals):", error);
+                    reject(error);
+                }
+            );
+        });
+    });
+};
+
+export const addExpenseTransaction = (
+    bId,
+    eId,
+    entryDate,
+    amount,
+    details,
+    local_path
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          INSERT INTO ExpenseTransaction 
+          (bId, eId, entryDate, amount, details, local_path)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `;
+
+                const params = [
+                    Number(bId),
+                    Number(eId),
+                    entryDate,
+                    Number(amount),
+                    details || '',
+                    local_path || '',
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ Inserted Expense Transaction:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (ExpenseTransaction):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (ExpenseTransaction):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const updateExpenseTransaction = (
+    id,
+    bId,
+    eId,
+    entryDate,
+    amount,
+    details,
+    local_path
+) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          UPDATE ExpenseTransaction
+          SET 
+            bId = ?, 
+            eId = ?, 
+            entryDate = ?, 
+            amount = ?, 
+            details = ?, 
+            local_path = ?, 
+            updated_at = datetime('now')
+          WHERE id = ?
+        `;
+
+                const params = [
+                    Number(bId),
+                    Number(eId),
+                    entryDate,
+                    Number(amount),
+                    details || '',
+                    local_path || '',
+                    Number(id),
+                ];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log("✅ Updated Expense Transaction:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (updateExpenseTransaction):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (updateExpenseTransaction):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const addExpenseImages = (expenseId, local_path) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `
+        INSERT INTO ExpenseImages 
+        (expenseId, local_path, created_at, updated_at) 
+        VALUES (?, ?, datetime('now'), datetime('now'))
+        `,
+                [expenseId, local_path],
+                (txObj, resultSet) => resolve(resultSet),
+                (txObj, error) => reject(error)
+            );
+        });
+    });
+};
+
+export const deleteExpenseImagesByExpenseId = (expenseId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `DELETE FROM ExpenseImages WHERE expenseId = ?`,
+                [expenseId],
+                (txObj, resultSet) => {
+                    console.log("deleteExpenseImagesByExpenseId rowsAffected:", resultSet.rowsAffected);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("SQLite error deleting expense images by expenseId:", error);
+                    reject(error);
+                }
+            );
+        });
+    });
+};
+
+export const getExpenseTransactions = (bId, eId = null, startDate = null, endDate = null) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            let sql = `
+        SELECT * 
+        FROM ExpenseTransaction 
+        WHERE (isDeleted IS NULL OR isDeleted = 0)
+          AND bId = ?
+      `;
+            const params = [bId];
+
+            if (eId !== null) {
+                sql += ` AND eId = ?`;
+                params.push(eId);
+            }
+
+            if (startDate && endDate) {
+                sql += ` AND date(entryDate) BETWEEN date(?) AND date(?)`;
+                params.push(startDate, endDate);
+            }
+
+            sql += ` ORDER BY datetime(entryDate) DESC`;
+
+            tx.executeSql(
+                sql,
+                params,
+                (txObj, resultSet) => {
+                    const transactions = [];
+                    for (let i = 0; i < resultSet.rows.length; i++) {
+                        transactions.push({
+                            ...resultSet.rows.item(i),
+                            attachments: [],
+                        });
+                    }
+
+                    if (transactions.length === 0) {
+                        resolve([]);
+                        return;
+                    }
+
+                    const expenseIds = transactions.map((t) => t.id);
+                    const placeholders = expenseIds.map(() => "?").join(",");
+
+                    tx.executeSql(
+                        `SELECT * FROM ExpenseImages WHERE expenseId IN (${placeholders})`,
+                        expenseIds,
+                        (txObj2, resultSet2) => {
+                            const attachments = [];
+                            for (let i = 0; i < resultSet2.rows.length; i++) {
+                                attachments.push(resultSet2.rows.item(i));
+                            }
+
+                            const transactionMap = {};
+                            transactions.forEach((t) => {
+                                transactionMap[t.id] = t;
+                            });
+
+                            attachments.forEach((att) => {
+                                if (transactionMap[att.expenseId]) {
+                                    transactionMap[att.expenseId].attachments.push(att);
+                                }
+                            });
+
+                            resolve(transactions);
+                        },
+                        (txObj2, error) => {
+                            console.log("❌ SQL Error fetching ExpenseImages:", error);
+                            reject(error);
+                        }
+                    );
+                },
+                (txObj, error) => {
+                    console.log("❌ SQL Error fetching ExpenseTransaction:", error);
+                    reject(error);
+                }
+            );
+        });
+    });
+};
+
+export const softDeleteExpenseCategory = (id) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                tx.executeSql(
+                    `UPDATE ExpenseCategory 
+           SET isDeleted = 1, updated_at = datetime('now') 
+           WHERE id = ?`,
+                    [id],
+                    (txObj, resultSet) => {
+                        console.log("🗑️ Soft deleted Expense category:", resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (softDeleteExpenseCategory):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (softDeleteExpenseCategory):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+export const softDeleteExpenseTransaction = (transactionId) => {
+    return new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(
+                `
+          UPDATE ExpenseTransaction
+          SET isDeleted = 1
+          WHERE id = ?;
+        `,
+                [transactionId],
+                (txObj, resultSet) => {
+                    console.log("Rows affected (soft delete ExpenseTransaction):", resultSet.rowsAffected);
+                    resolve(resultSet);
+                },
+                (txObj, error) => {
+                    console.log("❌ Error soft deleting ExpenseTransaction entry:", error);
+                    reject(error);
+                }
+            );
+        });
+    });
+};
+
+export const updateExpenseTransactionIsCash = (transactionId, isCashValue) => {
+    return new Promise((resolve, reject) => {
+        db.transaction(
+            (tx) => {
+                const query = `
+          UPDATE ExpenseTransaction
+          SET isCash = ?
+          WHERE id = ?
+        `;
+
+                const params = [isCashValue || '', Number(transactionId)];
+
+                tx.executeSql(
+                    query,
+                    params,
+                    (txObj, resultSet) => {
+                        console.log(`✅ Updated isCash for ExpenseTransaction ID ${transactionId}:`, resultSet);
+                        resolve(resultSet);
+                    },
+                    (txObj, error) => {
+                        console.log("❌ SQL Error (updateExpenseTransactionIsCash):", error);
+                        reject(error);
+                    }
+                );
+            },
+            (transactionError) => {
+                console.log("❌ Transaction Error (updateExpenseTransactionIsCash):", transactionError);
+                reject(transactionError);
+            }
+        );
+    });
+};
+
+
+
+
+
+
+
+
+

package/src/app/database/schema.js

@@ -59,6 +59,8 @@ export const createTables = () => {
         phone VARCHAR,
         gender TEXT DEFAULT '',
         owner_name TEXT,
+        other_cat_name TEXT,
+        other_type_name TEXT,
         currency TEXT DEFAULT 'Pakistan Rupee-Rs',
         email VARCHAR,
         type TEXT DEFAULT '',
@@ -70,6 +72,7 @@ export const createTables = () => {
         offlineId TEXT,
         serverId INTEGER,
         isSynced BOOLEAN,
+        isSelected BOOLEAN,
         isDeleted BOOLEAN,
         isEdited BOOLEAN,
         tagline VARCHAR,
@@ -147,7 +150,8 @@ export const createTables = () => {
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
         reRef BOOLEAN DEFAULT 0,
-        catId TEXT
+        catId TEXT,
+        partyTransactionId TEXT
       );
     `);
 
@@ -198,8 +202,8 @@ export const createTables = () => {
         storage_path VARCHAR,
         serverTime TEXT,
         pinned BOOLEAN DEFAULT 0,
-        created_at DEFAULT current_timestamp,
-        updated_at DEFAULT current_timestamp,
+        created_at DATETIME DEFAULT (datetime('now','localtime')),
+        updated_at DATETIME DEFAULT (datetime('now','localtime')),
         credit_limit REAL DEFAULT 0,
         payment_mode TEXT,
         sale_man_id TEXT
@@ -282,6 +286,22 @@ export const createTables = () => {
       );
     `);
 
+    //InvoiceImages
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS InvoiceImages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    invoiceId INTEGER NOT NULL,
+    local_path TEXT DEFAULT '',
+    storage_path TEXT DEFAULT '',
+    fb_id TEXT DEFAULT '',
+    isSynced BOOLEAN DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    offlineId TEXT,
+    serverId INTEGER
+  );
+    `);
+
     //ItemCategory
     tx.executeSql(`
       CREATE TABLE IF NOT EXISTS ItemCategory (
@@ -468,6 +488,7 @@ export const createTables = () => {
         isDeleted BOOLEAN,
         isEdited BOOLEAN,
         local_path VARCHAR,
+        cash_type VARCHAR,
         storage_path VARCHAR,
         serverTime TEXT,
         offlineId TEXT,
@@ -515,11 +536,101 @@ export const createTables = () => {
       );
     `);
 
+    // Bank
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS Bank (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    bank_id INTEGER,
+    bank_name TEXT,
+    bank_charges REAL,
+    transfer_time INTEGER,
+    icon TEXT,
+    code TEXT,
+    allowed_digits TEXT,
+    bank_hint TEXT
+  );
+`);
+
     //android_metadata
     tx.executeSql(`
       CREATE TABLE IF NOT EXISTS android_metadata (
         locale TEXT
       );
     `);
+
+    // ItemImages
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS ItemImages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    itemId INTEGER NOT NULL,       
+    local_path TEXT DEFAULT '',  
+    storage_path TEXT DEFAULT '',
+    fb_id TEXT DEFAULT '',       
+    isSynced BOOLEAN DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    offlineId TEXT,
+    serverId INTEGER
+  );
+`);
+
+    // ExpenseTransaction
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS ExpenseTransaction (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    bId INTEGER NOT NULL,             
+    eId INTEGER,                      
+    bill TEXT DEFAULT '',             
+    entryDate TEXT NOT NULL,          
+    amount REAL DEFAULT 0,            
+    subAmount REAL DEFAULT 0,         
+    details TEXT DEFAULT '',          
+    local_path TEXT DEFAULT '',       
+    storage_path TEXT DEFAULT '',     
+    fbId TEXT DEFAULT '',             
+    imagesCount INTEGER DEFAULT -1,   
+    isSynced BOOLEAN DEFAULT 0,       
+    isEdited BOOLEAN DEFAULT 0,       
+    isDeleted BOOLEAN DEFAULT 0,      
+    serverTime TEXT DEFAULT '',       
+    created_at TEXT DEFAULT (datetime('now', 'localtime')),         
+    updated_at TEXT DEFAULT (datetime('now', 'localtime')),         
+    offlineId TEXT,                   
+    serverId INTEGER                  
+  );
+`);
+
+    // ExpenseCategory
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS ExpenseCategory (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    businessId INTEGER NOT NULL,      
+    name TEXT NOT NULL,               
+    offlineId TEXT,                   
+    serverId INTEGER,                 
+    isSynced BOOLEAN DEFAULT 0,       
+    isEdited BOOLEAN DEFAULT 0,       
+    isDeleted BOOLEAN DEFAULT 0,      
+    created_at TEXT DEFAULT (datetime('now', 'localtime')),         
+    updated_at TEXT DEFAULT (datetime('now', 'localtime'))          
+  );
+`);
+
+    // ExpenseImages
+    tx.executeSql(`
+  CREATE TABLE IF NOT EXISTS ExpenseImages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    expenseId INTEGER NOT NULL,       
+    local_path TEXT DEFAULT '',       
+    storage_path TEXT DEFAULT '',     
+    fb_id TEXT DEFAULT '',            
+    isSynced BOOLEAN DEFAULT 0,       
+    created_at TEXT DEFAULT (datetime('now', 'localtime')),         
+    updated_at TEXT DEFAULT (datetime('now', 'localtime')),         
+    offlineId TEXT,                   
+    serverId INTEGER                  
+  );
+`);
+
   });
-};
+};