"use client"; import * as React from "react"; import { ChevronRightIcon, SearchIcon } from "lucide-react"; import { kes } from "@/components/medora/payroll"; import { Button } from "@/components/ui/button"; import { Input } from "@/components/ui/input"; import { NativeSelect, NativeSelectOption } from "@/components/ui/native-select"; import { addDays, count, daysBetween, formatDate } from "@/lib/format"; import { cn } from "@/lib/utils"; /* * Purchasing chain, second half: receiving against an order (IN-16), the goods received notes it creates * (IN-17, SU-05), and the supplier bills and credit notes posted against them (AC-10). A supplier bill is * for goods received, never goods ordered, so it is raised from a GRN and checked against its value. */ const r2 = (n: number) => Math.round(n * 100) / 100; const th = "px-2 py-2 font-medium"; const thR = "px-2 py-2 text-right font-medium"; /* ------------------------------------ Receiving (IN-16) ------------------------------------ */ export type ReceiveLine = { id: number; product: string; ordered: number; before: number; unitCost: number; vat: 0 | 16; delivered: string; received: string; batch: string; expiry: string; reason: string }; export type ReceiveHeader = { po: string; supplier: string; dnNo: string; cuNo: string; location: string; date: string }; export const SHORT_REASONS = ["Damaged", "Wrong item", "Short expiry", "Not on the delivery note"] as const; export type ReceiveCheck = { blocking: string[]; warnings: string[] }; /** * What stops a GRN being posted, and what only needs a second look. Received can't exceed delivered, and * delivered can't exceed what is still outstanding; anything delivered but refused needs a reason; every * received line needs a batch and a future expiry. Short shelf life is a warning, not a block. */ export function receiveCheck(h: ReceiveHeader, lines: ReceiveLine[], today: string): ReceiveCheck { const blocking: string[] = []; const warnings: string[] = []; if (!h.dnNo.trim()) blocking.push("Enter the delivery note number from the supplier's paperwork."); if (!/^\d{10,20}$/.test(h.cuNo.replace(/\s/g, ""))) blocking.push("Enter the KRA CU invoice number from the supplier's eTIMS invoice: 10 to 20 digits. Without it the VAT can't be claimed."); if (!h.location) blocking.push("Choose the location the goods go into."); if (!lines.some((l) => Number(l.received) > 0)) blocking.push("Nothing is being received. Enter the quantities accepted."); for (const l of lines) { const left = l.ordered - l.before; const dl = l.delivered === "" ? 0 : Number(l.delivered); const rc = l.received === "" ? 0 : Number(l.received); if (!/^\d*$/.test(l.delivered) || !/^\d*$/.test(l.received)) { blocking.push(`${l.product}: quantities are whole numbers.`); continue; } if (dl > left) blocking.push(`${l.product}: ${dl} delivered but only ${left} still on order. Receive ${left} and return the rest, or amend the order first.`); if (rc > dl) blocking.push(`${l.product}: can't accept ${rc} when ${dl} were delivered.`); if (rc < dl && !l.reason) blocking.push(`${l.product}: ${dl - rc} delivered but not accepted. Say why.`); if (rc > 0) { if (!l.batch.trim()) blocking.push(`${l.product}: enter the batch number printed on the pack.`); if (!l.expiry) blocking.push(`${l.product}: enter the expiry date.`); else if (l.expiry <= today) blocking.push(`${l.product}: expiry ${formatDate(l.expiry)} has passed. Refuse these and record the reason.`); else if (daysBetween(today, l.expiry) < 180) warnings.push(`${l.product}: expires ${formatDate(l.expiry)}, under 6 months away. Accept only if you'll sell it in time.`); } if (dl > 0 && dl < left && rc === dl) warnings.push(`${l.product}: ${left - dl} still to come; the order stays open.`); } return { blocking, warnings }; } export const receivedValue = (lines: ReceiveLine[]) => { let sub = 0; let vat = 0; for (const l of lines) { const v = (Number(l.received) || 0) * l.unitCost; sub += v; vat += (v * l.vat) / 100; } return { subtotal: r2(sub), vat: r2(vat), total: r2(sub + vat) }; }; /** IN-16: book a delivery against its order, line by line: ordered, delivered, accepted, batch and expiry. */ export function ReceiveGoodsForm({ header, onHeader, lines, onLines, locations, check, tried }: { header: ReceiveHeader; onHeader: (h: ReceiveHeader) => void; lines: ReceiveLine[]; onLines: (l: ReceiveLine[]) => void; locations: string[]; check: ReceiveCheck; tried: boolean }) { const setH = (k: K, v: ReceiveHeader[K]) => onHeader({ ...header, [k]: v }); const setL = (id: number, p: Partial) => onLines(lines.map((l) => (l.id === id ? { ...l, ...p } : l))); const v = receivedValue(lines); return (

Against {header.po} from {header.supplier}. The GRN number is assigned when posted.

setH("dnNo", e.target.value)} aria-invalid={tried && !header.dnNo.trim()} />
setH("cuNo", e.target.value.replace(/[^\d\s]/g, ""))} aria-invalid={tried && !/^\d{10,20}$/.test(header.cuNo.replace(/\s/g, ""))} />
setH("location", e.target.value)} aria-invalid={tried && !header.location}> Choose… {locations.map((l) => ( {l} ))}
setH("date", e.target.value)} />
{lines.map((l) => { const short = Number(l.received || 0) < Number(l.delivered || 0); const rc = Number(l.received) || 0; return ( ); })}
Product Ordered Already in Delivered Accepted Not accepted because Batch Expiry Value
{l.product} at {kes(l.unitCost)} {l.ordered} {l.before || "–"} setL(l.id, { delivered: e.target.value })} /> setL(l.id, { received: e.target.value })} /> {short ? ( setL(l.id, { reason: e.target.value })} aria-invalid={tried && !l.reason}> Choose… {SHORT_REASONS.map((r) => ( {r} ))} ) : ( – )} setL(l.id, { batch: e.target.value.toUpperCase() })} aria-invalid={tried && rc > 0 && !l.batch.trim()} /> setL(l.id, { expiry: e.target.value })} aria-invalid={tried && rc > 0 && !l.expiry} /> {kes(rc * l.unitCost)}
Accepted before VAT {kes(v.subtotal)} · VAT {kes(v.vat)} · total {kes(v.total)}
{tried && check.blocking.length ? (

Fix before posting:

    {check.blocking.map((b) => (
  • {b}
    • ))}
) : null} {check.warnings.length ? (
    {check.warnings.map((w) => (
  • {w}
    • ))}
) : null}
); } /* ------------------------------------ GRN list (IN-17, SU-05) ------------------------------------ */ export type Grn = { no: string; date: string; supplier: string; po: string; dnNo: string; cuNo: string; location: string; lines: { product: string; batch: string; expiry: string; qty: number; unitCost: number; vat: 0 | 16 }[] }; export const grnTotals = (g: Grn) => { const sub = g.lines.reduce((s, l) => s + l.qty * l.unitCost, 0); const vat = g.lines.reduce((s, l) => s + (l.qty * l.unitCost * l.vat) / 100, 0); return { subtotal: r2(sub), vat: r2(vat), total: r2(sub + vat) }; }; /** * IN-17: goods received notes, as a summary (one row each) or itemised (one row per batch received). * Searchable by GRN, order, delivery note and CU numbers. Pass `supplier` to show one supplier's GRNs * on their record (SU-05): the supplier column and filter then drop away. */ export function GrnList({ grns, supplier, onOpen }: { grns: Grn[]; supplier?: string; onOpen?: (no: string) => void }) { const [view, setView] = React.useState<"summary" | "itemised">("summary"); const [q, setQ] = React.useState(""); const [sup, setSup] = React.useState(""); const [open, setOpen] = React.useState(null); const [from, setFrom] = React.useState(""); const [to, setTo] = React.useState(""); const term = q.trim().toLowerCase(); const shown = grns.filter((g) => (supplier ? g.supplier === supplier : !sup || g.supplier === sup) && (!from || g.date >= from) && (!to || g.date <= to) && (!term || `${g.no} ${g.po} ${g.dnNo} ${g.cuNo}`.toLowerCase().includes(term))); const totals = shown.reduce((t, g) => { const x = grnTotals(g); return { subtotal: t.subtotal + x.subtotal, vat: t.vat + x.vat, total: t.total + x.total }; }, { subtotal: 0, vat: 0, total: 0 }); const suppliers = [...new Set(grns.map((g) => g.supplier))].sort(); return ( // One container (data table spec, 02-data-display §1): the toolbar sits inside it, above the table
setQ(e.target.value)} />
setFrom(e.target.value)} /> setTo(e.target.value)} /> {!supplier ? ( setSup(e.target.value)}> All suppliers {suppliers.map((s) => ( {s} ))} ) : null}
{(["summary", "itemised"] as const).map((k) => ( ))}
{view === "summary" ? ( {!supplier ? : null} ) : ( )} {view === "summary" ? ( shown.map((g) => { const t = grnTotals(g); const isOpen = open === g.no; return ( {!supplier ? : null} {isOpen ? ( ) : null} ); }) ) : ( {shown.flatMap((g) => g.lines.map((l) => ( )), )} )} {view === "summary" ? ( <> ) : ( )}
GRNSupplierOrder and delivery note Before VAT VAT Invoice total
GRN Product Batch and expiry Qty Unit cost Value
{formatDate(g.date)} · {g.location} {g.supplier} {g.po} · DN {g.dnNo} CU {g.cuNo} {kes(t.subtotal)} {kes(t.vat)} {kes(t.total)}
    {g.lines.map((l) => (
  • {l.qty} × {l.product} {l.batch}, exp {formatDate(l.expiry)} {kes(l.qty * l.unitCost)}
    • ))}
{g.no} {l.product} {l.batch} · {formatDate(l.expiry)} {l.qty} {kes(l.unitCost)} {kes(l.qty * l.unitCost)}
{count(shown.length, "GRN")}{view === "itemised" ? " (value before VAT)" : ""} {kes(totals.subtotal)} {kes(totals.vat)} {kes(totals.total)}{kes(totals.subtotal)}
); } /* ------------------------------------ Supplier bills (AC-10) ------------------------------------ */ export type BillDraft = { invoiceNo: string; cuNo: string; invoiceDate: string; amount: string; note: string }; /** * A bill is entered against a GRN. Its amount should equal the goods received (VAT included); a difference * above a shilling must be explained, and the bill is held from payment until someone clears it. The due * date comes from the supplier's payment terms, not from typing. */ export function billProblems(b: BillDraft, grnTotal: number, existingInvoiceNos: string[]) { const p: string[] = []; if (!b.invoiceNo.trim()) p.push("Enter the supplier's invoice number."); else if (existingInvoiceNos.includes(b.invoiceNo.trim().toUpperCase())) p.push(`Invoice ${b.invoiceNo.trim()} from this supplier is already entered. Don't pay it twice.`); if (!/^\d{10,20}$/.test(b.cuNo.replace(/\s/g, ""))) p.push("Enter the KRA CU invoice number (digits only)."); if (!b.invoiceDate) p.push("Enter the invoice date."); const amt = Number(b.amount.replace(/,/g, "")); if (!/^\d+(\.\d{1,2})?$/.test(b.amount.replace(/,/g, ""))) p.push("Enter the invoice total."); else if (Math.abs(amt - grnTotal) > 1 && !b.note.trim()) p.push(`The invoice is ${amt > grnTotal ? "more" : "less"} than the goods received by ${kes(Math.abs(amt - grnTotal))}. Explain the difference, or correct the amount.`); return p; } export function BillForm({ grn, termsDays, b, onChange, problems, tried }: { grn: Grn; termsDays: number; b: BillDraft; onChange: (b: BillDraft) => void; problems: string[]; tried: boolean }) { const t = grnTotals(grn); const amt = Number(b.amount.replace(/,/g, "")); const diff = Number.isFinite(amt) && b.amount ? r2(amt - t.total) : 0; const set = (k: K, v: BillDraft[K]) => onChange({ ...b, [k]: v }); return (

For {grn.no} ({grn.supplier}, received {formatDate(grn.date)}): goods worth {kes(t.total)} including VAT.

set("invoiceNo", e.target.value)} />
set("cuNo", e.target.value.replace(/[^\d\s]/g, ""))} />

