lib-fints 1.0.0

package/dist/interactions/initDialogInteraction.js

@@ -0,0 +1,155 @@
+import { CustomerInteraction } from './customerInteraction.js';
+import { HKIDN } from '../segments/HKIDN.js';
+import { HKVVB } from '../segments/HKVVB.js';
+import { Language, SyncMode } from '../codes.js';
+import { HKSYN } from '../segments/HKSYN.js';
+import { HISYN } from '../segments/HISYN.js';
+import { HIBPA } from '../segments/HIBPA.js';
+import { HITANS } from '../segments/HITANS.js';
+import { HIKOM } from '../segments/HIKOM.js';
+import { HIPINS } from '../segments/HIPINS.js';
+import { HIUPA } from '../segments/HIUPA.js';
+import { finTsAccountTypeToEnum } from '../bankAccount.js';
+import { HIKIM } from '../segments/HIKIM.js';
+import { HIUPD } from '../segments/HIUPD.js';
+export class InitDialogInteraction extends CustomerInteraction {
+    init;
+    syncSystemId;
+    constructor(init, syncSystemId = false) {
+        super(HKIDN.Id);
+        this.init = init;
+        this.syncSystemId = syncSystemId;
+    }
+    createSegments(init) {
+        const segments = [];
+        const hkidn = {
+            header: { segId: HKIDN.Id, segNr: 0, version: HKIDN.Version },
+            bank: { country: init.countryCode, bankId: init.bankId },
+            customerId: init.customerId ?? init.userId ?? '9999999999',
+            systemId: init.bankingInformation.systemId,
+            systemIdRequired: this.init.userId ? 1 : 0,
+        };
+        segments.push(hkidn);
+        const hkvvb = {
+            header: { segId: HKVVB.Id, segNr: 0, version: HKVVB.Version },
+            bpdVersion: init.bankingInformation.bpd?.version ?? 0,
+            updVersion: init.bankingInformation.upd?.version ?? 0,
+            dialogLanguage: Language.Default,
+            productId: init.productId,
+            productVersion: init.productVersion,
+        };
+        segments.push(hkvvb);
+        if (this.syncSystemId && this.init.userId && init.bankingInformation.systemId === '0') {
+            const hksyn = {
+                header: { segId: HKSYN.Id, segNr: 0, version: HKSYN.Version },
+                mode: SyncMode.NewSystemId,
+            };
+            segments.push(hksyn);
+        }
+        return segments;
+    }
+    handleResponse(response, clientResponse) {
+        const currentBankingInformationSnapshot = JSON.stringify(this.init.bankingInformation);
+        const hisyn = response.findSegment(HISYN.Id);
+        if (hisyn && hisyn.systemId) {
+            this.init.bankingInformation.systemId = hisyn.systemId;
+        }
+        const bankAnswers = clientResponse.bankAnswers;
+        const hibpa = response.findSegment(HIBPA.Id);
+        if (hibpa) {
+            const hitansSegments = response.findAllSegments(HITANS.Id);
+            const supportedTanMethods = [];
+            hitansSegments.forEach((hitans) => {
+                supportedTanMethods.push(...(hitans?.params.tanMethods.map((t) => ({
+                    id: t.secFunc,
+                    name: t.methodName,
+                    version: hitans.header.version,
+                    activeTanMediaCount: t.activeTanMedia,
+                    activeTanMedia: [],
+                    tanMediaRequirement: t.tanMediaRequired,
+                })) ?? []));
+            });
+            let bankingUrl = this.init.bankingUrl;
+            const hikom = response.findSegment(HIKOM.Id);
+            if (hikom) {
+                bankingUrl = hikom?.comParams.address;
+                if (!bankingUrl.toLowerCase().startsWith('https://')) {
+                    bankingUrl = 'https://' + bankingUrl;
+                }
+            }
+            const hipins = response.findSegment(HIPINS.Id);
+            if (!hipins) {
+                throw new Error('Bank does not support PIN/TAN transactions (HIPINS segment not found in BPA)');
+            }
+            const bankTransactions = hipins.params.transactions.map((t) => {
+                return { transId: t.transId, tanRequired: t.tanRequired, versions: [] };
+            });
+            bankTransactions.forEach((transaction) => {
+                if (transaction.transId.startsWith('HK') || transaction.transId.startsWith('DK')) {
+                    const paramSegId = 'HI' + transaction.transId.slice(2) + 'S';
+                    const paramSegments = [
+                        ...response.findAllSegments(paramSegId),
+                        ...response.findAllUnknownSegments(paramSegId),
+                    ];
+                    paramSegments.forEach((paramSegment) => {
+                        if (paramSegment) {
+                            transaction.versions.push(paramSegment.header.version);
+                        }
+                    });
+                }
+            });
+            const bpd = {
+                version: hibpa?.bpdVersion,
+                countryCode: hibpa?.bank.country,
+                bankId: hibpa?.bank.bankId,
+                bankName: hibpa?.bankName,
+                maxTransactionsPerMessage: hibpa?.maxNumTransactions,
+                supportedLanguages: hibpa?.supportedLanguages,
+                supportedHbciVersions: hibpa?.supportedHbciVersions,
+                url: bankingUrl,
+                supportedTanMethods: supportedTanMethods,
+                availableTanMethodIds: [],
+                allowedTransactions: bankTransactions,
+            };
+            this.init.bankingInformation.bpd = bpd;
+        }
+        const tanMethodMessaqe = bankAnswers.find((answer) => answer.code === 3920);
+        let availableTanMethodIds = [];
+        if (tanMethodMessaqe && this.init.bankingInformation.bpd) {
+            this.init.bankingInformation.bpd.availableTanMethodIds =
+                tanMethodMessaqe.params?.map((p) => Number.parseInt(p)) ?? [];
+        }
+        const hiupa = response.findSegment(HIUPA.Id);
+        if (hiupa) {
+            const hiupds = response.findAllSegments(HIUPD.Id);
+            const accounts = hiupds.map((upd) => {
+                return {
+                    accountNumber: upd.account.accountNumber,
+                    subAccountId: upd.account.subAccountId,
+                    bank: upd.account.bank,
+                    iban: upd.iban,
+                    customerId: upd.customerId,
+                    accountType: finTsAccountTypeToEnum(upd.accountType),
+                    currency: upd.currency,
+                    holder1: upd.accountHolder1,
+                    holder2: upd.accountHolder2,
+                    product: upd.accountProduct,
+                    limit: upd.accountLimit,
+                    allowedTransactions: upd.allowedTransactions?.filter((t) => !!t),
+                };
+            });
+            const upd = {
+                version: hiupa.updVersion,
+                usage: hiupa.updUsage,
+                bankAccounts: accounts,
+            };
+            this.init.bankingInformation.upd = upd;
+        }
+        const hikimSegments = response.findAllSegments(HIKIM.Id);
+        const bankMessages = hikimSegments.map((s) => ({ subject: s.subject, text: s.text }));
+        this.init.bankingInformation.bankMessages = bankMessages;
+        clientResponse.bankingInformation = this.init.bankingInformation;
+        clientResponse.bankingInformationUpdated =
+            currentBankingInformationSnapshot !== JSON.stringify(this.init.bankingInformation);
+    }
+}

