{cheaper ? `Saves ${inr(po.amount - newAmount)} vs the current vendor — allowed.` : `Must be lower than the current PO (${inr(po.amount)}). A more expensive switch isn't allowed.`}
)}
);
}
window.ChangeVendorModal = ChangeVendorModal;
// The write side of editing which SOs share an ALREADY-ISSUED line (Moment
// 3) — same so_alloc primitive CreateVendorPOModal/BulkVendorPOModal write
// at creation. Pure: builds the patched PO and says which SOs are newly
// linked (so the caller can advance/notify them); writes nothing itself.
function applyLineSoAlloc(po, productId, so_alloc) {
const before = new Set(poLinkedSoIds(po));
const items = (po.items || []).map(it => it.product_id === productId ? { ...it, so_alloc } : it);
const amount = Math.round(items.reduce((s, it) => s + (Number(it.qty) || 0) * (Number(it.rate) || 0), 0));
const linkedSoIds = poLinkedSoIds({ ...po, items });
const newlyLinked = linkedSoIds.filter(id => !before.has(id));
return { po: { ...po, items, amount }, linkedSoIds, newlyLinked };
}
window.applyLineSoAlloc = applyLineSoAlloc;
// Per-product on-PO / received totals for an SO, AND which specific PO(s)
// each total comes from — an SO routinely has more than one vendor PO
// (different vendors, batches, or a PO combined with another SO entirely),
// and a combined number with no way to see which PO it came from is exactly
// the guess-presented-as-fact "show where a number came from" rule exists
// to prevent. Only lists a PO against a product when it actually has
// quantity on/received for it — never a phantom zero entry. Pure read-only.
function soItemPOBreakdown(state, so, pos) {
const receivedByProd = {}, onPOByProd = {};
const onPOByProdPO = {}, receivedByProdPO = {};
const grnsForPO = (poId) => (state.grns || []).filter(g => g.po_id === poId);
pos.forEach(po => {
(po.items || []).forEach(it => {
const q = poLineSoQty(po, it.product_id, so.id);
onPOByProd[it.product_id] = (onPOByProd[it.product_id] || 0) + q;
if (q > 0.0001) (onPOByProdPO[it.product_id] = onPOByProdPO[it.product_id] || []).push({ po_id: po.id, po_no: po.po_no, qty: q });
});
const recvForThisPO = {};
grnsForPO(po.id).forEach(g => (g.items || []).forEach(it => {
const q = grnLineSoQty(it, po, so.id);
receivedByProd[it.product_id] = (receivedByProd[it.product_id] || 0) + q;
if (q > 0.0001) recvForThisPO[it.product_id] = (recvForThisPO[it.product_id] || 0) + q;
}));
Object.keys(recvForThisPO).forEach(pid => { (receivedByProdPO[pid] = receivedByProdPO[pid] || []).push({ po_id: po.id, po_no: po.po_no, qty: recvForThisPO[pid] }); });
});
return { onPOByProd, receivedByProd, onPOByProdPO, receivedByProdPO };
}
window.soItemPOBreakdown = soItemPOBreakdown;
// A quick, upfront, visual answer to "which SO(s) is this PO for, and how
// much of what" — shown once, before any line-item ticking, so Stores never
// discovers a PO is shared only after a per-line split editor appears deep
// in the form. Renders nothing for the overwhelming majority of POs, which
// still serve just one SO — zero visual change there.
function ComboPOSummary({ po, getSO, getProduct }) {
const linked = poLinkedSoIds(po);
if (linked.length <= 1) return null;
const rows = [];
(po.items || []).forEach(it => {
const p = getProduct(it.product_id);
linked.forEach(soId => {
const q = poLineSoQty(po, it.product_id, soId);
if (q > 0.0001) rows.push({ product: p ? p.name : it.product_id, so_id: soId, qty: q });
});
});
return (
This PO combines {linked.length} Sales Orders
Each line's own split (below) decides exactly what this receipt gives each one
Item
Sales Order
Ordered qty
{rows.map((r, i) => { const so = getSO(r.so_id); return (
{r.product}
{so ? so.so_no : r.so_id}
{qty(r.qty)}
); })}
);
}
window.ComboPOSummary = ComboPOSummary;
// ===== Per-SO Vendor POs tab — every vendor mapped to ONE SO, with margins,
// item tracking (ordered → received → remaining) and payable status, in one
// place. Read-only consolidation; actions reuse the existing GRN / 3-way flow. =====
function SOVendorPOsTab({ so }) {
const { state, navigate, mutate, getVendor, getProduct, soSubtotal, currentUser, getUser } = useStore();
const toast = useToast();
const [vF, setVF] = React.useState('');
const [sF, setSF] = React.useState('');
const [q, setQ] = React.useState('');
const [showSplit, setShowSplit] = React.useState(false);
const [receivePo, setReceivePo] = React.useState(null);
const role = currentUser ? getUser(currentUser)?.role : '';
const canProcure = ['Purchase', 'Project Manager', 'Stores', 'Org Admin'].includes(role);
const canApprove = ['Managing Director', 'Org Admin'].includes(role);
const sourcing = window.soSourcing ? window.soSourcing(state, so.id) : null;
const setPoStatus = (po, status, msg) => {
mutate(s => ({ ...s, vendor_pos: s.vendor_pos.map(p => p.id === po.id ? { ...p, status } : p), notifications: [{ id: 'n-poapp-' + Date.now(), kind: 'po', text: `${po.po_no} ${status === 'Issued' ? 'resumed' : status === 'Rejected' ? 'rejected by MD' : 'put on hold by MD'}`, date: TODAY, read: false, role: 'Purchase' }, ...s.notifications] }), { action: 'po-status', entity: 'VendorPO', entity_id: po.id });
toast(msg, status === 'Rejected' ? '' : 'success');
};
const reviewPo = (po, approve) => {
const changed = !!po.pending_change;
mutate(s => ({ ...s, vendor_pos: s.vendor_pos.map(p => p.id === po.id ? applyPOReview(p, approve) : p), notifications: [{ id: 'n-porev-' + Date.now(), kind: 'po', text: `${po.po_no} ${approve ? (changed ? 'vendor change approved → ' + (getVendor(po.pending_change.vendor_id)?.name || '') : 'approved') : (changed ? 'vendor change declined' : 'rejected')} by MD`, date: TODAY, read: false, role: 'Purchase' }, ...s.notifications] }), { action: 'po-review', entity: 'VendorPO', entity_id: po.id });
toast(approve ? `${po.po_no} approved` : `${po.po_no} ${changed ? 'change declined' : 'rejected'}`, approve ? 'success' : '');
};
const pos = state.vendor_pos.filter(p => poServesSO(p, so.id));
const grnsFor = (poId) => state.grns.filter(g => g.po_id === poId);
const viFor = (poId) => (state.vendor_invoices || []).filter(v => v.po_id === poId);
const PoolPanel = window.VGAddFromPoolPanel; // smart pool-suggestion panel (reused)
// ===== Inline Vendor-PO editing (Purchase, after procurement starts) =====
// Editable only while a PO hasn't been received and isn't awaiting MD — so no
// GRN/e-Bill/3-way history is ever disturbed. Amount + MD gate recompute live.
const [expanded, setExpanded] = React.useState({});
const [addSel, setAddSel] = React.useState({}); // po.id -> product_id to add
const [splitOpen, setSplitOpen] = React.useState({}); // "po.id|product_id" -> bool
const mdThreshold = state.config.vendor_po_md_threshold != null ? state.config.vendor_po_md_threshold : 500000;
const editablePO = (po) => canProcure && ['Issued', 'In Transit'].includes(po.status) && grnsFor(po.id).length === 0;
// A PO that has received SOME of its lines can still have its OTHER,
// unreceived lines edited — the lock is per-line, not per-PO. (Vendor
// replacement above keeps the strict, zero-GRN-at-all gate: swapping
// vendors after any stock has arrived would corrupt the GRN/invoice trail.)
const poOpenForEdit = (po) => canProcure && ['Issued', 'In Transit', 'Partially Received'].includes(po.status);
const lineReceived = (po, pid) => grnsFor(po.id).some(g => (g.items || []).some(it => it.product_id === pid && (Number(it.accepted) || 0) > 0));
const lineEditable = (po, pid) => poOpenForEdit(po) && !lineReceived(po, pid);
const recalc = (items) => items.reduce((s, it) => s + (Number(it.qty) || 0) * (Number(it.rate) || 0), 0);
const savePOItems = (po, items, vendorId) => {
const amount = Math.round(recalc(items));
const needsMD = amount > mdThreshold;
mutate(s => ({
...s,
vendor_pos: s.vendor_pos.map(p => p.id === po.id ? { ...p, items, amount, status: needsMD ? 'Pending MD Approval' : po.status, ...(vendorId ? { vendor_id: vendorId } : {}) } : p),
notifications: [{ id: 'n-poedit-' + Date.now(), kind: 'po', text: `${po.po_no} edited by Purchase · ${inrK(amount)}${needsMD ? ' · needs MD approval' : ''}`, date: TODAY, read: false, role: needsMD ? 'Managing Director' : 'Stores' }, ...s.notifications],
}), { action: 'po-edit', entity: 'VendorPO', entity_id: po.id });
};
const setItemQty = (po, pid, qty) => savePOItems(po, (po.items || []).map(it => it.product_id === pid ? { ...it, qty: Math.max(0, Number(qty) || 0) } : it));
const setItemRate = (po, pid, rate) => savePOItems(po, (po.items || []).map(it => it.product_id === pid ? { ...it, rate: Math.max(0, Number(rate) || 0) } : it));
const removeItem = (po, pid) => savePOItems(po, (po.items || []).filter(it => it.product_id !== pid));
const addItemToPO = (po) => { const pid = addSel[po.id]; if (!pid || (po.items || []).some(it => it.product_id === pid)) return; const p = getProduct(pid); const rate = window.vendorUnitPrice ? window.vendorUnitPrice(po.vendor_id, p) : (p ? p.buy || 0 : 0); savePOItems(po, [...(po.items || []), { product_id: pid, qty: 1, rate }]); setAddSel(m => ({ ...m, [po.id]: '' })); };
const changePOVendor = (po, vid) => { if (!vid || vid === po.vendor_id) return; const items = (po.items || []).map(it => { const p = getProduct(it.product_id); const rate = window.vendorUnitPrice ? window.vendorUnitPrice(vid, p) : it.rate; return { ...it, rate }; }); savePOItems(po, items, vid); };
// Editing which SOs share a line, after the PO already exists — same
// so_alloc primitive CreateVendorPOModal writes at creation. Any newly
// added SO gets notified and advances to 'Procurement Started', exactly
// like today's single-SO "Create PO" already does.
const setItemSoAlloc = (po, pid, so_alloc) => {
const { po: patched, linkedSoIds, newlyLinked } = applyLineSoAlloc(po, pid, so_alloc);
const needsMD = patched.amount > mdThreshold;
mutate(s => ({
...s,
vendor_pos: s.vendor_pos.map(p => p.id === po.id ? { ...p, items: patched.items, amount: patched.amount, status: needsMD ? 'Pending MD Approval' : po.status } : p),
sales_orders: newlyLinked.length ? s.sales_orders.map(x => newlyLinked.includes(x.id) ? { ...x, status: soAdvanceStatus(x.status, 'Procurement Started') } : x) : s.sales_orders,
notifications: [{ id: 'n-posplit-' + Date.now(), kind: 'po', text: `${po.po_no}: ${getProduct(pid)?.name || pid} now split across ${linkedSoIds.length} SO(s)${newlyLinked.length ? ' — ' + newlyLinked.map(id => (state.sales_orders.find(x => x.id === id) || {}).so_no || id).join(', ') + ' notified' : ''}${needsMD ? ' · needs MD approval' : ''}`, date: TODAY, read: false, role: needsMD ? 'Managing Director' : 'Stores' }, ...s.notifications],
}), { action: 'po-split', entity: 'VendorPO', entity_id: po.id });
};
// Aggregate received / on-PO per product across this SO's POs, AND which
// specific PO(s) each total comes from — see soItemPOBreakdown.
const { onPOByProd, receivedByProd, onPOByProdPO, receivedByProdPO } = soItemPOBreakdown(state, so, pos);
const required = soReqComponents(so);
// A PO shared across SOs counts only this SO's own share here, never the
// whole PO — identical to po.amount whenever the PO isn't actually shared.
const poCostForSO = (po) => poLinkedSoIds(po).length > 1 ? poSoAmount(po, so.id) : (po.amount || 0);
const poOurForSO = (po) => poLinkedSoIds(po).length > 1 ? poOurValueForSO(po, so.id, getProduct) : poOurValue(po, getProduct);
// Actually committed so far — real money on real POs. Still the right
// number for the per-PO table's own footer below (what's been placed),
// but NOT the whole story for "what will this order earn": a component
// never yet put on a PO used to read as zero cost here, so the grand
// totals below used the SAME soProfit() the SO Overview's own profit
// panel uses — committed + an estimate for what's still to buy — so the
// two screens can never show a different margin for the same order.
const vendorSpend = pos.reduce((s, p) => s + poCostForSO(p), 0);
const profit = window.soProfit ? window.soProfit(state, so, getProduct) : null;
const projectSell = profit ? profit.revenue : soSubtotal(so);
const projectCost = profit ? profit.cost : vendorSpend;
const projectEstimated = profit ? profit.estimated : 0;
const projectMargin = profit ? profit.profit : projectSell - vendorSpend;
const marginPct = profit && profit.margin != null ? profit.margin : (projectSell > 0 ? (projectMargin / projectSell) * 100 : 0);
const payableBooked = pos.reduce((s, p) => s + viFor(p.id).filter(v => v.status === 'Booked').reduce((a, v) => a + (v.amount || 0), 0), 0);
// Supply vs Implementation classification for the split view.
const supplySet = new Set(); (so.lines || []).forEach(l => (l.components || []).forEach(c => supplySet.add(c.product_id)));
const implReq = soImplReq(so); const implSet = new Set(Object.keys(implReq));
const im = so.extra && so.extra.implementation;
const typeOf = (pid) => (supplySet.has(pid) && implSet.has(pid)) ? 'Both' : implSet.has(pid) ? 'Impl' : 'Supply';
const prodIds = Array.from(new Set([...Object.keys(required), ...Object.keys(onPOByProd), ...Object.keys(receivedByProd)]));
const track = prodIds.map(pid => {
const p = getProduct(pid);
const req = required[pid] || 0, onPO = onPOByProd[pid] || 0, recv = receivedByProd[pid] || 0;
return { pid, p, req, onPO, recv, remaining: Math.max(0, onPO - recv), shortfall: Math.max(0, req - onPO), type: typeOf(pid),
onPOBreakdown: onPOByProdPO[pid] || [], recvBreakdown: receivedByProdPO[pid] || [] };
}).filter(r => !q || (r.p && (r.p.name.toLowerCase().includes(q.toLowerCase()) || (r.p.code || '').toLowerCase().includes(q.toLowerCase()))));
const shortfalls = track.filter(r => r.shortfall > 0).length;
const awaiting = track.filter(r => r.remaining > 0).length;
const statuses = [...new Set(pos.map(p => p.status))];
const vRows = pos.filter(po => (!vF || po.vendor_id === vF) && (!sF || po.status === sF));
const poStatusBadge = (st) => st === 'Material Received' ? Received
: st === 'Pending MD Approval' ? MD approval
: st === 'Rejected' ? Rejected
: st === 'On Hold' ? On hold
: {st};
// Before POs exist: show the PLANNED vendors from the inquiry allocation so the
// SO already lists its vendors, with one-click generate.
if (pos.length === 0) {
const planned = sourcing && window.vendorPOGroups ? window.vendorPOGroups(state, so, sourcing, getProduct) : [];
if (planned.length === 0) return (
No vendors yet
Vendors come from the inquiry. Add them in Sourcing (Add vendor & quote → Allocate across vendors); they'll appear here and POs auto-generate when you click Start Procurement.
);
return (
Planned vendors from inquiry {sourcing.src_no}
{planned.length} vendor(s) · POs auto-generate on “Start Procurement”, or generate now.
{canProcure && }
Vendor (planned)
Items
Planned cost
{planned.map(g => { const v = getVendor(g.vendor_id); return
{v ? v.name : g.vendor_id}
{g.items.length}
{inr(g.amount)}
; })}
Planned total
{inr(planned.reduce((s, g) => s + g.amount, 0))}
);
}
return (
{/* Anything Stores has confirmed as arrived, waiting on Purchase. Same
records and actions as the GRN screen and the Virtual Godown — this is
simply the third place the person who must act on it might be. */}
{/* Grand totals */}
Vendors
{pos.length}
Our value
{inrK(projectSell)}
Vendor cost
{inrK(projectCost)}
{projectEstimated > 0 &&
{inrK(vendorSpend)} ordered + {inrK(projectEstimated)} still to buy
Tracking engine:{shortfalls === 0 ? ✓ all required items are on a PO : ⚠ {shortfalls} item(s) still need a vendor PO}·{awaiting === 0 ? ✓ nothing awaiting receipt : {awaiting} item(s) awaiting receipt (GRN)}
{/* Smart pool suggestions — add stock from the Master Pool & cut vendor need */}
{PoolPanel && canProcure && }
{/* Vendor mapping */}
{!r.procurable ? Tracked on site : r.remaining <= 0 ? Received : r.onPO >= r.req ? Awaiting : Procure}
))}
)}
Catalogue BOQ items are procured with the supply items above (pool-first, then vendor PO). Service/manual items (labour, etc.) are tracked via the supervisor's daily usage. Everything lands in the same Virtual Godown.
For each item, give each vendor a quantity (and rate). The split is auto-grouped into one Vendor PO per vendor. Rate prefills from the inquiry quote / estimate.
{po.pending_change
? <>Vendor change awaiting MD approval · switch to {getVendor(po.pending_change.vendor_id)?.name} at {inr(po.pending_change.amount)} (was {inr(po.pending_change.old_amount)}, saves {inr(po.pending_change.old_amount - po.pending_change.amount)}). On approval the vendor swaps in automatically and the flow continues.
: <>Awaiting MD approval · this PO is over the approval threshold ({inr(grand)}). Receiving is blocked until approved.}{!canApprovePO && ' Only the Managing Director / Org Admin can approve.'}
}
{po.status === 'Rejected' &&
Rejected by MD. Re-create a PO via the Vendor POs tab if needed.
{so && so.invoice_no
? <>Tax invoice {so.invoice_no} · navigate(`invoices/${so.id}`)}>view
: 'Customer not invoiced yet — billed on the SO, separate from this PO'}
PO Items
{inVendorLang &&
Printed in {v.name} part numbers{unmapped > 0 ? ` · ${unmapped} line(s) not mapped yet` : ' · all lines mapped'} · navigate('mapping')}>edit mapping
}
{inVendorLang ? `${v.name} part no. / description` : 'Product'}
{inVendorLang ? 'Our item' : 'HSN'}
Qty
Rate
Amount
{po.items.map((it, i) => {
const p = getProduct(it.product_id);
const n = partyItemName(vendorAliases, p, poLang);
return (
{n.name}
{n.code}
{inVendorLang && !n.mapped &&
⚠ not mapped to {v.name}
}
{inVendorLang
? {n.altCode || p.code}
{n.altName || p.name}
: p.hsn}
{qty(it.qty)} {(inVendorLang && n.uom) || p.uom}
{inr(it.rate)}
{inr(it.qty * it.rate)}
);
})}
Subtotal
{inr(subtotal)}
{taxBreakdown.map(t =>
{t.label}
{inr(t.amount)}
)}
Grand Total
{inr(grand)}
Terms & Conditions
Material to be delivered to {state.org.address} unless otherwise specified.
Payment terms: {v.terms} from invoice date.
Defective material to be replaced free of cost within 7 days of intimation.
);
}
window.SoSplitEditor = SoSplitEditor;
// Editing an ALREADY-ISSUED PO line's SO split (Moment 3 — "which SO is this
// extra qty for?"). Candidates are every other open SO still outstanding for
// this item (soOutstandingProcurement — the same discovery CreateVendorPOModal
// uses) PLUS whoever is already on this line's so_alloc, shown even at zero
// outstanding since this very PO is what already covers them.
//
// A member already GRN'd on this PO can never be edited below what it has
// actually received — "can't un-receive", the same rule this screen already
// follows for a received PO as a whole.
function LinePoSplitEditor({ state, po, it, onSave, onCancel }) {
// Same "how much has each linked SO already received on this exact line"
// poSoAllocations already answers for SoSplitEditor — one definition, not
// two independently-maintained loops that could silently drift apart.
const already = {};
poSoAllocations(state, po, it.product_id).forEach(a => { already[a.so_id] = a.alreadyReceived; });
const linkedIds = (it.so_alloc && it.so_alloc.length ? it.so_alloc.map(a => a.so_id) : [po.so_id]);
const otherOpen = (state.sales_orders || []).filter(s => s.id !== po.so_id && linkedIds.indexOf(s.id) === -1 && ['Closed', 'Cancelled'].indexOf(s.status) === -1);
const otherOutstanding = {};
otherOpen.forEach(os => { otherOutstanding[os.id] = (window.soOutstandingProcurement ? window.soOutstandingProcurement(state, os)[it.product_id] : 0) || 0; });
const candidateIds = Array.from(new Set([
po.so_id, ...linkedIds,
...otherOpen.filter(os => otherOutstanding[os.id] > 0.0001).map(os => os.id),
]));
const [alloc, setAlloc] = React.useState(() => {
const m = {};
candidateIds.forEach(id => {
const ex = it.so_alloc && it.so_alloc.find(a => a.so_id === id);
m[id] = ex ? ex.qty : (id === po.so_id && !(it.so_alloc && it.so_alloc.length) ? it.qty : 0);
});
return m;
});
const [picked, setPicked] = React.useState(() => {
const m = {}; candidateIds.forEach(id => { m[id] = (alloc[id] || 0) > 0 || (already[id] || 0) > 0; }); return m;
});
const floor = (id) => already[id] || 0;
const total = candidateIds.reduce((s, id) => s + (picked[id] ? (Number(alloc[id]) || 0) : 0), 0);
const balanced = Math.abs(total - (Number(it.qty) || 0)) < 0.0001;
const save = () => {
const entries = candidateIds.filter(id => picked[id] && (Number(alloc[id]) || 0) > 0).map(id => ({ so_id: id, qty: Number(alloc[id]) || 0 }));
onSave(entries.length >= 2 ? entries : undefined); // 1 survivor -> back to the plain default
};
return (
Which SO(s) is this line's {qty(it.qty)} for?
{candidateIds.map(id => {
const so = (state.sales_orders || []).find(s => s.id === id);
const min = floor(id);
return (
);
}
window.LinePoSplitEditor = LinePoSplitEditor;
// Per-vendor receive modal (used from the SO Vendor POs tab — scalable to many vendors).
// The PO e-Bill as a document.
//
// "Print e-Bill" used to call window.print(), which prints the BROWSER PAGE —
// sidebar, buttons and all. That is not a document anybody can send, so the
// e-Bill was in practice a record with no output. This renders the real thing
// in its own window.
function poEbillHtml(po, vendor, so, org, getProduct, opts) {
const autoPrint = !!(opts && opts.autoPrint);
const e = po.ebill || {};
const esc = (x) => String(x == null ? '' : x).replace(/[&<>]/g, c => ({ '&': '&', '<': '<', '>': '>' }[c]));
const due = po.expected ? fmtDate(po.expected) : '—';
// Tax per line, from the PO's own configuration. Lines can differ: one may be
// CGST+SGST, another IGST, a labour charge TDS. The totals below are summed
// from these, never recomputed at a flat rate.
let sumBase = 0, sumTax = 0;
const summaryRows = [];
const rows = (po.items || []).map((it, n) => {
const p = getProduct(it.product_id) || {};
const q = Number(it.qty) || 0;
const rate = Number(it.rate) || 0;
const base = q * rate;
const taxes = poLineTaxes(po, it.product_id);
const calc = taxesOn(base, taxes);
sumBase += base; sumTax += calc.tax;
summaryRows.push({ amount: base, taxes });
// Each tax on its own line in the cell, so a line carrying GST AND TDS
// shows both rather than one blended figure nobody can check.
const taxCell = calc.parts.length
? calc.parts.map(x => `