@fin.cx/skr 1.0.0 → 1.2.0

package/ts/skr.classes.ledger.ts

@@ -9,6 +9,14 @@ import type {
   IJournalEntryLine,
   IAccountBalance,
 } from './skr.types.js';
+import { SKR03_ACCOUNTS } from './skr03.data.js';
+import { SKR04_ACCOUNTS } from './skr04.data.js';
+
+// Module-level Maps for O(1) SKR standard lookups
+const STANDARD_SKR_MAP = {
+  SKR03: new Map(SKR03_ACCOUNTS.map(a => [a.accountNumber, a])),
+  SKR04: new Map(SKR04_ACCOUNTS.map(a => [a.accountNumber, a])),
+};
 
 export class Ledger {
   private logger: plugins.smartlog.Smartlog;
@@ -81,6 +89,12 @@ export class Ledger {
     const accountNumbers = journalData.lines.map((line) => line.accountNumber);
     await this.validateAccounts(accountNumbers);
 
+    // Validate against SKR standard (warnings only by default)
+    await this.validateAccountsAgainstSKR(journalData.lines, { 
+      strict: false,  // Start with warnings only
+      warnOnNameMismatch: false  // Names vary, don't spam logs
+    });
+
     // Validate journal entry is balanced
     this.validateJournalBalance(journalData.lines);
 
@@ -139,6 +153,77 @@ export class Ledger {
     }
   }
 
+  /**
+   * Validate accounts against SKR standard data
+   */
+  private async validateAccountsAgainstSKR(
+    lines: IJournalEntryLine[],
+    options?: { strict?: boolean; warnOnNameMismatch?: boolean }
+  ): Promise<void> {
+    const { strict = false, warnOnNameMismatch = false } = options || {};
+    const skrMap = STANDARD_SKR_MAP[this.skrType];
+    
+    if (!skrMap) {
+      this.logger.log('warn', `No SKR standard map available for ${this.skrType}`);
+      return;
+    }
+    
+    const uniqueAccountNumbers = [...new Set(lines.map(line => line.accountNumber))];
+    
+    for (const accountNumber of uniqueAccountNumbers) {
+      const standardAccount = skrMap.get(accountNumber);
+      
+      if (!standardAccount) {
+        // Special case: SKR04 class 8 is designated for custom accounts ("frei")
+        if (this.skrType === 'SKR04' && accountNumber.startsWith('8')) {
+          this.logger.log('debug', `Account ${accountNumber} is in SKR04 class 8 (custom accounts allowed)`);
+          continue;
+        }
+        
+        const message = `Account ${accountNumber} is not a standard ${this.skrType} account`;
+        if (strict) {
+          throw new Error(message);
+        } else {
+          this.logger.log('warn', message);
+        }
+        continue;
+      }
+      
+      // Get actual account from database to compare
+      const dbAccount = await Account.getAccountByNumber(accountNumber, this.skrType);
+      if (!dbAccount) {
+        // Account doesn't exist in DB, will be caught by validateAccounts()
+        continue;
+      }
+      
+      // Validate type and class match SKR standard
+      if (dbAccount.accountType !== standardAccount.accountType) {
+        const message = `Account ${accountNumber} type mismatch: expected '${standardAccount.accountType}', got '${dbAccount.accountType}'`;
+        if (strict) {
+          throw new Error(message);
+        } else {
+          this.logger.log('warn', message);
+        }
+      }
+      
+      if (dbAccount.accountClass !== standardAccount.accountClass) {
+        const message = `Account ${accountNumber} class mismatch: expected ${standardAccount.accountClass}, got ${dbAccount.accountClass}`;
+        if (strict) {
+          throw new Error(message);
+        } else {
+          this.logger.log('warn', message);
+        }
+      }
+      
+      // Warn on name mismatch (common and acceptable in practice)
+      if (warnOnNameMismatch && dbAccount.accountName !== standardAccount.accountName) {
+        this.logger.log('info', 
+          `Account ${accountNumber} name differs from SKR standard: '${dbAccount.accountName}' vs '${standardAccount.accountName}'`
+        );
+      }
+    }
+  }
+
   /**
    * Reverse a transaction
    */

package/ts/skr.classes.reports.ts

@@ -122,11 +122,11 @@ export class Reports {
         const entry: IIncomeStatementEntry = {
           accountNumber: account.accountNumber,
           accountName: account.accountName,
-          amount: Math.abs(balance),
+          amount: balance, // Keep the sign for correct calculation
         };
 
         revenueEntries.push(entry);
-        totalRevenue += Math.abs(balance);
+        totalRevenue += balance; // Revenue accounts normally have credit balance (positive)
       }
     }
 
