digikhata-mashreq-sdk 1.0.0 → 1.1.0

package/lib/module/app/database/clients.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import db from "./database.js";
-export const addClient = (name, phoneNum, type) => {
+export const addClient = (name, phoneNum, type, business_id = null, serverId = null,
+// NEW: serverId
+created_at = null, updated_at = null) => {
   return new Promise((resolve, reject) => {
-    // Default JSON for status
     const defaultStatus = JSON.stringify({
       flat: "",
       landmark: "",
@@ -11,23 +12,138 @@ export const addClient = (name, phoneNum, type) => {
       city: "",
       state: ""
     });
+    const normalizedPhone = phoneNum ? String(phoneNum).trim() : "";
     db.transaction(tx => {
-      tx.executeSql("INSERT INTO Clients (name, phone, type, status) VALUES (?, ?, ?, ?)", [name, phoneNum, type, defaultStatus], (txObj, resultSet) => resolve(resultSet), (txObj, error) => reject(error));
+      // 🟢 Case 1: No phone number → insert directly
+      if (!normalizedPhone) {
+        const fields = ["name", "phone", "type", "status", "isDeleted", "business_id"];
+        const placeholders = ["?", "?", "?", "?", 0, "?"];
+        const values = [name, null, type, defaultStatus, business_id];
+        if (serverId !== null) {
+          fields.push("serverId");
+          placeholders.push("?");
+          values.push(serverId);
+        }
+        if (created_at) {
+          fields.push("created_at");
+          placeholders.push("?");
+          values.push(created_at);
+        }
+        if (updated_at) {
+          fields.push("updated_at");
+          placeholders.push("?");
+          values.push(updated_at);
+        }
+        const sql = `INSERT INTO Clients (${fields.join(",")}) VALUES (${placeholders.join(",")})`;
+        tx.executeSql(sql, values, (txObj, insertResult) => resolve(insertResult), (txObj, error) => reject(error));
+        return;
+      }
+
+      // 🟢 Case 2: Check for existing client (same phone & same business)
+      tx.executeSql(`
+        SELECT * FROM Clients 
+        WHERE phone = ? 
+        AND (isDeleted IS NULL OR isDeleted = 0)
+        AND business_id = ?
+        `, [normalizedPhone, business_id], (txObj, resultSet) => {
+        if (resultSet.rows.length > 0) {
+          // 🟥 Duplicate found → don't insert
+          const existing = resultSet.rows.item(0);
+          resolve({
+            insertId: existing.id,
+            rowsAffected: 0,
+            existing: true,
+            client: existing
+          });
+        } else {
+          // 🟢 Case 3: Insert new client (unique phone + business_id)
+          const fields = ["name", "phone", "type", "status", "isDeleted", "business_id"];
+          const placeholders = ["?", "?", "?", "?", 0, "?"];
+          const values = [name, normalizedPhone, type, defaultStatus, business_id];
+          if (serverId !== null) {
+            fields.push("serverId");
+            placeholders.push("?");
+            values.push(serverId);
+          }
+          if (created_at) {
+            fields.push("created_at");
+            placeholders.push("?");
+            values.push(created_at);
+          }
+          if (updated_at) {
+            fields.push("updated_at");
+            placeholders.push("?");
+            values.push(updated_at);
+          }
+          const sql = `INSERT INTO Clients (${fields.join(",")}) VALUES (${placeholders.join(",")})`;
+          tx.executeSql(sql, values, (txObj, insertResult) => resolve(insertResult), (txObj, error) => reject(error));
+        }
+      }, (txObj, error) => reject(error));
     });
   });
 };
-export const getAllClients = () => {
+export const getAllClients = (sortBy = 'most_recent', business_id = null) => {
   return new Promise((resolve, reject) => {
     db.transaction(tx => {
-      tx.executeSql("SELECT * FROM Clients", [], (txObj, resultSet) => {
-        let results = [];
+      // Base query
+      let sql = `
+        SELECT 
+          c.id,
+          c.serverId AS serverId,           -- ✅ Ensure serverId is returned
+          c.name,
+          c.type,
+          c.local_path,
+          c.notification,
+          c.phone,
+          c.paydate,
+          c.business_id,
+
+          IFNULL(SUM(CAST(t.amount AS REAL)), 0) AS total_amount,
+          IFNULL(SUM(CAST(t.subamount AS REAL)), 0) AS total_subamount,
+          IFNULL(MAX(t.created_at), '') AS latest_created_at,
+          IFNULL(MAX(t.updated_at), '') AS latest_updated_at,
+          IFNULL(MAX(c.created_at), '') AS created_at,
+          IFNULL(MAX(t.date), '') AS latest_transaction_date,
+          COALESCE(MAX(t.date), MAX(c.created_at)) AS effective_date
+        FROM Clients c
+        LEFT JOIN Transactions t 
+          ON c.id = t.customer_id 
+          AND (t.isDeleted IS NULL OR t.isDeleted = 0)
+        WHERE 
+          (c.isDeleted IS NULL OR c.isDeleted = 0)
+      `;
+      const params = [];
+      // Add filter if business_id is provided
+      if (business_id !== null && business_id !== undefined) {
+        sql += ` AND c.business_id = ?`;
+        params.push(business_id);
+      }
+
+      // GROUP BY clause
+      sql += `
+        GROUP BY 
+          c.id, 
+          c.serverId,          -- ✅ Include in GROUP BY
+          c.name, 
+          c.type, 
+          c.local_path, 
+          c.notification, 
+          c.phone,
+          c.paydate,
+          c.business_id
+      `;
+
+      // Sorting logic
+      if (sortBy === 'most_recent') sql += ` ORDER BY effective_date DESC`;else if (sortBy === 'oldest') sql += ` ORDER BY effective_date ASC`;else if (sortBy === 'name_az') sql += ` ORDER BY c.name COLLATE NOCASE ASC`;else if (sortBy === 'name_za') sql += ` ORDER BY c.name COLLATE NOCASE DESC`;else sql += ` ORDER BY effective_date DESC`;
+
+      // Execute SQL
+      tx.executeSql(sql, params, (txObj, resultSet) => {
+        const data = [];
         for (let i = 0; i < resultSet.rows.length; i++) {
-          results.push(resultSet.rows.item(i));
+          data.push(resultSet.rows.item(i));
         }
-        resolve(results);
-      }, (txObj, error) => {
-        reject(error);
-      });
+        resolve(data);
+      }, (txObj, error) => reject(error));
     });
   });
 };
@@ -46,37 +162,277 @@ export const deleteClientById = id => {
     });
   });
 };
