feat(cashier): add end-of-day report, my work, and cashier updates
This commit is contained in:
@@ -0,0 +1,536 @@
|
||||
/**
|
||||
* Copyright since 2025 Mifos Initiative
|
||||
*
|
||||
* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
*/
|
||||
|
||||
import { Component, OnInit, inject } from '@angular/core';
|
||||
import { CommonModule } from '@angular/common';
|
||||
import { FormsModule } from '@angular/forms';
|
||||
import { MatIconModule } from '@angular/material/icon';
|
||||
import { CashierService } from '../cashier.service';
|
||||
import { SettingsService } from 'app/settings/settings.service';
|
||||
import { AuthenticationService } from 'app/core/authentication/authentication.service';
|
||||
|
||||
/** One part of the day's work — a section of the day book, or a kind of entry within it. */
|
||||
interface SummaryLine {
|
||||
label: string;
|
||||
credit: number;
|
||||
debit: number;
|
||||
count: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* The single sheet a cashier signs the day off with.
|
||||
*
|
||||
* Every other cashier screen answers one question — what is in the drawer, which vouchers are
|
||||
* unverified, what did each person handle. At close of day somebody has to sign one piece of paper
|
||||
* saying the money was counted and it agreed, and until now that meant reading four screens and
|
||||
* copying figures onto a form by hand.
|
||||
*
|
||||
* Nothing here is computed on the server that was not already being computed: the closing report
|
||||
* supplies the drawer legs, the day book supplies the transactions, and the cashier position
|
||||
* supplies what the system believes is held. This screen assembles them in the order a person
|
||||
* verifying the day reads them in, and prints.
|
||||
*/
|
||||
@Component({
|
||||
selector: 'mifosx-end-of-day-report',
|
||||
templateUrl: './end-of-day-report.component.html',
|
||||
styleUrls: [
|
||||
'../cashier-shared.scss',
|
||||
'./end-of-day-report.component.scss'
|
||||
],
|
||||
standalone: true,
|
||||
imports: [
|
||||
CommonModule,
|
||||
FormsModule,
|
||||
MatIconModule
|
||||
]
|
||||
})
|
||||
export class EndOfDayReportComponent implements OnInit {
|
||||
private service = inject(CashierService);
|
||||
private settings = inject(SettingsService);
|
||||
private auth = inject(AuthenticationService);
|
||||
|
||||
date = '';
|
||||
loading = false;
|
||||
loaded = false;
|
||||
|
||||
/** Who is signing, and for which branch — read from the session, never typed in. */
|
||||
preparedBy = '';
|
||||
branchName = '';
|
||||
|
||||
// ── Section 1: transaction summary ──
|
||||
rows: any[] = [];
|
||||
creditTotal = 0;
|
||||
debitTotal = 0;
|
||||
|
||||
// ── Section 2: cash drawer ──
|
||||
/** Drawn from the vault in the morning: a cashier's opening float. */
|
||||
openingFloat = 0;
|
||||
cashDeposits = 0;
|
||||
interCashierIn = 0;
|
||||
cashWithdrawals = 0;
|
||||
settledOut = 0;
|
||||
interCashierOut = 0;
|
||||
/** Whether the server sent this day's own cash legs, which only a cashier-scoped call gets. */
|
||||
hasDayLegs = false;
|
||||
/** Whether the drawer figures are one cashier's or the whole branch's counter work. */
|
||||
scopedToCashier = false;
|
||||
|
||||
/** What the drawers hold between them, per the system. */
|
||||
drawersTotal: number | null = null;
|
||||
|
||||
/**
|
||||
* Each cashier and what their drawer holds.
|
||||
*
|
||||
* A clerk holds no drawer of their own — they supervise the counter — so a single "actual cash"
|
||||
* figure says nothing to them. The position endpoint already answers for whoever is asking: one
|
||||
* drawer for a cashier, every drawer for a clerk or officer, so the same call serves both and the
|
||||
* screen reads differently depending on who opened it.
|
||||
*/
|
||||
cashierPositions: { cashierId: number | null; cashierName: string; totalAmount: number }[] = [];
|
||||
|
||||
/**
|
||||
* The branch's own expected cash, from the day register.
|
||||
*
|
||||
* A branch-wide reading cannot be assembled from the per-cashier day legs: those are only
|
||||
* returned when the call is scoped to one cashier. The branch day register already keeps this
|
||||
* arithmetic for the close-day gate — opening cash, plus approved deposits, less what was
|
||||
* withdrawn — so the sheet reads it rather than inventing a second version of the same sum.
|
||||
*
|
||||
* Null when no day has been opened for this date, which is a real state: there is nothing to
|
||||
* reconcile against on a day the branch never opened.
|
||||
*/
|
||||
branchOpeningCash: number | null = null;
|
||||
branchDeposits: number | null = null;
|
||||
branchWithdrawals: number | null = null;
|
||||
branchExpectedCash: number | null = null;
|
||||
|
||||
/**
|
||||
* What the vaults hold, which a branch-wide count must include.
|
||||
*
|
||||
* The branch register's expected cash covers the whole branch — vault and every drawer together —
|
||||
* because cash moved from the vault to a cashier has not left the branch. Counting only the
|
||||
* drawers against it would report the entire vault as a shortage.
|
||||
*/
|
||||
vaultTotal: number | null = null;
|
||||
|
||||
ngOnInit(): void {
|
||||
this.date = this.businessDate();
|
||||
this.preparedBy = this.currentUserName();
|
||||
this.branchName = this.currentOfficeName();
|
||||
this.load();
|
||||
}
|
||||
|
||||
/**
|
||||
* The date the books are open on, not the wall clock.
|
||||
*
|
||||
* An EOD sheet dated by the browser would be filed against the wrong day whenever the branch is
|
||||
* still working yesterday's business date, which is exactly when a day is being closed.
|
||||
*/
|
||||
private businessDate(): string {
|
||||
const d = this.settings.businessDate;
|
||||
const safe = d instanceof Date && !isNaN(d.getTime()) ? d : new Date();
|
||||
return `${safe.getFullYear()}-${String(safe.getMonth() + 1).padStart(2, '0')}-${String(safe.getDate()).padStart(2, '0')}`;
|
||||
}
|
||||
|
||||
/** The member of staff behind the login, falling back to the username when no staff is linked. */
|
||||
private currentUserName(): string {
|
||||
const c = this.auth.getCredentials();
|
||||
return c ? c.staffDisplayName || c.username || '' : '';
|
||||
}
|
||||
|
||||
private currentOfficeName(): string {
|
||||
return this.auth.getCredentials()?.officeName || '';
|
||||
}
|
||||
|
||||
load(): void {
|
||||
this.loading = true;
|
||||
this.loaded = false;
|
||||
|
||||
this.service.dayBook(this.date).subscribe({
|
||||
next: (res: any) => {
|
||||
this.rows = res?.rows || [];
|
||||
this.creditTotal = Number(res?.creditTotal || 0);
|
||||
this.debitTotal = Number(res?.debitTotal || 0);
|
||||
this.loading = false;
|
||||
this.loaded = true;
|
||||
},
|
||||
error: () => {
|
||||
this.rows = [];
|
||||
this.creditTotal = 0;
|
||||
this.debitTotal = 0;
|
||||
this.loading = false;
|
||||
this.loaded = true;
|
||||
}
|
||||
});
|
||||
|
||||
this.service.closingCashReport(this.date).subscribe({
|
||||
next: (res: any) => {
|
||||
// The four day legs are only sent for a cashier-scoped call. Read as absent rather than
|
||||
// zero: a leg that is missing and a leg that is genuinely nil mean different things, and
|
||||
// treating the first as the second is what let the sheet claim an expected balance of zero
|
||||
// for a whole branch.
|
||||
this.hasDayLegs = res?.todayVaultIn != null;
|
||||
this.openingFloat = Number(res?.todayVaultIn || 0);
|
||||
this.cashDeposits = Number(res?.depositTotalWithDd ?? res?.depositTotal ?? 0);
|
||||
this.cashWithdrawals = Number(res?.withdrawalTotal || 0);
|
||||
this.settledOut = Number(res?.todaySettledOut || 0);
|
||||
this.interCashierIn = Number(res?.todayInterCashierIn || 0);
|
||||
this.interCashierOut = Number(res?.todayInterCashierOut || 0);
|
||||
this.scopedToCashier = res?.scopedToCashier === true;
|
||||
},
|
||||
error: () => {
|
||||
this.openingFloat = 0;
|
||||
this.cashDeposits = 0;
|
||||
this.cashWithdrawals = 0;
|
||||
this.settledOut = 0;
|
||||
this.interCashierIn = 0;
|
||||
this.interCashierOut = 0;
|
||||
this.scopedToCashier = false;
|
||||
this.hasDayLegs = false;
|
||||
}
|
||||
});
|
||||
|
||||
// The branch's expected cash for the date, which is the only basis a branch-wide reading can
|
||||
// reconcile on. Fails quietly for a plain cashier, who is not allowed to operate the day.
|
||||
this.service.branchDayClosePreview(this.date).subscribe({
|
||||
next: (res: any) => {
|
||||
this.branchOpeningCash = res?.openingCash == null ? null : Number(res.openingCash);
|
||||
this.branchDeposits = res?.deposits == null ? null : Number(res.deposits);
|
||||
this.branchWithdrawals = res?.withdrawals == null ? null : Number(res.withdrawals);
|
||||
this.branchExpectedCash = res?.expectedCash == null ? null : Number(res.expectedCash);
|
||||
},
|
||||
error: () => {
|
||||
this.branchOpeningCash = null;
|
||||
this.branchDeposits = null;
|
||||
this.branchWithdrawals = null;
|
||||
this.branchExpectedCash = null;
|
||||
}
|
||||
});
|
||||
|
||||
// One object for a cashier, an array of every cashier for a clerk or officer — the server
|
||||
// decides from the caller's own roles, so this screen does not have to ask who is reading it.
|
||||
this.service.cashierPositionReport(undefined, this.date).subscribe({
|
||||
next: (res: any) => {
|
||||
const list = Array.isArray(res) ? res : res ? [res] : [];
|
||||
this.cashierPositions = list
|
||||
.filter((p: any) => p && p.cashierId != null)
|
||||
.map((p: any) => ({
|
||||
cashierId: p.cashierId == null ? null : Number(p.cashierId),
|
||||
cashierName: p.cashierName || `Cashier ${p.cashierId}`,
|
||||
totalAmount: Number(p.totalAmount || 0)
|
||||
}))
|
||||
.sort((a: any, b: any) => b.totalAmount - a.totalAmount);
|
||||
this.drawersTotal = this.cashierPositions.length
|
||||
? this.cashierPositions.reduce((s, p) => s + p.totalAmount, 0)
|
||||
: null;
|
||||
},
|
||||
error: () => {
|
||||
// Nothing to count against, so the variance line stays blank rather than reading zero — a
|
||||
// variance of zero is a claim that somebody counted and it agreed.
|
||||
this.cashierPositions = [];
|
||||
this.drawersTotal = null;
|
||||
}
|
||||
});
|
||||
|
||||
// Vault stock, so a branch-wide count is of the whole branch and not just the counters.
|
||||
this.service.vaultPosition(undefined, this.date).subscribe({
|
||||
next: (res: any) => {
|
||||
const list = Array.isArray(res) ? res : res ? [res] : [];
|
||||
this.vaultTotal = list.reduce((s: number, v: any) => s + Number(v?.totalAmount || 0), 0);
|
||||
},
|
||||
error: () => {
|
||||
this.vaultTotal = null;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// ── Section 1 ──
|
||||
|
||||
/**
|
||||
* Only the entries that actually moved money.
|
||||
*
|
||||
* A pending request is listed on the day book so nobody loses sight of it, but it has taken no
|
||||
* cash — counting it into an EOD summary would make the sheet disagree with the drawer.
|
||||
*/
|
||||
/**
|
||||
* Last night's batch: posted against yesterday, surfacing on this report.
|
||||
*
|
||||
* A voucher's timestamp is the minute the job ran, while the transaction and the journal entry
|
||||
* behind it carry the business date. So the interest run that fires just after midnight stamps
|
||||
* itself with today although the ledger says yesterday — and yesterday was counted, reported and
|
||||
* signed off hours before. Re-opening that day would invalidate a signed sheet, so the work is
|
||||
* listed here instead, under its own heading, saying which day it belongs to. It is excluded from
|
||||
* every total on this page: it is not today's money.
|
||||
*/
|
||||
get priorDayRows(): any[] {
|
||||
return this.rows.filter((r) => r.section === 'SYSTEM_PRIOR');
|
||||
}
|
||||
|
||||
get priorDayCredit(): number {
|
||||
return this.priorDayRows.reduce((s, r) => s + (r.side === 'CR' ? Number(r.amount || 0) : 0), 0);
|
||||
}
|
||||
|
||||
get priorDayDebit(): number {
|
||||
return this.priorDayRows.reduce((s, r) => s + (r.side === 'DR' ? Number(r.amount || 0) : 0), 0);
|
||||
}
|
||||
|
||||
/** The business date last night's batch worked on, for the heading. */
|
||||
get priorDayDate(): string | null {
|
||||
const withDate = this.priorDayRows.find((r) => r.effectiveDate);
|
||||
return withDate ? withDate.effectiveDate : null;
|
||||
}
|
||||
|
||||
get approvedRows(): any[] {
|
||||
return this.rows.filter(
|
||||
(r) =>
|
||||
r.section !== 'SYSTEM_PRIOR' &&
|
||||
(r.status === 'APPROVED' || r.status === 'COMPLETED' || r.status === 'WITHDRAWN')
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The day split the way this system actually records it: where the entry came from.
|
||||
*
|
||||
* Not split by payment mode, which is the obvious shape for a retail till but the wrong one here.
|
||||
* A payment type is only recorded against a denomination breakdown, and a breakdown is only
|
||||
* written for physical cash — so a UPI or transfer deposit carries no payment type at all, and a
|
||||
* mode-wise table would file every non-cash entry under "not specified" while claiming to be a
|
||||
* breakdown by mode. The day book's own sections are recorded on every row, so this agrees with
|
||||
* the day book for the same date instead of quietly disagreeing with it.
|
||||
*/
|
||||
get sectionLines(): SummaryLine[] {
|
||||
const order = [
|
||||
'CASHIER',
|
||||
'CLERK',
|
||||
'SYSTEM'
|
||||
];
|
||||
const labels: Record<string, string> = {
|
||||
CASHIER: 'Cash counter',
|
||||
CLERK: 'Clerk desk',
|
||||
SYSTEM: 'System — interest, charges, journals'
|
||||
};
|
||||
const map = new Map<string, SummaryLine>();
|
||||
for (const r of this.approvedRows) {
|
||||
const key = order.includes(r.section) ? r.section : 'SYSTEM';
|
||||
let line = map.get(key);
|
||||
if (!line) {
|
||||
line = { label: labels[key] || key, credit: 0, debit: 0, count: 0 };
|
||||
map.set(key, line);
|
||||
}
|
||||
this.addTo(line, r);
|
||||
}
|
||||
return order.filter((k) => map.has(k)).map((k) => map.get(k)!);
|
||||
}
|
||||
|
||||
/**
|
||||
* What kind of entry it was — deposit, withdrawal, interest posting, charge.
|
||||
*
|
||||
* The sections above say where the day's work came from; this says what the work was, which is
|
||||
* the question somebody checking a figure against a register actually asks.
|
||||
*/
|
||||
get kindLines(): SummaryLine[] {
|
||||
const map = new Map<string, SummaryLine>();
|
||||
for (const r of this.approvedRows) {
|
||||
const key = (r.kind || 'OTHER').toString();
|
||||
let line = map.get(key);
|
||||
if (!line) {
|
||||
line = { label: this.titleCase(key), credit: 0, debit: 0, count: 0 };
|
||||
map.set(key, line);
|
||||
}
|
||||
this.addTo(line, r);
|
||||
}
|
||||
return Array.from(map.values()).sort((a, b) => b.credit + b.debit - (a.credit + a.debit));
|
||||
}
|
||||
|
||||
/** Adds one day-book row onto a summary line, on the side the row belongs to. */
|
||||
private addTo(line: SummaryLine, row: any): void {
|
||||
const amt = Number(row.amount || 0);
|
||||
if (row.side === 'CR') {
|
||||
line.credit += amt;
|
||||
} else {
|
||||
line.debit += amt;
|
||||
}
|
||||
line.count += 1;
|
||||
}
|
||||
|
||||
/** DD CASH, INTEREST_POSTING and the like, as a person would read them. */
|
||||
kindLabel(raw: string | null | undefined): string {
|
||||
if (!raw) {
|
||||
return '—';
|
||||
}
|
||||
return raw
|
||||
.toString()
|
||||
.replace(/_/g, ' ')
|
||||
.toLowerCase()
|
||||
.replace(/\b\w/g, (c) => c.toUpperCase());
|
||||
}
|
||||
|
||||
private titleCase(raw: string): string {
|
||||
return this.kindLabel(raw);
|
||||
}
|
||||
|
||||
get txnCount(): number {
|
||||
return this.approvedRows.length;
|
||||
}
|
||||
|
||||
/** More than one drawer in view means a supervisor is reading, not a cashier. */
|
||||
get supervising(): boolean {
|
||||
return this.cashierPositions.length > 1 || (!this.scopedToCashier && this.cashierPositions.length > 0);
|
||||
}
|
||||
|
||||
get cashierPositionTotal(): number {
|
||||
return this.cashierPositions.reduce((s, p) => s + p.totalAmount, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Each person who handled the day's work, with their own credit, debit and net.
|
||||
*
|
||||
* The clerk signing the day off is verifying other people's work, so the sheet has to say whose.
|
||||
* Read off the day book's own handledBy, which every register stamps.
|
||||
*/
|
||||
get byUser(): SummaryLine[] {
|
||||
const map = new Map<string, SummaryLine>();
|
||||
for (const r of this.approvedRows) {
|
||||
const key = (r.handledBy || 'Unattributed').toString();
|
||||
let line = map.get(key);
|
||||
if (!line) {
|
||||
line = { label: key, credit: 0, debit: 0, count: 0 };
|
||||
map.set(key, line);
|
||||
}
|
||||
this.addTo(line, r);
|
||||
}
|
||||
return Array.from(map.values()).sort((a, b) => b.credit + b.debit - (a.credit + a.debit));
|
||||
}
|
||||
|
||||
get summaryCreditTotal(): number {
|
||||
return this.sectionLines.reduce((s, l) => s + l.credit, 0);
|
||||
}
|
||||
|
||||
get summaryDebitTotal(): number {
|
||||
return this.sectionLines.reduce((s, l) => s + l.debit, 0);
|
||||
}
|
||||
|
||||
// ── Section 2 ──
|
||||
|
||||
/** Everything that came into the drawer today, over the counter and from another cashier. */
|
||||
get totalReceived(): number {
|
||||
return this.cashDeposits + this.interCashierIn;
|
||||
}
|
||||
|
||||
/** Everything that left it: paid to members, handed to the vault, passed to another cashier. */
|
||||
get totalPaidOut(): number {
|
||||
return this.cashWithdrawals + this.settledOut + this.interCashierOut;
|
||||
}
|
||||
|
||||
/** What should be on the desk: the float, plus what came in, less what went out. */
|
||||
get expectedClosing(): number {
|
||||
return this.openingFloat + this.totalReceived - this.totalPaidOut;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether an expected-against-held comparison can honestly be made.
|
||||
*
|
||||
* Only for a single cashier, and only when the server sent that cashier's day legs. Both halves
|
||||
* then describe the same thing: today's legs, against a drawer that carries nothing forward
|
||||
* because a cashier draws in the morning and hands back at close.
|
||||
*
|
||||
* Never branch-wide. The branch register's expected cash is *today's* arithmetic — yesterday's
|
||||
* closing, plus today's deposits, less today's withdrawals — while the vault and drawer positions
|
||||
* are running totals accumulated since the system went live. Subtracting one from the other
|
||||
* compares an afternoon against a lifetime: it reported ₹2,11,932 extra on a day when ₹100 came
|
||||
* in and ₹100 went out. There is no branch-wide running total to compare against, so the sheet
|
||||
* shows the branch its movement and each drawer's position, and states no difference at all
|
||||
* rather than a confident wrong one.
|
||||
*/
|
||||
get canReconcile(): boolean {
|
||||
return this.scopedToCashier && this.hasDayLegs;
|
||||
}
|
||||
|
||||
/** The cash the system believes this cashier is holding. */
|
||||
get actualCash(): number | null {
|
||||
return this.scopedToCashier ? this.drawersTotal : null;
|
||||
}
|
||||
|
||||
/** What today's legs say should be in the drawer. */
|
||||
get expectedCash(): number | null {
|
||||
return this.canReconcile ? this.expectedClosing : null;
|
||||
}
|
||||
|
||||
/** Held less expected, for one cashier's own day. Null wherever that comparison is not honest. */
|
||||
get variance(): number | null {
|
||||
const expected = this.expectedCash;
|
||||
if (expected === null || this.actualCash === null) {
|
||||
return null;
|
||||
}
|
||||
return this.actualCash - expected;
|
||||
}
|
||||
|
||||
/** Vaults and drawers together — what the branch is holding, per the system. */
|
||||
get branchHeldTotal(): number | null {
|
||||
if (this.drawersTotal === null && this.vaultTotal === null) {
|
||||
return null;
|
||||
}
|
||||
return Number(this.drawersTotal ?? 0) + Number(this.vaultTotal ?? 0);
|
||||
}
|
||||
|
||||
/** Today's net cash movement across the branch: what came in less what went out. */
|
||||
get branchNetMovement(): number {
|
||||
return Number(this.branchDeposits ?? 0) - Number(this.branchWithdrawals ?? 0);
|
||||
}
|
||||
|
||||
/** True only when a count exists and it agrees to the paisa. */
|
||||
get varianceOk(): boolean {
|
||||
return this.variance !== null && Math.abs(this.variance) < 0.005;
|
||||
}
|
||||
|
||||
get varianceClass(): string {
|
||||
if (this.variance === null) {
|
||||
return '';
|
||||
}
|
||||
return this.varianceOk ? 'eod-ok' : 'eod-bad';
|
||||
}
|
||||
|
||||
// ── Section 3 ──
|
||||
|
||||
/** Entries still waiting on somebody, which is what a day cannot be closed over. */
|
||||
get pendingRows(): any[] {
|
||||
return this.rows.filter((r) => r.status === 'PENDING' || r.status === 'SUBMITTED');
|
||||
}
|
||||
|
||||
/** Cash entries whose paper slip nobody has checked against the screen. */
|
||||
get unverifiedRows(): any[] {
|
||||
return this.approvedRows.filter((r) => !r.verifyStatus);
|
||||
}
|
||||
|
||||
/** A slip that was checked and did not agree with what was keyed in. */
|
||||
get mismatchRows(): any[] {
|
||||
return this.rows.filter((r) => r.verifyStatus === 'MISMATCH' || r.verifyStatus === 'DISPUTED');
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the day is ready to close.
|
||||
*
|
||||
* Nothing pending, no slip disagreeing, and — where a cash comparison was actually made — the
|
||||
* cash agreeing. A branch-wide reading makes no comparison, so it is not held to one: requiring
|
||||
* `varianceOk` there meant the sheet could never say a day was clear however clean it was.
|
||||
*/
|
||||
get allClear(): boolean {
|
||||
if (this.pendingRows.length > 0 || this.mismatchRows.length > 0) {
|
||||
return false;
|
||||
}
|
||||
return this.variance === null || this.varianceOk;
|
||||
}
|
||||
|
||||
reload(): void {
|
||||
this.load();
|
||||
}
|
||||
|
||||
print(): void {
|
||||
window.print();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user