@kreiseck/kasseneck-api 1.31.0 → 1.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (119) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/dist/cjs/client/aufrufe.d.ts +3 -3
  3. package/dist/cjs/client/aufrufe.js +8 -0
  4. package/dist/cjs/client/receipts.d.ts +11 -0
  5. package/dist/cjs/client/receipts.js +14 -0
  6. package/dist/cjs/index.d.ts +2 -2
  7. package/dist/cjs/index.js +8 -5
  8. package/dist/cjs/models/index.d.ts +1 -1
  9. package/dist/cjs/models/index.js +5 -2
  10. package/dist/cjs/models/receipt-errors.d.ts +1 -1
  11. package/dist/cjs/models/receipt-errors.js +9 -0
  12. package/dist/cjs/models/receipt-item.d.ts +44 -2
  13. package/dist/cjs/models/receipt-item.js +56 -1
  14. package/dist/cjs/models/receipt.d.ts +17 -0
  15. package/dist/cjs/models/receipt.js +9 -0
  16. package/dist/cjs/pos/artikel.d.ts +14 -0
  17. package/dist/cjs/pos/artikel.js +3 -0
  18. package/dist/cjs/pos/client.d.ts +1 -0
  19. package/dist/cjs/pos/client.js +3 -0
  20. package/dist/cjs/pos/errors.d.ts +1 -1
  21. package/dist/cjs/pos/errors.js +12 -0
  22. package/dist/cjs/pos/index.d.ts +4 -2
  23. package/dist/cjs/pos/index.js +24 -4
  24. package/dist/cjs/pos/leergut.d.ts +60 -0
  25. package/dist/cjs/pos/leergut.js +82 -0
  26. package/dist/cjs/pos/pfand.d.ts +144 -0
  27. package/dist/cjs/pos/pfand.js +382 -0
  28. package/dist/cjs/pos/settings.d.ts +3 -7
  29. package/dist/cjs/pos/settings.js +7 -0
  30. package/dist/cjs/pos/texte.d.ts +68 -0
  31. package/dist/cjs/pos/texte.js +40 -1
  32. package/dist/cjs/receipt/discount.js +3 -0
  33. package/dist/cjs/receipt/due.d.ts +6 -0
  34. package/dist/cjs/receipt/due.js +16 -5
  35. package/dist/cjs/receipt/gutschein-plan.d.ts +7 -1
  36. package/dist/cjs/receipt/gutschein-plan.js +16 -2
  37. package/dist/cjs/receipt/layout.js +108 -2
  38. package/dist/cjs/register/pairing.d.ts +15 -1
  39. package/dist/cjs/register/pairing.js +14 -1
  40. package/dist/cjs/stored/vokabular.d.ts +1 -1
  41. package/dist/cjs/stored/vokabular.js +72 -4
  42. package/dist/cjs/version.d.ts +1 -1
  43. package/dist/cjs/version.js +1 -1
  44. package/dist/esm/client/aufrufe.d.ts +3 -3
  45. package/dist/esm/client/aufrufe.js +8 -0
  46. package/dist/esm/client/receipts.d.ts +11 -0
  47. package/dist/esm/client/receipts.js +14 -0
  48. package/dist/esm/index.d.ts +2 -2
  49. package/dist/esm/index.js +2 -2
  50. package/dist/esm/models/index.d.ts +1 -1
  51. package/dist/esm/models/index.js +1 -1
  52. package/dist/esm/models/receipt-errors.d.ts +1 -1
  53. package/dist/esm/models/receipt-errors.js +9 -0
  54. package/dist/esm/models/receipt-item.d.ts +44 -2
  55. package/dist/esm/models/receipt-item.js +54 -1
  56. package/dist/esm/models/receipt.d.ts +17 -0
  57. package/dist/esm/models/receipt.js +9 -0
  58. package/dist/esm/pos/artikel.d.ts +14 -0
  59. package/dist/esm/pos/artikel.js +3 -0
  60. package/dist/esm/pos/client.d.ts +1 -0
  61. package/dist/esm/pos/client.js +3 -0
  62. package/dist/esm/pos/errors.d.ts +1 -1
  63. package/dist/esm/pos/errors.js +12 -0
  64. package/dist/esm/pos/index.d.ts +4 -2
  65. package/dist/esm/pos/index.js +4 -2
  66. package/dist/esm/pos/leergut.d.ts +60 -0
  67. package/dist/esm/pos/leergut.js +77 -0
  68. package/dist/esm/pos/pfand.d.ts +144 -0
  69. package/dist/esm/pos/pfand.js +371 -0
  70. package/dist/esm/pos/settings.d.ts +3 -7
  71. package/dist/esm/pos/settings.js +7 -0
  72. package/dist/esm/pos/texte.d.ts +68 -0
  73. package/dist/esm/pos/texte.js +38 -0
  74. package/dist/esm/receipt/discount.js +4 -1
  75. package/dist/esm/receipt/due.d.ts +6 -0
  76. package/dist/esm/receipt/due.js +17 -6
  77. package/dist/esm/receipt/gutschein-plan.d.ts +7 -1
  78. package/dist/esm/receipt/gutschein-plan.js +14 -2
  79. package/dist/esm/receipt/layout.js +109 -3
  80. package/dist/esm/register/pairing.d.ts +15 -1
  81. package/dist/esm/register/pairing.js +13 -1
  82. package/dist/esm/stored/vokabular.d.ts +1 -1
  83. package/dist/esm/stored/vokabular.js +72 -4
  84. package/dist/esm/version.d.ts +1 -1
  85. package/dist/esm/version.js +1 -1
  86. package/fixtures/deposit-cases.json +4758 -0
  87. package/fixtures/expected/deposit-return.grid32.txt +28 -0
  88. package/fixtures/expected/deposit-return.grid48.txt +28 -0
  89. package/fixtures/expected/deposit-return.lines.json +275 -0
  90. package/fixtures/expected/deposit-return.sheet32.json +194 -0
  91. package/fixtures/expected/deposit-return.sheet48.json +194 -0
  92. package/fixtures/expected/deposit.grid32.txt +34 -0
  93. package/fixtures/expected/deposit.grid48.txt +32 -0
  94. package/fixtures/expected/deposit.lines.json +316 -0
  95. package/fixtures/expected/deposit.sheet32.json +230 -0
  96. package/fixtures/expected/deposit.sheet48.json +218 -0
  97. package/fixtures/hobex-hps-codes.json +1 -1
  98. package/fixtures/invoice-api.schema.json +1 -1
  99. package/fixtures/invoice-texts.json +1 -1
  100. package/fixtures/manifest.json +16 -0
  101. package/fixtures/pos-texts.json +62 -1
  102. package/fixtures/receipts/deposit-return.json +63 -0
  103. package/fixtures/receipts/deposit.json +83 -0
  104. package/fixtures/return-code-cases.json +1338 -0
  105. package/fixtures/surface.json +44 -4
  106. package/fixtures/v3/antworten/belege.json +2 -2
  107. package/fixtures/v3/antworten/belegmail.json +2 -2
  108. package/fixtures/v3/antworten/berichte.json +2 -2
  109. package/fixtures/v3/antworten/kasse-belege.json +2 -2
  110. package/fixtures/v3/antworten/kasse.json +428 -13
  111. package/fixtures/v3/antworten/lager.json +1 -1
  112. package/fixtures/v3/antworten/rechnungen.json +2 -2
  113. package/fixtures/v3/antworten/storno.json +2 -2
  114. package/fixtures/v3/stored/belege.json +2 -2
  115. package/fixtures/v3/stored/kasse.json +42 -4
  116. package/fixtures/v3/stored/rechnungen.json +2 -2
  117. package/fixtures/v3/v3-vokabular.json +808 -27
  118. package/fixtures/v3/zahlbetrag-faelle.json +187 -3
  119. package/package.json +1 -1
