rmancinasandClaude Opus 5
48e01ddd21
The capture form only ever had prima neta, derecho de póliza and comisión.
The Access form it replaces has seven figures, and the four that were missing
are the ones that make a policy paid in installments add up.
Adds recargo, IVA, prima total and forma de pago to the policy header, the
same breakdown per installment, and a per-line-of-business IVA rate.
IVA and prima total are the only derived figures:
base = prima neta + recargo + derecho de póliza
IVA = round(base * tasa)
total = base + IVA
The recargo is inside the taxable base. That is not a guess — policy 7006785
prints IVA 52.03 on 610.86 + 8.55 + 31.00, and leaving the recargo out gives
51.35, which matches nothing on the page. Both of its money rows are asserted
in premium.spec.ts. The recargo itself is never derived: the carrier quotes it,
so staff key it in, and the field is disabled on ANNUAL/SINGLE. Both derived
figures are stored rather than recomputed on read, and stay editable, because
the printed policy is the record of truth and a later rate change must not
silently restate what was issued.
The rate lives on PolicyType (seeded to 0.08, editable in Catálogos), which is
the legacy one-row IMPUESTOS / IMPUESTOS_AUTOS tables made configurable. The
rate applied is stamped on the policy so an old one reads back at its original
rate.
Per-installment, not two fixed slots on the header: a policy split into several
exhibiciones prices each payment separately — that is why the Access form drew
the money row twice — and a trimestral policy needs four, which the Access
layout could not hold.
Also fixes two losses in the ETL, which is how these went missing:
- `forma_pago` was marked consumed by the coverage sweep and then never
written to any column, so FORMA PAGO existed nowhere in the platform.
- `recargo` and the whole second money row fell into `coveragesJson` as
loose strings, mislabeled as coverage amounts.
transform_policies.py now writes all of it directly;
backfill_policy_premium_breakdown.py recovers it on a database that must not be
re-imported, and strips the migrated keys back out of coveragesJson. Both are
COALESCE-only, so a figure a human has corrected in the app wins.
IVA and TOTAL are NOT backfilled: they were unbound calculated controls on the
Access form, never columns, so there is nothing to recover and every migrated
policy reads null until it is edited.
The backfill warns on 5 annual policies that carry a non-zero recargo — a
contradiction that predates this change and is left for a human, not silently
corrected.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
80 lines
2.9 KiB
TypeScript
80 lines
2.9 KiB
TypeScript
import type { PaymentFrequency } from "./types";
|
|
|
|
/**
|
|
* Client-side twin of apps/api/src/policies/premium.ts. Duplicated rather than
|
|
* shared because the API and the web app do not share a package today, and
|
|
* both need it: the form computes IVA and Total live as the operator types,
|
|
* the API stores what it is sent.
|
|
*
|
|
* base = prima neta + recargo + derecho de póliza
|
|
* IVA = round(base * tasa)
|
|
* Total = base + IVA
|
|
*
|
|
* The recargo is inside the taxable base — that is what reconciles the Access
|
|
* books (policy 7006785 prints IVA 52.03 on 610.86 + 8.55 + 31.00; leaving the
|
|
* recargo out gives 51.35, which matches nothing on the page).
|
|
*/
|
|
|
|
/** Applied when neither the policy nor its type carries a rate. The single
|
|
* row both legacy IMPUESTOS tables held. */
|
|
export const DEFAULT_TAX_RATE = 0.08;
|
|
|
|
/** Paying in more than one exhibición is what earns a recargo. A null
|
|
* frequency (every migrated policy) is treated as "unknown, allow it": the
|
|
* legacy recargo figures are real and hiding the field would hide them. */
|
|
export function surchargeApplies(
|
|
frequency: PaymentFrequency | null | undefined,
|
|
): boolean {
|
|
return frequency !== "ANNUAL" && frequency !== "SINGLE";
|
|
}
|
|
|
|
export function num(v: string | number | null | undefined): number {
|
|
if (v === null || v === undefined || v === "") return 0;
|
|
const n = typeof v === "number" ? v : Number(String(v).trim());
|
|
return Number.isFinite(n) ? n : 0;
|
|
}
|
|
|
|
/** Half-up to cents, matching how the printed policy rounds. */
|
|
export function round2(n: number): number {
|
|
return Math.round((n + Number.EPSILON) * 100) / 100;
|
|
}
|
|
|
|
export interface PremiumParts {
|
|
netPremium: string | number | null | undefined;
|
|
surcharge: string | number | null | undefined;
|
|
policyFee: string | number | null | undefined;
|
|
}
|
|
|
|
export function taxableBase(p: PremiumParts): number {
|
|
return round2(num(p.netPremium) + num(p.surcharge) + num(p.policyFee));
|
|
}
|
|
|
|
export function computeTax(p: PremiumParts, rate: number): number {
|
|
return round2(taxableBase(p) * rate);
|
|
}
|
|
|
|
export function computeTotal(p: PremiumParts, rate: number): number {
|
|
return round2(taxableBase(p) + computeTax(p, rate));
|
|
}
|
|
|
|
/** Rate ladder: what the policy was issued at, else its line of business, else
|
|
* the default. Keeps an old policy reading back at its original rate after
|
|
* somebody edits the catalog. */
|
|
export function resolveTaxRate(
|
|
policyRate: string | number | null | undefined,
|
|
policyTypeRate: string | number | null | undefined,
|
|
): number {
|
|
for (const candidate of [policyRate, policyTypeRate]) {
|
|
if (candidate === null || candidate === undefined || candidate === "") continue;
|
|
const n = Number(candidate);
|
|
if (Number.isFinite(n) && n >= 0) return n;
|
|
}
|
|
return DEFAULT_TAX_RATE;
|
|
}
|
|
|
|
/** 0.08 -> "8%". Rates are stored as fractions but read as percentages. */
|
|
export function formatRate(rate: number): string {
|
|
const pct = round2(rate * 100);
|
|
return `${pct}%`;
|
|
}
|