{b.cuNo && b.cuNo.replace(/\s/g, "") === grn.cuNo ? "Matches the GRN." : grn.cuNo ? `The GRN recorded ${grn.cuNo}.` : null}

set("invoiceDate", e.target.value)} />

{b.invoiceDate ? `Due ${formatDate(addDays(b.invoiceDate, termsDays))} on ${termsDays}-day terms.` : null}

set("amount", e.target.value)} />

1 ? "text-status-warning-text" : "text-muted-foreground")}>{b.amount ? (Math.abs(diff) <= 1 ? "Agrees with the goods received." : `${diff > 0 ? "Over" : "Under"} the goods received by ${kes(Math.abs(diff))}.`) : null}

{Math.abs(diff) > 1 ? (
set("note", e.target.value)} placeholder="e.g. Supplier billed the 6 damaged tubes; credit note requested" />

The bill is held from payment until an Admin clears the difference.

) : null}
{tried && problems.length ? (
    {problems.map((x) => (
  • {x}
    • ))}
) : null}
); } export type SupplierBill = { no: string; supplier: string; invoiceNo: string; grn: string; invoiceDate: string; dueDate: string; amount: number; grnValue: number; paid: number; credited: number; held?: string }; export const billBalance = (b: SupplierBill) => r2(b.amount - b.paid - b.credited); export function billState(b: SupplierBill, today: string): { label: string; tone: "ok" | "warn" | "bad" | "neutral" } { const bal = billBalance(b); if (bal <= 0.005) return { label: "Settled", tone: "ok" }; if (b.held) return { label: "Held: query", tone: "bad" }; if (b.dueDate < today) return { label: `Overdue ${daysBetween(b.dueDate, today)} day${daysBetween(b.dueDate, today) === 1 ? "" : "s"}`, tone: "bad" }; if (b.paid || b.credited) return { label: "Part paid", tone: "warn" }; return { label: `Due ${formatDate(b.dueDate, { short: true })}`, tone: "neutral" }; } const TONE: Record<"ok" | "warn" | "bad" | "neutral", string> = { ok: "bg-status-success-bg text-status-success-text", warn: "bg-status-warning-bg text-status-warning-text", bad: "bg-status-error-bg text-status-error-text", neutral: "bg-muted text-muted-foreground", }; /** AC-10: bills against goods received, with what's paid, credited and left, and why any is held. */ export function SupplierBills({ bills, today }: { bills: SupplierBill[]; today: string }) { const t = bills.reduce((s, b) => ({ amount: s.amount + b.amount, paid: s.paid + b.paid, credited: s.credited + b.credited }), { amount: 0, paid: 0, credited: 0 }); return (
{bills.map((b) => { const s = billState(b, today); const diff = r2(b.amount - b.grnValue); return ( ); })}
Bill Against Status Amount Paid Credited Balance
{b.no} {b.supplier} · inv {b.invoiceNo} {b.grn} {Math.abs(diff) > 1 ? {diff > 0 ? `${kes(diff)} more than received` : `${kes(-diff)} less than received`} : Agrees with GRN} {s.label} {b.held ? {b.held} : null} {kes(b.amount)} {b.paid ? kes(b.paid) : "–"} {b.credited ? kes(b.credited) : "–"} {kes(billBalance(b))}
{count(bills.length, "bill")} {kes(t.amount)} {kes(t.paid)} {kes(t.credited)} {kes(t.amount - t.paid - t.credited)}
); } /* ------------------------------------ Supplier credit note (AC-10) ------------------------------------ */ export type CreditNoteDraft = { bill: string; supplierCn: string; returnRef: string; amount: string; reason: string }; /** A supplier credit note reduces one bill. It can't take a bill below zero; a return reference links it to the goods sent back. */ export function creditNoteProblems(d: CreditNoteDraft, bills: SupplierBill[]) { const p: string[] = []; const b = bills.find((x) => x.no === d.bill); if (!b) p.push("Choose the bill this credit note reduces."); if (!d.supplierCn.trim()) p.push("Enter the supplier's credit note number."); const amt = Number(d.amount.replace(/,/g, "")); if (!/^\d+(\.\d{1,2})?$/.test(d.amount.replace(/,/g, "")) || amt <= 0) p.push("Enter the credit amount."); else if (b && amt > billBalance(b) + 0.005) p.push(`That's more than the ${kes(billBalance(b))} still owed on ${b.no}. Record the rest as credit on account with the supplier.`); if (!d.reason.trim()) p.push("Say what the credit is for."); return p; } export function SupplierCreditNoteForm({ d, onChange, bills, returns, problems, tried }: { d: CreditNoteDraft; onChange: (d: CreditNoteDraft) => void; bills: SupplierBill[]; returns: { ref: string; value: number }[]; problems: string[]; tried: boolean }) { const set = (k: K, v: CreditNoteDraft[K]) => onChange({ ...d, [k]: v }); const open = bills.filter((b) => billBalance(b) > 0.005); const b = bills.find((x) => x.no === d.bill); const ret = returns.find((r) => r.ref === d.returnRef); return (
set("bill", e.target.value)}> Choose… {open.map((x) => ( {x.no} · {x.supplier} · owes {kes(billBalance(x))} ))}
set("supplierCn", e.target.value)} />
set("returnRef", e.target.value)}> Not for a return {returns.map((r) => ( {r.ref} · {kes(r.value)} ))}
set("amount", e.target.value)} />

{ret && !d.amount ? `The return was worth ${kes(ret.value)}.` : b ? `${b.no} has ${kes(billBalance(b))} left to pay.` : null}

set("reason", e.target.value)} />
{tried && problems.length ? (
    {problems.map((x) => (
  • {x}
    • ))}
) : null}
); }