@fin.cx/skr 1.1.0 → 1.2.1

package/dist_ts/skr.export.accounts.js

@@ -0,0 +1,111 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+export class AccountsExporter {
+    constructor(exportPath) {
+        this.accounts = [];
+        this.exportPath = exportPath;
+    }
+    /**
+     * Adds an account to the export
+     */
+    addAccount(account) {
+        const exportRow = {
+            account_code: account.accountNumber,
+            name: account.accountName,
+            type: account.accountType,
+            class: account.accountClass,
+            parent: account.parentAccount,
+            skr_set: account.skrType,
+            tax_code_default: account.defaultTaxCode,
+            active_from: account.activeFrom ? this.formatDate(account.activeFrom) : undefined,
+            active_to: account.activeTo ? this.formatDate(account.activeTo) : undefined,
+            description: account.description,
+            is_active: account.isActive !== false
+        };
+        this.accounts.push(exportRow);
+    }
+    /**
+     * Exports accounts to CSV format
+     */
+    async exportToCSV() {
+        const csvPath = path.join(this.exportPath, 'data', 'accounting', 'accounts.csv');
+        await plugins.smartfile.fs.ensureDir(path.dirname(csvPath));
+        // Create CSV header
+        const headers = [
+            'account_code',
+            'name',
+            'type',
+            'class',
+            'parent',
+            'skr_set',
+            'tax_code_default',
+            'active_from',
+            'active_to',
+            'description',
+            'is_active'
+        ];
+        let csvContent = headers.join(',') + '\n';
+        // Add account rows
+        for (const account of this.accounts) {
+            const row = [
+                this.escapeCSV(account.account_code),
+                this.escapeCSV(account.name),
+                this.escapeCSV(account.type),
+                account.class.toString(),
+                this.escapeCSV(account.parent || ''),
+                this.escapeCSV(account.skr_set),
+                this.escapeCSV(account.tax_code_default || ''),
+                this.escapeCSV(account.active_from || ''),
+                this.escapeCSV(account.active_to || ''),
+                this.escapeCSV(account.description || ''),
+                account.is_active.toString()
+            ];
+            csvContent += row.join(',') + '\n';
+        }
+        await plugins.smartfile.memory.toFs(csvContent, csvPath);
+    }
+    /**
+     * Exports accounts to JSON format (alternative)
+     */
+    async exportToJSON() {
+        const jsonPath = path.join(this.exportPath, 'data', 'accounting', 'accounts.json');
+        await plugins.smartfile.fs.ensureDir(path.dirname(jsonPath));
+        const jsonData = {
+            schema_version: '1.0',
+            export_date: new Date().toISOString(),
+            accounts: this.accounts
+        };
+        await plugins.smartfile.memory.toFs(JSON.stringify(jsonData, null, 2), jsonPath);
+    }
+    /**
+     * Escapes CSV values
+     */
+    escapeCSV(value) {
+        if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+            return `"${value.replace(/"/g, '""')}"`;
+        }
+        return value;
+    }
+    /**
+     * Formats a date to ISO date string
+     */
+    formatDate(date) {
+        if (typeof date === 'string') {
+            return date.split('T')[0];
+        }
+        return date.toISOString().split('T')[0];
+    }
+    /**
+     * Gets the number of accounts
+     */
+    getAccountCount() {
+        return this.accounts.length;
+    }
+    /**
+     * Clears the accounts list
+     */
+    clear() {
+        this.accounts = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/skr.export.balances.d.ts

@@ -0,0 +1,59 @@
+import type { IAccountBalance } from './skr.types.js';
+export interface IAccountBalanceExport extends IAccountBalance {
+    openingBalance?: number;
+    transactionCount?: number;
+}
+export interface IBalanceExportRow {
+    account_code: string;
+    account_name: string;
+    fiscal_year: number;
+    period?: string;
+    opening_balance: string;
+    closing_balance: string;
+    debit_sum: string;
+    credit_sum: string;
+    balance: string;
+    transaction_count: number;
+}
+export declare class BalancesExporter {
+    private exportPath;
+    private balances;
+    private fiscalYear;
+    constructor(exportPath: string, fiscalYear: number);
+    /**
+     * Adds a balance entry to the export
+     */
+    addBalance(accountCode: string, accountName: string, balance: IAccountBalanceExport, period?: string): void;
+    /**
+     * Exports balances to CSV format
+     */
+    exportToCSV(): Promise<void>;
+    /**
+     * Exports trial balance (Summen- und Saldenliste)
+     */
+    exportTrialBalance(): Promise<void>;
+    /**
+     * Exports balances to JSON format
+     */
+    exportToJSON(): Promise<void>;
+    /**
+     * Generates balance summary for specific account classes
+     */
+    exportClassSummary(): Promise<void>;
+    /**
+     * Escapes CSV values
+     */
+    private escapeCSV;
+    /**
+     * Formats number in German format (1.234,56)
+     */
+    private formatGermanNumber;
+    /**
+     * Gets the number of balance entries
+     */
+    getBalanceCount(): number;
+    /**
+     * Clears the balances list
+     */
+    clear(): void;
+}

package/dist_ts/skr.export.balances.js

@@ -0,0 +1,205 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+export class BalancesExporter {
+    constructor(exportPath, fiscalYear) {
+        this.balances = [];
+        this.exportPath = exportPath;
+        this.fiscalYear = fiscalYear;
+    }
+    /**
+     * Adds a balance entry to the export
+     */
+    addBalance(accountCode, accountName, balance, period) {
+        const exportRow = {
+            account_code: accountCode,
+            account_name: accountName,
+            fiscal_year: this.fiscalYear,
+            period: period,
+            opening_balance: (balance.openingBalance || 0).toFixed(2),
+            closing_balance: balance.balance.toFixed(2),
+            debit_sum: balance.debitTotal.toFixed(2),
+            credit_sum: balance.creditTotal.toFixed(2),
+            balance: balance.balance.toFixed(2),
+            transaction_count: balance.transactionCount || 0
+        };
+        this.balances.push(exportRow);
+    }
+    /**
+     * Exports balances to CSV format
+     */
+    async exportToCSV() {
+        const csvPath = path.join(this.exportPath, 'data', 'accounting', 'balances.csv');
+        await plugins.smartfile.fs.ensureDir(path.dirname(csvPath));
+        // Create CSV header
+        const headers = [
+            'account_code',
+            'account_name',
+            'fiscal_year',
+            'period',
+            'opening_balance',
+            'closing_balance',
+            'debit_sum',
+            'credit_sum',
+            'balance',
+            'transaction_count'
+        ];
+        let csvContent = headers.join(',') + '\n';
+        // Sort balances by account code
+        this.balances.sort((a, b) => a.account_code.localeCompare(b.account_code));
+        // Add balance rows
+        for (const balance of this.balances) {
+            const row = [
+                this.escapeCSV(balance.account_code),
+                this.escapeCSV(balance.account_name),
+                balance.fiscal_year.toString(),
+                this.escapeCSV(balance.period || ''),
+                balance.opening_balance,
+                balance.closing_balance,
+                balance.debit_sum,
+                balance.credit_sum,
+                balance.balance,
+                balance.transaction_count.toString()
+            ];
+            csvContent += row.join(',') + '\n';
+        }
+        await plugins.smartfile.memory.toFs(csvContent, csvPath);
+    }
+    /**
+     * Exports trial balance (Summen- und Saldenliste)
+     */
+    async exportTrialBalance() {
+        const csvPath = path.join(this.exportPath, 'data', 'accounting', 'trial_balance.csv');
+        await plugins.smartfile.fs.ensureDir(path.dirname(csvPath));
+        // Create CSV header for trial balance
+        const headers = [
+            'Konto',
+            'Bezeichnung',
+            'Anfangssaldo',
+            'Soll',
+            'Haben',
+            'Saldo',
+            'Endsaldo'
+        ];
+        let csvContent = headers.join(',') + '\n';
+        // Add rows with German formatting
+        for (const balance of this.balances) {
+            const row = [
+                this.escapeCSV(balance.account_code),
+                this.escapeCSV(balance.account_name),
+                this.formatGermanNumber(parseFloat(balance.opening_balance)),
+                this.formatGermanNumber(parseFloat(balance.debit_sum)),
+                this.formatGermanNumber(parseFloat(balance.credit_sum)),
+                this.formatGermanNumber(parseFloat(balance.debit_sum) - parseFloat(balance.credit_sum)),
+                this.formatGermanNumber(parseFloat(balance.closing_balance))
+            ];
+            csvContent += row.join(',') + '\n';
+        }
+        // Add totals row
+        const totalDebit = this.balances.reduce((sum, b) => sum + parseFloat(b.debit_sum), 0);
+        const totalCredit = this.balances.reduce((sum, b) => sum + parseFloat(b.credit_sum), 0);
+        csvContent += '\n';
+        csvContent += [
+            'SUMME',
+            '',
+            '',
+            this.formatGermanNumber(totalDebit),
+            this.formatGermanNumber(totalCredit),
+            this.formatGermanNumber(totalDebit - totalCredit),
+            ''
+        ].join(',') + '\n';
+        await plugins.smartfile.memory.toFs(csvContent, csvPath);
+    }
+    /**
+     * Exports balances to JSON format
+     */
+    async exportToJSON() {
+        const jsonPath = path.join(this.exportPath, 'data', 'accounting', 'balances.json');
+        await plugins.smartfile.fs.ensureDir(path.dirname(jsonPath));
+        const jsonData = {
+            schema_version: '1.0',
+            export_date: new Date().toISOString(),
+            fiscal_year: this.fiscalYear,
+            balances: this.balances,
+            totals: {
+                total_debit: this.balances.reduce((sum, b) => sum + parseFloat(b.debit_sum), 0).toFixed(2),
+                total_credit: this.balances.reduce((sum, b) => sum + parseFloat(b.credit_sum), 0).toFixed(2),
+                account_count: this.balances.length
+            }
+        };
+        await plugins.smartfile.memory.toFs(JSON.stringify(jsonData, null, 2), jsonPath);
+    }
+    /**
+     * Generates balance summary for specific account classes
+     */
+    async exportClassSummary() {
+        const csvPath = path.join(this.exportPath, 'data', 'accounting', 'class_summary.csv');
+        await plugins.smartfile.fs.ensureDir(path.dirname(csvPath));
+        // Group balances by account class (first digit of account code)
+        const classSummary = {};
+        for (const balance of this.balances) {
+            const accountClass = balance.account_code.charAt(0);
+            if (!classSummary[accountClass]) {
+                classSummary[accountClass] = { debit: 0, credit: 0, balance: 0 };
+            }
+            classSummary[accountClass].debit += parseFloat(balance.debit_sum);
+            classSummary[accountClass].credit += parseFloat(balance.credit_sum);
+            classSummary[accountClass].balance += parseFloat(balance.balance);
+        }
+        // Create CSV
+        let csvContent = 'Kontenklasse,Bezeichnung,Soll,Haben,Saldo\n';
+        const classNames = {
+            '0': 'Anlagevermögen',
+            '1': 'Umlaufvermögen',
+            '2': 'Eigenkapital',
+            '3': 'Fremdkapital',
+            '4': 'Betriebliche Erträge',
+            '5': 'Materialaufwand',
+            '6': 'Betriebsaufwand',
+            '7': 'Weitere Aufwendungen',
+            '8': 'Erträge',
+            '9': 'Abschlusskonten'
+        };
+        for (const [classNum, summary] of Object.entries(classSummary)) {
+            const row = [
+                classNum,
+                this.escapeCSV(classNames[classNum] || `Klasse ${classNum}`),
+                this.formatGermanNumber(summary.debit),
+                this.formatGermanNumber(summary.credit),
+                this.formatGermanNumber(summary.balance)
+            ];
+            csvContent += row.join(',') + '\n';
+        }
+        await plugins.smartfile.memory.toFs(csvContent, csvPath);
+    }
+    /**
+     * Escapes CSV values
+     */
+    escapeCSV(value) {
+        if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+            return `"${value.replace(/"/g, '""')}"`;
+        }
+        return value;
+    }
+    /**
+     * Formats number in German format (1.234,56)
+     */
+    formatGermanNumber(value) {
+        return value.toLocaleString('de-DE', {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        });
+    }
+    /**
+     * Gets the number of balance entries
+     */
+    getBalanceCount() {
+        return this.balances.length;
+    }
+    /**
+     * Clears the balances list
+     */
+    clear() {
+        this.balances = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.export.balances.js","sourceRoot":"","sources":["../ts/skr.export.balances.ts"],"names":[],"mappings":"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"}

package/dist_ts/skr.export.d.ts

@@ -0,0 +1,110 @@
+import type { TSKRType } from './skr.types.js';
+export interface IExportOptions {
+    exportPath: string;
+    fiscalYear: number;
+    dateFrom: Date;
+    dateTo: Date;
+    includeDocuments?: boolean;
+    generatePdfReports?: boolean;
+    signExport?: boolean;
+    timestampExport?: boolean;
+    companyInfo?: {
+        name: string;
+        taxId: string;
+        registrationNumber?: string;
+        address?: string;
+    };
+}
+export interface IExportMetadata {
+    exportVersion: string;
+    exportTimestamp: string;
+    generator: {
+        name: string;
+        version: string;
+    };
+    company?: {
+        name: string;
+        taxId: string;
+        registrationNumber?: string;
+        address?: string;
+    };
+    fiscalYear: number;
+    dateRange: {
+        from: string;
+        to: string;
+    };
+    skrType: TSKRType;
+    schemaVersion: string;
+    crypto: {
+        digestAlgorithms: string[];
+        signatureType?: string;
+        timestampPolicy?: string;
+        merkleTree: boolean;
+    };
+    options: {
+        packagedAs: 'bagit';
+        compression: 'none' | 'deflate';
+        deduplication: boolean;
+    };
+}
+export interface IBagItManifest {
+    [filePath: string]: string;
+}
+export interface IDocumentIndex {
+    contentHash: string;
+    sizeBytes: number;
+    mimeType: string;
+    createdAt: string;
+    originalFilename?: string;
+    pdfaAvailable: boolean;
+    zugferdXml?: string;
+    retentionClass: string;
+}
+export declare class SkrExport {
+    private logger;
+    private options;
+    private exportDir;
+    private manifest;
+    private tagManifest;
+    constructor(options: IExportOptions);
+    /**
+     * Creates the BagIt directory structure for the export
+     */
+    createBagItStructure(): Promise<void>;
+    /**
+     * Creates the bagit.txt declaration file
+     */
+    private createBagItDeclaration;
+    /**
+     * Creates the README.txt file with Verfahrensdokumentation
+     */
+    private createReadme;
+    /**
+     * Creates the export metadata JSON file
+     */
+    createExportMetadata(skrType: TSKRType): Promise<void>;
+    /**
+     * Creates JSON schemas for the export data structures
+     */
+    createSchemas(): Promise<void>;
+    /**
+     * Writes the BagIt manifest files
+     */
+    writeManifests(): Promise<void>;
+    /**
+     * Calculates SHA-256 hash of a file
+     */
+    private hashFile;
+    /**
+     * Stores a document in content-addressed storage
+     */
+    storeDocument(content: Buffer, originalFilename?: string): Promise<string>;
+    /**
+     * Creates a Merkle tree from all file hashes
+     */
+    createMerkleTree(): Promise<string>;
+    /**
+     * Validates the BagIt structure
+     */
+    validateBagIt(): Promise<boolean>;
+}