-export const getClientsByType = type => {
+export const getClientsByType = (type, sortBy = 'most_recent', monthName = null, business_id) => {
   return new Promise((resolve, reject) => {
     db.transaction(tx => {
-      tx.executeSql(`SELECT 
-    c.id,
-    c.name,
-    c.type,
-    IFNULL(SUM(t.amount), 0) AS total_amount,
-    IFNULL(SUM(t.subamount), 0) AS total_subamount,
-    IFNULL(MAX(t.created_at), DATETIME('now')) AS latest_created_at,
-    IFNULL(MAX(t.updated_at), DATETIME('now')) AS latest_updated_at
-FROM Clients c
-LEFT JOIN Transactions t 
-    ON c.id = t.customer_id
-WHERE c.type = ?
-GROUP BY c.id, c.name, c.type;`, [type], (txObj, resultSet) => {
-        let data = [];
+      let sql = `
+        SELECT 
+          c.id,
+          c.name,
+          c.type,
+          c.account,          -- ✅ Added account
+          c.local_path,
+          c.notification,
+          c.phone,
+          c.paydate,
+          c.business_id,
+
+          IFNULL(SUM(CAST(t.amount AS REAL)), 0) AS total_amount,
+          IFNULL(SUM(CAST(t.subamount AS REAL)), 0) AS total_subamount,
+          IFNULL(MAX(t.created_at), '') AS latest_created_at,
+          IFNULL(MAX(t.updated_at), '') AS latest_updated_at,
+          IFNULL(MAX(c.updated_at), '') AS created_at,
+          IFNULL(MAX(t.date), '') AS latest_transaction_date,
+          COALESCE(MAX(t.date), MAX(c.created_at)) AS effective_date
+        FROM Clients c
+        LEFT JOIN Transactions t 
+          ON c.id = t.customer_id 
+          AND (t.isDeleted IS NULL OR t.isDeleted = 0)
+        WHERE 
+          c.type = ?
+          AND c.business_id = ?
+          AND (c.isDeleted IS NULL OR c.isDeleted = 0)
+        GROUP BY 
+          c.id,
+          c.name,
+          c.type,
+          c.account,          -- ✅ Added to GROUP BY
+          c.local_path,
+          c.notification,
+          c.phone,
+          c.paydate,
+          c.business_id
+      `;
+
+      // Sorting
+      if (sortBy === 'most_recent') sql += ` ORDER BY effective_date DESC`;else if (sortBy === 'oldest') sql += ` ORDER BY effective_date ASC`;else if (sortBy === 'name_az') sql += ` ORDER BY c.name COLLATE NOCASE ASC`;else if (sortBy === 'name_za') sql += ` ORDER BY c.name COLLATE NOCASE DESC`;else sql += ` ORDER BY effective_date DESC`;
+      tx.executeSql(sql, [type, business_id], (txObj, resultSet) => {
+        const data = [];
         for (let i = 0; i < resultSet.rows.length; i++) {
           data.push(resultSet.rows.item(i));
         }
-        resolve(data);
-      }, (txObj, error) => {
-        reject(error);
-      });
+
+        // ✅ Optional month filter
+        let filteredData = data;
+        if (monthName) {
+          const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+          filteredData = data.filter(item => {
+            const dateStr = item?.latest_transaction_date || item?.created_at;
+            if (!dateStr) return false;
+            const date = new Date(dateStr.replace(" ", "T"));
+            return months[date.getMonth()] === monthName;
+          });
+        }
+        resolve(filteredData);
+      }, (txObj, error) => reject(error));
+    });
+  });
+};
+
+// export const getClientsByType = (type, sortBy = 'most_recent') => {
+//     return new Promise((resolve, reject) => {
+//         db.transaction((tx) => {
+//             // Base query
+//             let sql = `
+//         SELECT 
+//           c.id,
+//           c.name,
+//           c.type,
+//           c.local_path,
+//           c.notification,
+//           c.phone,
+//           c.paydate,  -- added here
+
+//           IFNULL(SUM(t.amount), 0) AS total_amount,
+//           IFNULL(SUM(t.subamount), 0) AS total_subamount,
+//           IFNULL(MAX(t.created_at), '') AS latest_created_at,
+//           IFNULL(MAX(t.updated_at), '') AS latest_updated_at,
+//           IFNULL(MAX(c.updated_at), '') AS created_at,
+//           IFNULL(MAX(t.date), '') AS latest_transaction_date,
+//           COALESCE(MAX(t.date), MAX(c.created_at)) AS effective_date
+//         FROM Clients c
+//         LEFT JOIN Transactions t 
+//           ON c.id = t.customer_id 
+//           AND (t.isDeleted IS NULL OR t.isDeleted = 0)  -- exclude deleted transactions
+//         WHERE c.type = ?
+//         GROUP BY 
+//           c.id, 
+//           c.name, 
+//           c.type, 
+//           c.local_path, 
+//           c.notification, 
+//           c.phone,
+//           c.paydate
+//       `;
+
+//             // Decide order by clause based on sortBy
+//             if (sortBy === 'most_recent') {
+//                 sql += ` ORDER BY effective_date DESC`;
+//             } else if (sortBy === 'oldest') {
+//                 sql += ` ORDER BY effective_date ASC`;
+//             } else if (sortBy === 'name_az') {
+//                 sql += ` ORDER BY c.name COLLATE NOCASE ASC`;
+//             } else if (sortBy === 'name_za') {
+//                 sql += ` ORDER BY c.name COLLATE NOCASE DESC`;
+//             } else {
+//                 // default
+//                 sql += ` ORDER BY effective_date DESC`;
+//             }
+
+//             tx.executeSql(
+//                 sql,
+//                 [type],
+//                 (txObj, resultSet) => {
+//                     let data = [];
+//                     for (let i = 0; i < resultSet.rows.length; i++) {
+//                         data.push(resultSet.rows.item(i));
+//                     }
+//                     resolve(data);
+//                 },
+//                 (txObj, error) => {
+//                     reject(error);
+//                 }
+//             );
+//         });
+//     });
+// };
+
+// export const getClientsByType = (type, sortBy = 'most_recent') => {
+//     return new Promise((resolve, reject) => {
+//         db.transaction((tx) => {
+//             // Base query
+//             let sql = `
+//         SELECT 
+//           c.id,
+//           c.name,
+//           c.type,
+//           c.local_path,
+//           c.notification,
+//           c.phone,
+//           c.paydate,  -- added here
+
+//           IFNULL(SUM(t.amount), 0) AS total_amount,
+//           IFNULL(SUM(t.subamount), 0) AS total_subamount,
+//           IFNULL(MAX(t.created_at), '') AS latest_created_at,
+//           IFNULL(MAX(t.updated_at), '') AS latest_updated_at,
+//           IFNULL(MAX(c.updated_at), '') AS created_at,
+//           IFNULL(MAX(t.date), '') AS latest_transaction_date,
+//           COALESCE(MAX(t.date), MAX(c.created_at)) AS effective_date
+//         FROM Clients c
+//         LEFT JOIN Transactions t 
+//           ON c.id = t.customer_id
+//         WHERE c.type = ?
+//         GROUP BY 
+//           c.id, 
+//           c.name, 
+//           c.type, 
+//           c.local_path, 
+//           c.notification, 
+//           c.phone,
+//           c.paydate
+//       `;
+
+//             // Decide order by clause based on sortBy
+//             if (sortBy === 'most_recent') {
+//                 sql += ` ORDER BY effective_date DESC`;
+//             } else if (sortBy === 'oldest') {
+//                 sql += ` ORDER BY effective_date ASC`;
+//             } else if (sortBy === 'name_az') {
+//                 sql += ` ORDER BY c.name COLLATE NOCASE ASC`;
+//             } else if (sortBy === 'name_za') {
+//                 sql += ` ORDER BY c.name COLLATE NOCASE DESC`;
+//             } else {
+//                 // default
+//                 sql += ` ORDER BY effective_date DESC`;
+//             }
+
+//             tx.executeSql(
+//                 sql,
+//                 [type],
+//                 (txObj, resultSet) => {
+//                     let data = [];
+//                     for (let i = 0; i < resultSet.rows.length; i++) {
+//                         data.push(resultSet.rows.item(i));
+//                     }
+//                     resolve(data);
+//                 },
+//                 (txObj, error) => {
+//                     reject(error);
+//                 }
+//             );
+//         });
+//     });
+// };
+
+export const addTransaction = (customer_id, amount, subamount, notes, date, local_path, cash_type, items = '',
+// optional field
+isInstallment = 0,
+// optional field
+serverId = null,
+// optional serverId
+created_at = null,
+// optional created_at
+updated_at = null // optional updated_at
+) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      const fields = ["customer_id", "amount", "subamount", "notes", "date", "local_path", "cash_type", "items", "isInstallment"];
+      const placeholders = ["?", "?", "?", "?", "?", "?", "?", "?", "?"];
+      const values = [customer_id, amount, subamount, notes, date, local_path, cash_type, items, isInstallment];
+
+      // Add serverId if provided
+      if (serverId) {
+        fields.push("serverId");
+        placeholders.push("?");
+        values.push(serverId);
+      }
+
+      // Add created_at if provided
+      if (created_at) {
+        fields.push("created_at");
+        placeholders.push("?");
+        values.push(created_at);
+      }
+
+      // Add updated_at if provided
+      if (updated_at) {
+        fields.push("updated_at");
+        placeholders.push("?");
+        values.push(updated_at);
+      }
+      const sql = `INSERT INTO Transactions (${fields.join(",")}) VALUES (${placeholders.join(",")})`;
+      tx.executeSql(sql, values, (txObj, resultSet) => resolve(resultSet), (txObj, error) => reject(error));
+    });
+  });
+};
+export const getAllTransactions = () => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`SELECT * FROM Transactions ORDER BY date DESC, id DESC`,
+      // latest first
+      [], (txObj, resultSet) => {
+        const transactions = [];
+        for (let i = 0; i < resultSet.rows.length; i++) {
+          transactions.push(resultSet.rows.item(i));
+        }
+        resolve(transactions);
+      }, (txObj, error) => reject(error));
     });
   });
 };
