@kreiseck/kasseneck-api 1.10.1 → 1.11.1

package/dist/cjs/pos/schicht-lesen.js

@@ -0,0 +1,405 @@
+"use strict";
+/**
+ * Leser der Schicht-Antworten: aus dem Draht `/v3` werden die Modelle in
+ * `schicht-typen.ts`. Paketintern, nicht Teil der Oberflaeche.
+ *
+ * Regel wie beim Lager: ein Betrag, eine Anzahl oder eine Nummer ist eine
+ * Ganzzahl, eine Kennung ein nicht leerer Text, sonst endet der Aufruf mit
+ * `KasseneckValidationError`. Ein Ersatzwert wie `0` waere eine falsche
+ * Aussage („nichts in der Lade“ statt „Antwort kaputt“). Texte sind
+ * nachsichtiger: ein fehlender oder fremder Wert wird `null`.
+ *
+ * Felder, die nur mit Recht kommen (`expectedCents`, `runningTotals` …),
+ * stehen im Modell genau dann, wenn der Server sie sendet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pflichtObjekt = pflichtObjekt;
+exports.schicht = schicht;
+exports.ladeStand = ladeStand;
+exports.bewegung = bewegung;
+exports.schichtBon = schichtBon;
+exports.bewegungsBon = bewegungsBon;
+exports.abschluss = abschluss;
+exports.geoeffnet = geoeffnet;
+exports.gebucht = gebucht;
+exports.gemeldet = gemeldet;
+exports.bericht = bericht;
+const errors_js_1 = require("../client/errors.js");
+const schicht_typen_js_1 = require("./schicht-typen.js");
+const hat = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+const unter = (ort, teil) => ({ ...ort, pfad: ort.pfad === '' ? teil : `${ort.pfad}.${teil}` });
+function fehler(ort, grund) {
+    return new errors_js_1.KasseneckValidationError(ort.name, `${ort.scope === 'response' ? 'Antwort' : 'Bon-Daten'}: ${grund}`, ort.scope);
+}
+function objekt(w) {
+    return w !== null && typeof w === 'object' && !Array.isArray(w) ? w : null;
+}
+/** Ein Objekt, das da sein muss. */
+function pflichtObjekt(ort, w) {
+    const o = objekt(w);
+    if (!o)
+        throw fehler(ort, `${ort.pfad || 'data'} ist kein Objekt`);
+    return o;
+}
+const text = (w) => (typeof w === 'string' ? w : null);
+function kennung(ort, o, feld) {
+    const w = o[feld];
+    if (typeof w !== 'string' || w === '')
+        throw fehler(ort, `${ort.pfad}.${feld} fehlt`);
+    return w;
+}
+function ganzzahl(ort, o, feld) {
+    const w = o[feld];
+    if (typeof w !== 'number' || !Number.isSafeInteger(w))
+        throw fehler(ort, `${ort.pfad}.${feld} ist keine ganze Zahl`);
+    return w;
+}
+function ganzzahlOderNull(ort, o, feld) {
+    const w = o[feld];
+    return w === undefined || w === null ? null : ganzzahl(ort, o, feld);
+}
+function wahr(ort, o, feld) {
+    const w = o[feld];
+    if (typeof w !== 'boolean')
+        throw fehler(ort, `${ort.pfad}.${feld} ist kein Wahrheitswert`);
+    return w;
+}
+function wahrOderNull(ort, o, feld) {
+    const w = o[feld];
+    return w === undefined || w === null ? null : wahr(ort, o, feld);
+}
+function liste(ort, o, feld, lese) {
+    const w = o[feld];
+    if (!Array.isArray(w))
+        throw fehler(ort, `${ort.pfad}.${feld} ist keine Liste`);
+    return w.map((e, i) => lese(unter(ort, `${feld}[${i}]`), e));
+}
+/** Setzt ein Feld nur, wenn der Server es sendet (Recht). */
+function wennDa(ziel, o, feld, lese) {
+    if (hat(o, feld))
+        ziel[feld] = lese();
+}
+/** Setzt ein Feld nur, wenn der Server einen Wert sendet; `null` gilt wie fehlend. */
+function wennWert(ziel, o, feld, lese) {
+    if (o[feld] !== undefined && o[feld] !== null)
+        ziel[feld] = lese();
+}
+function stueckelung(ort, o, feld) {
+    const w = o[feld];
+    if (w === undefined || w === null)
+        return null;
+    const karte = objekt(w);
+    if (!karte)
+        throw fehler(ort, `${ort.pfad}.${feld} ist keine Stueckelung`);
+    const raus = {};
+    for (const k of Object.keys(karte))
+        raus[k] = ganzzahl(unter(ort, feld), karte, k);
+    return raus;
+}
+function akteur(ort, w) {
+    if (w === undefined || w === null)
+        return null;
+    const o = pflichtObjekt(ort, w);
+    return { registerUserId: text(o.registerUserId), name: text(o.name), role: text(o.role) ?? '' };
+}
+function unbar(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return { method: kennung(ort, o, 'method'), cents: ganzzahl(ort, o, 'cents') };
+}
+function trinkgeld(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return {
+        registerUserId: kennung(ort, o, 'registerUserId'),
+        name: text(o.name),
+        receivedImmediatelyCents: ganzzahl(ort, o, 'receivedImmediatelyCents'),
+        retainedCents: ganzzahl(ort, o, 'retainedCents'),
+        paidOutCents: ganzzahl(ort, o, 'paidOutCents'),
+        // Fehlt bei einem Backend vor der Regel R62: dann 0, statt die ganze Antwort zu verwerfen.
+        refundedByEmployeeCents: o.refundedByEmployeeCents === undefined || o.refundedByEmployeeCents === null ? 0 : ganzzahl(ort, o, 'refundedByEmployeeCents'),
+    };
+}
+/** Trinkgeld mit offenem Anspruch (Kassenstand, Bon). */
+function trinkgeldMitOffen(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return {
+        ...trinkgeld(ort, o),
+        // Fehlt bei einem Backend vor der Regel R64: dann 0.
+        carriedOverCents: o.carriedOverCents === undefined || o.carriedOverCents === null ? 0 : ganzzahl(ort, o, 'carriedOverCents'),
+        openCents: ganzzahl(ort, o, 'openCents'),
+    };
+}
+function laufstand(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return {
+        cashSalesCents: ganzzahl(ort, o, 'cashSalesCents'),
+        cashCancellationsCents: ganzzahl(ort, o, 'cashCancellationsCents'),
+        nonCashByMethod: liste(ort, o, 'nonCashByMethod', unbar),
+        // Fehlt bei einem Server vor dem Gutschein-Feld: dann 0.
+        voucherRedeemedCents: o.voucherRedeemedCents === undefined || o.voucherRedeemedCents === null ? 0 : ganzzahl(ort, o, 'voucherRedeemedCents'),
+        receiptCount: ganzzahl(ort, o, 'receiptCount'),
+        cancellationCount: ganzzahl(ort, o, 'cancellationCount'),
+        cashInCents: ganzzahl(ort, o, 'cashInCents'),
+        cashOutCents: ganzzahl(ort, o, 'cashOutCents'),
+        tips: liste(ort, o, 'tips', trinkgeld),
+        openingsWithoutSale: ganzzahl(ort, o, 'openingsWithoutSale'),
+    };
+}
+/** Entnehmen oder Einlegen nach dem Zaehlen; die Art bleibt offen fuer kuenftige Werte (Text). */
+function nachZaehlung(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return { type: kennung(ort, o, 'type'), amountCents: ganzzahl(ort, o, 'amountCents') };
+}
+function abgleich(ort, w) {
+    if (w === undefined || w === null)
+        return null;
+    const o = pflichtObjekt(ort, w);
+    const abw = o.deviations;
+    let deviations = null;
+    if (abw !== undefined && abw !== null) {
+        const karte = pflichtObjekt(unter(ort, 'deviations'), abw);
+        deviations = {};
+        for (const [feld, eintrag] of Object.entries(karte)) {
+            const e = pflichtObjekt(unter(ort, `deviations.${feld}`), eintrag);
+            deviations[feld] = { stored: e.stored, recomputed: e.recomputed };
+        }
+    }
+    return { matches: wahr(ort, o, 'matches'), deviations };
+}
+/** Eine Schicht; was nur mit `cashView` kommt, steht nur, wenn gesendet. */
+function schicht(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const status = o.status;
+    if (status !== 'open' && status !== 'closed')
+        throw fehler(ort, `${ort.pfad}.status ist unbekannt`);
+    const raus = {
+        id: kennung(ort, o, 'id'),
+        drawerId: kennung(ort, o, 'drawerId'),
+        cashregisterId: text(o.cashregisterId),
+        number: ganzzahl(ort, o, 'number'),
+        status,
+        openedAt: text(o.openedAt),
+        openedBy: akteur(unter(ort, 'openedBy'), o.openedBy),
+    };
+    const r = raus;
+    // Ohne Recht `shift` fehlen sie (Grunddaten der offenen Schicht).
+    wennDa(r, o, 'openedDeviceId', () => text(o.openedDeviceId));
+    wennDa(r, o, 'closedAt', () => text(o.closedAt));
+    wennDa(r, o, 'closedBy', () => akteur(unter(ort, 'closedBy'), o.closedBy));
+    wennDa(r, o, 'closedDeviceId', () => text(o.closedDeviceId));
+    wennDa(r, o, 'openingFloatCents', () => ganzzahlOderNull(ort, o, 'openingFloatCents'));
+    wennDa(r, o, 'openingDenominations', () => stueckelung(ort, o, 'openingDenominations'));
+    wennDa(r, o, 'openingFloatTakenOver', () => wahr(ort, o, 'openingFloatTakenOver'));
+    wennDa(r, o, 'comment', () => text(o.comment));
+    wennDa(r, o, 'blind', () => wahrOderNull(ort, o, 'blind'));
+    wennDa(r, o, 'countedCents', () => ganzzahlOderNull(ort, o, 'countedCents'));
+    wennDa(r, o, 'suggestedFloatCents', () => ganzzahlOderNull(ort, o, 'suggestedFloatCents'));
+    wennDa(r, o, 'runningTotals', () => laufstand(unter(ort, 'runningTotals'), o.runningTotals));
+    wennDa(r, o, 'expectedCents', () => ganzzahlOderNull(ort, o, 'expectedCents'));
+    wennDa(r, o, 'differenceCents', () => ganzzahlOderNull(ort, o, 'differenceCents'));
+    wennDa(r, o, 'reconciliation', () => abgleich(unter(ort, 'reconciliation'), o.reconciliation));
+    // Nur wenn beim Abschluss Geld entnommen oder eingelegt wurde.
+    wennWert(r, o, 'afterCount', () => nachZaehlung(unter(ort, 'afterCount'), o.afterCount));
+    wennWert(r, o, 'leftInDrawerCents', () => ganzzahl(ort, o, 'leftInDrawerCents'));
+    return raus;
+}
+function schichtOderNull(ort, w) {
+    return w === null ? null : schicht(ort, w);
+}
+function anspruch(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return { registerUserId: kennung(ort, o, 'registerUserId'), name: text(o.name), cents: ganzzahl(ort, o, 'cents') };
+}
+function oeffnung(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const von = objekt(o.by);
+    return {
+        at: text(o.at),
+        deviceTime: text(o.deviceTime),
+        reason: kennung(ort, o, 'reason'),
+        by: von ? { name: text(von.name) } : null,
+        ok: wahr(ort, o, 'ok'),
+    };
+}
+function ladeStand(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const lade = pflichtObjekt(unter(ort, 'drawer'), o.drawer);
+    const ladeOrt = unter(ort, 'drawer');
+    const rechte = pflichtObjekt(unter(ort, 'rights'), o.rights);
+    const rechteOrt = unter(ort, 'rights');
+    const raus = {
+        drawer: {
+            id: kennung(ladeOrt, lade, 'id'),
+            name: text(lade.name),
+            shiftMode: wahr(ladeOrt, lade, 'shiftMode'),
+            cashregisterId: text(lade.cashregisterId),
+        },
+        rights: {
+            shift: wahr(rechteOrt, rechte, 'shift'),
+            cashMove: wahr(rechteOrt, rechte, 'cashMove'),
+            cashView: wahr(rechteOrt, rechte, 'cashView'),
+            drawer: wahr(rechteOrt, rechte, 'drawer'),
+        },
+        tipClaims: liste(ort, o, 'tipClaims', anspruch),
+        tips: liste(ort, o, 'tips', trinkgeldMitOffen),
+    };
+    const r = raus;
+    wennDa(r, o, 'shift', () => schichtOderNull(unter(ort, 'shift'), o.shift));
+    wennDa(r, o, 'longOpenWarning', () => wahr(ort, o, 'longOpenWarning'));
+    wennDa(r, o, 'suggestedFloatCents', () => ganzzahlOderNull(ort, o, 'suggestedFloatCents'));
+    wennDa(r, o, 'expectedCents', () => ganzzahlOderNull(ort, o, 'expectedCents'));
+    wennDa(r, o, 'recentOpenings', () => liste(ort, o, 'recentOpenings', oeffnung));
+    wennWert(r, o, 'suggestedFromShiftNumber', () => ganzzahl(ort, o, 'suggestedFromShiftNumber'));
+    // Wechselgeld der Lade: nur wenn eingestellt.
+    wennWert(raus.drawer, lade, 'changeFloatCents', () => ganzzahl(ladeOrt, lade, 'changeFloatCents'));
+    return raus;
+}
+function bewegung(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const empfaenger = objekt(o.recipient);
+    const paar = objekt(o.counterpart);
+    return {
+        id: kennung(ort, o, 'id'),
+        number: ganzzahl(ort, o, 'number'),
+        shiftId: text(o.shiftId),
+        type: kennung(ort, o, 'type'),
+        amountCents: ganzzahl(ort, o, 'amountCents'),
+        location: text(o.location),
+        note: text(o.note),
+        by: akteur(unter(ort, 'by'), o.by),
+        at: text(o.at),
+        recipient: empfaenger ? { registerUserId: text(empfaenger.registerUserId), name: text(empfaenger.name) } : null,
+        counterpart: paar ? { drawerId: text(paar.drawerId), movementId: text(paar.movementId) } : null,
+    };
+}
+function bonKopf(ort, o) {
+    const art = o.kind;
+    if (typeof art !== 'string' || !schicht_typen_js_1.SHIFT_RECEIPT_KINDS.includes(art))
+        throw fehler(ort, `${ort.pfad}.kind ist unbekannt`);
+    const betrieb = objekt(o.business) ?? {};
+    const kasse = objekt(o.cashregister) ?? {};
+    const lade = objekt(o.drawer) ?? {};
+    return {
+        kind: art,
+        blind: wahr(ort, o, 'blind'),
+        business: { name: text(betrieb.name) },
+        cashregister: { id: text(kasse.id), name: text(kasse.name) },
+        drawer: { name: text(lade.name) },
+    };
+}
+/** Bon-Daten eines Z- oder X-Bons; eine andere Art ist ein Fehler. */
+function schichtBon(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const kopf = bonKopf(ort, o);
+    if (kopf.kind === 'cash_movement')
+        throw fehler(ort, `${ort.pfad}.kind ist cash_movement, erwartet Z- oder X-Bon`);
+    const s = pflichtObjekt(unter(ort, 'shift'), o.shift);
+    const sOrt = unter(ort, 'shift');
+    const raus = {
+        ...kopf,
+        kind: kopf.kind,
+        shift: {
+            number: ganzzahl(sOrt, s, 'number'),
+            openedAt: text(s.openedAt),
+            closedAt: text(s.closedAt),
+            openedByName: text(s.openedByName),
+            closedByName: text(s.closedByName),
+        },
+        openingFloatCents: ganzzahlOderNull(ort, o, 'openingFloatCents'),
+        openingFloatTakenOver: wahr(ort, o, 'openingFloatTakenOver'),
+        openingDenominations: stueckelung(ort, o, 'openingDenominations'),
+        cashSalesCents: ganzzahlOderNull(ort, o, 'cashSalesCents'),
+        cashCancellationsCents: ganzzahlOderNull(ort, o, 'cashCancellationsCents'),
+        receiptCount: ganzzahl(ort, o, 'receiptCount'),
+        cancellationCount: ganzzahl(ort, o, 'cancellationCount'),
+        nonCashByMethod: liste(ort, o, 'nonCashByMethod', unbar),
+        movements: liste(ort, o, 'movements', (mOrt, mw) => {
+            const m = pflichtObjekt(mOrt, mw);
+            return {
+                number: ganzzahl(mOrt, m, 'number'),
+                type: kennung(mOrt, m, 'type'),
+                amountCents: ganzzahl(mOrt, m, 'amountCents'),
+                note: text(m.note),
+                byName: text(m.byName),
+                at: text(m.at),
+            };
+        }),
+        tips: liste(ort, o, 'tips', trinkgeldMitOffen),
+        expectedCents: ganzzahlOderNull(ort, o, 'expectedCents'),
+        countedCents: ganzzahlOderNull(ort, o, 'countedCents'),
+        countedDenominations: stueckelung(ort, o, 'countedDenominations'),
+        differenceCents: ganzzahlOderNull(ort, o, 'differenceCents'),
+        comment: text(o.comment),
+        openingsWithoutSale: ganzzahl(ort, o, 'openingsWithoutSale'),
+    };
+    // Nur wenn beim Abschluss Geld entnommen oder eingelegt wurde; „Bleibt“ blind `null`.
+    const r = raus;
+    wennWert(r, o, 'afterCount', () => nachZaehlung(unter(ort, 'afterCount'), o.afterCount));
+    wennDa(r, o, 'leftInDrawerCents', () => ganzzahlOderNull(ort, o, 'leftInDrawerCents'));
+    return raus;
+}
+/** Bon-Daten einer Kassenbewegung; eine andere Art ist ein Fehler. */
+function bewegungsBon(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const kopf = bonKopf(ort, o);
+    if (kopf.kind !== 'cash_movement')
+        throw fehler(ort, `${ort.pfad}.kind ist ${kopf.kind}, erwartet cash_movement`);
+    const s = objekt(o.shift);
+    const m = pflichtObjekt(unter(ort, 'movement'), o.movement);
+    const mOrt = unter(ort, 'movement');
+    return {
+        ...kopf,
+        kind: 'cash_movement',
+        shift: s ? { number: ganzzahl(unter(ort, 'shift'), s, 'number') } : null,
+        movement: {
+            number: ganzzahl(mOrt, m, 'number'),
+            type: kennung(mOrt, m, 'type'),
+            amountCents: ganzzahl(mOrt, m, 'amountCents'),
+            note: text(m.note),
+            location: text(m.location),
+            recipientName: text(m.recipientName),
+            targetDrawerName: text(m.targetDrawerName),
+            byName: text(m.byName),
+            at: text(m.at),
+        },
+    };
+}
+function abschluss(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    if (o.status === 'recount')
+        return { status: 'recount' };
+    if (o.status === 'ready')
+        return { status: 'ready' };
+    if (o.status !== 'closed')
+        throw fehler(ort, `${ort.pfad || 'data'}.status ist unbekannt`);
+    const raus = {
+        status: 'closed',
+        shift: schicht(unter(ort, 'shift'), o.shift),
+        receipt: schichtBon(unter(ort, 'receipt'), o.receipt),
+        lastShiftOfRegister: wahr(ort, o, 'lastShiftOfRegister'),
+    };
+    // Bon „Kassenbewegung“ der Entnahme bzw. Einlage, nur wenn Geld bewegt wurde.
+    wennWert(raus, o, 'afterCountReceipt', () => bewegungsBon(unter(ort, 'afterCountReceipt'), o.afterCountReceipt));
+    return raus;
+}
+function geoeffnet(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    const raus = { shift: schicht(unter(ort, 'shift'), o.shift) };
+    wennDa(raus, o, 'handoverDifferenceCents', () => ganzzahlOderNull(ort, o, 'handoverDifferenceCents'));
+    return raus;
+}
+function gebucht(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return { movement: bewegung(unter(ort, 'movement'), o.movement), receipt: bewegungsBon(unter(ort, 'receipt'), o.receipt) };
+}
+function gemeldet(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return { accepted: ganzzahl(ort, o, 'accepted'), duplicates: ganzzahl(ort, o, 'duplicates'), drawerId: text(o.drawerId) };
+}
+function bericht(ort, w) {
+    const o = pflichtObjekt(ort, w);
+    return {
+        shift: schicht(unter(ort, 'shift'), o.shift),
+        movements: liste(ort, o, 'movements', bewegung),
+        receipt: schichtBon(unter(ort, 'receipt'), o.receipt),
+    };
+}