@@ -138,23 +138,24 @@ export class Reports {
         const entry: IIncomeStatementEntry = {
           accountNumber: account.accountNumber,
           accountName: account.accountName,
-          amount: Math.abs(balance),
+          amount: balance, // Keep the sign - negative balance reduces expenses
         };
 
         expenseEntries.push(entry);
-        totalExpenses += Math.abs(balance);
+        totalExpenses += balance; // Expense accounts normally have debit balance (positive)
+                                  // But credit balances (negative) reduce total expenses
       }
     }
 
-    // Calculate percentages
+    // Calculate percentages using absolute values to avoid negative percentages
     revenueEntries.forEach((entry) => {
       entry.percentage =
-        totalRevenue > 0 ? (entry.amount / totalRevenue) * 100 : 0;
+        totalRevenue !== 0 ? (Math.abs(entry.amount) / Math.abs(totalRevenue)) * 100 : 0;
     });
 
     expenseEntries.forEach((entry) => {
       entry.percentage =
-        totalRevenue > 0 ? (entry.amount / totalRevenue) * 100 : 0;
+        totalRevenue !== 0 ? (Math.abs(entry.amount) / Math.abs(totalRevenue)) * 100 : 0;
     });
 
     // Sort entries by account number
@@ -214,7 +215,7 @@ export class Reports {
         const entry: IBalanceSheetEntry = {
           accountNumber: account.accountNumber,
           accountName: account.accountName,
-          amount: Math.abs(balance),
+          amount: balance, // Keep the sign for display
         };
 
         // Classify as current or fixed based on account class
@@ -224,7 +225,7 @@ export class Reports {
           fixedAssets.push(entry);
         }
 
-        totalAssets += Math.abs(balance);
+        totalAssets += balance; // Add with sign to get correct total
       }
     }
 
@@ -240,7 +241,7 @@ export class Reports {
         const entry: IBalanceSheetEntry = {
           accountNumber: account.accountNumber,
           accountName: account.accountName,
-          amount: Math.abs(balance),
+          amount: balance, // Keep the sign for display
         };
 
         // Classify as current or long-term based on account number
@@ -253,7 +254,7 @@ export class Reports {
           longTermLiabilities.push(entry);
         }
 
-        totalLiabilities += Math.abs(balance);
+        totalLiabilities += balance; // Add with sign to get correct total
       }
     }
 
@@ -268,23 +269,27 @@ export class Reports {
         const entry: IBalanceSheetEntry = {
           accountNumber: account.accountNumber,
           accountName: account.accountName,
-          amount: Math.abs(balance),
+          amount: balance, // Keep the sign for display
         };
 
         equityEntries.push(entry);
-        totalEquity += Math.abs(balance);
+        totalEquity += balance; // Add with sign to get correct total
       }
     }
 
-    // Add current year profit/loss
+    // Add current year profit/loss only if accounts haven't been closed
+    // Check if revenue/expense accounts have non-zero balances (indicates not closed)
     const incomeStatement = await this.getIncomeStatement(params);