@@ -0,0 +1,60 @@
1
+ /**
2
+ * Leergut-Codes an der Kasse (Pfand & Leergut): ein Code, den die Kasse im Leergut-Blatt noch nicht kennt,
3
+ * wird einer Pfandart zugeordnet und gelernt (`learnReturnCode`); `listReturnCodes` liest die gelernten Codes.
4
+ * `matchReturnCode` ist die Regel, mit der ein Scan im Leergut-Blatt einer Pfandart zugeordnet wird – Web-Kasse
5
+ * und Kassen-App (ueber den Dart-Zwilling) benutzen genau diese Regel.
6
+ */
7
+ import type { InternerTransport } from '../client/aufrufe.js';
8
+ import { type DepositEntry, type DepositType } from './pfand.js';
9
+ /** Ein gelernter Leergut-Code: die GTIN und die Pfandart, der sie zugeordnet ist. */
10
+ export interface ReturnCode {
11
+ gtin: string;
12
+ depositTypeId: string;
13
+ }
14
+ /** Eine Zeile der Zuordnung: Pfandart und Stueckzahl, die ein Scan ins Leergut-Blatt bringt. */
15
+ export interface ReturnCodeEntry {
16
+ depositTypeId: string;
17
+ quantity: number;
18
+ }
19
+ /** Ergebnis von `matchReturnCode`: die Eintraege oder `unknown` (Code ist keiner Pfandart zuzuordnen). */
20
+ export type ReturnCodeMatch = {
21
+ entries: ReturnCodeEntry[];
22
+ } | {
23
+ unknown: true;
24
+ };
25
+ /**
26
+ * Lernt einen Leergut-Code (`learnMyLeergutCode`, nur Kassenweg, Recht `depositReturn`): `gtin` muss eine gueltige
27
+ * GTIN sein, `depositTypeId` eine aktive Pfandart. Die Form wird vor dem Senden geprueft; was der Server nicht
28
+ * annimmt, lehnt er mit `invalid_deposit` oder `deposit_type_not_found` ab.
29
+ */
30
+ export declare function learnReturnCode(transport: InternerTransport, code: ReturnCode): Promise<ReturnCode>;
31
+ /** Liest die gelernten Leergut-Codes (`listMyLeergutCodes`, nur Kassenweg): nur aktive Pfandarten, nach GTIN sortiert. */
32
+ export declare function listReturnCodes(transport: InternerTransport): Promise<ReturnCode[]>;
33
+ /** Was `matchReturnCode` von einem Artikel braucht (Teil von `PosArticle`). */
34
+ export interface ReturnCodeArticle {
35
+ groupId?: string | null;
36
+ ean?: string | null;
37
+ number?: string | null;
38
+ internalCode?: string | null;
39
+ deposits?: DepositEntry[] | null;
40
+ externalVoucher?: unknown;
41
+ }
42
+ /** Was `matchReturnCode` von einer Gruppe braucht (Teil von `ArticleGroup`). */
43
+ export interface ReturnCodeGroup {
44
+ id: string;
45
+ deposits?: DepositEntry[] | null;
46
+ }
47
+ export interface ReturnCodeInput {
48
+ articles: ReadonlyArray<ReturnCodeArticle>;
49
+ groups: ReadonlyArray<ReturnCodeGroup>;
50
+ learned: ReadonlyArray<ReturnCode>;
51
+ depositTypes: ReadonlyArray<Pick<DepositType, 'id' | 'active'>>;
52
+ }
53
+ /**
54
+ * Ordnet einen Scan im Leergut-Blatt einer Pfandart zu. Reihenfolge: (1) gelernter Code -> 1 Stueck; (2) `gtin` eines
55
+ * Pfandeintrags an Artikel oder Gruppe -> 1 Stueck dieser Pfandart; (3) Artikel-EAN, -Nummer oder -Code mit wirksamer
56
+ * Pfandliste -> jeder Eintrag mit seiner `quantity` (Kiste: 1 Kiste + 20 Flaschen); sonst `unknown`. Es zaehlen nur
57
+ * aktive Pfandarten: ein Treffer auf eine stillgelegte oder unbekannte Pfandart ist `unknown` (die Suche endet am
58
+ * ersten Treffer, sie faellt nicht auf die naechste Stufe zurueck). Der Code wird getrimmt, ein leerer ist `unknown`.
59
+ */
60
+ export declare function matchReturnCode(code: string, input: ReturnCodeInput): ReturnCodeMatch;
@@ -0,0 +1,77 @@
1
+ /**
2
+ * Leergut-Codes an der Kasse (Pfand & Leergut): ein Code, den die Kasse im Leergut-Blatt noch nicht kennt,
3
+ * wird einer Pfandart zugeordnet und gelernt (`learnReturnCode`); `listReturnCodes` liest die gelernten Codes.
4
+ * `matchReturnCode` ist die Regel, mit der ein Scan im Leergut-Blatt einer Pfandart zugeordnet wird – Web-Kasse
5
+ * und Kassen-App (ueber den Dart-Zwilling) benutzen genau diese Regel.
6
+ */
7
+ import { Gtin } from '@kreiseck/validator';
8
+ import { KasseneckValidationError } from '../client/errors.js';
9
+ import { depositsFor } from './pfand.js';
10
+ const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
11
+ function leergutCode(wert) {
12
+ if (!istObjekt(wert) || typeof wert['gtin'] !== 'string' || typeof wert['depositTypeId'] !== 'string')
13
+ return null;
14
+ return { gtin: wert['gtin'], depositTypeId: wert['depositTypeId'] };
15
+ }
16
+ /**
17
+ * Lernt einen Leergut-Code (`learnMyLeergutCode`, nur Kassenweg, Recht `depositReturn`): `gtin` muss eine gueltige
18
+ * GTIN sein, `depositTypeId` eine aktive Pfandart. Die Form wird vor dem Senden geprueft; was der Server nicht
19
+ * annimmt, lehnt er mit `invalid_deposit` oder `deposit_type_not_found` ab.
20
+ */
21
+ export async function learnReturnCode(transport, code) {
22
+ const name = 'learnMyLeergutCode';
23
+ const anfrage = (grund) => new KasseneckValidationError(name, grund, 'request');
24
+ if (!istObjekt(code))
25
+ throw anfrage('Anfrage muss ein Objekt sein');
26
+ const fremd = Object.keys(code).find((k) => k !== 'gtin' && k !== 'depositTypeId');
27
+ if (fremd != null)
28
+ throw anfrage(`unbekanntes Feld "${fremd}"`);
29
+ if (typeof code.gtin !== 'string' || !Gtin.isValid(code.gtin))
30
+ throw anfrage('gtin ist keine gueltige GTIN');
31
+ if (typeof code.depositTypeId !== 'string' || code.depositTypeId === '')
32
+ throw anfrage('depositTypeId fehlt');
33
+ const antwort = await transport(name, { gtin: code.gtin, depositTypeId: code.depositTypeId });
34
+ return leergutCode(antwort) ?? { gtin: code.gtin, depositTypeId: code.depositTypeId };
35
+ }
36
+ /** Liest die gelernten Leergut-Codes (`listMyLeergutCodes`, nur Kassenweg): nur aktive Pfandarten, nach GTIN sortiert. */
37
+ export async function listReturnCodes(transport) {
38
+ const antwort = await transport('listMyLeergutCodes', {});
39
+ const liste = istObjekt(antwort) && Array.isArray(antwort['codes']) ? antwort['codes'] : [];
40
+ return liste.map(leergutCode).filter((c) => c != null);
41
+ }
42
+ /**
43
+ * Ordnet einen Scan im Leergut-Blatt einer Pfandart zu. Reihenfolge: (1) gelernter Code -> 1 Stueck; (2) `gtin` eines
44
+ * Pfandeintrags an Artikel oder Gruppe -> 1 Stueck dieser Pfandart; (3) Artikel-EAN, -Nummer oder -Code mit wirksamer
45
+ * Pfandliste -> jeder Eintrag mit seiner `quantity` (Kiste: 1 Kiste + 20 Flaschen); sonst `unknown`. Es zaehlen nur
46
+ * aktive Pfandarten: ein Treffer auf eine stillgelegte oder unbekannte Pfandart ist `unknown` (die Suche endet am
47
+ * ersten Treffer, sie faellt nicht auf die naechste Stufe zurueck). Der Code wird getrimmt, ein leerer ist `unknown`.
48
+ */
49
+ export function matchReturnCode(code, input) {
50
+ const unbekannt = { unknown: true };
51
+ const gesucht = typeof code === 'string' ? code.trim() : '';
52
+ if (gesucht === '')
53
+ return unbekannt;
54
+ const aktiv = new Set(input.depositTypes.filter((t) => t.active).map((t) => t.id));
55
+ const eins = (depositTypeId) => (aktiv.has(depositTypeId) ? { entries: [{ depositTypeId, quantity: 1 }] } : unbekannt);
56
+ const gelernt = input.learned.find((l) => l.gtin === gesucht);
57
+ if (gelernt != null)
58
+ return eins(gelernt.depositTypeId);
59
+ const gruppeVon = (a) => input.groups.find((g) => g.id === a.groupId) ?? null;
60
+ for (const a of input.articles) {
61
+ const hit = (depositsFor(a, gruppeVon(a))).find((d) => d.gtin === gesucht);
62
+ if (hit != null)
63
+ return eins(hit.depositTypeId);
64
+ }
65
+ for (const g of input.groups) {
66
+ const hit = (g.deposits ?? []).find((d) => d.gtin === gesucht);
67
+ if (hit != null)
68
+ return eins(hit.depositTypeId);
69
+ }
70
+ const artikel = input.articles.find((a) => a.ean === gesucht || a.number === gesucht || a.internalCode === gesucht);
71
+ if (artikel == null)
72
+ return unbekannt;
73
+ const liste = depositsFor(artikel, gruppeVon(artikel));
74
+ if (liste.length === 0 || !liste.every((d) => aktiv.has(d.depositTypeId)))
75
+ return unbekannt;
76
+ return { entries: liste.map((d) => ({ depositTypeId: d.depositTypeId, quantity: d.quantity })) };
77
+ }
@@ -0,0 +1,144 @@
1
+ /**
2
+ * Pfand & Leergut an der Kasse: Pfandarten und Einstellungen aus
3
+ * `getKasseSettings` (Block `deposit`), Pfandliste am Artikel und an der
4
+ * Gruppe (`deposits`) und die Pfand-Angaben des Kassenobjekts aus
5
+ * `listRegisterUsersForDevice`. Alles nur Lesen und Schreiben der Formen; die
6
+ * Rechnung (Betrag, Staffel nach Tag) kommt in einem eigenen Modul.
7
+ */
8
+ import type { ReceiptItem } from '../models/receipt-item.js';
9
+ /** Art einer Pfandart: Einweg oder Mehrweg. */
10
+ export declare const DEPOSIT_KINDS: readonly ["single_use", "reusable"];
11
+ export type DepositKind = typeof DEPOSIT_KINDS[number];
12
+ /** Gebindetyp einer Pfandart (frei, nur zur Anzeige). */
13
+ export declare const DEPOSIT_TYPES: readonly ["bottle", "crate", "keg", "cup", "glass", "other"];
14
+ export type DepositContainerType = typeof DEPOSIT_TYPES[number];
15
+ /** Wer nimmt Leergut an der Kasse zurueck: diese Kasse, eine gemeinsame Stelle oder niemand. */
16
+ export declare const DEPOSIT_RETURN_MODES: readonly ["here", "shared", "none"];
17
+ export type DepositReturnMode = typeof DEPOSIT_RETURN_MODES[number];
18
+ /** Vorbelegung, ob Getraenke vor Ort getrunken oder mitgenommen werden. */
19
+ export declare const DEPOSIT_ON_PREMISES_DEFAULTS: readonly ["on_premises", "takeaway", "ask"];
20
+ export type DepositOnPremisesDefault = typeof DEPOSIT_ON_PREMISES_DEFAULTS[number];
21
+ /** Ein Pfandbetrag ab einem Tag (`from`, Wiener Tag `YYYY-MM-DD`), in Cent je Stueck. */
22
+ export interface DepositAmount {
23
+ from: string;
24
+ cents: number;
25
+ }
26
+ /** Eine Pfandart des Betriebs. */
27
+ export interface DepositType {
28
+ id: string;
29
+ kind: DepositKind;
30
+ name: string;
31
+ type: DepositContainerType | null;
32
+ /** Betraege nach Gueltigkeit, wie vom Server geliefert (aufsteigend nach `from`). */
33
+ amounts: DepositAmount[];
34
+ /** Steuersatz in Prozent, mit dem Mehrweg-Leergut zurueckgenommen wird (Rueckgabesatz), oder null (noch nie ausgegeben). */
35
+ returnRate: number | null;
36
+ /** Die Pfandart steht an mindestens einem Artikel oder Beleg. */
37
+ used: boolean;
38
+ active: boolean;
39
+ }
40
+ /** Block `deposit` aus `getKasseSettings`; fehlt bei ausgeschaltetem Pfand. */
41
+ export interface DepositSettings {
42
+ singleUse: boolean;
43
+ reusable: boolean;
44
+ depositTypes: DepositType[];
45
+ }
46
+ /** Eine Pfandangabe an Artikel oder Gruppe (`deposits[]`). */
47
+ export interface DepositEntry {
48
+ depositTypeId: string;
49
+ quantity: number;
50
+ gtin?: string;
51
+ ownFilling?: boolean;
52
+ }
53
+ /** Gemeinsame Rueckgabestelle (Kassen-Pfandangaben). */
54
+ export interface DepositSharedReturnPoint {
55
+ name: string;
56
+ address: string;
57
+ }
58
+ /** Pfand-Angaben des Kassenobjekts aus `listRegisterUsersForDevice`; fehlt bei ausgeschaltetem Pfand. */
59
+ export interface CashRegisterDeposit {
60
+ returns: DepositReturnMode;
61
+ onPremisesDefault: DepositOnPremisesDefault;
62
+ usualQuantity: number;
63
+ sharedReturnPoint: DepositSharedReturnPoint | null;
64
+ }
65
+ /**
66
+ * Den Block `deposit` einer Antwort lesen. Kein Objekt (Pfand aus, alter
67
+ * Server) -> `undefined`: das Feld fehlt dann am Modell, es wird nichts erfunden.
68
+ * Eine Pfandart in unbekannter Form faellt weg.
69
+ */
70
+ export declare function posDepositSettingsFromWire(value: unknown): DepositSettings | undefined;
71
+ /** Die Pfandliste eines Artikels oder einer Gruppe; keine Liste -> `null`, unlesbare Eintraege fallen weg. */
72
+ export declare function depositEntriesFromWire(value: unknown): DepositEntry[] | null;
73
+ /** Die Pfand-Angaben eines Kassenobjekts; fehlt der Block oder ist er unbrauchbar -> `undefined`. */
74
+ export declare function cashRegisterDepositFromWire(value: unknown): CashRegisterDeposit | undefined;
75
+ /** Pfandangaben, wirksam fuer einen Artikel: Artikel vor Gruppe, `[]` = kein Pfand, `null`/fehlend = wie die Gruppe. */
76
+ export declare function depositsFor(article: {
77
+ deposits?: DepositEntry[] | null;
78
+ externalVoucher?: unknown;
79
+ } | null | undefined, group: {
80
+ deposits?: DepositEntry[] | null;
81
+ } | null | undefined): DepositEntry[];
82
+ /** Pfandbetrag in Cent am Wiener Tag `day` (`YYYY-MM-DD`): letzter Eintrag mit `from <= day`, sonst `null`. */
83
+ export declare function depositAmountOn(type: Pick<DepositType, 'amounts'>, day: string): number | null;
84
+ /** Wiener Kalendertag `YYYY-MM-DD` zum Zeitpunkt `nowMs` (nie der UTC-Tag). */
85
+ export declare function viennaDay(nowMs: number): string;
86
+ /** Eine Position des Korbs in der Leitungsform (`amount`/`quantity`, `vat`/`vatRate`, `addOnOf` ...). */
87
+ export type DepositPreviewItem = object | null;
88
+ /** Eine Pfand- oder Leergutzeile in der Leitungsform, wie der Server sie baut. */
89
+ export type DepositPreviewLine = Record<string, unknown>;
90
+ /** Fehlercodes der Vorschau (die /v3-Codes von `createReceipt`). */
91
+ export type DepositPreviewErrorCode = 'invalid_deposit' | 'deposit_set_by_server' | 'deposit_type_not_found' | 'invalid_deposit_quantity' | 'deposit_return_not_offered' | 'deposit_type_not_issued' | 'not_permitted';
92
+ /** Eingabe der Vorschau (ohne die Positionen): was der Server aus Konto, Kasse und Beleg wuesste. */
93
+ export interface DepositPreviewInput {
94
+ /** Pfand zu Artikeln selbst ableiten (`autoDeposits`). */
95
+ auto: boolean;
96
+ articles: ReadonlyMap<string, DepositPreviewArticle> | Readonly<Record<string, DepositPreviewArticle>>;
97
+ groups: ReadonlyMap<string, {
98
+ deposits?: DepositEntry[] | null;
99
+ }> | Readonly<Record<string, {
100
+ deposits?: DepositEntry[] | null;
101
+ }>>;
102
+ depositTypes: ReadonlyMap<string, DepositType> | Readonly<Record<string, DepositType>>;
103
+ /** Wiener Tag des Belegs. */
104
+ day: string;
105
+ /** Vor Ort getrunken: Einweg entfaellt. */
106
+ onPremises: boolean;
107
+ /** Pfand-Angaben der Kasse (nur `returns` zaehlt); ohne Angabe nimmt die Kasse kein Leergut zurueck. */
108
+ cashRegister?: Pick<CashRegisterDeposit, 'returns'> | null;
109
+ smallBusiness: boolean;
110
+ /** Der Benutzer darf Leergut zuruecknehmen (`depositReturnOf`). */
111
+ mayReturn: boolean;
112
+ }
113
+ /** Artikel, soweit die Vorschau ihn liest. */
114
+ export interface DepositPreviewArticle {
115
+ id?: string;
116
+ groupId?: string | null;
117
+ deposits?: DepositEntry[] | null;
118
+ externalVoucher?: unknown;
119
+ }
120
+ export type DepositPreviewResult<T> = {
121
+ ok: true;
122
+ items: T[];
123
+ } | {
124
+ ok: false;
125
+ code: DepositPreviewErrorCode;
126
+ };
127
+ /**
128
+ * Pfand- und Leergutzeilen eines Belegs wie der Server: leitet Pfand zu Artikeln ab (`auto`), prueft ausdrueckliche
129
+ * `deposit`-Zeilen und `deposit_return`-Zeilen und rechnet `addOnOf` und `depositFor` auf die neuen Positionen um.
130
+ * Ohne Pfand-/Leergutzeile und ohne Ableitung kommen die Positionen unveraendert zurueck. Die Fehlercodes sind die
131
+ * von `createReceipt`.
132
+ */
133
+ export declare function withDepositLines<T extends DepositPreviewItem>(items: readonly T[], input: DepositPreviewInput): DepositPreviewResult<T | DepositPreviewLine>;
134
+ /**
135
+ * Die Leergutzeile zu `quantity` Stueck einer Pfandart, wie `withDepositLines` sie fuer eine
136
+ * `deposit_return`-Eingabe baut (fuer die Korb-Vorschau). Wirft, wenn sich keine Zeile ergibt
137
+ * (unbekannte Pfandart, Menge ausserhalb 1 bis 1000, Mehrweg ohne Rueckgabesatz, ungueltige Codes);
138
+ * ob die Kasse Leergut annimmt, prueft der Aufrufer.
139
+ */
140
+ export declare function depositReturnLine(type: DepositType, quantity: number, options: {
141
+ day: string;
142
+ smallBusiness: boolean;
143
+ codes?: Record<string, number>;
144
+ }): ReceiptItem;
@@ -0,0 +1,371 @@
1
+ /**
2
+ * Pfand & Leergut an der Kasse: Pfandarten und Einstellungen aus
3
+ * `getKasseSettings` (Block `deposit`), Pfandliste am Artikel und an der
4
+ * Gruppe (`deposits`) und die Pfand-Angaben des Kassenobjekts aus
5
+ * `listRegisterUsersForDevice`. Alles nur Lesen und Schreiben der Formen; die
6
+ * Rechnung (Betrag, Staffel nach Tag) kommt in einem eigenen Modul.
7
+ */
8
+ import { Gtin } from '@kreiseck/validator';
9
+ import { readVatRateByRate } from '../models/enum-payload.js';
10
+ /** Art einer Pfandart: Einweg oder Mehrweg. */
11
+ export const DEPOSIT_KINDS = ['single_use', 'reusable'];
12
+ /** Gebindetyp einer Pfandart (frei, nur zur Anzeige). */
13
+ export const DEPOSIT_TYPES = ['bottle', 'crate', 'keg', 'cup', 'glass', 'other'];
14
+ /** Wer nimmt Leergut an der Kasse zurueck: diese Kasse, eine gemeinsame Stelle oder niemand. */
15
+ export const DEPOSIT_RETURN_MODES = ['here', 'shared', 'none'];
16
+ /** Vorbelegung, ob Getraenke vor Ort getrunken oder mitgenommen werden. */
17
+ export const DEPOSIT_ON_PREMISES_DEFAULTS = ['on_premises', 'takeaway', 'ask'];
18
+ const istObjekt = (w) => w !== null && typeof w === 'object' && !Array.isArray(w);
19
+ const istGanz = (w, min) => Number.isInteger(w) && w >= min;
20
+ function aus(liste, value) {
21
+ return typeof value === 'string' && liste.includes(value) ? value : null;
22
+ }
23
+ function betrag(value) {
24
+ if (!istObjekt(value) || typeof value['from'] !== 'string' || !istGanz(value['cents'], 0))
25
+ return null;
26
+ return { from: value['from'], cents: value['cents'] };
27
+ }
28
+ function pfandart(value) {
29
+ if (!istObjekt(value) || typeof value['id'] !== 'string' || value['id'] === '')
30
+ return null;
31
+ const kind = aus(DEPOSIT_KINDS, value['kind']);
32
+ if (kind == null)
33
+ return null;
34
+ const rate = value['returnRate'];
35
+ return {
36
+ id: value['id'],
37
+ kind,
38
+ name: typeof value['name'] === 'string' ? value['name'] : '',
39
+ type: aus(DEPOSIT_TYPES, value['type']),
40
+ amounts: Array.isArray(value['amounts']) ? value['amounts'].map(betrag).filter((b) => b != null) : [],
41
+ returnRate: typeof rate === 'number' && Number.isFinite(rate) ? rate : null,
42
+ used: value['used'] === true,
43
+ active: value['active'] !== false,
44
+ };
45
+ }
46
+ /**
47
+ * Den Block `deposit` einer Antwort lesen. Kein Objekt (Pfand aus, alter
48
+ * Server) -> `undefined`: das Feld fehlt dann am Modell, es wird nichts erfunden.
49
+ * Eine Pfandart in unbekannter Form faellt weg.
50
+ */
51
+ export function posDepositSettingsFromWire(value) {
52
+ if (!istObjekt(value))
53
+ return undefined;
54
+ return {
55
+ singleUse: value['singleUse'] === true,
56
+ reusable: value['reusable'] === true,
57
+ depositTypes: Array.isArray(value['depositTypes']) ? value['depositTypes'].map(pfandart).filter((a) => a != null) : [],
58
+ };
59
+ }
60
+ /** Die Pfandliste eines Artikels oder einer Gruppe; keine Liste -> `null`, unlesbare Eintraege fallen weg. */
61
+ export function depositEntriesFromWire(value) {
62
+ if (!Array.isArray(value))
63
+ return null;
64
+ const raus = [];
65
+ for (const e of value) {
66
+ if (!istObjekt(e) || typeof e['depositTypeId'] !== 'string' || e['depositTypeId'] === '' || !istGanz(e['quantity'], 1))
67
+ continue;
68
+ raus.push({
69
+ depositTypeId: e['depositTypeId'],
70
+ quantity: e['quantity'],
71
+ ...(typeof e['gtin'] === 'string' && e['gtin'] !== '' ? { gtin: e['gtin'] } : {}),
72
+ ...(typeof e['ownFilling'] === 'boolean' ? { ownFilling: e['ownFilling'] } : {}),
73
+ });
74
+ }
75
+ return raus;
76
+ }
77
+ /** Die Pfand-Angaben eines Kassenobjekts; fehlt der Block oder ist er unbrauchbar -> `undefined`. */
78
+ export function cashRegisterDepositFromWire(value) {
79
+ if (!istObjekt(value))
80
+ return undefined;
81
+ const returns = aus(DEPOSIT_RETURN_MODES, value['returns']);
82
+ const onPremisesDefault = aus(DEPOSIT_ON_PREMISES_DEFAULTS, value['onPremisesDefault']);
83
+ if (returns == null || onPremisesDefault == null)
84
+ return undefined;
85
+ const stelle = value['sharedReturnPoint'];
86
+ return {
87
+ returns,
88
+ onPremisesDefault,
89
+ usualQuantity: istGanz(value['usualQuantity'], 1) ? value['usualQuantity'] : 1,
90
+ sharedReturnPoint: istObjekt(stelle) && typeof stelle['name'] === 'string'
91
+ ? { name: stelle['name'], address: typeof stelle['address'] === 'string' ? stelle['address'] : '' }
92
+ : null,
93
+ };
94
+ }
95
+ // ---------------------------------------------------------------------------------------------------------------
96
+ // Vorschau-Rechnung: dieselben Pfand- und Leergutzeilen wie der Server (`createReceipt`), damit der Korb sie vor
97
+ // dem Buchen zeigt. Vertrag sind die Pruefaelle `fixtures/deposit-cases.json` (Backend `pfand-faelle.json`).
98
+ // ---------------------------------------------------------------------------------------------------------------
99
+ /** EWP-GTIN der Einweg-Pfandzeile (gesetzlich festgelegt). */
100
+ const EWP_GTIN = '9010945000011';
101
+ /** Pfandangaben, wirksam fuer einen Artikel: Artikel vor Gruppe, `[]` = kein Pfand, `null`/fehlend = wie die Gruppe. */
102
+ export function depositsFor(article, group) {
103
+ if (article == null)
104
+ return [];
105
+ if (article.externalVoucher != null)
106
+ return []; // fremde Gutscheine tragen nie Pfand, auch nicht von der Gruppe
107
+ if (Array.isArray(article.deposits))
108
+ return article.deposits;
109
+ if (group != null && Array.isArray(group.deposits))
110
+ return group.deposits;
111
+ return [];
112
+ }
113
+ /** Pfandbetrag in Cent am Wiener Tag `day` (`YYYY-MM-DD`): letzter Eintrag mit `from <= day`, sonst `null`. */
114
+ export function depositAmountOn(type, day) {
115
+ let cents = null;
116
+ for (const e of type.amounts) {
117
+ if (e.from <= day)
118
+ cents = e.cents;
119
+ else
120
+ break;
121
+ }
122
+ return cents;
123
+ }
124
+ const tagFormat = new Intl.DateTimeFormat('en-CA', { timeZone: 'Europe/Vienna', year: 'numeric', month: '2-digit', day: '2-digit' });
125
+ /** Wiener Kalendertag `YYYY-MM-DD` zum Zeitpunkt `nowMs` (nie der UTC-Tag). */
126
+ export function viennaDay(nowMs) {
127
+ const teile = {};
128
+ for (const t of tagFormat.formatToParts(new Date(nowMs)))
129
+ teile[t.type] = t.value;
130
+ return `${teile['year']}-${teile['month']}-${teile['day']}`;
131
+ }
132
+ const istObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
133
+ const ganz = (v, min, max) => Number.isInteger(v) && v >= min && v <= max;
134
+ const nachId = (karte, id) => {
135
+ if (karte instanceof Map)
136
+ return karte.get(id);
137
+ return Object.prototype.hasOwnProperty.call(karte, id) ? karte[id] : undefined;
138
+ };
139
+ const fehler = (code) => ({ ok: false, code });
140
+ const OHNE_PFAND = ['tip', 'discount', 'voucher', 'voucher_float', 'deposit', 'deposit_return'];
141
+ const istHaupt = (it) => istObj(it) && !OHNE_PFAND.includes(it['kind']);
142
+ const mengeVon = (it) => (it['amount'] !== undefined && it['amount'] !== null ? it['amount'] : it['quantity']);
143
+ const satzVon = (it) => (it['vat'] !== undefined && it['vat'] !== null ? it['vat'] : it['vatRate']);
144
+ const hatVerweis = (it) => it['addOnOf'] !== undefined && it['addOnOf'] !== null;
145
+ const aktiv = (arten, id) => {
146
+ const a = typeof id === 'string' ? nachId(arten, id) : undefined;
147
+ return a && a.active !== false ? a : null;
148
+ };
149
+ function zeile(kind, art, name, quantity, cents, vatRate) {
150
+ return {
151
+ kind, name, quantity, amount: quantity,
152
+ unitPriceCents: cents, priceOneCents: cents, priceOne: cents / 100, vatRate, vat: vatRate,
153
+ depositTypeId: art.id, depositKind: art.kind,
154
+ };
155
+ }
156
+ function pfandPreis(art, haupt, day, smallBusiness) {
157
+ const cents = depositAmountOn(art, day);
158
+ if (cents === null)
159
+ return null;
160
+ if (art.kind === 'single_use')
161
+ return { cents, vatRate: 0 };
162
+ if (smallBusiness)
163
+ return { cents, vatRate: 0 };
164
+ const satz = satzVon(haupt);
165
+ return typeof satz === 'number' && Number.isFinite(satz) ? { cents, vatRate: satz } : null;
166
+ }
167
+ function abgeleitet(it, input) {
168
+ if (!input.auto || !istHaupt(it) || typeof it['articleId'] !== 'string' || it['articleId'] === '')
169
+ return [];
170
+ const a = nachId(input.articles, it['articleId']);
171
+ if (!a)
172
+ return [];
173
+ const g = a.groupId ? nachId(input.groups, a.groupId) : null;
174
+ return depositsFor(a, g);
175
+ }
176
+ function gtinOk(v) {
177
+ return typeof v === 'string' && Gtin.isValid(v);
178
+ }
179
+ function leergut(it, input) {
180
+ if (!input.cashRegister || input.cashRegister.returns !== 'here')
181
+ return fehler('deposit_return_not_offered');
182
+ if (input.mayReturn === false)
183
+ return fehler('not_permitted');
184
+ const art = aktiv(input.depositTypes, it['depositTypeId']);
185
+ if (!art)
186
+ return fehler('deposit_type_not_found');
187
+ if (art.kind === 'reusable' && art.used !== true)
188
+ return fehler('deposit_type_not_issued');
189
+ const quantity = it['quantity'];
190
+ if (!ganz(quantity, 1, 1000))
191
+ return fehler('invalid_deposit');
192
+ let codes;
193
+ if (it['codes'] !== undefined && it['codes'] !== null) {
194
+ if (!istObj(it['codes']))
195
+ return fehler('invalid_deposit');
196
+ const schluessel = Object.keys(it['codes']);
197
+ if (schluessel.length > 50)
198
+ return fehler('invalid_deposit');
199
+ let summe = 0;
200
+ for (const k of schluessel) {
201
+ const n = it['codes'][k];
202
+ if (!gtinOk(k) || !ganz(n, 1, 1000))
203
+ return fehler('invalid_deposit');
204
+ summe += n;
205
+ }
206
+ if (summe !== quantity)
207
+ return fehler('invalid_deposit');
208
+ codes = { ...it['codes'] };
209
+ }
210
+ const cents = depositAmountOn(art, input.day);
211
+ if (cents === null)
212
+ return fehler('invalid_deposit');
213
+ // Mehrweg-Leergut rechnet mit dem Rueckgabesatz der Pfandart (`returnRate` = Steuersatz), bei Kleinunternehmern 0.
214
+ let vatRate = 0;
215
+ if (art.kind === 'reusable' && !input.smallBusiness) {
216
+ if (art.returnRate === null || !Number.isFinite(art.returnRate))
217
+ return fehler('invalid_deposit');
218
+ vatRate = art.returnRate;
219
+ }
220
+ const z = zeile('deposit_return', art, 'Leergut ' + art.name.replace(/^Pfand /, ''), quantity, -cents, vatRate);
221
+ if (art.kind === 'single_use')
222
+ z['ean'] = EWP_GTIN;
223
+ if (codes)
224
+ z['codes'] = codes;
225
+ return { ok: true, line: z };
226
+ }
227
+ /**
228
+ * Pfand- und Leergutzeilen eines Belegs wie der Server: leitet Pfand zu Artikeln ab (`auto`), prueft ausdrueckliche
229
+ * `deposit`-Zeilen und `deposit_return`-Zeilen und rechnet `addOnOf` und `depositFor` auf die neuen Positionen um.
230
+ * Ohne Pfand-/Leergutzeile und ohne Ableitung kommen die Positionen unveraendert zurueck. Die Fehlercodes sind die
231
+ * von `createReceipt`.
232
+ */
233
+ export function withDepositLines(items, input) {
234
+ const liste = Array.isArray(items) ? items : [];
235
+ const dahinter = new Map();
236
+ const ersetzt = new Map();
237
+ const hinzu = (i, z) => { dahinter.set(i, [...(dahinter.get(i) ?? []), z]); };
238
+ for (let i = 0; i < liste.length; i += 1) {
239
+ const it = liste[i];
240
+ if (!istObj(it))
241
+ continue;
242
+ if (it['kind'] === 'deposit_return') {
243
+ const r = leergut(it, input);
244
+ if (!r.ok)
245
+ return r;
246
+ ersetzt.set(i, r.line);
247
+ continue;
248
+ }
249
+ if (it['kind'] === 'deposit') {
250
+ const verweis = it['depositFor'];
251
+ const haupt = Number.isInteger(verweis) ? liste[verweis] : null;
252
+ if (!istHaupt(haupt))
253
+ return fehler('invalid_deposit');
254
+ if (abgeleitet(haupt, input).length > 0)
255
+ return fehler('deposit_set_by_server');
256
+ const art = aktiv(input.depositTypes, it['depositTypeId']);
257
+ if (!art)
258
+ return fehler('deposit_type_not_found');
259
+ const menge = mengeVon(haupt);
260
+ if (!Number.isInteger(menge) || menge === 0)
261
+ return fehler('invalid_deposit_quantity');
262
+ const quantity = it['quantity'] === undefined || it['quantity'] === null ? menge : it['quantity'];
263
+ if (!Number.isInteger(quantity) || quantity % menge !== 0 || quantity / menge < 1)
264
+ return fehler('invalid_deposit_quantity');
265
+ const preis = pfandPreis(art, haupt, input.day, input.smallBusiness);
266
+ if (!preis)
267
+ return fehler('invalid_deposit');
268
+ const hatGtin = it['gtin'] !== undefined && it['gtin'] !== null;
269
+ if (hatGtin && !gtinOk(it['gtin']))
270
+ return fehler('invalid_deposit');
271
+ if (it['ownFilling'] !== undefined && it['ownFilling'] !== null && typeof it['ownFilling'] !== 'boolean')
272
+ return fehler('invalid_deposit');
273
+ if (it['ownFilling'] === true && !hatGtin)
274
+ return fehler('invalid_deposit');
275
+ const q = quantity;
276
+ const z = zeile('deposit', art, art.name, q, preis.cents, preis.vatRate);
277
+ z['depositFor'] = verweis;
278
+ z['perUnit'] = q / menge;
279
+ if (art.kind === 'single_use')
280
+ z['ean'] = EWP_GTIN;
281
+ if (hatGtin)
282
+ z['gtin'] = it['gtin'];
283
+ if (it['ownFilling'] === true)
284
+ z['ownFilling'] = true;
285
+ ersetzt.set(i, z);
286
+ continue;
287
+ }
288
+ const eintraege = abgeleitet(it, input);
289
+ if (!eintraege.length)
290
+ continue;
291
+ const menge = mengeVon(it);
292
+ const gelten = [];
293
+ for (const e of eintraege) {
294
+ const art = aktiv(input.depositTypes, e.depositTypeId);
295
+ if (!art)
296
+ return fehler('deposit_type_not_found');
297
+ if (art.kind === 'single_use' && input.onPremises === true)
298
+ continue;
299
+ gelten.push({ e, art });
300
+ }
301
+ if (!gelten.length)
302
+ continue;
303
+ if (!Number.isInteger(menge))
304
+ return fehler('invalid_deposit_quantity');
305
+ if (menge === 0)
306
+ continue;
307
+ for (const { e, art } of gelten) {
308
+ const preis = pfandPreis(art, it, input.day, input.smallBusiness);
309
+ if (!preis)
310
+ return fehler('invalid_deposit');
311
+ const z = zeile('deposit', art, art.name, e.quantity * menge, preis.cents, preis.vatRate);
312
+ z['depositFor'] = i;
313
+ z['perUnit'] = e.quantity;
314
+ if (art.kind === 'single_use')
315
+ z['ean'] = EWP_GTIN;
316
+ if (e.gtin)
317
+ z['gtin'] = e.gtin;
318
+ if (e.ownFilling === true)
319
+ z['ownFilling'] = true;
320
+ hinzu(i, z);
321
+ }
322
+ }
323
+ if (!ersetzt.size && !dahinter.size)
324
+ return { ok: true, items: [...liste] };
325
+ const neu = [];
326
+ let verschiebung = 0;
327
+ liste.forEach((_, i) => { neu.push(i + verschiebung); verschiebung += dahinter.get(i)?.length ?? 0; });
328
+ const umgerechnet = (v) => (typeof v === 'number' && Number.isInteger(v) ? neu[v] : undefined);
329
+ const raus = [];
330
+ liste.forEach((it, i) => {
331
+ if (!istObj(it)) {
332
+ raus.push(it);
333
+ return;
334
+ }
335
+ let z = ersetzt.get(i) ?? it;
336
+ if (z['kind'] === 'deposit' && umgerechnet(z['depositFor']) !== undefined)
337
+ z = { ...z, depositFor: umgerechnet(z['depositFor']) };
338
+ else if (hatVerweis(z) && umgerechnet(z['addOnOf']) !== undefined)
339
+ z = { ...z, addOnOf: umgerechnet(z['addOnOf']) };
340
+ raus.push(z);
341
+ for (const d of dahinter.get(i) ?? [])
342
+ raus.push({ ...d, depositFor: neu[i] });
343
+ });
344
+ return { ok: true, items: raus };
345
+ }
346
+ /**
347
+ * Die Leergutzeile zu `quantity` Stueck einer Pfandart, wie `withDepositLines` sie fuer eine
348
+ * `deposit_return`-Eingabe baut (fuer die Korb-Vorschau). Wirft, wenn sich keine Zeile ergibt
349
+ * (unbekannte Pfandart, Menge ausserhalb 1 bis 1000, Mehrweg ohne Rueckgabesatz, ungueltige Codes);
350
+ * ob die Kasse Leergut annimmt, prueft der Aufrufer.
351
+ */
352
+ export function depositReturnLine(type, quantity, options) {
353
+ const r = leergut({ kind: 'deposit_return', depositTypeId: type.id, quantity, ...(options.codes ? { codes: options.codes } : {}) }, { depositTypes: { [type.id]: type }, day: options.day, smallBusiness: options.smallBusiness, cashRegister: { returns: 'here' }, mayReturn: true });
354
+ if (!r.ok)
355
+ throw new Error(`Leergutzeile nicht moeglich: ${r.code}`);
356
+ const l = r.line;
357
+ const item = {
358
+ name: l['name'],
359
+ quantity: l['quantity'],
360
+ vat: readVatRateByRate(l['vatRate']),
361
+ priceCents: l['unitPriceCents'],
362
+ kind: 'deposit_return',
363
+ depositTypeId: l['depositTypeId'],
364
+ depositKind: type.kind,
365
+ };
366
+ if (typeof l['ean'] === 'string')
367
+ item.ean = l['ean'];
368
+ if (l['codes'] !== undefined)
369
+ item.codes = l['codes'];
370
+ return item;
371
+ }