package/dist/interactions/statementInteraction.js

@@ -0,0 +1,44 @@
+import { CustomerOrderInteraction } from './customerInteraction.js';
+import { HKKAZ } from '../segments/HKKAZ.js';
+import { HIKAZ } from '../segments/HIKAZ.js';
+import { Mt940Parser } from '../mt940parser.js';
+export class StatementInteraction extends CustomerOrderInteraction {
+    accountNumber;
+    from;
+    to;
+    constructor(accountNumber, from, to) {
+        super(HKKAZ.Id, HIKAZ.Id);
+        this.accountNumber = accountNumber;
+        this.from = from;
+        this.to = to;
+    }
+    createSegments(init) {
+        const bankAccount = init.getBankAccount(this.accountNumber);
+        if (!init.isAccountTransactionSupported(this.accountNumber, this.segId)) {
+            throw Error(`Account ${this.accountNumber} does not support business transaction '${this.segId}'`);
+        }
+        const account = { ...bankAccount, iban: undefined };
+        const version = init.getMaxSupportedTransactionVersion(HKKAZ.Id);
+        if (!version) {
+            throw Error(`There is no supported version for business transaction '${HKKAZ.Id}`);
+        }
+        const hkkaz = {
+            header: { segId: HKKAZ.Id, segNr: 0, version: version },
+            account,
+            allAccounts: false,
+            from: this.from,
+            to: this.to,
+        };
+        return [hkkaz];
+    }
+    handleResponse(response, clientResponse) {
+        const hikaz = response.findSegment(HIKAZ.Id);
+        if (hikaz) {
+            const parser = new Mt940Parser(hikaz.bookedTransactions);
+            clientResponse.statements = parser.parse();
+        }
+        else {
+            clientResponse.statements = [];
+        }
+    }
+}

