bkper-js 2.28.0 → 2.29.0

package/lib/builders/GroupsDataTableBuilder.js

@@ -0,0 +1,193 @@
+import { AccountType } from '../model/Enums.js';
+import { convertInMatrix } from '../utils.js';
+/**
+ * A GroupsDataTableBuilder is used to setup and build two-dimensional arrays containing groups.
+ *
+ * @public
+ */
+export class GroupsDataTableBuilder {
+    constructor(groups) {
+        this.COMPARATOR = (g1, g2) => {
+            let ret = this.getTypeIndex(this.getStringType(g1)) - this.getTypeIndex(this.getStringType(g2));
+            if (ret === 0) {
+                ret =
+                    this.getHasChildrenIndex(g1.hasChildren()) -
+                        this.getHasChildrenIndex(g2.hasChildren());
+            }
+            if (ret === 0) {
+                ret = g1.getNormalizedName().localeCompare(g2.getNormalizedName());
+            }
+            return ret;
+        };
+        this.groups = groups;
+        this.shouldAddProperties = false;
+        this.shouldAddIds = false;
+        this.shouldAddHiddenProperties = false;
+        this.shouldShowTree = false;
+        this.propertyKeys = [];
+    }
+    /**
+     * Defines whether include custom group properties.
+     *
+     * @param include - Whether to include properties
+     *
+     * @returns This builder with respective include properties option, for chaining.
+     */
+    properties(include) {
+        this.shouldAddProperties = include;
+        return this;
+    }
+    /**
+     * Defines whether include group ids.
+     *
+     * @param include - Whether to include ids
+     *
+     * @returns This builder with respective include ids option, for chaining.
+     */
+    ids(include) {
+        this.shouldAddIds = include;
+        return this;
+    }
+    /**
+     * Defines whether to include hidden properties (keys ending with underscore "_").
+     * Only relevant when {@link properties} is enabled.
+     * Default is false — hidden properties are excluded.
+     *
+     * @param include - Whether to include hidden properties
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    hiddenProperties(include) {
+        this.shouldAddHiddenProperties = include;
+        return this;
+    }
+    /**
+     * Defines whether to render groups as an indented tree instead of flat rows with a Parent column.
+     * When enabled, child group names are indented by depth level and the Parent column is removed.
+     * Default is false.
+     *
+     * @param enable - Whether to enable tree rendering
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    tree(enable) {
+        this.shouldShowTree = enable;
+        return this;
+    }
+    mapPropertyKeys() {
+        this.propertyKeys = [];
+        for (const group of this.groups) {
+            for (const key of group.getPropertyKeys()) {
+                if (!this.shouldAddHiddenProperties && key.endsWith('_')) {
+                    continue;
+                }
+                if (this.propertyKeys.indexOf(key) <= -1) {
+                    this.propertyKeys.push(key);
+                }
+            }
+        }
+        this.propertyKeys = this.propertyKeys.sort();
+    }
+    getStringType(group) {
+        let groupType = group.getType() ? group.getType() + '' : undefined;
+        if (!groupType) {
+            groupType = group.isPermanent()
+                ? AccountType.ASSET + '_' + AccountType.LIABILITY
+                : AccountType.INCOMING + '_' + AccountType.OUTGOING;
+        }
+        return groupType;
+    }
+    getTypeIndex(type) {
+        if (type === AccountType.ASSET + '_' + AccountType.LIABILITY) {
+            return 0;
+        }
+        if (type === AccountType.ASSET) {
+            return 1;
+        }
+        if (type === AccountType.LIABILITY) {
+            return 2;
+        }
+        if (type === AccountType.INCOMING + '_' + AccountType.OUTGOING) {
+            return 3;
+        }
+        if (type === AccountType.INCOMING) {
+            return 4;
+        }
+        return 5;
+    }
+    getHasChildrenIndex(hasChildren) {
+        return hasChildren ? 0 : 1;
+    }
+    /**
+     * Builds a two-dimensional array containing all Groups.
+     *
+     * @returns A two-dimensional array containing all Groups
+     */
+    build() {
+        let table = new Array();
+        const groups = this.groups;
+        groups.sort(this.COMPARATOR);
+        let headers = [];
+        if (this.shouldAddIds) {
+            headers.push('Group Id');
+        }
+        headers.push('Name');
+        headers.push('Type');
+        if (!this.shouldShowTree) {
+            headers.push('Parent');
+        }
+        if (this.shouldAddProperties) {
+            this.mapPropertyKeys();
+        }
+        for (const group of groups) {
+            if (group.isHidden() || group.getParent()) {
+                continue;
+            }
+            table.push(this.buildGroupLine(group, 0));
+            table = this.traverse(group, table, 1);
+        }
+        if (this.shouldAddProperties) {
+            headers = headers.concat(this.propertyKeys);
+        }
+        table.unshift(headers);
+        convertInMatrix(table);
+        return table;
+    }
+    buildGroupLine(group, depth) {
+        const line = [];
+        if (this.shouldAddIds) {
+            line.push(group.getId());
+        }
+        const name = this.shouldShowTree ? '  '.repeat(depth) + group.getName() : group.getName();
+        line.push(name);
+        line.push(this.getStringType(group));
+        if (!this.shouldShowTree) {
+            const parentName = group.getParent() ? group.getParent().getName() : '';
+            line.push(parentName);
+        }
+        if (this.shouldAddProperties) {
+            const properties = group.getProperties();
+            for (const key of this.propertyKeys) {
+                const propertyValue = properties[key];
+                if (propertyValue) {
+                    line.push(propertyValue);
+                    continue;
+                }
+                line.push('');
+            }
+        }
+        return line;
+    }
+    traverse(group, table, depth) {
+        const children = group.getChildren();
+        children.sort(this.COMPARATOR);
+        for (const child of children) {
+            table.push(this.buildGroupLine(child, depth));
+            if (child.hasChildren()) {
+                this.traverse(child, table, depth + 1);
+            }
+        }
+        return table;
+    }
+}
+//# sourceMappingURL=GroupsDataTableBuilder.js.map

