701 lines
25 KiB
TypeScript
701 lines
25 KiB
TypeScript
/**
|
|
* @license
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* POS REST client — the counter-sales surface served at
|
|
* `https://fiesta.nearle.app/live/api/v1/pos`.
|
|
*
|
|
* This is a *different base* from `./fiestaApi` (which is `/live/api/v1/web`),
|
|
* so it gets its own client rather than a helper on that one.
|
|
*
|
|
* Two things about this API shape every function below:
|
|
*
|
|
* 1. **There is no tenant parameter.** `locationid` is required on every read
|
|
* and is the authorisation boundary server-side. A tenant-wide view is
|
|
* therefore a fan-out, one request per outlet, merged here — see `mapLimit`.
|
|
*
|
|
* 2. **The health endpoints return a Redis hash**, so every value is a string —
|
|
* `"today_amount": "170"`, `"printer_reachable": "0"`. Nothing may be used
|
|
* as a number or a boolean without going through the parsers here.
|
|
*
|
|
* Components call the hooks in `./posQueries`, not these functions.
|
|
*/
|
|
|
|
/**
|
|
* The console reads counter sales from `/v1/web/pos`, not `/v1/pos`.
|
|
*
|
|
* `/v1/pos` is the terminal group and sits behind `PosAuth`, which pins a
|
|
* request to the outlet inside a till's token. A browser has no such token and
|
|
* cannot get one — `/pos/login` refuses any account that is not a till account.
|
|
* So the day `POS_AUTH_REQUIRED=true` is set, every read on that group would
|
|
* 401 and this page would go blank.
|
|
*
|
|
* `/v1/web/pos` serves the same five handlers outside the guard. Identical
|
|
* responses — they read their scope from query parameters and never touch the
|
|
* session — so nothing else in this client changes.
|
|
*/
|
|
const POS_BASE = import.meta.env.VITE_FIESTA_POS_URL || 'https://fiesta.nearle.app/live/api/v1/web/pos';
|
|
|
|
type QueryParams = Record<string, string | number | undefined | null>;
|
|
|
|
// ── Wire types ───────────────────────────────────────────────────────────────
|
|
|
|
/** One counter bill. Mirrors `models.PosOrders` — the list endpoint is a
|
|
* `SELECT *`, so every column arrives whether the doc's example shows it or not. */
|
|
export interface PosBill {
|
|
posorderid: number;
|
|
terminalorderid: string;
|
|
invoicenumber: string;
|
|
tenantid: number;
|
|
locationid: number;
|
|
terminalid: string;
|
|
cashiername: string;
|
|
customerid: number;
|
|
customermobile: string;
|
|
customername: string;
|
|
billedat: string;
|
|
businessdate: string;
|
|
subtotal: number;
|
|
discount: number;
|
|
taxamount: number;
|
|
roundoff: number;
|
|
total: number;
|
|
pointsearned: number;
|
|
pointsredeemed: number;
|
|
itemcount: number;
|
|
paymentmode: string;
|
|
paymentsjson: string;
|
|
promosjson: string;
|
|
taxbreakdownjson: string;
|
|
batchid: string;
|
|
receivedat: string;
|
|
created?: string;
|
|
updated?: string;
|
|
/** Populated only by `/sales/detail`. The list endpoint sends `items: null`
|
|
* (the Go field is `gorm:"-"` with no `omitempty`), so this is nullable. */
|
|
items?: PosBillItem[] | null;
|
|
}
|
|
|
|
export interface PosBillItem {
|
|
posorderitemid: number;
|
|
posorderid: number;
|
|
tenantid: number;
|
|
locationid: number;
|
|
productid: number;
|
|
productname: string;
|
|
barcode: string;
|
|
unitname: string;
|
|
/** Fractional — a counter sells 1.5 kg. */
|
|
quantity: number;
|
|
unitprice: number;
|
|
discountamount: number;
|
|
/** A fraction (0.18), not a percentage (18). */
|
|
gstrate: number;
|
|
taxamount: number;
|
|
linetotal: number;
|
|
}
|
|
|
|
export interface PosSalesPage {
|
|
total: number;
|
|
pageno: number;
|
|
pagesize: number;
|
|
bills: PosBill[];
|
|
}
|
|
|
|
export interface PosPaymentTotal { paymentmode: string; billcount: number; amount: number }
|
|
export interface PosDayTotal { businessdate: string; billcount: number; amount: number }
|
|
export interface PosTerminalTotal { terminalid: string; billcount: number; amount: number }
|
|
|
|
export interface PosSalesSummary {
|
|
locationid: number;
|
|
fromdate: string;
|
|
todate: string;
|
|
billcount: number;
|
|
itemcount: number;
|
|
/** Named "gross" by the API but computed as `SUM(total)` — i.e. **net of
|
|
* discount and round-off**. `grosssales + discountgiven` is the gross figure.
|
|
* Labelled honestly in the UI as "Net collected". */
|
|
grosssales: number;
|
|
taxcollected: number;
|
|
discountgiven: number;
|
|
roundoff: number;
|
|
averagebill: number;
|
|
bypaymentmode: PosPaymentTotal[];
|
|
byday: PosDayTotal[];
|
|
byterminal: PosTerminalTotal[];
|
|
}
|
|
|
|
/** Raw Redis hash for one till. Every value is a string; use `parseTerminal`. */
|
|
export type PosTerminalRaw = Record<string, string>;
|
|
|
|
export interface PosLocationHealth {
|
|
location_id: string;
|
|
total: number;
|
|
online: number;
|
|
terminals: PosTerminalRaw[];
|
|
}
|
|
|
|
export interface PosSalesFilter {
|
|
locationid: number;
|
|
fromdate?: string;
|
|
todate?: string;
|
|
terminalid?: string;
|
|
/** A real filter the handler reads, applied as an exact case-sensitive match. */
|
|
cashiername?: string;
|
|
paymentmode?: string;
|
|
pageno?: number;
|
|
pagesize?: number;
|
|
}
|
|
|
|
/**
|
|
* The terminal group, used only until the console base exists on a server.
|
|
*
|
|
* TRANSITIONAL. The frontend and the backend deploy separately and the backend
|
|
* is currently behind, so shipping this build first would point every read at a
|
|
* route that answers 404 and blank the page. Rather than make the two deploys
|
|
* ordered — a constraint nobody would remember in six months — the base is
|
|
* resolved once at runtime: try the console group, and if the server is old
|
|
* enough not to have it, fall back to the terminal group for this session.
|
|
*
|
|
* Safe to delete once every environment is past the deploy that added
|
|
* `/v1/web/pos`. It is a no-op there: the first probe succeeds and the fallback
|
|
* is never reached.
|
|
*/
|
|
const POS_BASE_LEGACY = POS_BASE.replace('/v1/web/pos', '/v1/pos').replace('/v1/mob/pos', '/v1/pos');
|
|
|
|
let resolvedBase: string | null = POS_BASE === POS_BASE_LEGACY ? POS_BASE : null;
|
|
let baseProbe: Promise<string> | null = null;
|
|
|
|
/** Resolves the base once per session; concurrent callers share one probe. */
|
|
async function posBase(): Promise<string> {
|
|
if (resolvedBase) return resolvedBase;
|
|
if (!baseProbe) {
|
|
baseProbe = (async () => {
|
|
try {
|
|
// `sales/summary` needs no data to exist — a missing route 404s, a
|
|
// present one answers 200 even for an outlet with no bills.
|
|
const res = await fetch(`${POS_BASE}/sales/summary?locationid=0`, {
|
|
headers: { Accept: 'application/json' },
|
|
});
|
|
resolvedBase = res.status === 404 ? POS_BASE_LEGACY : POS_BASE;
|
|
} catch {
|
|
// A network failure says nothing about which routes exist; assume the
|
|
// current one and let the real request surface the error.
|
|
resolvedBase = POS_BASE;
|
|
}
|
|
return resolvedBase;
|
|
})();
|
|
}
|
|
return baseProbe;
|
|
}
|
|
|
|
// ── Transport ────────────────────────────────────────────────────────────────
|
|
|
|
async function posGet<T = unknown>(endpoint: string, params: QueryParams = {}): Promise<T> {
|
|
const qs = new URLSearchParams();
|
|
Object.entries(params).forEach(([k, v]) => {
|
|
if (v !== undefined && v !== null && v !== '') qs.append(k, String(v));
|
|
});
|
|
const query = qs.toString();
|
|
const base = await posBase();
|
|
const res = await fetch(`${base}/${endpoint}${query ? `?${query}` : ''}`, {
|
|
headers: { Accept: 'application/json' },
|
|
});
|
|
if (!res.ok) {
|
|
// 404 from /sales/detail is a legitimate "no such bill at this outlet",
|
|
// not a transport failure — surfaced as null by getPosSaleDetail.
|
|
throw new Error(`POS ${endpoint} failed: ${res.status} ${res.statusText}`);
|
|
}
|
|
return res.json() as Promise<T>;
|
|
}
|
|
|
|
/** The sales reads use the `{code, status, details}` envelope. Note there is no
|
|
* `message` key on success — only on errors. */
|
|
function details<T>(json: unknown): T | null {
|
|
if (json && typeof json === 'object' && 'details' in json) {
|
|
return (json as { details: T }).details ?? null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Run `fn` over `items` with at most `limit` in flight.
|
|
*
|
|
* The tenant views fan out one request per outlet. The largest tenant on the
|
|
* platform has 22 outlets, so an unbounded fan-out would open 44 sockets at
|
|
* once (health + summary) on every refresh. Six keeps it civil without making
|
|
* the page feel serial.
|
|
*/
|
|
export async function mapLimit<T, R>(
|
|
items: T[],
|
|
limit: number,
|
|
fn: (item: T, index: number) => Promise<R>,
|
|
): Promise<R[]> {
|
|
const out = new Array<R>(items.length);
|
|
let cursor = 0;
|
|
const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
|
|
for (;;) {
|
|
const i = cursor++;
|
|
if (i >= items.length) return;
|
|
out[i] = await fn(items[i], i);
|
|
}
|
|
});
|
|
await Promise.all(workers);
|
|
return out;
|
|
}
|
|
|
|
// ── Reads ────────────────────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* A page of bills for one outlet, newest first.
|
|
*
|
|
* `pagesize` is clamped to 500 here because the server does *not* clamp — it
|
|
* resets anything over 500 back to 50, so asking for 1000 quietly returns 50.
|
|
*/
|
|
export async function getPosSales(filter: PosSalesFilter): Promise<PosSalesPage> {
|
|
const pagesize = Math.min(Math.max(filter.pagesize ?? 50, 1), 500);
|
|
const json = await posGet('sales', {
|
|
locationid: filter.locationid,
|
|
fromdate: filter.fromdate,
|
|
todate: filter.todate,
|
|
terminalid: filter.terminalid,
|
|
cashiername: filter.cashiername,
|
|
paymentmode: filter.paymentmode,
|
|
pageno: filter.pageno ?? 0,
|
|
pagesize,
|
|
});
|
|
return (
|
|
details<PosSalesPage>(json) ?? { total: 0, pageno: 0, pagesize, bills: [] }
|
|
);
|
|
}
|
|
|
|
/**
|
|
* One bill with its lines. `reference` matches any of three columns server-side
|
|
* — the terminal's UUID, the invoice number, or the posorderid — so a support
|
|
* call can start from whichever the caller is looking at.
|
|
*
|
|
* Returns null on 404, which is what the server sends when the reference is
|
|
* real but belongs to a different outlet.
|
|
*/
|
|
export async function getPosSaleDetail(
|
|
locationid: number,
|
|
reference: string,
|
|
): Promise<PosBill | null> {
|
|
try {
|
|
const json = await posGet('sales/detail', { locationid, reference });
|
|
return details<PosBill>(json);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export async function getPosSalesSummary(filter: PosSalesFilter): Promise<PosSalesSummary | null> {
|
|
const json = await posGet('sales/summary', {
|
|
locationid: filter.locationid,
|
|
fromdate: filter.fromdate,
|
|
todate: filter.todate,
|
|
terminalid: filter.terminalid,
|
|
cashiername: filter.cashiername,
|
|
paymentmode: filter.paymentmode,
|
|
});
|
|
return details<PosSalesSummary>(json);
|
|
}
|
|
|
|
/** One product exactly as a till stores it. */
|
|
export interface PosCatalogueProduct {
|
|
id: string;
|
|
name: string;
|
|
barcode: string;
|
|
sku: string;
|
|
category: string;
|
|
price: number;
|
|
mrp?: number;
|
|
stock: number;
|
|
unit: string;
|
|
/** A fraction (0.05), matching how the till holds it. */
|
|
gst_rate: number;
|
|
hsn_code?: string;
|
|
brand?: string;
|
|
/** False for anything a till must not be able to ring up — chiefly unpriced
|
|
* products, which would otherwise sell at ₹0. */
|
|
is_active: boolean;
|
|
}
|
|
|
|
export interface PosCatalogueCustomer {
|
|
id: string;
|
|
name: string;
|
|
mobile: string;
|
|
loyalty_points: number;
|
|
lifetime_spend: number;
|
|
visit_count: number;
|
|
last_visit_at?: string;
|
|
}
|
|
|
|
export interface PosCatalogue {
|
|
revision: string;
|
|
is_delta: boolean;
|
|
has_more: boolean;
|
|
products: PosCatalogueProduct[];
|
|
customers: PosCatalogueCustomer[];
|
|
retired_product_ids: string[];
|
|
}
|
|
|
|
/**
|
|
* What a till at this store currently sees.
|
|
*
|
|
* Answered as a **bare body**, not the `{code, status, details}` envelope the
|
|
* sales reads use — it is a terminal-facing endpoint, so it is parsed directly.
|
|
*
|
|
* Always called without `since`, which yields a full snapshot. A delta would be
|
|
* cheaper but describes only what changed, and this panel is asking what the
|
|
* till can sell *right now*.
|
|
*/
|
|
export async function getPosCatalogue(storeId: number, pageSize = 500): Promise<PosCatalogue> {
|
|
const json = await posGet<PosCatalogue>('catalogue', { store_id: storeId, page_size: pageSize });
|
|
return {
|
|
revision: json?.revision ?? '',
|
|
is_delta: Boolean(json?.is_delta),
|
|
has_more: Boolean(json?.has_more),
|
|
products: json?.products ?? [],
|
|
customers: json?.customers ?? [],
|
|
retired_product_ids: json?.retired_product_ids ?? [],
|
|
};
|
|
}
|
|
|
|
export async function getPosLocationHealth(locationid: number): Promise<PosLocationHealth> {
|
|
const json = await posGet('health/location', { location_id: locationid });
|
|
return (
|
|
details<PosLocationHealth>(json) ?? {
|
|
location_id: String(locationid),
|
|
total: 0,
|
|
online: 0,
|
|
terminals: [],
|
|
}
|
|
);
|
|
}
|
|
|
|
// ── Parsing the health hash ──────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Four states, not two.
|
|
*
|
|
* The heartbeat is every 30s under a 90s TTL, so between those a live till has
|
|
* no fresh reading and is *not* dead — showing two states would make healthy
|
|
* tills blink red. And a key can exist while saying "offline", because the
|
|
* broker's Last Will overwrites the status when a till loses power mid-shift.
|
|
* That is the only way to tell *closed for the night* from *unplugged*, so it
|
|
* is kept distinct from a key that simply expired.
|
|
*/
|
|
export type TerminalState = 'online' | 'stale' | 'offline_declared' | 'offline_vanished';
|
|
|
|
export interface PosTerminal {
|
|
terminalId: string;
|
|
locationId: string;
|
|
storeName: string;
|
|
appVersion: string;
|
|
state: TerminalState;
|
|
/** Server-supplied explanation on the expired-key stub. */
|
|
reason: string;
|
|
pendingBills: number;
|
|
pendingRegistrations: number;
|
|
oldestPendingAt: string;
|
|
todayBills: number;
|
|
todayAmount: number;
|
|
lastBillAt: string;
|
|
reportedAt: string;
|
|
receivedAt: string;
|
|
/** Seconds since the *server* stamped the reading. Deliberately measured from
|
|
* `received_at`, never `reported_at` — a till with a wrong clock must not be
|
|
* able to make itself look fresh. */
|
|
ageSeconds: number | null;
|
|
/** `reported_at` minus `received_at`, in seconds. A large value means the
|
|
* till's clock is wrong, which matters because bills are filed under the
|
|
* business date the till decided. */
|
|
clockDriftSeconds: number | null;
|
|
/** Absent when the till does not collect them — never coerced to zero, or a
|
|
* board would show every terminal on a flat battery. */
|
|
batteryLevel: number | null;
|
|
batteryCharging: boolean | null;
|
|
storageFreeMb: number | null;
|
|
printerReachable: boolean | null;
|
|
drawerStatus: string | null;
|
|
}
|
|
|
|
const s = (h: PosTerminalRaw, k: string): string => (h[k] ?? '').trim();
|
|
|
|
function optNum(h: PosTerminalRaw, k: string): number | null {
|
|
const raw = s(h, k);
|
|
if (raw === '') return null;
|
|
const n = Number(raw);
|
|
return Number.isFinite(n) ? n : null;
|
|
}
|
|
|
|
/** Redis stores a Go bool as "1"/"0"; tolerate "true"/"false" too. */
|
|
function optBool(h: PosTerminalRaw, k: string): boolean | null {
|
|
const raw = s(h, k).toLowerCase();
|
|
if (raw === '') return null;
|
|
return raw === '1' || raw === 'true';
|
|
}
|
|
|
|
function secondsSince(iso: string, now: number): number | null {
|
|
if (!iso) return null;
|
|
const t = Date.parse(iso);
|
|
return Number.isFinite(t) ? Math.round((now - t) / 1000) : null;
|
|
}
|
|
|
|
export function parseTerminal(h: PosTerminalRaw, now: number = Date.now()): PosTerminal {
|
|
const status = s(h, 'status').toLowerCase();
|
|
const reason = s(h, 'reason');
|
|
const receivedAt = s(h, 'received_at');
|
|
const reportedAt = s(h, 'reported_at');
|
|
const ageSeconds = secondsSince(receivedAt, now);
|
|
|
|
// The expired-key stub is exactly {terminal_id, location_id, status, reason}
|
|
// — it carries no heartbeat fields at all, which is how it's told apart from
|
|
// a till that is present and declaring itself offline.
|
|
const isStub = status === 'offline' && reason !== '' && receivedAt === '';
|
|
|
|
let state: TerminalState;
|
|
if (isStub) state = 'offline_vanished';
|
|
else if (status !== 'online') state = 'offline_declared';
|
|
else if (ageSeconds == null || ageSeconds <= 40) state = 'online';
|
|
else state = 'stale';
|
|
|
|
const reportedT = reportedAt ? Date.parse(reportedAt) : NaN;
|
|
const receivedT = receivedAt ? Date.parse(receivedAt) : NaN;
|
|
|
|
return {
|
|
terminalId: s(h, 'terminal_id'),
|
|
locationId: s(h, 'location_id'),
|
|
storeName: s(h, 'store_name'),
|
|
appVersion: s(h, 'app_version'),
|
|
state,
|
|
reason,
|
|
pendingBills: optNum(h, 'pending_bills') ?? 0,
|
|
pendingRegistrations: optNum(h, 'pending_registrations') ?? 0,
|
|
oldestPendingAt: s(h, 'oldest_pending_at'),
|
|
todayBills: optNum(h, 'today_bills') ?? 0,
|
|
todayAmount: optNum(h, 'today_amount') ?? 0,
|
|
lastBillAt: s(h, 'last_bill_at'),
|
|
reportedAt,
|
|
receivedAt,
|
|
ageSeconds,
|
|
clockDriftSeconds:
|
|
Number.isFinite(reportedT) && Number.isFinite(receivedT)
|
|
? Math.round((reportedT - receivedT) / 1000)
|
|
: null,
|
|
batteryLevel: optNum(h, 'battery_level'),
|
|
batteryCharging: optBool(h, 'battery_charging'),
|
|
storageFreeMb: optNum(h, 'storage_free_mb'),
|
|
printerReachable: optBool(h, 'printer_reachable'),
|
|
drawerStatus: s(h, 'drawer_status') || null,
|
|
};
|
|
}
|
|
|
|
export const TERMINAL_STATE_LABEL: Record<TerminalState, string> = {
|
|
online: 'Online',
|
|
stale: 'Stale',
|
|
offline_declared: 'Offline',
|
|
offline_vanished: 'No heartbeat',
|
|
};
|
|
|
|
export const TERMINAL_STATE_COLOR: Record<TerminalState, string> = {
|
|
online: '#10b981',
|
|
stale: '#f59e0b',
|
|
offline_declared: '#ef4444',
|
|
offline_vanished: '#94a3b8',
|
|
};
|
|
|
|
// ── Merging a fan-out ────────────────────────────────────────────────────────
|
|
|
|
export interface PosOutletSummary {
|
|
locationid: number;
|
|
name: string;
|
|
summary: PosSalesSummary | null;
|
|
}
|
|
|
|
/**
|
|
* Fold per-outlet summaries into one.
|
|
*
|
|
* `averagebill` is **recomputed** as `Σtotal / Σbills`, never averaged. Taking
|
|
* the mean of twelve outlets' averages weights a four-bill kiosk the same as a
|
|
* nine-hundred-bill store, which is not a number anyone should act on.
|
|
*/
|
|
export function mergeSummaries(parts: Array<PosSalesSummary | null>): PosSalesSummary {
|
|
const merged: PosSalesSummary = {
|
|
locationid: 0,
|
|
fromdate: '',
|
|
todate: '',
|
|
billcount: 0,
|
|
itemcount: 0,
|
|
grosssales: 0,
|
|
taxcollected: 0,
|
|
discountgiven: 0,
|
|
roundoff: 0,
|
|
averagebill: 0,
|
|
bypaymentmode: [],
|
|
byday: [],
|
|
byterminal: [],
|
|
};
|
|
|
|
const byMode = new Map<string, PosPaymentTotal>();
|
|
const byDay = new Map<string, PosDayTotal>();
|
|
const byTerm = new Map<string, PosTerminalTotal>();
|
|
|
|
for (const p of parts) {
|
|
if (!p) continue;
|
|
merged.billcount += p.billcount || 0;
|
|
merged.itemcount += p.itemcount || 0;
|
|
merged.grosssales += p.grosssales || 0;
|
|
merged.taxcollected += p.taxcollected || 0;
|
|
merged.discountgiven += p.discountgiven || 0;
|
|
merged.roundoff += p.roundoff || 0;
|
|
merged.fromdate ||= p.fromdate;
|
|
merged.todate ||= p.todate;
|
|
|
|
for (const m of p.bypaymentmode ?? []) {
|
|
const key = m.paymentmode || '';
|
|
const at = byMode.get(key) ?? { paymentmode: key, billcount: 0, amount: 0 };
|
|
at.billcount += m.billcount || 0;
|
|
at.amount += m.amount || 0;
|
|
byMode.set(key, at);
|
|
}
|
|
for (const d of p.byday ?? []) {
|
|
const at = byDay.get(d.businessdate) ?? { businessdate: d.businessdate, billcount: 0, amount: 0 };
|
|
at.billcount += d.billcount || 0;
|
|
at.amount += d.amount || 0;
|
|
byDay.set(d.businessdate, at);
|
|
}
|
|
for (const t of p.byterminal ?? []) {
|
|
const key = t.terminalid || '';
|
|
const at = byTerm.get(key) ?? { terminalid: key, billcount: 0, amount: 0 };
|
|
at.billcount += t.billcount || 0;
|
|
at.amount += t.amount || 0;
|
|
byTerm.set(key, at);
|
|
}
|
|
}
|
|
|
|
merged.averagebill = merged.billcount > 0 ? merged.grosssales / merged.billcount : 0;
|
|
merged.bypaymentmode = [...byMode.values()].sort((a, b) => b.amount - a.amount);
|
|
merged.byday = [...byDay.values()].sort((a, b) => a.businessdate.localeCompare(b.businessdate));
|
|
merged.byterminal = [...byTerm.values()].sort((a, b) => b.amount - a.amount);
|
|
return merged;
|
|
}
|
|
|
|
/** Average bill for one outlet, recomputed rather than trusted — same trap as
|
|
* the merge above, and the store leaderboard is where it would bite. */
|
|
export const averageBill = (sm: PosSalesSummary | null): number =>
|
|
sm && sm.billcount > 0 ? sm.grosssales / sm.billcount : 0;
|
|
|
|
// ── Bill helpers ─────────────────────────────────────────────────────────────
|
|
|
|
export interface PosPaymentSplit { method: string; amount: number; reference?: string }
|
|
export interface PosPromo { id?: string; name?: string; type?: string; amount?: number }
|
|
|
|
function parseJsonField<T>(raw: string | undefined, fallback: T): T {
|
|
if (!raw) return fallback;
|
|
try {
|
|
const v = JSON.parse(raw);
|
|
return (v ?? fallback) as T;
|
|
} catch {
|
|
return fallback;
|
|
}
|
|
}
|
|
|
|
/** The full tender split. A bill can be part cash, part card, part loyalty, and
|
|
* `paymentmode` only names the largest of them. */
|
|
export const billPayments = (b: PosBill): PosPaymentSplit[] =>
|
|
parseJsonField<PosPaymentSplit[]>(b.paymentsjson, []);
|
|
|
|
/** GST per slab, as printed on the tax invoice. Keys are rate fractions
|
|
* ("0.05"), values are the tax amount at that slab. */
|
|
export const billTaxBreakdown = (b: PosBill): Array<{ rate: number; amount: number }> => {
|
|
const raw = parseJsonField<Record<string, number>>(b.taxbreakdownjson, {});
|
|
return Object.entries(raw)
|
|
.map(([rate, amount]) => ({ rate: Number(rate), amount: Number(amount) }))
|
|
.filter((r) => Number.isFinite(r.rate) && Number.isFinite(r.amount))
|
|
// Tills send a `{"0.0": 0}` placeholder on zero-rated bills. Rendering it
|
|
// as a "0.00% — ₹0.00" slab reads like a real tax line for an untaxed sale.
|
|
.filter((r) => r.amount !== 0 || r.rate !== 0)
|
|
.sort((a, b2) => a.rate - b2.rate);
|
|
};
|
|
|
|
/** Who the bill was rung for. A till can attach a customer id without a name or
|
|
* mobile, so "Walk-in" is reserved for bills with no customer at all. */
|
|
export function billCustomer(b: PosBill): string {
|
|
const named = (b.customername || '').trim() || (b.customermobile || '').trim();
|
|
if (named) return named;
|
|
return b.customerid > 0 ? `Customer #${b.customerid}` : 'Walk-in';
|
|
}
|
|
|
|
export const billPromos = (b: PosBill): PosPromo[] => parseJsonField<PosPromo[]>(b.promosjson, []);
|
|
|
|
export type SyncLag =
|
|
| { kind: 'legacy'; seconds: number }
|
|
| { kind: 'ok'; seconds: number }
|
|
| { kind: 'delayed'; seconds: number }
|
|
| { kind: 'unknown' };
|
|
|
|
/**
|
|
* How long a bill took to reach us.
|
|
*
|
|
* A negative value is **not** a fast upload — it is a bill written before the
|
|
* till started sending a UTC offset, whose `billedat` holds IST wall-clock
|
|
* stamped as though it were UTC. Those come back exactly 5h30m "early". They
|
|
* are classed `legacy` rather than alerted on, because flooring the panel at a
|
|
* date would still leak the ones rung on the morning of the fix.
|
|
*
|
|
* `businessdate` is unaffected by that skew (storing local wall-clock as UTC
|
|
* preserves the date), so day bucketing and the date filters stay correct — the
|
|
* damage is confined to this one comparison.
|
|
*/
|
|
export function syncLag(b: PosBill): SyncLag {
|
|
const billed = Date.parse(b.billedat);
|
|
const received = Date.parse(b.receivedat);
|
|
if (!Number.isFinite(billed) || !Number.isFinite(received)) return { kind: 'unknown' };
|
|
const seconds = Math.round((received - billed) / 1000);
|
|
if (seconds < 0) return { kind: 'legacy', seconds };
|
|
if (seconds > 900) return { kind: 'delayed', seconds };
|
|
return { kind: 'ok', seconds };
|
|
}
|
|
|
|
/** Terminal ids are blank on bills ingested before the fallback landed. Shown
|
|
* as a named bucket rather than an empty cell so the column reads honestly. */
|
|
export const terminalLabel = (t: string): string => (t && t.trim()) || 'Unassigned';
|
|
|
|
export const todayISO = (): string => {
|
|
const d = new Date();
|
|
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
|
|
};
|
|
|
|
export const daysAgoISO = (days: number): string => {
|
|
const d = new Date();
|
|
d.setDate(d.getDate() - days);
|
|
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
|
|
};
|
|
|
|
export const inr = (n: number): string =>
|
|
`₹${(Number.isFinite(n) ? n : 0).toLocaleString('en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
|
|
|
|
export const inrCompact = (n: number): string =>
|
|
`₹${(Number.isFinite(n) ? n : 0).toLocaleString('en-IN', { maximumFractionDigits: 0 })}`;
|
|
|
|
/** Duration in the units a person reading a sync board actually wants. */
|
|
export function humanDuration(seconds: number): string {
|
|
const abs = Math.abs(seconds);
|
|
if (abs < 60) return `${abs}s`;
|
|
if (abs < 3600) return `${Math.round(abs / 60)}m`;
|
|
if (abs < 86400) return `${(abs / 3600).toFixed(1)}h`;
|
|
return `${(abs / 86400).toFixed(1)}d`;
|
|
}
|
|
|
|
/** `2026-08-05T17:29:00Z` → `17:29`. Rendered as sent; no timezone maths, since
|
|
* the stored value's offset is not trustworthy across the fix boundary. */
|
|
export function billTime(iso: string): string {
|
|
if (!iso) return '—';
|
|
const m = iso.match(/T(\d{2}:\d{2})/);
|
|
return m ? m[1] : '—';
|
|
}
|