@fin.cx/skr 1.0.0 → 1.1.0

package/ts/skr.classes.journalentry.ts

@@ -96,6 +96,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       this.postedAt = null;
       this.createdBy = 'system';
 
+      // Normalize any negative amounts to the correct side
+      this.sanitizeLines();
       // Calculate totals
       this.calculateTotals();
     }
@@ -107,6 +109,36 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
     return `JE-${timestamp}-${random}`;
   }
 
+  private sanitizeLines(): void {
+    for (const line of this.lines) {
+      // Check if both debit and credit are set (not allowed)
+      if (line.debit !== undefined && line.debit !== 0 && 
+          line.credit !== undefined && line.credit !== 0) {
+        throw new Error('A line cannot have both debit and credit amounts');
+      }
+      
+      // Handle negative debit - convert to positive credit
+      if (line.debit !== undefined && line.debit < 0) {
+        line.credit = Math.abs(line.debit);
+        delete (line as any).debit;
+      }
+      
+      // Handle negative credit - convert to positive debit
+      if (line.credit !== undefined && line.credit < 0) {
+        line.debit = Math.abs(line.credit);
+        delete (line as any).credit;
+      }
+      
+      // Check that at least one side has a positive value
+      const hasDebit = line.debit !== undefined && line.debit > 0;
+      const hasCredit = line.credit !== undefined && line.credit > 0;
+      
+      if (!hasDebit && !hasCredit) {
+        throw new Error('Either debit or credit must be a positive number');
+      }
+    }
+  }
+
   private calculateTotals(): void {
     this.totalDebits = 0;
     this.totalCredits = 0;
@@ -204,6 +236,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       throw new Error('Journal entry is already posted');
     }
 
+    // Normalize any negative amounts to the correct side
+    this.sanitizeLines();
     // Validate before posting
     await this.validate();
 
@@ -230,28 +264,41 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
       transactions.push(transaction);
     } else {
       // Complex entry: multiple debits and/or credits
-      // Create transactions to balance the entry
-      for (const debitLine of debitLines) {
-        for (const creditLine of creditLines) {
-          const amount = Math.min(debitLine.debit || 0, creditLine.credit || 0);
+      // Build working queues with remaining amounts (don't mutate original lines)
+      const debitQueue = debitLines.map(l => ({ 
+        line: l, 
+        remaining: l.debit || 0 
+      }));
+      
+      const creditQueue = creditLines.map(l => ({ 
+        line: l, 
+        remaining: l.credit || 0 
+      }));
 
-          if (amount > 0) {
+      // Create transactions to balance the entry
+      for (const d of debitQueue) {
+        for (const c of creditQueue) {
+          const amount = Math.min(d.remaining, c.remaining);
+          
+          if (amount > 0.0000001) { // small epsilon to avoid float artifacts
             const transaction = await Transaction.createTransaction({
               date: this.date,
-              debitAccount: debitLine.accountNumber,
-              creditAccount: creditLine.accountNumber,
-              amount: amount,
-              description: `${this.description} - ${debitLine.description || creditLine.description || ''}`,
+              debitAccount: d.line.accountNumber,
+              creditAccount: c.line.accountNumber,
+              amount: Math.round(amount * 100) / 100, // round to 2 decimals
+              description: `${this.description} - ${d.line.description || c.line.description || ''}`,
               reference: this.reference,
               skrType: this.skrType,
-              costCenter: debitLine.costCenter || creditLine.costCenter,
+              costCenter: d.line.costCenter || c.line.costCenter,
             });
             transactions.push(transaction);
-
-            // Reduce amounts for tracking
-            if (debitLine.debit) debitLine.debit -= amount;
-            if (creditLine.credit) creditLine.credit -= amount;
+            
+            // Reduce remaining amounts in working copies (not original lines)
+            d.remaining -= amount;
+            c.remaining -= amount;
           }
+          
+          if (d.remaining <= 0.0000001) break;
         }
       }
     }
@@ -299,6 +346,8 @@ export class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
   }
 
   public async beforeSave(): Promise<void> {
+    // Normalize any negative amounts to the correct side
+    this.sanitizeLines();
     // Recalculate totals before saving
     this.calculateTotals();
 

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;
       });
     }