package/lib/builders/TransactionsDataTableBuilder.js

@@ -0,0 +1,359 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { convertInMatrix, formatValue, getRepresentativeValue } from '../utils.js';
+/**
+ * A TransactionsDataTableBuilder is used to setup and build two-dimensional arrays containing transactions.
+ *
+ * @public
+ */
+export class TransactionsDataTableBuilder {
+    constructor(book, transactions, account) {
+        this.shouldFormatDates = false;
+        this.shouldFormatValues = false;
+        this.shouldAddUrls = false;
+        this.shouldAddProperties = false;
+        this.shouldAddIds = false;
+        this.shouldAddRecordedAt = true;
+        this.shouldAddHiddenProperties = false;
+        this.book = book;
+        this.transactions = transactions;
+        this.account = account;
+    }
+    /**
+     * Defines whether the dates should be formatted, based on date pattern of the [[Book]].
+     *
+     * @param format - Whether to format dates
+     *
+     * @returns This builder with respective formatting option, for chaining.
+     */
+    formatDates(format) {
+        this.shouldFormatDates = format;
+        return this;
+    }
+    /**
+     * Defines whether amounts should be formatted based on [[DecimalSeparator]] of the [[Book]].
+     *
+     * @param format - Whether to format values
+     *
+     * @returns This builder with respective formatting option, for chaining.
+     */
+    formatValues(format) {
+        this.shouldFormatValues = format;
+        return this;
+    }
+    /**
+     * Defines whether to include attachments and url links.
+     *
+     * @param include - Whether to include URLs
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    urls(include) {
+        this.shouldAddUrls = include;
+        return this;
+    }
+    /**
+     * Defines whether to include custom transaction properties.
+     *
+     * @param include - Whether to include properties
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    properties(include) {
+        this.shouldAddProperties = include;
+        return this;
+    }
+    /**
+     * Defines whether to include transaction ids and remote ids.
+     *
+     * @param include - Whether to include ids
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    ids(include) {
+        this.shouldAddIds = include;
+        return this;
+    }
+    /**
+     * Defines whether to include the "Recorded at" column.
+     *
+     * @param include - Whether to include the recorded at column
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    recordedAt(include) {
+        this.shouldAddRecordedAt = include;
+        return this;
+    }
+    /**
+     * Defines whether to include hidden properties (keys ending with underscore "_").
+     * Only relevant when {@link properties} is enabled.
+     * Default is false — hidden properties are excluded.
+     *
+     * @param include - Whether to include hidden properties
+     *
+     * @returns This builder with respective option, for chaining.
+     */
+    hiddenProperties(include) {
+        this.shouldAddHiddenProperties = include;
+        return this;
+    }
+    /**
+     * @deprecated Use {@link urls} instead.
+     */
+    includeUrls(include) {
+        return this.urls(include);
+    }
+    /**
+     * @deprecated Use {@link properties} instead.
+     */
+    includeProperties(include) {
+        return this.properties(include);
+    }
+    /**
+     * @deprecated Use {@link ids} instead.
+     */
+    includeIds(include) {
+        return this.ids(include);
+    }
+    /**
+     * Gets the account used to filter transactions, when applicable.
+     *
+     * @returns The account, when filtering by a single account.
+     */
+    getAccount() {
+        return this.account;
+    }
+    /**
+     * Builds a two-dimensional array containing all transactions.
+     *
+     * @returns A promise resolving to a two-dimensional array containing all transactions
+     */
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headerLine = this.getHeaderLine();
+            const dataTable = yield this.get2DArray_();
+            if (dataTable.length > 0) {
+                dataTable.splice(0, 0, headerLine);
+                convertInMatrix(dataTable);
+                return dataTable;
+            }
+            else {
+                return [headerLine];
+            }
+        });
+    }
+    getHeaderLine() {
+        const headerLine = [];
+        if (this.shouldAddIds) {
+            headerLine.push('Transaction Id');
+        }
+        headerLine.push('Status');
+        headerLine.push('Date');
+        headerLine.push('Origin');
+        headerLine.push('Destination');
+        headerLine.push('Description');
+        headerLine.push('Amount');
+        if (this.shouldShowBalances()) {
+            headerLine.push('Balance');
+        }
+        if (this.shouldAddRecordedAt) {
+            headerLine.push('Recorded at');
+        }
+        if (this.shouldAddProperties) {
+            for (const key of this.getPropertyKeys()) {
+                headerLine.push(key);
+            }
+        }
+        if (this.shouldAddIds) {
+            for (const remoteIdHeader of this.getRemoteIdHeaders()) {
+                headerLine.push(remoteIdHeader);
+            }
+        }
+        if (this.shouldAddUrls) {
+            for (const attachmentHeader of this.getAttachmentHeaders()) {
+                headerLine.push(attachmentHeader);
+            }
+        }
+        return headerLine;
+    }
+    get2DArray_() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataTable = [];
+            for (const transaction of this.transactions) {
+                const line = [];
+                if (this.shouldAddIds) {
+                    line.push(transaction.getId());
+                }
+                line.push(transaction.getStatus());
+                if (this.shouldFormatDates) {
+                    line.push(transaction.getDateFormatted());
+                }
+                else {
+                    line.push(transaction.getDateObject());
+                }
+                line.push(yield transaction.getCreditAccountName());
+                line.push(yield transaction.getDebitAccountName());
+                line.push(transaction.getDescription());
+                let amount = transaction.getAmount();
+                if (amount != null) {
+                    if (this.shouldShowBalances() && this.account) {
+                        const isCreditOnTx = yield this.isCreditOnTransaction_(transaction, this.account);
+                        amount = getRepresentativeValue(amount, !isCreditOnTx);
+                    }
+                    if (this.shouldFormatValues) {
+                        line.push(formatValue(amount, this.book.getDecimalSeparator(), this.book.getFractionDigits()));
+                    }
+                    else {
+                        line.push(amount.toNumber());
+                    }
+                }
+                else {
+                    line.push('');
+                }
+                if (this.shouldShowBalances()) {
+                    const accountBalance = yield transaction.getAccountBalance();
+                    if (accountBalance != null) {
+                        if (this.shouldFormatValues) {
+                            line.push(formatValue(accountBalance, this.book.getDecimalSeparator(), this.book.getFractionDigits()));
+                        }
+                        else {
+                            line.push(accountBalance.toNumber());
+                        }
+                    }
+                    else {
+                        line.push('');
+                    }
+                }
+                if (this.shouldAddRecordedAt) {
+                    if (this.shouldFormatDates) {
+                        line.push(transaction.getCreatedAtFormatted());
+                    }
+                    else {
+                        line.push(transaction.getCreatedAt());
+                    }
+                }
+                if (this.shouldAddProperties) {
+                    this.addPropertiesToLine(line, transaction);
+                }
+                if (this.shouldAddIds) {
+                    this.addRemoteIdsToLine(line, transaction);
+                }
+                if (this.shouldAddUrls) {
+                    this.addUrlsToLine(line, transaction);
+                }
+                dataTable.push(line);
+            }
+            return dataTable;
+        });
+    }
+    shouldShowBalances() {
+        return this.account != null && this.account.isPermanent() === true;
+    }
+    isCreditOnTransaction_(transaction, account) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const creditAccount = yield transaction.getCreditAccount();
+            if (account == null || creditAccount == null) {
+                return false;
+            }
+            return creditAccount.getId() === account.getId();
+        });
+    }
+    getPropertyKeys() {
+        if (this.propertyKeys == null) {
+            this.propertyKeys = [];
+            for (const transaction of this.transactions) {
+                for (const key of transaction.getPropertyKeys()) {
+                    if (!this.shouldAddHiddenProperties && key.endsWith('_')) {
+                        continue;
+                    }
+                    if (this.propertyKeys.indexOf(key) <= -1) {
+                        this.propertyKeys.push(key);
+                    }
+                }
+            }
+            this.propertyKeys = this.propertyKeys.sort();
+        }
+        return this.propertyKeys;
+    }
+    getAttachmentHeaders() {
+        if (this.attachmentHeaders == null) {
+            this.attachmentHeaders = [];
+            for (const transaction of this.transactions) {
+                const urls = this.getUrls(transaction);
+                if (urls.length > this.attachmentHeaders.length) {
+                    this.attachmentHeaders = [];
+                    urls.forEach(() => this.attachmentHeaders.push('Attachment'));
+                }
+            }
+        }
+        return this.attachmentHeaders;
+    }
+    getRemoteIdHeaders() {
+        if (this.remoteIdHeaders == null) {
+            this.remoteIdHeaders = [];
+            for (const transaction of this.transactions) {
+                const remoteIds = transaction.getRemoteIds();
+                if (remoteIds && remoteIds.length > this.remoteIdHeaders.length) {
+                    this.remoteIdHeaders = [];
+                    remoteIds.forEach(() => this.remoteIdHeaders.push('Remote Id'));
+                }
+            }
+        }
+        return this.remoteIdHeaders;
+    }
+    addPropertiesToLine(line, transaction) {
+        const lineLength = line.length;
+        for (const key of this.getPropertyKeys()) {
+            line.push('');
+        }
+        for (const key of transaction.getPropertyKeys()) {
+            if (!this.shouldAddHiddenProperties && key.endsWith('_')) {
+                continue;
+            }
+            const index = this.getPropertyKeys().indexOf(key) + lineLength;
+            line[index] = transaction.getProperty(key);
+        }
+    }
+    addRemoteIdsToLine(line, transaction) {
+        const lineLength = line.length;
+        for (const key of this.getRemoteIdHeaders()) {
+            line.push('');
+        }
+        const remoteIds = transaction.getRemoteIds();
+        if (remoteIds) {
+            for (let index = lineLength; index < lineLength + remoteIds.length; index++) {
+                line[index] = remoteIds[index - lineLength];
+            }
+        }
+    }
+    addUrlsToLine(line, transaction) {
+        const lineLength = line.length;
+        for (const key of this.getAttachmentHeaders()) {
+            line.push('');
+        }
+        const urls = this.getUrls(transaction);
+        for (let index = lineLength; index < lineLength + urls.length; index++) {
+            line[index] = urls[index - lineLength];
+        }
+    }
+    getUrls(transaction) {
+        let urls = transaction.getUrls();
+        if (urls == null) {
+            urls = [];
+        }
+        const files = transaction.getFiles();
+        if (files != null) {
+            urls = urls.concat(files.map(f => f.getUrl()).filter((url) => url != null));
+        }
+        return urls;
+    }
+}
+//# sourceMappingURL=TransactionsDataTableBuilder.js.map