@fin.cx/skr 1.1.0 → 1.2.0

package/ts/skr.export.balances.ts

@@ -0,0 +1,270 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import type { IAccountBalance } from './skr.types.js';
+
+// Extended interface for export with additional fields
+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 class BalancesExporter {
+  private exportPath: string;
+  private balances: IBalanceExportRow[] = [];
+  private fiscalYear: number;
+  
+  constructor(exportPath: string, fiscalYear: number) {
+    this.exportPath = exportPath;
+    this.fiscalYear = fiscalYear;
+  }
+
+  /**
+   * Adds a balance entry to the export
+   */
+  public addBalance(
+    accountCode: string,
+    accountName: string,
+    balance: IAccountBalanceExport,
+    period?: string
+  ): void {
+    const exportRow: IBalanceExportRow = {
+      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
+   */
+  public async exportToCSV(): Promise<void> {
+    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)
+   */
+  public async exportTrialBalance(): Promise<void> {
+    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
+   */
+  public async exportToJSON(): Promise<void> {
+    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
+   */
+  public async exportClassSummary(): Promise<void> {
+    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: { [key: string]: { debit: number; credit: number; balance: number } } = {};
+    
+    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: { [key: string]: string } = {
+      '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
+   */
+  private escapeCSV(value: string): string {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+
+  /**
+   * Formats number in German format (1.234,56)
+   */
+  private formatGermanNumber(value: number): string {
+    return value.toLocaleString('de-DE', {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    });
+  }
+
+  /**
+   * Gets the number of balance entries
+   */
+  public getBalanceCount(): number {
+    return this.balances.length;
+  }
+
+  /**
+   * Clears the balances list
+   */
+  public clear(): void {
+    this.balances = [];
+  }
+}

package/ts/skr.export.ledger.ts

@@ -0,0 +1,249 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import type { ITransactionData, IJournalEntry, IJournalEntryLine } from './skr.types.js';
+import { createWriteStream, type WriteStream } from 'fs';
+
+// Extended interfaces for export with additional tracking fields
+export interface ITransactionDataExport extends ITransactionData {
+  _id?: string;
+  postingDate?: Date;
+  currency?: string;
+  createdAt?: Date | string;
+  modifiedAt?: Date | string;
+  reversalOf?: string;
+  reversedBy?: string;
+  taxCode?: string;
+  project?: string;
+  vatAccount?: string;
+}
+
+export interface IJournalEntryExport extends IJournalEntry {
+  _id?: string;
+  postingDate?: Date;
+  currency?: string;
+  journal?: string;
+  createdAt?: Date | string;
+  modifiedAt?: Date | string;
+  reversalOf?: string;
+  reversedBy?: string;
+}
+
+export interface IJournalEntryLineExport extends IJournalEntryLine {
+  taxCode?: string;
+  project?: string;
+}
+
+export interface ILedgerEntry {
+  schema_version: string;
+  entry_id: string;
+  booking_date: string;
+  posting_date: string;
+  period?: string;
+  currency: string;
+  journal: string;
+  description: string;
+  reference?: string;
+  lines: ILedgerLine[];
+  document_refs?: IDocumentRef[];
+  created_at: string;
+  modified_at?: string;
+  user?: string;
+  reversal_of?: string;
+  reversed_by?: string;
+}
+
+export interface ILedgerLine {
+  posting_id: string;
+  account_code: string;
+  debit: string;
+  credit: string;
+  tax_code?: string;
+  cost_center?: string;
+  project?: string;
+  description?: string;
+}
+
+export interface IDocumentRef {
+  content_hash: string;
+  doc_role: 'invoice' | 'receipt' | 'contract' | 'bank-statement' | 'other';
+  doc_mime: string;
+  doc_original_name?: string;
+}
+
+export class LedgerExporter {
+  private exportPath: string;
+  private stream: WriteStream | null = null;
+  private entryCount: number = 0;
+  
+  constructor(exportPath: string) {
+    this.exportPath = exportPath;
+  }
+
+  /**
+   * Initializes the NDJSON export stream
+   */
+  public async initialize(): Promise<void> {
+    const ledgerPath = path.join(this.exportPath, 'data', 'accounting', 'ledger.ndjson');
+    await plugins.smartfile.fs.ensureDir(path.dirname(ledgerPath));
+    
+    this.stream = createWriteStream(ledgerPath, {
+      encoding: 'utf8',
+      flags: 'w'
+    });
+  }
+
+  /**
+   * Exports a transaction as a ledger entry
+   */
+  public async exportTransaction(transaction: ITransactionDataExport): Promise<void> {
+    if (!this.stream) {
+      throw new Error('Ledger exporter not initialized');
+    }
+
+    const entry: ILedgerEntry = {
+      schema_version: '1.0',
+      entry_id: transaction._id || plugins.smartunique.shortId(),
+      booking_date: this.formatDate(transaction.date),
+      posting_date: this.formatDate(transaction.postingDate || transaction.date),
+      currency: transaction.currency || 'EUR',
+      journal: 'GL',
+      description: transaction.description,
+      reference: transaction.reference,
+      lines: [],
+      created_at: transaction.createdAt ? new Date(transaction.createdAt).toISOString() : new Date().toISOString(),
+      modified_at: transaction.modifiedAt ? new Date(transaction.modifiedAt).toISOString() : undefined,
+      reversal_of: transaction.reversalOf,
+      reversed_by: transaction.reversedBy
+    };
+
+    // Add debit line
+    if (transaction.amount > 0) {
+      entry.lines.push({
+        posting_id: `${entry.entry_id}-1`,
+        account_code: transaction.debitAccount,
+        debit: transaction.amount.toFixed(2),
+        credit: '0.00',
+        tax_code: transaction.taxCode,
+        cost_center: transaction.costCenter,
+        project: transaction.project
+      });
+
+      // Add credit line
+      entry.lines.push({
+        posting_id: `${entry.entry_id}-2`,
+        account_code: transaction.creditAccount,
+        debit: '0.00',
+        credit: transaction.amount.toFixed(2)
+      });
+    }
+
+    // Add VAT lines if applicable
+    if (transaction.vatAmount && transaction.vatAmount > 0) {
+      entry.lines.push({
+        posting_id: `${entry.entry_id}-3`,
+        account_code: transaction.vatAccount || '1576', // Default VAT account
+        debit: transaction.vatAmount.toFixed(2),
+        credit: '0.00',
+        description: 'Vorsteuer'
+      });
+    }
+
+    await this.writeLine(entry);
+  }
+
+  /**
+   * Exports a journal entry
+   */
+  public async exportJournalEntry(journalEntry: IJournalEntryExport): Promise<void> {
+    if (!this.stream) {
+      throw new Error('Ledger exporter not initialized');
+    }
+
+    const entry: ILedgerEntry = {
+      schema_version: '1.0',
+      entry_id: journalEntry._id || plugins.smartunique.shortId(),
+      booking_date: this.formatDate(journalEntry.date),
+      posting_date: this.formatDate(journalEntry.postingDate || journalEntry.date),
+      currency: journalEntry.currency || 'EUR',
+      journal: journalEntry.journal || 'GL',
+      description: journalEntry.description,
+      reference: journalEntry.reference,
+      lines: [],
+      created_at: journalEntry.createdAt ? new Date(journalEntry.createdAt).toISOString() : new Date().toISOString(),
+      modified_at: journalEntry.modifiedAt ? new Date(journalEntry.modifiedAt).toISOString() : undefined,
+      reversal_of: journalEntry.reversalOf,
+      reversed_by: journalEntry.reversedBy
+    };
+
+    // Convert journal entry lines
+    journalEntry.lines.forEach((line, index) => {
+      const extLine = line as IJournalEntryLineExport;
+      entry.lines.push({
+        posting_id: `${entry.entry_id}-${index + 1}`,
+        account_code: line.accountNumber,
+        debit: (line.debit || 0).toFixed(2),
+        credit: (line.credit || 0).toFixed(2),
+        tax_code: extLine.taxCode,
+        cost_center: line.costCenter,
+        project: extLine.project,
+        description: line.description
+      });
+    });
+
+    await this.writeLine(entry);
+  }
+
+  /**
+   * Writes a single NDJSON line
+   */
+  private async writeLine(entry: ILedgerEntry): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (!this.stream) {
+        reject(new Error('Stream not initialized'));
+        return;
+      }
+
+      const line = JSON.stringify(entry) + '\n';
+      this.stream.write(line, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          this.entryCount++;
+          resolve();
+        }
+      });
+    });
+  }
+
+  /**
+   * Formats a date to ISO date string
+   */
+  private formatDate(date: Date | string): string {
+    if (typeof date === 'string') {
+      return date.split('T')[0];
+    }
+    return date.toISOString().split('T')[0];
+  }
+
+  /**
+   * Closes the export stream
+   */
+  public async close(): Promise<number> {
+    return new Promise((resolve) => {
+      if (this.stream) {
+        this.stream.end(() => {
+          resolve(this.entryCount);
+        });
+      } else {
+        resolve(this.entryCount);
+      }
+    });
+  }
+
+  /**
+   * Gets the number of exported entries
+   */
+  public getEntryCount(): number {
+    return this.entryCount;
+  }
+}