@fin.cx/skr 1.0.0

package/dist_ts/skr.classes.reports.js

@@ -0,0 +1,514 @@
+import * as plugins from './plugins.js';
+import { Account } from './skr.classes.account.js';
+import { Transaction } from './skr.classes.transaction.js';
+import { Ledger } from './skr.classes.ledger.js';
+export class Reports {
+    constructor(skrType) {
+        this.skrType = skrType;
+        this.logger = new plugins.smartlog.Smartlog({
+            logContext: {
+                company: 'fin.cx',
+                companyunit: 'skr',
+                containerName: 'Reports',
+                environment: 'local',
+                runtime: 'node',
+                zone: 'local',
+            },
+        });
+        this.ledger = new Ledger(skrType);
+    }
+    /**
+     * Generate Trial Balance
+     */
+    async getTrialBalance(params) {
+        this.logger.log('info', 'Generating trial balance');
+        const accounts = await Account.getInstances({
+            skrType: this.skrType,
+            isActive: true,
+        });
+        const entries = [];
+        let totalDebits = 0;
+        let totalCredits = 0;
+        for (const account of accounts) {
+            // Get balance for the period if specified
+            const balance = params?.dateTo
+                ? await this.ledger.getAccountBalance(account.accountNumber, params.dateTo)
+                : await this.ledger.getAccountBalance(account.accountNumber);
+            if (balance.debitTotal !== 0 || balance.creditTotal !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    debitBalance: balance.debitTotal,
+                    creditBalance: balance.creditTotal,
+                    netBalance: balance.balance,
+                };
+                entries.push(entry);
+                totalDebits += balance.debitTotal;
+                totalCredits += balance.creditTotal;
+            }
+        }
+        // Sort entries by account number
+        entries.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        const report = {
+            date: params?.dateTo || new Date(),
+            skrType: this.skrType,
+            entries,
+            totalDebits,
+            totalCredits,
+            isBalanced: Math.abs(totalDebits - totalCredits) < 0.01,
+        };
+        this.logger.log('info', `Trial balance generated with ${entries.length} accounts`);
+        return report;
+    }
+    /**
+     * Generate Income Statement (P&L)
+     */
+    async getIncomeStatement(params) {
+        this.logger.log('info', 'Generating income statement');
+        // Get revenue accounts
+        const revenueAccounts = await Account.getAccountsByType('revenue', this.skrType);
+        const expenseAccounts = await Account.getAccountsByType('expense', this.skrType);
+        const revenueEntries = [];
+        const expenseEntries = [];
+        let totalRevenue = 0;
+        let totalExpenses = 0;
+        // Process revenue accounts
+        for (const account of revenueAccounts) {
+            const balance = await this.getAccountBalanceForPeriod(account, params);
+            if (balance !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    amount: Math.abs(balance),
+                };
+                revenueEntries.push(entry);
+                totalRevenue += Math.abs(balance);
+            }
+        }
+        // Process expense accounts
+        for (const account of expenseAccounts) {
+            const balance = await this.getAccountBalanceForPeriod(account, params);
+            if (balance !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    amount: Math.abs(balance),
+                };
+                expenseEntries.push(entry);
+                totalExpenses += Math.abs(balance);
+            }
+        }
+        // Calculate percentages
+        revenueEntries.forEach((entry) => {
+            entry.percentage =
+                totalRevenue > 0 ? (entry.amount / totalRevenue) * 100 : 0;
+        });
+        expenseEntries.forEach((entry) => {
+            entry.percentage =
+                totalRevenue > 0 ? (entry.amount / totalRevenue) * 100 : 0;
+        });
+        // Sort entries by account number
+        revenueEntries.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        expenseEntries.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        const report = {
+            date: params?.dateTo || new Date(),
+            skrType: this.skrType,
+            revenue: revenueEntries,
+            expenses: expenseEntries,
+            totalRevenue,
+            totalExpenses,
+            netIncome: totalRevenue - totalExpenses,
+        };
+        this.logger.log('info', `Income statement generated: Revenue ${totalRevenue}, Expenses ${totalExpenses}`);
+        return report;
+    }
+    /**
+     * Generate Balance Sheet
+     */
+    async getBalanceSheet(params) {
+        this.logger.log('info', 'Generating balance sheet');
+        // Get accounts by type
+        const assetAccounts = await Account.getAccountsByType('asset', this.skrType);
+        const liabilityAccounts = await Account.getAccountsByType('liability', this.skrType);
+        const equityAccounts = await Account.getAccountsByType('equity', this.skrType);
+        // Process assets
+        const currentAssets = [];
+        const fixedAssets = [];
+        let totalAssets = 0;
+        for (const account of assetAccounts) {
+            const balance = await this.getAccountBalanceForPeriod(account, params);
+            if (balance !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    amount: Math.abs(balance),
+                };
+                // Classify as current or fixed based on account class
+                if (account.accountClass === 1) {
+                    currentAssets.push(entry);
+                }
+                else {
+                    fixedAssets.push(entry);
+                }
+                totalAssets += Math.abs(balance);
+            }
+        }
+        // Process liabilities
+        const currentLiabilities = [];
+        const longTermLiabilities = [];
+        let totalLiabilities = 0;
+        for (const account of liabilityAccounts) {
+            const balance = await this.getAccountBalanceForPeriod(account, params);
+            if (balance !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    amount: Math.abs(balance),
+                };
+                // Classify as current or long-term based on account number
+                if (account.accountNumber.startsWith('16') ||
+                    account.accountNumber.startsWith('17')) {
+                    currentLiabilities.push(entry);
+                }
+                else {
+                    longTermLiabilities.push(entry);
+                }
+                totalLiabilities += Math.abs(balance);
+            }
+        }
+        // Process equity
+        const equityEntries = [];
+        let totalEquity = 0;
+        for (const account of equityAccounts) {
+            const balance = await this.getAccountBalanceForPeriod(account, params);
+            if (balance !== 0) {
+                const entry = {
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    amount: Math.abs(balance),
+                };
+                equityEntries.push(entry);
+                totalEquity += Math.abs(balance);
+            }
+        }
+        // Add current year profit/loss
+        const incomeStatement = await this.getIncomeStatement(params);
+        if (incomeStatement.netIncome !== 0) {
+            equityEntries.push({
+                accountNumber: '9999',
+                accountName: 'Current Year Profit/Loss',
+                amount: Math.abs(incomeStatement.netIncome),
+            });
+            totalEquity += Math.abs(incomeStatement.netIncome);
+        }
+        // Sort entries
+        currentAssets.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        fixedAssets.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        currentLiabilities.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        longTermLiabilities.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        equityEntries.sort((a, b) => a.accountNumber.localeCompare(b.accountNumber));
+        const report = {
+            date: params?.dateTo || new Date(),
+            skrType: this.skrType,
+            assets: {
+                current: currentAssets,
+                fixed: fixedAssets,
+                totalAssets,
+            },
+            liabilities: {
+                current: currentLiabilities,
+                longTerm: longTermLiabilities,
+                totalLiabilities,
+            },
+            equity: {
+                entries: equityEntries,
+                totalEquity,
+            },
+            isBalanced: Math.abs(totalAssets - (totalLiabilities + totalEquity)) < 0.01,
+        };
+        this.logger.log('info', `Balance sheet generated: Assets ${totalAssets}, Liabilities ${totalLiabilities}, Equity ${totalEquity}`);
+        return report;
+    }
+    /**
+     * Get account balance for a specific period
+     */
+    async getAccountBalanceForPeriod(account, params) {
+        let transactions = await Transaction.getTransactionsByAccount(account.accountNumber, this.skrType);
+        // Apply date filter if provided
+        if (params?.dateFrom || params?.dateTo) {
+            transactions = transactions.filter((transaction) => {
+                if (params.dateFrom && transaction.date < params.dateFrom)
+                    return false;
+                if (params.dateTo && transaction.date > params.dateTo)
+                    return false;
+                return true;
+            });
+        }
+        let debitTotal = 0;
+        let creditTotal = 0;
+        for (const transaction of transactions) {
+            if (transaction.debitAccount === account.accountNumber) {
+                debitTotal += transaction.amount;
+            }
+            if (transaction.creditAccount === account.accountNumber) {
+                creditTotal += transaction.amount;
+            }
+        }
+        // Calculate net balance based on account type
+        switch (account.accountType) {
+            case 'asset':
+            case 'expense':
+                return debitTotal - creditTotal;
+            case 'liability':
+            case 'equity':
+            case 'revenue':
+                return creditTotal - debitTotal;
+        }
+    }
+    /**
+     * Generate General Ledger report
+     */
+    async getGeneralLedger(params) {
+        this.logger.log('info', 'Generating general ledger');
+        const accounts = await Account.getInstances({
+            skrType: this.skrType,
+            isActive: true,
+        });
+        const ledgerEntries = [];
+        for (const account of accounts) {
+            const transactions = await this.getAccountTransactions(account.accountNumber, params);
+            if (transactions.length > 0) {
+                let runningBalance = 0;
+                const accountEntries = [];
+                for (const transaction of transactions) {
+                    const isDebit = transaction.debitAccount === account.accountNumber;
+                    const amount = transaction.amount;
+                    // Update running balance based on account type
+                    if (account.accountType === 'asset' ||
+                        account.accountType === 'expense') {
+                        runningBalance += isDebit ? amount : -amount;
+                    }
+                    else {
+                        runningBalance += isDebit ? -amount : amount;
+                    }
+                    accountEntries.push({
+                        date: transaction.date,
+                        reference: transaction.reference,
+                        description: transaction.description,
+                        debit: isDebit ? amount : 0,
+                        credit: !isDebit ? amount : 0,
+                        balance: runningBalance,
+                    });
+                }
+                ledgerEntries.push({
+                    accountNumber: account.accountNumber,
+                    accountName: account.accountName,
+                    accountType: account.accountType,
+                    entries: accountEntries,
+                    finalBalance: runningBalance,
+                });
+            }
+        }
+        return {
+            date: params?.dateTo || new Date(),
+            skrType: this.skrType,
+            accounts: ledgerEntries,
+        };
+    }
+    /**
+     * Get account transactions for reporting
+     */
+    async getAccountTransactions(accountNumber, params) {
+        let transactions = await Transaction.getTransactionsByAccount(accountNumber, this.skrType);
+        // Apply date filter
+        if (params?.dateFrom || params?.dateTo) {
+            transactions = transactions.filter((transaction) => {
+                if (params.dateFrom && transaction.date < params.dateFrom)
+                    return false;
+                if (params.dateTo && transaction.date > params.dateTo)
+                    return false;
+                return true;
+            });
+        }
+        // Sort by date
+        transactions.sort((a, b) => a.date.getTime() - b.date.getTime());
+        return transactions;
+    }
+    /**
+     * Generate Cash Flow Statement
+     */
+    async getCashFlowStatement(params) {
+        this.logger.log('info', 'Generating cash flow statement');
+        // Get cash and bank accounts
+        const cashAccounts = ['1000', '1100', '1200', '1210']; // Standard cash/bank accounts
+        let operatingCashFlow = 0;
+        let investingCashFlow = 0;
+        let financingCashFlow = 0;
+        for (const accountNumber of cashAccounts) {
+            const account = await Account.getAccountByNumber(accountNumber, this.skrType);
+            if (!account)
+                continue;
+            const transactions = await this.getAccountTransactions(accountNumber, params);
+            for (const transaction of transactions) {
+                const otherAccount = transaction.debitAccount === accountNumber
+                    ? transaction.creditAccount
+                    : transaction.debitAccount;
+                const otherAccountObj = await Account.getAccountByNumber(otherAccount, this.skrType);
+                if (!otherAccountObj)
+                    continue;
+                const amount = transaction.debitAccount === accountNumber
+                    ? transaction.amount
+                    : -transaction.amount;
+                // Classify cash flow
+                if (otherAccountObj.accountType === 'revenue' ||
+                    otherAccountObj.accountType === 'expense') {
+                    operatingCashFlow += amount;
+                }
+                else if (otherAccountObj.accountClass === 0) {
+                    // Fixed assets
+                    investingCashFlow += amount;
+                }
+                else if (otherAccountObj.accountType === 'liability' ||
+                    otherAccountObj.accountType === 'equity') {
+                    financingCashFlow += amount;
+                }
+            }
+        }
+        return {
+            date: params?.dateTo || new Date(),
+            skrType: this.skrType,
+            operatingActivities: operatingCashFlow,
+            investingActivities: investingCashFlow,
+            financingActivities: financingCashFlow,
+            netCashFlow: operatingCashFlow + investingCashFlow + financingCashFlow,
+        };
+    }
+    /**
+     * Export report to CSV format
+     */
+    async exportToCSV(reportType, params) {
+        let csvContent = '';
+        switch (reportType) {
+            case 'trial_balance':
+                const trialBalance = await this.getTrialBalance(params);
+                csvContent = this.trialBalanceToCSV(trialBalance);
+                break;
+            case 'income_statement':
+                const incomeStatement = await this.getIncomeStatement(params);
+                csvContent = this.incomeStatementToCSV(incomeStatement);
+                break;
+            case 'balance_sheet':
+                const balanceSheet = await this.getBalanceSheet(params);
+                csvContent = this.balanceSheetToCSV(balanceSheet);
+                break;
+        }
+        return csvContent;
+    }
+    /**
+     * Convert trial balance to CSV
+     */
+    trialBalanceToCSV(report) {
+        const lines = [];
+        lines.push('"Account Number";"Account Name";"Debit";"Credit";"Balance"');
+        for (const entry of report.entries) {
+            lines.push(`"${entry.accountNumber}";"${entry.accountName}";${entry.debitBalance};${entry.creditBalance};${entry.netBalance}`);
+        }
+        lines.push(`"TOTAL";"";"${report.totalDebits}";"${report.totalCredits}";"""`);
+        return lines.join('\n');
+    }
+    /**
+     * Convert income statement to CSV
+     */
+    incomeStatementToCSV(report) {
+        const lines = [];
+        lines.push('"Type";"Account Number";"Account Name";"Amount";"Percentage"');
+        lines.push('"REVENUE";"";"";"";""');
+        for (const entry of report.revenue) {
+            lines.push(`"Revenue";"${entry.accountNumber}";"${entry.accountName}";${entry.amount};${entry.percentage?.toFixed(2)}%`);
+        }
+        lines.push(`"Total Revenue";"";"";"${report.totalRevenue}";"""`);
+        lines.push('"";"";"";"";""');
+        lines.push('"EXPENSES";"";"";"";""');
+        for (const entry of report.expenses) {
+            lines.push(`"Expense";"${entry.accountNumber}";"${entry.accountName}";${entry.amount};${entry.percentage?.toFixed(2)}%`);
+        }
+        lines.push(`"Total Expenses";"";"";"${report.totalExpenses}";"""`);
+        lines.push('"";"";"";"";""');
+        lines.push(`"NET INCOME";"";"";"${report.netIncome}";"""`);
+        return lines.join('\n');
+    }
+    /**
+     * Convert balance sheet to CSV
+     */
+    balanceSheetToCSV(report) {
+        const lines = [];
+        lines.push('"Category";"Account Number";"Account Name";"Amount"');
+        lines.push('"ASSETS";"";"";"";');
+        lines.push('"Current Assets";"";"";"";');
+        for (const entry of report.assets.current) {
+            lines.push(`"";"${entry.accountNumber}";"${entry.accountName}";${entry.amount}`);
+        }
+        lines.push('"Fixed Assets";"";"";"";');
+        for (const entry of report.assets.fixed) {
+            lines.push(`"";"${entry.accountNumber}";"${entry.accountName}";${entry.amount}`);
+        }
+        lines.push(`"Total Assets";"";"";"${report.assets.totalAssets}"`);
+        lines.push('"";"";"";"";');
+        lines.push('"LIABILITIES";"";"";"";');
+        lines.push('"Current Liabilities";"";"";"";');
+        for (const entry of report.liabilities.current) {
+            lines.push(`"";"${entry.accountNumber}";"${entry.accountName}";${entry.amount}`);
+        }
+        lines.push('"Long-term Liabilities";"";"";"";');
+        for (const entry of report.liabilities.longTerm) {
+            lines.push(`"";"${entry.accountNumber}";"${entry.accountName}";${entry.amount}`);
+        }
+        lines.push(`"Total Liabilities";"";"";"${report.liabilities.totalLiabilities}"`);
+        lines.push('"";"";"";"";');
+        lines.push('"EQUITY";"";"";"";');
+        for (const entry of report.equity.entries) {
+            lines.push(`"";"${entry.accountNumber}";"${entry.accountName}";${entry.amount}`);
+        }
+        lines.push(`"Total Equity";"";"";"${report.equity.totalEquity}"`);
+        lines.push('"";"";"";"";');
+        lines.push(`"Total Liabilities + Equity";"";"";"${report.liabilities.totalLiabilities + report.equity.totalEquity}"`);
+        return lines.join('\n');
+    }
+    /**
+     * Export to DATEV format
+     */
+    async exportToDATEV(params) {
+        // DATEV format is specific to German accounting software
+        // This is a simplified implementation
+        const transactions = await Transaction.getInstances({
+            skrType: this.skrType,
+            status: 'posted',
+        });
+        const lines = [];
+        // DATEV header
+        lines.push('EXTF;510;21;"Buchungsstapel";1;;;;;;;;;;;;;;');
+        for (const transaction of transactions) {
+            const date = transaction.date
+                .toISOString()
+                .split('T')[0]
+                .replace(/-/g, '');
+            const line = [
+                transaction.amount.toFixed(2).replace('.', ','),
+                'S',
+                'EUR',
+                '',
+                '',
+                transaction.debitAccount,
+                transaction.creditAccount,
+                '',
+                date,
+                '',
+                transaction.description.substring(0, 60),
+                '',
+            ].join(';');
+            lines.push(line);
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.classes.reports.js","sourceRoot":"","sources":["../ts/skr.classes.reports.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.classes.transaction.d.ts

@@ -0,0 +1,37 @@
+import * as plugins from './plugins.js';
+import type { TSKRType, TTransactionStatus, ITransactionData } from './skr.types.js';
+declare const SmartDataDbDoc: typeof plugins.smartdata.SmartDataDbDoc;
+export declare class Transaction extends SmartDataDbDoc<Transaction, Transaction> {
+    id: string;
+    transactionNumber: string;
+    date: Date;
+    debitAccount: string;
+    creditAccount: string;
+    amount: number;
+    description: string;
+    reference: string;
+    skrType: TSKRType;
+    vatAmount: number;
+    costCenter: string;
+    status: TTransactionStatus;
+    reversalOf: string;
+    reversedBy: string;
+    period: string;
+    fiscalYear: number;
+    createdAt: Date;
+    postedAt: Date;
+    createdBy: string;
+    constructor(data?: Partial<ITransactionData>);
+    private generateTransactionNumber;
+    static createTransaction(data: ITransactionData): Promise<Transaction>;
+    static getTransactionById(id: string): Promise<Transaction | null>;
+    static getTransactionsByAccount(accountNumber: string, skrType: TSKRType): Promise<Transaction[]>;
+    static getTransactionsByPeriod(period: string, skrType: TSKRType): Promise<Transaction[]>;
+    static getTransactionsByDateRange(dateFrom: Date, dateTo: Date, skrType: TSKRType): Promise<Transaction[]>;
+    validateAndPost(): Promise<void>;
+    private validateTransaction;
+    private updateAccountBalances;
+    reverseTransaction(): Promise<Transaction>;
+    beforeSave(): Promise<void>;
+}
+export {};