-export const addTransaction = (customer_id, amount, subamount, notes, date, local_path) => {
+export const updateTransaction = (trxId, customer_id, amount, subamount, notes, date, local_path, items = '' // ✅ new optional field
+) => {
   return new Promise((resolve, reject) => {
     db.transaction(tx => {
-      tx.executeSql("INSERT INTO Transactions (customer_id, amount, subamount, notes, date, local_path) VALUES (?, ?, ?, ?, ?, ?)", [customer_id, amount, subamount, notes, date, local_path], (txObj, resultSet) => resolve(resultSet), (txObj, error) => reject(error));
+      tx.executeSql(`UPDATE Transactions 
+                 SET customer_id = ?, 
+                     amount = ?, 
+                     subamount = ?, 
+                     notes = ?, 
+                     date = ?, 
+                     local_path = ?, 
+                     items = ? 
+                 WHERE id = ?`, [customer_id, amount, subamount, notes, date, local_path, items, trxId], (txObj, resultSet) => resolve(resultSet), (txObj, error) => reject(error));
     });
   });
 };
@@ -95,11 +451,27 @@ export const getClientDetails = id => {
     });
   });
 };
-export const getClientTransactions = client_id => {
+export const getClientTransactions = (client_id, startDate, endDate) => {
   return new Promise((resolve, reject) => {
     db.transaction(tx => {
-      // Step 1: Get all transactions for the client
-      tx.executeSql("SELECT * FROM Transactions WHERE customer_id = ? ORDER BY created_at DESC", [client_id], (txObj, resultSet) => {
+      // Base SQL
+      let sql = `
+                SELECT * 
+                FROM Transactions 
+                WHERE customer_id = ?
+                AND (isDeleted IS NULL OR isDeleted = 0)
+            `;
+      const params = [client_id];
+
+      // ✅ Filter by date range if provided
+      if (startDate && endDate) {
+        sql += ` AND date(date) BETWEEN date(?) AND date(?)`;
+        params.push(startDate, endDate);
+      }
+      sql += ` ORDER BY date DESC`;
+
+      // Step 1: Get transactions
+      tx.executeSql(sql, params, (txObj, resultSet) => {
         const transactions = [];
         for (let i = 0; i < resultSet.rows.length; i++) {
           transactions.push({
@@ -108,7 +480,7 @@ export const getClientTransactions = client_id => {
           });
         }
         if (transactions.length === 0) {
-          resolve([]); // no transactions → return empty array
+          resolve([]);
           return;
         }
 
@@ -139,6 +511,65 @@ export const getClientTransactions = client_id => {
     });
   });
 };
+
+// export const getClientTransactions = (client_id) => {
+//     return new Promise((resolve, reject) => {
+//         db.transaction((tx) => {
+//             // Step 1: Get all transactions for the client
+//             tx.executeSql(
+//                 "SELECT * FROM Transactions WHERE customer_id = ? ORDER BY created_at DESC",
+//                 [client_id],
+//                 (txObj, resultSet) => {
+//                     const transactions = [];
+//                     for (let i = 0; i < resultSet.rows.length; i++) {
+//                         transactions.push({
+//                             ...resultSet.rows.item(i),
+//                             attachments: [] // prepare attachments array
+//                         });
+//                     }
+
+//                     if (transactions.length === 0) {
+//                         resolve([]); // no transactions → return empty array
+//                         return;
+//                     }
+
+//                     // Step 2: Collect transaction IDs
+//                     const trxIds = transactions.map((t) => t.id);
+
+//                     // Step 3: Query all attachments for these trxIds
+//                     const placeholders = trxIds.map(() => "?").join(",");
+//                     tx.executeSql(
+//                         `SELECT * FROM TransactionImages WHERE trxId IN (${placeholders})`,
+//                         trxIds,
+//                         (txObj2, resultSet2) => {
+//                             const attachments = [];
+//                             for (let i = 0; i < resultSet2.rows.length; i++) {
+//                                 attachments.push(resultSet2.rows.item(i));
+//                             }
+
+//                             // Step 4: Merge attachments into transactions
+//                             const transactionMap = {};
+//                             transactions.forEach((t) => {
+//                                 transactionMap[t.id] = t;
+//                             });
+
+//                             attachments.forEach((att) => {
+//                                 if (transactionMap[att.trxId]) {
+//                                     transactionMap[att.trxId].attachments.push(att);
+//                                 }
+//                             });
+
+//                             resolve(transactions);
+//                         },
+//                         (txObj2, error) => reject(error)
+//                     );
+//                 },
+//                 (txObj, error) => reject(error)
+//             );
+//         });
+//     });
+// };
+
 export const addTransactionImages = (trxId, local_path) => {
   return new Promise((resolve, reject) => {
     db.transaction(tx => {
@@ -146,4 +577,719 @@ export const addTransactionImages = (trxId, local_path) => {
     });
   });
 };
+export const updateTransactionImage = (attachment_id, trxId, local_path) => {
+  return new Promise((resolve, reject) => {
+    // if uri is falsy or an empty string -> delete the row
+    if (!local_path || typeof local_path === 'string' && local_path.trim() === '') {
+      if (!attachment_id) {
+        // nothing to delete
+        console.log('updateTransactionImage: no attachment_id to delete');
+        return resolve({
+          rowsAffected: 0
+        });
+      }
+      // delete instead of update
+      return deleteTransactionImage(attachment_id).then(res => resolve(res)).catch(err => reject(err));
+    }
+
+    // if there's no attachment_id (new file), fall back to INSERT
+    if (!attachment_id) {
+      // call your existing addTransactionImages function
+      return addTransactionImages(trxId, local_path).then(res => {
+        console.log('Inserted new TransactionImage, insertId:', res.insertId);
+        resolve(res);
+      }).catch(err => {
+        console.log('Error inserting new TransactionImage:', err);
+        reject(err);
+      });
+    }
+
+    // Normal UPDATE branch
+    db.transaction(tx => {
+      tx.executeSql(`UPDATE TransactionImages 
+                 SET trxId = ?, 
+                     local_path = ?, 
+                     updated_at = datetime('now') 
+                 WHERE id = ?`, [trxId, local_path, attachment_id], (txObj, resultSet) => {
+        console.log('updateTransactionImage rowsAffected:', resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log('SQLite error updating image:', error);
+        reject(error);
+      });
+    });
+  });
+};
+export const deleteTransactionImage = attachment_id => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`DELETE FROM TransactionImages WHERE id = ?`, [attachment_id], (txObj, resultSet) => {
+        console.log('deleteTransactionImage rowsAffected:', resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log('SQLite error deleting image:', error);
+        reject(error);
+      });
+    });
+  });
+};
+export const deleteTransactionImagesByTrxId = trxId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`DELETE FROM TransactionImages WHERE trxId = ?`, [trxId], (txObj, resultSet) => {
+        console.log('deleteTransactionImagesByTrxId rowsAffected:', resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log('SQLite error deleting images by trxId:', error);
+        reject(error);
+      });
+    });
+  });
+};
+export const addBank = (bank_id, bank_name, bank_charges, transfer_time, icon, code, allowed_digits, bank_hint) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`INSERT INTO Bank 
+                (bank_id, bank_name, bank_charges, transfer_time, icon, code, allowed_digits, bank_hint)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [bank_id, bank_name, bank_charges, transfer_time, icon, code, allowed_digits, bank_hint], (txObj, resultSet) => resolve(resultSet),
+      // success
+      (txObj, error) => reject(error) // error
+      );
+    });
+  });
+};
+export const getAllBanks = () => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("SELECT * FROM Bank",
+      // your table name
+      [], (txObj, resultSet) => {
+        let results = [];
+        for (let i = 0; i < resultSet.rows.length; i++) {
+          results.push(resultSet.rows.item(i));
+        }
+        resolve(results);
+      }, (txObj, error) => {
+        reject(error);
+      });
+    });
+  });
+};
+export const clearAllBanks = () => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("DELETE FROM Bank",
+      // delete all rows
+      [], (txObj, resultSet) => {
+        resolve(resultSet); // success
+      }, (txObj, error) => {
+        reject(error); // error
+      });
+    });
+  });
+};
+export const bankExists = bank_id => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("SELECT COUNT(*) as count FROM Bank WHERE bank_id = ?", [bank_id], (txObj, resultSet) => {
+        const count = resultSet.rows.item(0).count;
+        resolve(count > 0); // true if exists
+      }, (txObj, error) => reject(error));
+    });
+  });
+};
+export const insertBank = (name, phoneNum, type, notification, local_path, business_id, serverId = null,
+// NEW: serverId
+created_at = null, updated_at = null) => {
+  return new Promise((resolve, reject) => {
+    // Default JSON for status
+    const defaultStatus = JSON.stringify({
+      flat: "",
+      landmark: "",
+      pincode: "",
+      city: "",
+      state: ""
+    });
+
+    // Normalize inputs
+    const normalizedName = name ? String(name).trim() : "";
+    const normalizedPhone = phoneNum ? String(phoneNum).trim() : "";
+    db.transaction(tx => {
+      // Step 1: Check if a client with SAME name, SAME phone, AND SAME business exists
+      tx.executeSql(`SELECT * FROM Clients 
+                 WHERE name = ? 
+                   AND phone = ? 
+                   AND business_id = ?
+                   AND (isDeleted IS NULL OR isDeleted = 0)`, [normalizedName, normalizedPhone, business_id], (txObj, resultSet) => {
+        if (resultSet.rows.length > 0) {
+          // Already exists → build a "fake" insertResult
+          const existing = resultSet.rows.item(0);
+          resolve({
+            insertId: existing.id,
+            rowsAffected: 0,
+            existing: true,
+            client: existing
+          });
+        } else {
+          // Step 2: Insert new record with optional created_at / updated_at / serverId
+          const fields = ["name", "phone", "type", "status", "notification", "local_path", "business_id", "isDeleted"];
+          const placeholders = ["?", "?", "?", "?", "?", "?", "?", 0];
+          const values = [normalizedName, normalizedPhone, type, defaultStatus, notification, local_path, business_id];
+          if (serverId !== null) {
+            fields.push("serverId");
+            placeholders.push("?");
+            values.push(serverId);
+          }
+          if (created_at) {
+            fields.push("created_at");
+            placeholders.push("?");
+            values.push(created_at);
+          }
+          if (updated_at) {
+            fields.push("updated_at");
+            placeholders.push("?");
+            values.push(updated_at);
+          }
+          const sql = `INSERT INTO Clients (${fields.join(",")}) VALUES (${placeholders.join(",")})`;
+          tx.executeSql(sql, values, (txObj, insertResult) => resolve(insertResult), (txObj, error) => reject(error));
+        }
+      }, (txObj, error) => reject(error));
+    });
+  });
+};
+export const setPayDate = (newPayDate, clientId, optionId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET paydate = ?, fb_id = ? WHERE id = ?", [newPayDate, optionId, clientId], (txObj, resultSet) => {
+        console.log("Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating paydate and fb_id:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const insertPhoneNum = (phoneNum, clientId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET phone = ? WHERE id = ?", [phoneNum, clientId], (txObj, resultSet) => {
+        console.log("Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating phone num:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const setProfilePic = (uri, clientId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET local_path = ? WHERE id = ?", [uri, clientId], (txObj, resultSet) => {
+        console.log("Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating profile pic and fb_id:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const setClientName = (name, clientId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET name = ? WHERE id = ?", [name, clientId], (txObj, resultSet) => {
+        console.log("Name updated. Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating name:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const setClientPhone = (phone, clientId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET phone = ? WHERE id = ?", [phone, clientId], (txObj, resultSet) => {
+        console.log("Phone updated. Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating phone:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const setClientCnic = (cnic, clientId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET cnic = ? WHERE id = ?", [cnic, clientId], (txObj, resultSet) => {
+        console.log("CNIC updated. Rows affected:", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating CNIC:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const setClientAddress = (addressObj, clientId) => {
+  return new Promise((resolve, reject) => {
+    const jsonAddress = JSON.stringify(addressObj);
+    db.transaction(tx => {
+      tx.executeSql('UPDATE Clients SET status = ? WHERE id = ?', [jsonAddress, clientId], (txObj, res) => resolve(res), (txObj, err) => reject(err));
+    });
+  });
+};
+export const switchClientToSupplier = clientId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql("UPDATE Clients SET type = 1 WHERE id = ?", [clientId], (txObj, resultSet) => {
+        console.log("Rows affected (switch to supplier):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error switching client to supplier:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const getTransactionsByClientType = (type, startDate, endDate, businessId = null) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      // Base query
+      let sql = `
+        SELECT 
+          t.*, 
+          c.type AS client_type,
+          c.name AS client_name,
+          c.local_path AS client_local_path,
+          c.phone AS client_phone,
+          c.business_id AS client_business_id
+        FROM Transactions t
+        INNER JOIN Clients c ON t.customer_id = c.id
+        WHERE (t.isDeleted IS NULL OR t.isDeleted = 0)  -- exclude soft deleted transactions
+        AND (c.isDeleted IS NULL OR c.isDeleted = 0)    -- exclude soft deleted clients
+      `;
+
+      // Params array
+      const params = [];
+
+      // 🔹 Filter by client type if provided and not "all"
+      if (type && type.toLowerCase() !== 'all') {
+        sql += ` AND c.type = ?`;
+        params.push(type);
+      }
+
+      // 🔹 Filter by business ID if provided
+      if (businessId !== null && businessId !== undefined) {
+        sql += ` AND c.business_id = ?`;
+        params.push(businessId);
+      }
+
+      // 🔹 Filter by date range if both provided
+      if (startDate && endDate) {
+        sql += ` AND date(t.date) BETWEEN date(?) AND date(?)`;
+        params.push(startDate, endDate);
+      }
+
+      // 🔹 Order by most recent first
+      sql += ` ORDER BY t.date DESC;`;
+      tx.executeSql(sql, params, async (txObj, resultSet) => {
+        const transactions = [];
+        for (let i = 0; i < resultSet.rows.length; i++) {
+          transactions.push(resultSet.rows.item(i));
+        }
+
+        // ✅ If no transactions, resolve immediately
+        if (transactions.length === 0) return resolve([]);
+
+        // 🔹 Fetch transaction images for these transactions
+        const ids = transactions.map(t => t.id);
+        const placeholders = ids.map(() => '?').join(',');
+        tx.executeSql(`SELECT * FROM TransactionImages WHERE trxId IN (${placeholders})`, ids, (txObj2, imgResult) => {
+          const imagesMap = {};
+          for (let j = 0; j < imgResult.rows.length; j++) {
+            const row = imgResult.rows.item(j);
+            if (!imagesMap[row.trxId]) imagesMap[row.trxId] = [];
+            imagesMap[row.trxId].push(row);
+          }
+
+          // Attach images to each transaction
+          const withAttachments = transactions.map(t => ({
+            ...t,
+            attachments: imagesMap[t.id] || []
+          }));
+          resolve(withAttachments);
+        }, (txObj2, err2) => reject(err2));
+      }, (txObj, error) => {
+        console.log("Error getting transactions:", error);
+        reject(error);
+      });
+    });
+  });
+};
+
+// export const getTransactionsByClientType = (type, startDate, endDate) => {
+//     return new Promise((resolve, reject) => {
+//         db.transaction((tx) => {
+//             let sql = `
+//         SELECT 
+//             t.*, 
+//             c.type AS client_type,
+//             c.name AS client_name
+//         FROM Transactions t
+//         INNER JOIN Clients c ON t.customer_id = c.id
+//         WHERE c.type = ?
+//           AND (t.isDeleted IS NULL OR t.isDeleted = 0)  -- exclude soft deleted transactions
+//       `;
+//             const params = [type];
+
+//             if (startDate && endDate) {
+//                 sql += ` AND date(t.date) BETWEEN date(?) AND date(?)`;
+//                 params.push(startDate, endDate);
+//             }
+
+//             sql += ` ORDER BY t.date DESC;`;
+
+//             tx.executeSql(
+//                 sql,
+//                 params,
+//                 async (txObj, resultSet) => {
+//                     const transactions = [];
+//                     for (let i = 0; i < resultSet.rows.length; i++) {
+//                         transactions.push(resultSet.rows.item(i));
+//                     }
+
+//                     // Fetch all images for these transactions
+//                     const ids = transactions.map(t => t.id);
+//                     if (ids.length === 0) return resolve([]);
+
+//                     const placeholders = ids.map(() => '?').join(',');
+//                     tx.executeSql(
+//                         `SELECT * FROM TransactionImages WHERE trxId IN (${placeholders})`,
+//                         ids,
+//                         (txObj2, imgResult) => {
+//                             const imagesMap = {};
+//                             for (let j = 0; j < imgResult.rows.length; j++) {
+//                                 const row = imgResult.rows.item(j);
+//                                 if (!imagesMap[row.trxId]) imagesMap[row.trxId] = [];
+//                                 imagesMap[row.trxId].push(row);
+//                             }
+
+//                             // Attach images to their transactions
+//                             const withAttachments = transactions.map(t => ({
+//                                 ...t,
+//                                 attachments: imagesMap[t.id] || []
+//                             }));
+
+//                             resolve(withAttachments);
+//                         },
+//                         (txObj2, err2) => reject(err2)
+//                     );
+//                 },
+//                 (txObj, error) => {
+//                     console.log("Error getting transactions:", error);
+//                     reject(error);
+//                 }
+//             );
+//         });
+//     });
+// };
+
+// export const getTransactionsByClientType = (type, startDate, endDate) => {
+//     return new Promise((resolve, reject) => {
+//         db.transaction((tx) => {
+//             let sql = `
+//                 SELECT 
+//                     t.*, 
+//                     c.type AS client_type,
+//                     c.name AS client_name
+//                 FROM Transactions t
+//                 INNER JOIN Clients c ON t.customer_id = c.id
+//                 WHERE c.type = ?
+//             `;
+//             const params = [type];
+
+//             if (startDate && endDate) {
+//                 sql += ` AND date(t.date) BETWEEN date(?) AND date(?)`;
+//                 params.push(startDate, endDate);
+//             }
+
+//             sql += ` ORDER BY t.date DESC;`;
+
+//             tx.executeSql(
+//                 sql,
+//                 params,
+//                 async (txObj, resultSet) => {
+//                     const transactions = [];
+//                     for (let i = 0; i < resultSet.rows.length; i++) {
+//                         transactions.push(resultSet.rows.item(i));
+//                     }
+
+//                     // Fetch all images for these transactions
+//                     const ids = transactions.map(t => t.id);
+//                     if (ids.length === 0) return resolve([]);
+
+//                     const placeholders = ids.map(() => '?').join(',');
+//                     tx.executeSql(
+//                         `SELECT * FROM TransactionImages WHERE trxId IN (${placeholders})`,
+//                         ids,
+//                         (txObj2, imgResult) => {
+//                             const imagesMap = {};
+//                             for (let j = 0; j < imgResult.rows.length; j++) {
+//                                 const row = imgResult.rows.item(j);
+//                                 if (!imagesMap[row.trxId]) imagesMap[row.trxId] = [];
+//                                 imagesMap[row.trxId].push(row);
+//                             }
+
+//                             // Attach images to their transactions
+//                             const withAttachments = transactions.map(t => ({
+//                                 ...t,
+//                                 attachments: imagesMap[t.id] || []
+//                             }));
+
+//                             resolve(withAttachments);
+//                         },
+//                         (txObj2, err2) => reject(err2)
+//                     );
+//                 },
+//                 (txObj, error) => {
+//                     console.log("Error getting transactions:", error);
+//                     reject(error);
+//                 }
+//             );
+//         });
+//     });
+// };
+
+export const changeTransactionType = transactionId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+        UPDATE Transactions
+        SET 
+          amount = subamount,
+          subamount = amount
+        WHERE id = ?;
+        `, [transactionId], (txObj, resultSet) => {
+        console.log("Rows affected (swap amount & subamount):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error swapping amount & subamount:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const softDeleteTransaction = transactionId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+        UPDATE Transactions
+        SET isDeleted = 1
+        WHERE id = ?;
+        `, [transactionId], (txObj, resultSet) => {
+        console.log("Rows affected (soft delete):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error soft deleting transaction:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const changeClientType = (clientId, newType = 1) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+        UPDATE Clients
+        SET type = ?
+        WHERE id = ?;
+        `, [newType, clientId], (txObj, resultSet) => {
+        console.log(`Client type changed to ${newType} for id ${clientId}`);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error changing client type:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const updateClientCreditLimit = (clientId, newCreditLimit) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`UPDATE Clients SET credit_limit = ? WHERE id = ?;`, [newCreditLimit, clientId], (txObj, resultSet) => {
+        if (resultSet.rowsAffected > 0) {
+          resolve(true); // Successfully updated
+        } else {
+          resolve(false); // No rows updated (maybe wrong clientId)
+        }
+      }, (txObj, error) => {
+        console.error('Error updating credit_limit', error);
+        reject(error);
+      });
+    });
+  });
+};
+export const changeTransactionClient = (transactionId, newCustomerId) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+                UPDATE Transactions
+                SET customer_id = ?
+                WHERE id = ?;
+                `, [newCustomerId, transactionId], (txObj, resultSet) => {
+        console.log(`Transaction ${transactionId} now assigned to customer_id ${newCustomerId}`);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error changing transaction customer_id:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const softDeleteClient = clientId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+        UPDATE Clients
+        SET isDeleted = 1
+        WHERE id = ?;
+        `, [clientId], (txObj, resultSet) => {
+        console.log("Rows affected (soft delete):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error soft deleting transaction:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const updateClientInstallmentDetails = (clientId, paymentDetails) => {
+  return new Promise((resolve, reject) => {
+    const jsonString = JSON.stringify(paymentDetails); // Convert JSON to string
+
+    db.transaction(tx => {
+      tx.executeSql(`
+                UPDATE Clients
+                SET payment_mode = ?
+                WHERE id = ?;
+                `, [jsonString, clientId], (txObj, resultSet) => {
+        console.log("Rows affected (update payment_details):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating payment_details:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const updateBankProfile = (clientId, phone, notification) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`
+        UPDATE Clients
+        SET phone = ?, notification = ?
+        WHERE id = ?;
+        `, [phone, notification, clientId], (txObj, resultSet) => {
+        console.log("Rows affected (update):", resultSet.rowsAffected);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log("Error updating client:", error);
+        reject(error);
+      });
+    });
+  });
+};
+export const getActiveInstallments = () => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`SELECT id, payment_mode FROM Clients WHERE (isDeleted IS NULL OR isDeleted = 0)`, [], (txObj, resultSet) => {
+        let results = [];
+        for (let i = 0; i < resultSet.rows.length; i++) {
+          if (resultSet.rows.item(i).payment_mode) {
+            let parsedInstallment = JSON.parse(resultSet.rows.item(i).payment_mode);
+            let clientId = resultSet.rows.item(i).id;
+            if (parsedInstallment?.active == "1") {
+              results.push({
+                clientId,
+                ...parsedInstallment,
+                start_date: parsedInstallment?.start_date,
+                last_entry_date: parsedInstallment?.last_entry_date
+                // start_date: parsedInstallment?.start_date && new Date(parsedInstallment.start_date),
+                // last_entry_date: parsedInstallment?.last_entry_date && new Date(parsedInstallment.last_entry_date),
+              });
+            }
+          }
+        }
+        resolve(results);
+      }, (txObj, error) => {
+        reject(error);
+      });
+    });
+  });
+};
+export const ensureTransactionsTableColumns = () => {
+  db.transaction(tx => {
+    // ✅ 1. Check and add 'cash_type' in Transactions table
+    tx.executeSql(`PRAGMA table_info(Transactions);`, [], (txObj, resultSet) => {
+      const cols = [];
+      for (let i = 0; i < resultSet.rows.length; i++) {
+        cols.push(resultSet.rows.item(i).name);
+      }
+      if (!cols.includes('cash_type')) {
+        tx.executeSql(`ALTER TABLE Transactions ADD COLUMN cash_type VARCHAR;`, [], () => console.log('✅ Added cash_type column to Transactions table'), (txObj, error) => console.error('⚠️ Failed to add cash_type column:', error));
+      }
+    }, (txObj, error) => console.error('⚠️ PRAGMA error (Transactions):', error));
+
+    // ✅ 2. Check and add 'fromExpense' in CashRegister table
+    tx.executeSql(`PRAGMA table_info(CashRegister);`, [], (txObj, resultSet) => {
+      const cols = [];
+      for (let i = 0; i < resultSet.rows.length; i++) {
+        cols.push(resultSet.rows.item(i).name);
+      }
+      if (!cols.includes('fromExpense')) {
+        tx.executeSql(`ALTER TABLE CashRegister ADD COLUMN fromExpense TEXT;`, [], () => console.log('✅ Added fromExpense column to CashRegister table'), (txObj, error) => console.error('⚠️ Failed to add fromExpense column:', error));
+      }
+    }, (txObj, error) => console.error('⚠️ PRAGMA error (CashRegister):', error));
+
+    // ✅ 3. Check and add 'isCash' in ExpenseTransaction table
+    tx.executeSql(`PRAGMA table_info(ExpenseTransaction);`, [], (txObj, resultSet) => {
+      const cols = [];
+      for (let i = 0; i < resultSet.rows.length; i++) {
+        cols.push(resultSet.rows.item(i).name);
+      }
+      if (!cols.includes('isCash')) {
+        tx.executeSql(`ALTER TABLE ExpenseTransaction ADD COLUMN isCash TEXT;`, [], () => console.log('✅ Added isCash column to ExpenseTransaction table'), (txObj, error) => console.error('⚠️ Failed to add isCash column:', error));
+      }
+    }, (txObj, error) => console.error('⚠️ PRAGMA error (ExpenseTransaction):', error));
+  });
+};
+export const updateClientPaymentMode = (clientId, payment_mode) => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`UPDATE Clients 
+         SET payment_mode = ? 
+         WHERE id = ?`, [payment_mode, clientId], (txObj, resultSet) => resolve(resultSet), (txObj, error) => reject(error));
+    });
+  });
+};
+export const hardDeleteClientsNotOfUser = async userId => {
+  return new Promise((resolve, reject) => {
+    db.transaction(tx => {
+      tx.executeSql(`DELETE FROM Clients WHERE business_id NOT IN (
+            SELECT id FROM Business WHERE user_id = ?
+        )`, [userId], (txObj, resultSet) => {
+        console.log('Hard deleted clients not of user:', resultSet);
+        resolve(resultSet);
+      }, (txObj, error) => {
+        console.log('SQL Error (hard delete clients):', error);
+        reject(error);
+      });
+    });
+  });
+};
 //# sourceMappingURL=clients.js.map