Upload 25 files

package.json

@@ -7,6 +7,11 @@
     "start": "node src/server.js",
     "dev": "nodemon src/server.js",
     "migrate": "node src/db/migrate.js",
+    "migrate2": "node src/db/migrate2.js",
+    "migrate3": "node src/db/migrate3.js",
+    "migrate4": "node src/db/migrate4.js",
+    "migrate5": "node src/db/migrate5.js",
+    "undo_migrate5": "node src/db/undo_migrate5.js",
     "seed": "node src/db/seed.js",
     "reset": "node src/db/reset.js"
   },

src/db/config.js

@@ -1,48 +1,22 @@
 const { Pool } = require('pg');
+const fs = require('fs');
+const path = require('path');
 require('dotenv').config();
 
 const config = {
     user: process.env.DB_USER || "avnadmin",
     password: process.env.DB_PASSWORD || "AVNS_8YN2lShyUCy56qezi-_",
-    // Updated Host
     host: process.env.DB_HOST || "staging-photobrex-3b7a.j.aivencloud.com",
-    // Updated Port
     port: parseInt(process.env.DB_PORT || "10838"),
     database: process.env.DB_NAME || "defaultdb",
     ssl: {
-        rejectUnauthorized: true,
-        // Updated CA Certificate (Hardcoded string as requested)
-        ca: `-----BEGIN CERTIFICATE-----
-MIIEUDCCArigAwIBAgIUNcDCtq9UKVDahrOq1uPUfByWsZswDQYJKoZIhvcNAQEM
-BQAwQDE+MDwGA1UEAww1NDM0MmMxOTktZWEzOC00ODZmLTg3ZmItNjkxMTQ0MTJh
-YzQ4IEdFTiAxIFByb2plY3QgQ0EwHhcNMjUxMTI5MTMwODM5WhcNMzUxMTI3MTMw
-ODM5WjBAMT4wPAYDVQQDDDU0MzQyYzE5OS1lYTM4LTQ4NmYtODdmYi02OTExNDQx
-MmFjNDggR0VOIDEgUHJvamVjdCBDQTCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCC
-AYoCggGBAL4gSkKaQbOQz4eI1J3GfTTlG7BeFCQkxXD6M/ONZQY0CqLiOuIqQkcs
-qucBnZVk8ZqWRMqJZel+FhpUkk7Ddyole1m/DNnUh+ofO53R0ZnfrNmgqFlUkolc
-+VydiwgiprYUhne0G45Kjh87H4n73kbB+KsF5RkFXVwO4OO1AyrlUayUXhYyOzUg
-dP/NMupxGlL2rIlvfA1aVbEGwODmOkyGCvUHIEkytymhrXdkti6KX/M+9eM/ggKG
-zf4Ie4PTYXgWUxmRZsalwV1YlukUiwKS3X8SR0RhttWYopQmvVUhXYA0B8XHahcX
-4M57Wh2DIDHIMTRqK8cUvlLYEzMAmPW0SiYiMUITkdeqM7TgHr7qyPUzfurEQ4ew
-2RnZYbvBI/Yv5RG+2Wn5MDC1ccvfP6MXl+OdGf7GRcpCvJHaybzJy+7Hxj0LPc61
-h4XawJxtwlzxpdmZKbue/McqC/N0nKOQeVQxylvLKRUH29kKyNvnduCsLfYfVq5i
-iqOTrMQucwIDAQABo0IwQDAdBgNVHQ4EFgQUJmZTt7IsEdNVgLLHfDqMdm9F3mgw
-EgYDVR0TAQH/BAgwBgEB/wIBADALBgNVHQ8EBAMCAQYwDQYJKoZIhvcNAQEMBQAD
-ggGBALgLPFv1GMVta1W9O7ukFTqLFGAwDVG5FI7z+M6lSwhAoQat4gaSdpCc2NsS
-JpsVnF2xd+N2DTkg/pJs4iq1HQ2s0OwyrcWd4Z+1T4h5YN4V1gWbwBatXHUNHPEB
-2/SrS4LSLFxiYmDseU8bvjYcsBy6GlUesA+EN6M6t5tk9IhZt4wLziq/0heMivHW
-BMZGbVFJYqSFL/PVgqXCH5wCO5dSVhnkV6vFoGVYZCQPnQXC9DC84cUrX73P7rLj
-mgO3O+iOwjy++G219WIn3Ek2TWINFsNBZUlLCWpuYsxCaRl06Z9v0bni7BneGWYw
-smzdMUQWrprCD/czqse0BgXDHvbydj0lDFahixQ6Wt0PK5pcXwa+YouqiPecdflW
-OSDAMYM5O8s9KLe2D7qGyxhBNT55ljsMx4hEbMmuoyYTYSrs0THknSFppso0407e
-7CK61QMJWHzszde0njyBMTTcysJ1Dv89826h22dMNd5z97hGCmexNlfLB9v8DsoK
-Bj8KGw==
------END CERTIFICATE-----`,
+        rejectUnauthorized: false,
     },
 };
 
 const pool = new Pool(config);
 
+
 pool.on('connect', () => {
     console.log('✅ Connected to PostgreSQL database');
 });

src/db/migrate.js