-    if (incomeStatement.netIncome !== 0) {
+    
+    // Only add current year profit/loss if we have unclosed revenue/expense accounts
+    // (i.e., the income statement shows non-zero revenue or expenses)
+    if (incomeStatement.netIncome !== 0 && (incomeStatement.totalRevenue !== 0 || incomeStatement.totalExpenses !== 0)) {
       equityEntries.push({
         accountNumber: '9999',
         accountName: 'Current Year Profit/Loss',
-        amount: Math.abs(incomeStatement.netIncome),
+        amount: incomeStatement.netIncome, // Keep the sign
       });
-      totalEquity += Math.abs(incomeStatement.netIncome);
+      totalEquity += incomeStatement.netIncome; // Add with sign
     }
 
     // Sort entries
@@ -344,9 +349,28 @@ export class Reports {
 
     // Apply date filter if provided
     if (params?.dateFrom || params?.dateTo) {
+      // Normalize dates for inclusive comparison
+      const dateFrom = params.dateFrom ? new Date(params.dateFrom) : null;
+      const dateTo = params.dateTo ? new Date(params.dateTo) : null;
+      
+      // Set dateFrom to start of day (00:00:00.000)
+      if (dateFrom) {
+        dateFrom.setHours(0, 0, 0, 0);
+      }
+      
+      // Set dateTo to end of day (23:59:59.999) for inclusive comparison
+      if (dateTo) {
+        dateTo.setHours(23, 59, 59, 999);
+      }
+      
       transactions = transactions.filter((transaction) => {
-        if (params.dateFrom && transaction.date < params.dateFrom) return false;
-        if (params.dateTo && transaction.date > params.dateTo) return false;
+        const txDate = transaction.date instanceof Date 
+          ? transaction.date 
+          : new Date(transaction.date);
+        const txTime = txDate.getTime();
+        
+        if (dateFrom && txTime < dateFrom.getTime()) return false;
+        if (dateTo && txTime > dateTo.getTime()) return false;
         return true;
       });
     }
@@ -453,9 +477,28 @@ export class Reports {
 
     // Apply date filter
     if (params?.dateFrom || params?.dateTo) {
+      // Normalize dates for inclusive comparison
+      const dateFrom = params.dateFrom ? new Date(params.dateFrom) : null;
+      const dateTo = params.dateTo ? new Date(params.dateTo) : null;
+      
+      // Set dateFrom to start of day (00:00:00.000)
+      if (dateFrom) {
+        dateFrom.setHours(0, 0, 0, 0);
+      }
+      
+      // Set dateTo to end of day (23:59:59.999) for inclusive comparison
+      if (dateTo) {
+        dateTo.setHours(23, 59, 59, 999);
+      }
+      
       transactions = transactions.filter((transaction) => {
-        if (params.dateFrom && transaction.date < params.dateFrom) return false;
-        if (params.dateTo && transaction.date > params.dateTo) return false;
+        const txDate = transaction.date instanceof Date 
+          ? transaction.date 
+          : new Date(transaction.date);
+        const txTime = txDate.getTime();
+        
+        if (dateFrom && txTime < dateFrom.getTime()) return false;
+        if (dateTo && txTime > dateTo.getTime()) return false;
         return true;
       });
     }

package/ts/skr.export.accounts.ts

@@ -0,0 +1,154 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import type { IAccountData, TSKRType } from './skr.types.js';
+
+// Extended interface for export with additional fields
+export interface IAccountDataExport extends IAccountData {
+  parentAccount?: string;
+  defaultTaxCode?: string;
+  activeFrom?: Date | string;
+  activeTo?: Date | string;
+}
+
+export interface IAccountExportRow {
+  account_code: string;
+  name: string;
+  type: string;
+  class: number;
+  parent?: string;
+  skr_set: TSKRType;
+  tax_code_default?: string;
+  active_from?: string;
+  active_to?: string;
+  description?: string;
+  is_active: boolean;
+}
+
+export class AccountsExporter {
+  private exportPath: string;
+  private accounts: IAccountExportRow[] = [];
+  
+  constructor(exportPath: string) {
+    this.exportPath = exportPath;
+  }
+
+  /**
+   * Adds an account to the export
+   */
+  public addAccount(account: IAccountDataExport): void {
+    const exportRow: IAccountExportRow = {
+      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
+   */
+  public async exportToCSV(): Promise<void> {
+    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)
+   */
+  public async exportToJSON(): Promise<void> {
+    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
+   */
+  private escapeCSV(value: string): string {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+
+  /**
+   * 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];
+  }
+
+  /**
+   * Gets the number of accounts
+   */
+  public getAccountCount(): number {
+    return this.accounts.length;
+  }
+
+  /**
+   * Clears the accounts list
+   */
+  public clear(): void {
+    this.accounts = [];
+  }
+}

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 = [];
+  }
+}