package/dist/interactions/tanMediaInteraction.js

@@ -0,0 +1,27 @@
+import { CustomerOrderInteraction } from './customerInteraction.js';
+import { HKTAB } from '../segments/HKTAB.js';
+import { HITAB } from '../segments/HITAB.js';
+import { TanMediaClass, TanMediaType } from '../codes.js';
+export class TanMediaInteraction extends CustomerOrderInteraction {
+    constructor() {
+        super(HKTAB.Id, HITAB.Id);
+    }
+    createSegments(init) {
+        const version = init.getMaxSupportedTransactionVersion(HKTAB.Id);
+        if (!version) {
+            throw Error(`There is no supported version for business transaction '${HKTAB.Id}`);
+        }
+        const hktab = {
+            header: { segId: HKTAB.Id, segNr: 0, version: version },
+            mediaType: TanMediaType.Active,
+            mediaClass: TanMediaClass.All,
+        };
+        return [hktab];
+    }
+    handleResponse(response, clientResponse) {
+        const hitab = response.findSegment(HITAB.Id);
+        if (hitab) {
+            clientResponse.tanMediaList = hitab.mediaList.map((media) => media.name).filter((name) => name);
+        }
+    }
+}

package/dist/message.js

@@ -0,0 +1,198 @@
+import { HashAlgorithm } from './codes.js';
+import { splitBySeparator } from './parser.js';
+import { HNHBS } from './segments/HNHBS.js';
+import { HNHBK } from './segments/HNHBK.js';
+import { HNVSK } from './segments/HNVSK.js';
+import { HNSHK } from './segments/HNSHK.js';
+import { HNVSD } from './segments/HNVSD.js';
+import { HNSHA } from './segments/HNSHA.js';
+import { HIRMS } from './segments/HIRMS.js';
+import { HIRMG } from './segments/HIRMG.js';
+import { UnkownId } from './unknownSegment.js';
+import { decode, encode, segmentToString } from './segment.js';
+import { SegmentDefinition } from './segmentDefinition.js';
+import { PARTED } from './partedSegment.js';
+import { getSegmentDefinition } from './segments/registry.js';
+export class Message {
+    segments;
+    constructor(segments) {
+        this.segments = segments;
+    }
+    findSegment(segmentId) {
+        const segments = this.findAllSegments(segmentId);
+        return segments.length > 0 ? segments[0] : undefined;
+    }
+    findAllSegments(segmentId) {
+        return this.segments.filter((segment) => segment.header.segId === segmentId);
+    }
+    findAllUnknownSegments(segmentId) {
+        const unknownSegments = this.segments.filter((segment) => segment.header.segId === UnkownId);
+        return unknownSegments.filter((segment) => segment.originalId === segmentId);
+    }
+    hasReturnCode(code) {
+        const hirmg = this.findSegment(HIRMG.Id);
+        const hirmsList = this.findAllSegments(HIRMS.Id);
+        return ((hirmg && hirmg.answers.some((answer) => answer.code === code)) ||
+            hirmsList.some((hirms) => hirms.answers.some((answer) => answer.code === code)));
+    }
+    getHighestReturnCode() {
+        const hirmg = this.findSegment(HIRMG.Id);
+        const hirmsList = this.findAllSegments(HIRMS.Id);
+        const allAnswers = hirmg ? [...hirmg.answers] : [];
+        hirmsList.forEach((hirms) => allAnswers.push(...hirms.answers));
+        return allAnswers.reduce((max, answer) => (answer.code > max ? answer.code : max), 0);
+    }
+    getBankAnswers() {
+        let bankAnswers = [];
+        const hirmgSegments = this.findAllSegments(HIRMG.Id);
+        hirmgSegments.forEach((hirmg) => bankAnswers.push(...hirmg.answers.map((message) => ({ code: message.code, text: message.text, params: message.params }))));
+        const hirmsSegments = this.findAllSegments(HIRMS.Id);
+        hirmsSegments.forEach((hirms) => bankAnswers.push(...hirms.answers.map((message) => ({ code: message.code, text: message.text, params: message.params }))));
+        return bankAnswers;
+    }
+    static decode(text, partedResponseSegId) {
+        const segmentTexts = splitBySeparator(text, "'").filter((text) => !!text);
+        let segments = segmentTexts.map((text) => Message.decodeSegment(text, partedResponseSegId));
+        const hnvskIndex = segments.findIndex((segment) => segment.header.segId === HNVSK.Id);
+        const hnvsdIndex = segments.findIndex((segment) => segment.header.segId === HNVSD.Id);
+        const isEncrypted = hnvskIndex !== -1 && hnvsdIndex !== -1 && hnvsdIndex - hnvskIndex === 1;
+        if (isEncrypted) {
+            const hnvsd = segments[hnvsdIndex];
+            const hnvsdSegmentTexts = splitBySeparator(hnvsd.encryptedData, "'").filter((text) => !!text);
+            const hnvsdSegments = hnvsdSegmentTexts.map((text) => Message.decodeSegment(text, partedResponseSegId));
+            segments.splice(hnvskIndex, 2, ...hnvsdSegments);
+        }
+        const message = new Message(segments);
+        return message;
+    }
+    static decodeSegment(text, partedResponseSegId) {
+        if (partedResponseSegId && text.startsWith(partedResponseSegId)) {
+            const partedSegment = {
+                header: { ...SegmentDefinition.header.decode(text, 1), segId: PARTED.Id },
+                originalId: partedResponseSegId,
+                rawData: text,
+            };
+            return partedSegment;
+        }
+        return decode(text);
+    }
+    toString(includeUnknown = false) {
+        let text = `Message with ${this.segments.length} segments:\n`;
+        text += this.segments
+            .filter((segment) => includeUnknown || segment.header.segId !== UnkownId)
+            .map((segment) => segmentToString(segment))
+            .join('\n');
+        return text;
+    }
+}
+export class CustomerMessage extends Message {
+    lastSignatureNumber = 0;
+    constructor(dialogId = '0', msgNr = 1) {
+        const hnhbk = {
+            header: { segId: HNHBK.Id, segNr: 0, version: HNHBK.Version },
+            messageLength: 0,
+            hbciVersion: 300,
+            dialogId: dialogId,
+            msgNr: msgNr,
+        };
+        const hnhbs = {
+            header: { segId: HNHBS.Id, segNr: 0, version: HNHBS.Version },
+            msgNr: msgNr,
+        };
+        super([hnhbk, hnhbs]);
+    }
+    encode() {
+        if (this.segments.length < 3) {
+            throw new Error('a message must contain at least three segments');
+        }
+        if (this.segments[0].header.segId !== HNHBK.Id) {
+            throw new Error('the first segment in a message must always be of type HNHBK');
+        }
+        if (this.segments[this.segments.length - 1].header.segId !== HNHBS.Id) {
+            throw new Error('the last segment in a message must always be of type HNHBS');
+        }
+        let segmentNumber = 1;
+        this.segments.forEach((segment) => {
+            segment.header.segNr = segmentNumber++;
+        });
+        let segments = this.segments;
+        if (this.lastSignatureNumber > 0) {
+            const firstSignature = this.findSegment(HNSHK.Id);
+            const now = new Date();
+            const hnvsk = {
+                header: { segId: HNVSK.Id, segNr: 998, version: HNVSK.Version },
+                secProfile: { secMethod: 'PIN', secVersion: 1 },
+                secFunc: 998,
+                secRole: 1,
+                secId: { partyType: 1, partyId: firstSignature.secId.partyId },
+                dateTime: { type: 1, date: now, time: now },
+                encryption: { use: 2, mode: 2, algorithm: 13, keyParamValue: '00000000', keyParamName: 5, initParamName: 1 },
+                key: {
+                    bank: firstSignature.key.bank,
+                    userId: firstSignature.key.userId,
+                    keyType: 'S',
+                    keyNr: 0,
+                    keyVersion: 0,
+                },
+                compressMethod: 0,
+            };
+            const innerSegments = segments.slice(1, -1);
+            const hnvsd = {
+                header: { segId: HNVSD.Id, segNr: 999, version: HNVSD.Version },
+                encryptedData: innerSegments.map((segment) => encode(segment)).join(''),
+            };
+            segments = [this.segments[0], hnvsk, hnvsd, this.segments[this.segments.length - 1]];
+        }
+        const encodedMessage = segments.map((segment) => encode(segment)).join('');
+        const messageHeader = segments[0];
+        messageHeader.messageLength = encodedMessage.length;
+        const encodedHeader = encode(messageHeader);
+        return encodedHeader + encodedMessage.substring(encodedHeader.length);
+    }
+    sign(countryCode, bankId, userId, pin, systemId, tanMethodId, tan) {
+        const now = new Date();
+        this.lastSignatureNumber++;
+        const hnshk = {
+            header: { segId: HNSHK.Id, segNr: 0, version: HNSHK.Version },
+            secProfile: { secMethod: 'PIN', secVersion: tanMethodId ? 2 : 1 },
+            secFunc: tanMethodId ?? 999,
+            secControlRef: this.lastSignatureNumber.toString(),
+            secArea: 1,
+            secRole: 1,
+            secId: { partyType: 1, partyId: systemId ?? '0' },
+            secRefNum: 1,
+            dateTime: { type: 1, date: now, time: now },
+            hash: { use: 1, algorithm: HashAlgorithm.SHA256, paramName: 1 },
+            signature: { use: 6, algorithm: 10, mode: 16 },
+            key: { bank: { country: countryCode, bankId: bankId }, userId: userId, keyType: 'S', keyNr: 0, keyVersion: 0 },
+        };
+        this.segments.splice(1, 0, hnshk);
+        const pinTan = { pin: pin, tan: tan };
+        const hnsha = {
+            header: { segId: HNSHA.Id, segNr: 0, version: HNSHA.Version },
+            secControlRef: this.lastSignatureNumber.toString(),
+            customSignature: pinTan,
+        };
+        this.segments.splice(this.segments.length - 1, 0, hnsha);
+    }
+    addSegment(segment) {
+        let firstSignatureEndIndex = this.segments.findIndex((segment) => segment.header.segId === HNSHA.Id);
+        if (firstSignatureEndIndex === -1) {
+            firstSignatureEndIndex = this.segments.length - 1;
+        }
+        this.segments.splice(firstSignatureEndIndex, 0, segment);
+    }
+}
+export class CustomerOrderMessage extends CustomerMessage {
+    orderSegId;
+    orderResponseSegId;
+    constructor(orderSegId, orderResponseSegId, dialogId = '0', msgNr = 1) {
+        super(dialogId, msgNr);
+        this.orderSegId = orderSegId;
+        this.orderResponseSegId = orderResponseSegId;
+    }
+    get supportsPartedResponseSegments() {
+        const definition = getSegmentDefinition(this.orderSegId);
+        return definition?.elements.some((element) => element.name === 'continuationMark') ?? false;
+    }
+}