@@ -17,12 +17,18 @@ const createTables = async () => {
         city VARCHAR(100),
         party_type VARCHAR(20) NOT NULL CHECK (party_type IN ('awaak', 'jawaak', 'both')),
         current_balance DECIMAL(12, 2) DEFAULT 0,
+        past_due DECIMAL(12, 2) DEFAULT 0,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       )
     `);
         console.log('✅ Created table: parties');
 
+        await client.query(`
+      ALTER TABLE parties
+      ADD COLUMN IF NOT EXISTS past_due DECIMAL(12, 2) DEFAULT 0
+    `);
+
         // 2. Create mirchi_types table
         await client.query(`
       CREATE TABLE IF NOT EXISTS mirchi_types (

src/db/migrate2.js

@@ -0,0 +1,40 @@
+const pool = require('./config');
+
+const migrate2 = async () => {
+    const client = await pool.connect();
+
+    try {
+        console.log('🚀 Starting database migration (migrate2)...');
+
+        await client.query('BEGIN');
+
+        // Add past_due (opening balance) to parties
+        await client.query(`
+      ALTER TABLE parties
+      ADD COLUMN IF NOT EXISTS past_due DECIMAL(12, 2) DEFAULT 0
+    `);
+
+        // Ensure no NULL values exist
+        await client.query(`
+      UPDATE parties
+      SET past_due = 0
+      WHERE past_due IS NULL
+    `);
+
+        await client.query('COMMIT');
+        console.log('✅ migrate2 completed successfully!');
+
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('❌ migrate2 failed:', error);
+        throw error;
+    } finally {
+        client.release();
+        await pool.end();
+    }
+};
+
+migrate2().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

src/db/migrate3.js

@@ -0,0 +1,49 @@
+const pool = require('./config');
+
+const migrate3 = async () => {
+    const client = await pool.connect();
+
+    try {
+        console.log('🚀 Starting database migration (migrate3)...');
+
+        await client.query('BEGIN');
+
+        // Standalone Jama entries (overall party receipts) - not linked to bills
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS party_jama_entries (
+        id VARCHAR(50) PRIMARY KEY,
+        party_id VARCHAR(50) NOT NULL REFERENCES parties(id) ON DELETE CASCADE,
+        entry_date DATE NOT NULL DEFAULT CURRENT_DATE,
+        amount DECIMAL(12, 2) NOT NULL,
+        note VARCHAR(255),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_party_jama_entries_party_id
+      ON party_jama_entries(party_id)
+    `);
+
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_party_jama_entries_entry_date
+      ON party_jama_entries(entry_date)
+    `);
+
+        await client.query('COMMIT');
+        console.log('✅ migrate3 completed successfully!');
+
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('❌ migrate3 failed:', error);
+        throw error;
+    } finally {
+        client.release();
+        await pool.end();
+    }
+};
+
+migrate3().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

src/db/migrate4.js

@@ -0,0 +1,70 @@
+const pool = require('./config');
+
+const MIGRATION_KEY = 'migrate4_recompute_party_current_balance';
+
+const migrate4 = async () => {
+    const client = await pool.connect();
+
+    try {
+        console.log('🚀 Starting database migration (migrate4)...');
+
+        await client.query('BEGIN');
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS migration_history (
+        key VARCHAR(120) PRIMARY KEY,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        const already = await client.query('SELECT key FROM migration_history WHERE key = $1', [MIGRATION_KEY]);
+        if (already.rows.length > 0) {
+            await client.query('COMMIT');
+            console.log('✅ migrate4 already applied. Skipping.');
+            return;
+        }
+
+        await client.query(`
+      UPDATE parties p
+      SET current_balance = (
+        COALESCE((
+          SELECT SUM(
+            CASE
+              WHEN t.bill_type = 'jawaak' AND COALESCE(t.is_return, false) = false THEN COALESCE(t.balance_amount, 0)
+              WHEN t.bill_type = 'jawaak' AND COALESCE(t.is_return, false) = true  THEN -COALESCE(t.balance_amount, 0)
+              WHEN t.bill_type = 'awaak'  AND COALESCE(t.is_return, false) = false THEN -COALESCE(t.balance_amount, 0)
+              WHEN t.bill_type = 'awaak'  AND COALESCE(t.is_return, false) = true  THEN COALESCE(t.balance_amount, 0)
+              ELSE 0
+            END
+          )
+          FROM transactions t
+          WHERE t.party_id = p.id
+        ), 0)
+        - COALESCE((
+          SELECT SUM(COALESCE(j.amount, 0))
+          FROM party_jama_entries j
+          WHERE j.party_id = p.id
+        ), 0)
+      ),
+      updated_at = CURRENT_TIMESTAMP
+    `);
+
+        await client.query('INSERT INTO migration_history(key) VALUES ($1)', [MIGRATION_KEY]);
+
+        await client.query('COMMIT');
+        console.log('✅ migrate4 completed successfully!');
+
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('❌ migrate4 failed:', error);
+        throw error;
+    } finally {
+        client.release();
+        await pool.end();
+    }
+};
+
+migrate4().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

src/db/migrate5.js

@@ -0,0 +1,124 @@
+const pool = require('./config');
+
+const migrate5 = async () => {
+    const client = await pool.connect();
+
+    try {
+        console.log('🚀 Starting database migration (migrate5)...');
+
+        await client.query('BEGIN');
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS patti_lots (
+        id VARCHAR(50) PRIMARY KEY,
+        lot_number VARCHAR(100) NOT NULL UNIQUE,
+        mirchi_type_id VARCHAR(50) NOT NULL REFERENCES mirchi_types(id) ON DELETE CASCADE,
+        mirchi_name VARCHAR(100) NOT NULL,
+        total_quantity DECIMAL(10, 2) NOT NULL,
+        remaining_quantity DECIMAL(10, 2) NOT NULL,
+        owner_party_id VARCHAR(50) REFERENCES parties(id) ON DELETE SET NULL,
+        purchase_date DATE NOT NULL,
+        status VARCHAR(20) NOT NULL CHECK (status IN ('active', 'sold_out')),
+        avg_rate DECIMAL(10, 2) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS patti_transactions (
+        id VARCHAR(50) PRIMARY KEY,
+        bill_number VARCHAR(100) NOT NULL,
+        bill_date DATE NOT NULL,
+        bill_type VARCHAR(30) NOT NULL CHECK (bill_type IN ('patti_awaak', 'patti_jawaak')),
+        is_return BOOLEAN DEFAULT FALSE,
+        party_id VARCHAR(50) NOT NULL REFERENCES parties(id) ON DELETE CASCADE,
+        party_name VARCHAR(255),
+        invoice_group_id VARCHAR(80),
+        gross_weight_total DECIMAL(10, 2) DEFAULT 0,
+        net_weight_total DECIMAL(10, 2) DEFAULT 0,
+        subtotal DECIMAL(12, 2) DEFAULT 0,
+        total_expenses DECIMAL(12, 2) DEFAULT 0,
+        total_amount DECIMAL(12, 2) NOT NULL,
+        paid_amount DECIMAL(12, 2) DEFAULT 0,
+        balance_amount DECIMAL(12, 2) DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      ALTER TABLE transactions
+      ADD COLUMN IF NOT EXISTS invoice_group_id VARCHAR(80)
+    `);
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS patti_transaction_items (
+        id VARCHAR(50) PRIMARY KEY,
+        transaction_id VARCHAR(50) NOT NULL REFERENCES patti_transactions(id) ON DELETE CASCADE,
+        mirchi_type_id VARCHAR(50) NOT NULL REFERENCES mirchi_types(id),
+        mirchi_name VARCHAR(100),
+        quality VARCHAR(50),
+        lot_id VARCHAR(50) REFERENCES patti_lots(id),
+        lot_number VARCHAR(100),
+        poti_weights TEXT,
+        gross_weight DECIMAL(10, 2) NOT NULL,
+        poti_count INTEGER NOT NULL,
+        total_potya DECIMAL(10, 2) DEFAULT 0,
+        net_weight DECIMAL(10, 2) NOT NULL,
+        rate_per_kg DECIMAL(10, 2) NOT NULL,
+        item_total DECIMAL(12, 2) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS patti_expenses (
+        id SERIAL PRIMARY KEY,
+        transaction_id VARCHAR(50) NOT NULL REFERENCES patti_transactions(id) ON DELETE CASCADE,
+        packing DECIMAL(10, 2) DEFAULT 0,
+        godown DECIMAL(10, 2) DEFAULT 0,
+        hamali DECIMAL(10, 2) DEFAULT 0,
+        commission DECIMAL(10, 2) DEFAULT 0,
+        gaadi_bhade DECIMAL(10, 2) DEFAULT 0,
+        advance DECIMAL(10, 2) DEFAULT 0,
+        other_expenses DECIMAL(10, 2) DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS patti_payments (
+        id SERIAL PRIMARY KEY,
+        transaction_id VARCHAR(50) NOT NULL REFERENCES patti_transactions(id) ON DELETE CASCADE,
+        mode VARCHAR(20) NOT NULL CHECK (mode IN ('cash', 'online', 'cheque', 'due')),
+        amount DECIMAL(12, 2) NOT NULL,
+        reference VARCHAR(255),
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_patti_transactions_party ON patti_transactions(party_id);
+      CREATE INDEX IF NOT EXISTS idx_patti_transactions_date ON patti_transactions(bill_date);
+      CREATE INDEX IF NOT EXISTS idx_patti_transaction_items_tx ON patti_transaction_items(transaction_id);
+      CREATE INDEX IF NOT EXISTS idx_patti_lots_mirchi ON patti_lots(mirchi_type_id);
+      CREATE INDEX IF NOT EXISTS idx_patti_lots_status ON patti_lots(status);
+    `);
+
+        await client.query('COMMIT');
+        console.log('✅ migrate5 completed successfully!');
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('❌ migrate5 failed:', error);
+        throw error;
+    } finally {
+        client.release();
+        await pool.end();
+    }
+};
+
+migrate5().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

src/db/undo_migrate5.js

@@ -0,0 +1,32 @@
+const pool = require('./config');
+
+const undoMigrate5 = async () => {
+    const client = await pool.connect();
+
+    try {
+        console.log('🧹 Rolling back database migration (undo_migrate5)...');
+
+        await client.query('BEGIN');
+
+        await client.query('DROP TABLE IF EXISTS patti_payments CASCADE');
+        await client.query('DROP TABLE IF EXISTS patti_expenses CASCADE');
+        await client.query('DROP TABLE IF EXISTS patti_transaction_items CASCADE');
+        await client.query('DROP TABLE IF EXISTS patti_transactions CASCADE');
+        await client.query('DROP TABLE IF EXISTS patti_lots CASCADE');
+
+        await client.query('COMMIT');
+        console.log('✅ undo_migrate5 completed successfully!');
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('❌ undo_migrate5 failed:', error);
+        throw error;
+    } finally {
+        client.release();
+        await pool.end();
+    }
+};
+
+undoMigrate5().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

src/routes/jama.js

@@ -0,0 +1,120 @@
+const express = require('express');
+const router = express.Router();
+const pool = require('../db/config');
+const { v4: uuidv4 } = require('uuid');
+
+// GET jama entries for a party
+router.get('/:partyId', async (req, res) => {
+    try {
+        const { partyId } = req.params;
+        const result = await pool.query(
+            `SELECT id, party_id, entry_date, amount, note, created_at
+       FROM party_jama_entries
+       WHERE party_id = $1
+       ORDER BY entry_date ASC, created_at ASC`,
+            [partyId]
+        );
+        res.json({ success: true, data: result.rows });
+    } catch (error) {
+        console.error('Error fetching jama entries:', error);
+        res.status(500).json({ success: false, message: error.message });
+    }
+});
+
+// POST create jama entry for a party (overall receipt)
+router.post('/:partyId', async (req, res) => {
+    const client = await pool.connect();
+
+    try {
+        const { partyId } = req.params;
+        const { amount, entry_date, note } = req.body;
+
+        const parsed = typeof amount === 'number' ? amount : parseFloat(String(amount));
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            return res.status(400).json({ success: false, message: 'Amount must be greater than 0' });
+        }
+
+        await client.query('BEGIN');
+
+        // ensure party exists
+        const partyRes = await client.query('SELECT id, current_balance FROM parties WHERE id = $1', [partyId]);
+        if (partyRes.rows.length === 0) {
+            await client.query('ROLLBACK');
+            return res.status(404).json({ success: false, message: 'Party not found' });
+        }
+
+        const id = uuidv4();
+        const date = entry_date || new Date().toISOString().split('T')[0];
+
+        const insertRes = await client.query(
+            `INSERT INTO party_jama_entries (id, party_id, entry_date, amount, note)
+       VALUES ($1, $2, $3, $4, $5)
+       RETURNING id, party_id, entry_date, amount, note, created_at`,
+            [id, partyId, date, parsed, note || null]
+        );
+
+        // For JAWAAK (sales) parties, jama reduces receivable -> decrease current_balance
+        await client.query(
+            'UPDATE parties SET current_balance = current_balance - $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2',
+            [parsed, partyId]
+        );
+
+        await client.query('COMMIT');
+
+        res.json({
+            success: true,
+            data: insertRes.rows[0],
+            message: 'Jama saved successfully'
+        });
+
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('Error creating jama entry:', error);
+        res.status(500).json({ success: false, message: error.message });
+    } finally {
+        client.release();
+    }
+});
+
+// DELETE revert jama entry
+router.delete('/:partyId/:entryId', async (req, res) => {
+    const client = await pool.connect();
+
+    try {
+        const { partyId, entryId } = req.params;
+
+        await client.query('BEGIN');
+
+        const entryRes = await client.query(
+            'SELECT id, party_id, amount FROM party_jama_entries WHERE id = $1 AND party_id = $2',
+            [entryId, partyId]
+        );
+
+        if (entryRes.rows.length === 0) {
+            await client.query('ROLLBACK');
+            return res.status(404).json({ success: false, message: 'Jama entry not found' });
+        }
+
+        const amtRaw = entryRes.rows[0].amount;
+        const amt = typeof amtRaw === 'number' ? amtRaw : parseFloat(String(amtRaw)) || 0;
+
+        await client.query('DELETE FROM party_jama_entries WHERE id = $1 AND party_id = $2', [entryId, partyId]);
+
+        await client.query(
+            'UPDATE parties SET current_balance = current_balance + $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2',
+            [amt, partyId]
+        );
+
+        await client.query('COMMIT');
+
+        res.json({ success: true, message: 'Jama reverted successfully' });
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('Error reverting jama entry:', error);
+        res.status(500).json({ success: false, message: error.message });
+    } finally {
+        client.release();
+    }
+});
+
+module.exports = router;

src/routes/parties.js

@@ -41,7 +41,7 @@ router.post('/', async (req, res) => {
     const client = await pool.connect();
 
     try {
-        const { id, name, phone, city, party_type, current_balance } = req.body;
+        const { id, name, phone, city, party_type, current_balance, past_due } = req.body;
 
         if (!name) {
             return res.status(400).json({ success: false, message: 'Party name is required' });
@@ -59,18 +59,18 @@ router.post('/', async (req, res) => {
             // Update existing party
             result = await client.query(
                 `UPDATE parties 
-         SET name = $1, phone = $2, city = $3, party_type = $4, current_balance = $5, updated_at = CURRENT_TIMESTAMP 
-         WHERE id = $6 
+         SET name = $1, phone = $2, city = $3, party_type = $4, current_balance = $5, past_due = $6, updated_at = CURRENT_TIMESTAMP 
+         WHERE id = $7 
          RETURNING *`,
-                [name, phone || '', city || '', party_type || 'both', current_balance || 0, partyId]
+                [name, phone || '', city || '', party_type || 'both', current_balance || 0, past_due || 0, partyId]
             );
         } else {
             // Insert new party
             result = await client.query(
-                `INSERT INTO parties (id, name, phone, city, party_type, current_balance) 
-         VALUES ($1, $2, $3, $4, $5, $6) 
+                `INSERT INTO parties (id, name, phone, city, party_type, current_balance, past_due) 
+         VALUES ($1, $2, $3, $4, $5, $6, $7) 
          RETURNING *`,
-                [partyId, name, phone || '', city || '', party_type || 'both', current_balance || 0]
+                [partyId, name, phone || '', city || '', party_type || 'both', current_balance || 0, past_due || 0]
             );
         }
 

src/routes/patti.js

@@ -0,0 +1,446 @@
+const express = require('express');
+const router = express.Router();
+const pool = require('../db/config');
+const { v4: uuidv4 } = require('uuid');
+
+const fetchPattiTransaction = async (client, transactionId) => {
+    const result = await client.query(`
+      SELECT t.*, 
+             json_agg(DISTINCT jsonb_build_object(
+               'id', ti.id,
+               'mirchi_type_id', ti.mirchi_type_id,
+               'mirchi_name', ti.mirchi_name,
+               'quality', ti.quality,
+               'lot_id', ti.lot_id,
+               'lot_number', ti.lot_number,
+               'poti_weights', ti.poti_weights,
+               'gross_weight', ti.gross_weight,
+               'poti_count', ti.poti_count,
+               'total_potya', ti.total_potya,
+               'net_weight', ti.net_weight,
+               'rate_per_kg', ti.rate_per_kg,
+               'item_total', ti.item_total
+             )) FILTER (WHERE ti.id IS NOT NULL) as items,
+             json_build_object(
+               'packing', e.packing,
+               'godown', e.godown,
+               'hamali', e.hamali,
+               'commission', e.commission,
+               'gaadi_bhade', e.gaadi_bhade,
+               'advance', e.advance,
+               'other_expenses', e.other_expenses
+             ) as expenses,
+             json_agg(DISTINCT jsonb_build_object(
+               'mode', p.mode,
+               'amount', p.amount,
+               'reference', p.reference
+             )) FILTER (WHERE p.id IS NOT NULL) as payments
+      FROM patti_transactions t
+      LEFT JOIN patti_transaction_items ti ON t.id = ti.transaction_id
+      LEFT JOIN patti_expenses e ON t.id = e.transaction_id
+      LEFT JOIN patti_payments p ON t.id = p.transaction_id
+      WHERE t.id = $1
+      GROUP BY t.id, e.id
+    `, [transactionId]);
+
+    return result.rows[0];
+};
+
+// GET patti transactions
+router.get('/transactions', async (req, res) => {
+    try {
+        const { party_id, bill_type, is_return, invoice_group_id } = req.query;
+
+        let query = `
+      SELECT t.*, 
+             json_agg(DISTINCT jsonb_build_object(
+               'id', ti.id,
+               'mirchi_type_id', ti.mirchi_type_id,
+               'mirchi_name', ti.mirchi_name,
+               'quality', ti.quality,
+               'lot_id', ti.lot_id,
+               'lot_number', ti.lot_number,
+               'poti_weights', ti.poti_weights,
+               'gross_weight', ti.gross_weight,
+               'poti_count', ti.poti_count,
+               'total_potya', ti.total_potya,
+               'net_weight', ti.net_weight,
+               'rate_per_kg', ti.rate_per_kg,
+               'item_total', ti.item_total
+             )) FILTER (WHERE ti.id IS NOT NULL) as items,
+             json_build_object(
+               'packing', e.packing,
+               'godown', e.godown,
+               'hamali', e.hamali,
+               'commission', e.commission,
+               'gaadi_bhade', e.gaadi_bhade,
+               'advance', e.advance,
+               'other_expenses', e.other_expenses
+             ) as expenses,
+             json_agg(DISTINCT jsonb_build_object(
+               'mode', p.mode,
+               'amount', p.amount,
+               'reference', p.reference
+             )) FILTER (WHERE p.id IS NOT NULL) as payments
+      FROM patti_transactions t
+      LEFT JOIN patti_transaction_items ti ON t.id = ti.transaction_id
+      LEFT JOIN patti_expenses e ON t.id = e.transaction_id
+      LEFT JOIN patti_payments p ON t.id = p.transaction_id
+    `;
+
+        const conditions = [];
+        const params = [];
+        let paramCount = 1;
+
+        if (party_id) {
+            conditions.push(`t.party_id = $${paramCount}`);
+            params.push(party_id);
+            paramCount++;
+        }
+
+        if (bill_type) {
+            conditions.push(`t.bill_type = $${paramCount}`);
+            params.push(bill_type);
+            paramCount++;
+        }
+
+        if (is_return !== undefined) {
+            conditions.push(`t.is_return = $${paramCount}`);
+            params.push(is_return === 'true');
+            paramCount++;
+        }
+
+        if (invoice_group_id) {
+            conditions.push(`t.invoice_group_id = $${paramCount}`);
+            params.push(invoice_group_id);
+            paramCount++;
+        }
+
+        if (conditions.length > 0) {
+            query += ' WHERE ' + conditions.join(' AND ');
+        }
+
+        query += ' GROUP BY t.id, e.id ORDER BY t.bill_date DESC, t.created_at DESC';
+
+        const result = await pool.query(query, params);
+        res.json(result.rows);
+    } catch (error) {
+        console.error('Error fetching patti transactions:', error);
+        res.status(500).json({ success: false, message: error.message });
+    }
+});
+
+// GET patti active lots
+router.get('/lots/active', async (req, res) => {
+    try {
+        const result = await pool.query(
+            `SELECT * FROM patti_lots 
+       WHERE status = 'active' AND remaining_quantity > 0 
+       ORDER BY purchase_date DESC`
+        );
+        res.json(result.rows);
+    } catch (error) {
+        console.error('Error fetching patti lots:', error);
+        res.status(500).json({ success: false, message: error.message });
+    }
+});
+
+// GET patti available lots by mirchi type
+router.get('/lots/available/:mirchiTypeId', async (req, res) => {
+    try {
+        const { mirchiTypeId } = req.params;
+        const result = await pool.query(
+            `SELECT * FROM patti_lots 
+       WHERE mirchi_type_id = $1 
+       AND status = 'active' 
+       AND remaining_quantity > 0 
+       ORDER BY purchase_date DESC`,
+            [mirchiTypeId]
+        );
+        res.json(result.rows);
+    } catch (error) {
+        console.error('Error fetching patti available lots:', error);
+        res.status(500).json({ success: false, message: error.message });
+    }
+});
+
+const insertPattiTransaction = async (client, payload, billType) => {
+    const {
+        id,
+        bill_number,
+        bill_date,
+        is_return,
+        party_id,
+        party_name,
+        invoice_group_id,
+        items,
+        expenses,
+        payments,
+        gross_weight_total,
+        net_weight_total,
+        subtotal,
+        total_expenses,
+        total_amount,
+        paid_amount,
+        balance_amount,
+    } = payload;
+
+    if (!party_id) {
+        return { error: 'Party is required' };
+    }
+
+    if (!items || items.length === 0) {
+        return { error: 'At least one item is required' };
+    }
+
+    const transactionId = id || uuidv4();
+
+    await client.query(
+        `INSERT INTO patti_transactions (
+        id, bill_number, bill_date, bill_type, is_return, party_id, party_name, invoice_group_id,
+        gross_weight_total, net_weight_total, subtotal, total_expenses,
+        total_amount, paid_amount, balance_amount
+      ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
+      RETURNING *`,
+        [
+            transactionId,
+            bill_number,
+            bill_date,
+            billType,
+            is_return || false,
+            party_id,
+            party_name,
+            invoice_group_id || null,
+            gross_weight_total,
+            net_weight_total,
+            subtotal,
+            total_expenses,
+            total_amount,
+            paid_amount,
+            balance_amount,
+        ]
+    );
+
+    for (const item of items) {
+        const itemId = item.id || uuidv4();
+        await client.query(
+            `INSERT INTO patti_transaction_items (
+          id, transaction_id, mirchi_type_id, mirchi_name, quality, lot_id,
+          lot_number, poti_weights, gross_weight, poti_count, total_potya, net_weight,
+          rate_per_kg, item_total
+        ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)`,
+            [
+                itemId,
+                transactionId,
+                item.mirchi_type_id,
+                item.mirchi_name,
+                item.quality || null,
+                item.lot_id || null,
+                item.lot_number || null,
+                JSON.stringify(item.poti_weights || []),
+                item.gross_weight,
+                item.poti_count,
+                item.total_potya || 0,
+                item.net_weight,
+                item.rate_per_kg,
+                item.item_total,
+            ]
+        );
+    }
+
+    if (expenses) {
+        await client.query(
+            `INSERT INTO patti_expenses (
+          transaction_id, packing, godown, hamali, commission, gaadi_bhade, advance, other_expenses
+        ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`,
+            [
+                transactionId,
+                expenses.packing || 0,
+                expenses.godown || 0,
+                expenses.hamali || 0,
+                expenses.commission || 0,
+                expenses.gaadi_bhade || 0,
+                expenses.advance || 0,
+                expenses.other_expenses || 0,
+            ]
+        );
+    }
+
+    if (payments && payments.length > 0) {
+        for (const payment of payments) {
+            if (payment.amount > 0) {
+                await client.query(
+                    `INSERT INTO patti_payments (transaction_id, mode, amount, reference)
+           VALUES ($1, $2, $3, $4)`,
+                    [transactionId, payment.mode, payment.amount, payment.reference]
+                );
+            }
+        }
+    }
+
+    return { transactionId };
+};
+
+const upsertPattiLotForAwaak = async (client, item, billDate) => {
+    const mirchi = await client.query('SELECT name FROM mirchi_types WHERE id = $1', [item.mirchi_type_id]);
+    const mirchiName = mirchi.rows[0]?.name || 'Unknown';
+    const lotNumber = item.lot_number;
+
+    if (!lotNumber) {
+        throw new Error('LOT number is required for Patti Awaak');
+    }
+
+    const existingLot = await client.query(
+        'SELECT id FROM patti_lots WHERE lot_number = $1',
+        [lotNumber]
+    );
+
+    if (existingLot.rows.length > 0) {
+        const lotId = existingLot.rows[0].id;
+        await client.query(
+            `UPDATE patti_lots
+             SET total_quantity = total_quantity + $1,
+                 remaining_quantity = remaining_quantity + $1,
+                 status = 'active',
+                 updated_at = CURRENT_TIMESTAMP
+             WHERE id = $2`,
+            [item.net_weight, lotId]
+        );
+
+        return lotId;
+    }
+
+    const lotId = uuidv4();
+    await client.query(
+        `INSERT INTO patti_lots (id, lot_number, mirchi_type_id, mirchi_name, total_quantity, remaining_quantity, purchase_date, status, avg_rate, owner_party_id)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+        [
+            lotId,
+            lotNumber,
+            item.mirchi_type_id,
+            mirchiName,
+            item.net_weight,
+            item.net_weight,
+            billDate,
+            'active',
+            item.rate_per_kg,
+            item.owner_party_id || null
+        ]
+    );
+
+    return lotId;
+};
+
+const applyPattiAwaakStock = async (client, items, isReturn) => {
+    if (!items || items.length === 0) return;
+
+    for (const item of items) {
+        if (!item.lot_id) continue;
+
+        if (isReturn) {
+            await client.query(
+                `UPDATE patti_lots
+                 SET total_quantity = total_quantity - $1,
+                     remaining_quantity = remaining_quantity - $1,
+                     status = CASE WHEN remaining_quantity - $1 <= 0 THEN 'sold_out' ELSE 'active' END,
+                     updated_at = CURRENT_TIMESTAMP
+                 WHERE id = $2`,
+                [item.net_weight, item.lot_id]
+            );
+        }
+    }
+};
+
+const applyPattiJawaakStock = async (client, items, isReturn) => {
+    if (!items || items.length === 0) return;
+
+    for (const item of items) {
+        if (!item.lot_id) continue;
+
+        const delta = isReturn ? item.gross_weight : -item.gross_weight;
+        await client.query(
+            `UPDATE patti_lots
+             SET remaining_quantity = remaining_quantity + $1,
+                 status = CASE WHEN remaining_quantity + $1 <= 0 THEN 'sold_out' ELSE 'active' END,
+                 updated_at = CURRENT_TIMESTAMP
+             WHERE id = $2`,
+            [delta, item.lot_id]
+        );
+    }
+};
+
+// POST create patti awaak
+router.post('/awaak', async (req, res) => {
+    const client = await pool.connect();
+
+    try {
+        const payload = req.body;
+        const normalizedItems = [...(payload.items || [])];
+
+        if (!payload.is_return) {
+            for (const item of normalizedItems) {
+                const lotId = await upsertPattiLotForAwaak(client, item, payload.bill_date);
+                item.lot_id = lotId;
+            }
+        }
+
+        await client.query('BEGIN');
+
+        const insertResult = await insertPattiTransaction(
+            client,
+            { ...payload, items: normalizedItems },
+            'patti_awaak'
+        );
+        if (insertResult.error) {
+            await client.query('ROLLBACK');
+            return res.status(400).json({ success: false, message: insertResult.error });
+        }
+
+        // Patti Awaak return reduces stock (net). Incoming handled in upsert above.
+        await applyPattiAwaakStock(client, normalizedItems, payload.is_return);
+
+        await client.query('COMMIT');
+
+        const completeTransaction = await fetchPattiTransaction(client, insertResult.transactionId);
+        res.json({ success: true, data: completeTransaction, message: 'Patti Awaak saved successfully' });
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('Error saving patti awaak:', error);
+        res.status(500).json({ success: false, message: error.message });
+    } finally {
+        client.release();
+    }
+});
+
+// POST create patti jawaak
+router.post('/jawaak', async (req, res) => {
+    const client = await pool.connect();
+
+    try {
+        const payload = req.body;
+
+        await client.query('BEGIN');
+
+        const insertResult = await insertPattiTransaction(client, payload, 'patti_jawaak');
+        if (insertResult.error) {
+            await client.query('ROLLBACK');
+            return res.status(400).json({ success: false, message: insertResult.error });
+        }
+
+        // Patti Jawaak reduces stock (gross) or adds back on return
+        await applyPattiJawaakStock(client, payload.items, payload.is_return);
+
+        await client.query('COMMIT');
+
+        const completeTransaction = await fetchPattiTransaction(client, insertResult.transactionId);
+        res.json({ success: true, data: completeTransaction, message: 'Patti Jawaak saved successfully' });
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('Error saving patti jawaak:', error);
+        res.status(500).json({ success: false, message: error.message });
+    } finally {
+        client.release();
+    }
+});
+
+module.exports = router;

src/routes/transactions.js

@@ -161,6 +161,7 @@ router.post('/', async (req, res) => {
             is_return,
             party_id,
             party_name,
+            invoice_group_id,
             items,
             expenses,
             payments,
@@ -194,14 +195,14 @@ router.post('/', async (req, res) => {
         // 1. Insert transaction
         const txResult = await client.query(
             `INSERT INTO transactions (
-        id, bill_number, bill_date, bill_type, is_return, party_id, party_name,
+        id, bill_number, bill_date, bill_type, is_return, party_id, party_name, invoice_group_id,
         gross_weight_total, net_weight_total, subtotal, total_expenses, 
         total_amount, paid_amount, balance_amount
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
       RETURNING *`,
             [
                 transactionId, bill_number, bill_date, bill_type, is_return || false,
-                party_id, party_name, gross_weight_total, net_weight_total,
+                party_id, party_name, invoice_group_id || null, gross_weight_total, net_weight_total,
                 subtotal, total_expenses, total_amount, paid_amount, balance_amount
             ]
         );
@@ -260,33 +261,16 @@ router.post('/', async (req, res) => {
         }
 
         // 5. Update party balance
-        if (bill_type === 'jawaak') {
-            // Purchase: We owe them (decrease balance)
-            if (is_return) {
-                await client.query(
-                    'UPDATE parties SET current_balance = current_balance + $1 WHERE id = $2',
-                    [balance_amount, party_id]
-                );
-            } else {
-                await client.query(
-                    'UPDATE parties SET current_balance = current_balance - $1 WHERE id = $2',
-                    [balance_amount, party_id]
-                );
-            }
-        } else {
-            // Sales: They owe us (increase balance)
-            if (is_return) {
-                await client.query(
-                    'UPDATE parties SET current_balance = current_balance - $1 WHERE id = $2',
-                    [balance_amount, party_id]
-                );
-            } else {
-                await client.query(
-                    'UPDATE parties SET current_balance = current_balance + $1 WHERE id = $2',
-                    [balance_amount, party_id]
-                );
-            }
-        }
+        // Convention: +ve = they owe us (receivable), -ve = we owe them (payable)
+        // JAWAAK (sales): increases receivable (+). AWAAK (purchase): increases payable (-).
+        const sign = bill_type === 'jawaak' ? 1 : -1;
+        const dir = is_return ? -1 : 1;
+        const balanceDelta = sign * dir * balance_amount;
+
+        await client.query(
+            'UPDATE parties SET current_balance = current_balance + $1 WHERE id = $2',
+            [balanceDelta, party_id]
+        );
 
         // 6. Update lots (stock management)
         // AWAAK = Purchase (Stock IN), JAWAAK = Sale (Stock OUT)
@@ -530,4 +514,164 @@ router.patch('/:id/payment', async (req, res) => {
     }
 });
 
+// POST revert transaction (rollback stock + balances, then delete)
+router.post('/:id/revert', async (req, res) => {
+    const client = await pool.connect();
+
+    try {
+        const { id } = req.params;
+
+        await client.query('BEGIN');
+
+        const txResult = await client.query(
+            'SELECT * FROM transactions WHERE id = $1',
+            [id]
+        );
+
+        if (txResult.rows.length === 0) {
+            await client.query('ROLLBACK');
+            return res.status(404).json({ success: false, message: 'Transaction not found' });
+        }
+
+        const tx = txResult.rows[0];
+
+        const itemsResult = await client.query(
+            'SELECT * FROM transaction_items WHERE transaction_id = $1',
+            [id]
+        );
+
+        const items = itemsResult.rows;
+
+        if (!items || items.length === 0) {
+            await client.query('ROLLBACK');
+            return res.status(400).json({ success: false, message: 'No items found for this transaction' });
+        }
+
+        // Rollback lots (inverse of creation logic)
+        for (const item of items) {
+            if (!item.lot_id) continue;
+
+            const lotResult = await client.query(
+                'SELECT * FROM lots WHERE id = $1',
+                [item.lot_id]
+            );
+
+            if (lotResult.rows.length === 0) {
+                await client.query('ROLLBACK');
+                return res.status(400).json({ success: false, message: `Lot not found for item ${item.id}` });
+            }
+
+            const lot = lotResult.rows[0];
+            const netWeight = Number(item.net_weight || 0);
+            const grossWeight = Number(item.gross_weight || 0);
+
+            // AWAAK = Purchase (Stock IN), JAWAAK = Sale (Stock OUT)
+            if (tx.bill_type === 'awaak' && !tx.is_return) {
+                // Reverting a purchase: subtract stock that was added
+                if (Number(lot.remaining_quantity) < netWeight || Number(lot.total_quantity) < netWeight) {
+                    await client.query('ROLLBACK');
+                    return res.status(409).json({
+                        success: false,
+                        message: `Cannot revert: stock already used for lot ${lot.lot_number}. Remaining ${lot.remaining_quantity}, required ${netWeight}`
+                    });
+                }
+
+                await client.query(
+                    `UPDATE lots
+                     SET total_quantity = total_quantity - $1,
+                         remaining_quantity = remaining_quantity - $1,
+                         status = CASE WHEN remaining_quantity - $1 <= 0 THEN 'sold_out' ELSE 'active' END,
+                         updated_at = CURRENT_TIMESTAMP
+                     WHERE id = $2`,
+                    [netWeight, item.lot_id]
+                );
+            } else if (tx.bill_type === 'awaak' && tx.is_return) {
+                // Reverting a purchase return: add stock back
+                await client.query(
+                    `UPDATE lots
+                     SET total_quantity = total_quantity + $1,
+                         remaining_quantity = remaining_quantity + $1,
+                         status = 'active',
+                         updated_at = CURRENT_TIMESTAMP
+                     WHERE id = $2`,
+                    [netWeight, item.lot_id]
+                );
+            } else if (tx.bill_type === 'jawaak' && !tx.is_return) {
+                // Reverting a sale: add stock back to remaining (gross)
+                await client.query(
+                    `UPDATE lots
+                     SET remaining_quantity = remaining_quantity + $1,
+                         status = CASE WHEN remaining_quantity + $1 > 0 THEN 'active' ELSE status END,
+                         updated_at = CURRENT_TIMESTAMP
+                     WHERE id = $2`,
+                    [grossWeight, item.lot_id]
+                );
+            } else if (tx.bill_type === 'jawaak' && tx.is_return) {
+                // Reverting a sales return: subtract stock that was added back (gross)
+                if (Number(lot.remaining_quantity) < grossWeight) {
+                    await client.query('ROLLBACK');
+                    return res.status(409).json({
+                        success: false,
+                        message: `Cannot revert: not enough remaining stock in lot ${lot.lot_number}. Remaining ${lot.remaining_quantity}, required ${grossWeight}`
+                    });
+                }
+
+                await client.query(
+                    `UPDATE lots
+                     SET remaining_quantity = remaining_quantity - $1,
+                         status = CASE WHEN remaining_quantity - $1 <= 0 THEN 'sold_out' ELSE 'active' END,
+                         updated_at = CURRENT_TIMESTAMP
+                     WHERE id = $2`,
+                    [grossWeight, item.lot_id]
+                );
+            }
+        }
+
+        // Rollback party balance (inverse of creation logic in this file)
+        const balanceAmount = Number(tx.balance_amount || 0);
+
+        if (tx.bill_type === 'jawaak') {
+            if (tx.is_return) {
+                await client.query(
+                    'UPDATE parties SET current_balance = current_balance - $1 WHERE id = $2',
+                    [balanceAmount, tx.party_id]
+                );
+            } else {
+                await client.query(
+                    'UPDATE parties SET current_balance = current_balance + $1 WHERE id = $2',
+                    [balanceAmount, tx.party_id]
+                );
+            }
+        } else {
+            if (tx.is_return) {
+                await client.query(
+                    'UPDATE parties SET current_balance = current_balance + $1 WHERE id = $2',
+                    [balanceAmount, tx.party_id]
+                );
+            } else {
+                await client.query(
+                    'UPDATE parties SET current_balance = current_balance - $1 WHERE id = $2',
+                    [balanceAmount, tx.party_id]
+                );
+            }
+        }
+
+        // Delete transaction (items/expenses/payments will cascade delete)
+        await client.query('DELETE FROM transactions WHERE id = $1', [id]);
+
+        await client.query('COMMIT');
+
+        res.json({
+            success: true,
+            message: 'Transaction reverted successfully'
+        });
+    } catch (error) {
+        await client.query('ROLLBACK');
+        console.error('Error reverting transaction:', error);
+        res.status(500).json({ success: false, message: error.message });
+    } finally {
+        client.release();
+    }
+});
+
 module.exports = router;

src/server.js

@@ -6,6 +6,8 @@ const partiesRouter = require('./routes/parties');
 const mirchiTypesRouter = require('./routes/mirchiTypes');
 const lotsRouter = require('./routes/lots');
 const transactionsRouter = require('./routes/transactions');
+const jamaRouter = require('./routes/jama');
+const pattiRouter = require('./routes/patti');
 
 const app = express();
 const PORT = process.env.PORT || 4000;
@@ -26,6 +28,8 @@ app.use('/api/parties', partiesRouter);
 app.use('/api/mirchi-types', mirchiTypesRouter);
 app.use('/api/lots', lotsRouter);
 app.use('/api/transactions', transactionsRouter);
+app.use('/api/jama', jamaRouter);
+app.use('/api/patti', pattiRouter);
 
 // Health check
 app.get('/health', (req, res) => {