@fin.cx/skr 1.0.0

package/dist_ts/skr.classes.chartofaccounts.js

@@ -0,0 +1,377 @@
+import * as plugins from './plugins.js';
+import { getDb, closeDb } from './skr.database.js';
+import { Account } from './skr.classes.account.js';
+import { Transaction } from './skr.classes.transaction.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import { SKR03_ACCOUNTS, SKR03_ACCOUNT_CLASSES } from './skr03.data.js';
+import { SKR04_ACCOUNTS, SKR04_ACCOUNT_CLASSES } from './skr04.data.js';
+export class ChartOfAccounts {
+    constructor(config) {
+        this.config = config;
+        this.initialized = false;
+        this.skrType = null;
+        this.logger = new plugins.smartlog.Smartlog({
+            logContext: {
+                company: 'fin.cx',
+                companyunit: 'skr',
+                containerName: 'ChartOfAccounts',
+                environment: 'local',
+                runtime: 'node',
+                zone: 'local',
+            },
+        });
+        this.logger.enableConsole();
+    }
+    /**
+     * Initialize the database connection
+     */
+    async init() {
+        if (this.initialized) {
+            this.logger.log('info', 'ChartOfAccounts already initialized');
+            return;
+        }
+        if (!this.config) {
+            throw new Error('Database configuration required for initialization');
+        }
+        await getDb(this.config);
+        this.initialized = true;
+        this.logger.log('info', 'ChartOfAccounts initialized successfully');
+    }
+    /**
+     * Initialize SKR03 chart of accounts
+     */
+    async initializeSKR03() {
+        await this.init();
+        this.logger.log('info', 'Initializing SKR03 chart of accounts');
+        // Check if SKR03 accounts already exist
+        const existingAccounts = await Account.getInstances({ skrType: 'SKR03' });
+        if (existingAccounts.length > 0) {
+            this.logger.log('info', `SKR03 already initialized with ${existingAccounts.length} accounts`);
+            this.skrType = 'SKR03';
+            return;
+        }
+        // Create all SKR03 accounts
+        const accounts = [];
+        for (const accountData of SKR03_ACCOUNTS) {
+            const account = await Account.createAccount(accountData);
+            accounts.push(account);
+        }
+        this.skrType = 'SKR03';
+        this.logger.log('info', `Successfully initialized SKR03 with ${accounts.length} accounts`);
+    }
+    /**
+     * Initialize SKR04 chart of accounts
+     */
+    async initializeSKR04() {
+        await this.init();
+        this.logger.log('info', 'Initializing SKR04 chart of accounts');
+        // Check if SKR04 accounts already exist
+        const existingAccounts = await Account.getInstances({ skrType: 'SKR04' });
+        if (existingAccounts.length > 0) {
+            this.logger.log('info', `SKR04 already initialized with ${existingAccounts.length} accounts`);
+            this.skrType = 'SKR04';
+            return;
+        }
+        // Create all SKR04 accounts
+        const accounts = [];
+        for (const accountData of SKR04_ACCOUNTS) {
+            const account = await Account.createAccount(accountData);
+            accounts.push(account);
+        }
+        this.skrType = 'SKR04';
+        this.logger.log('info', `Successfully initialized SKR04 with ${accounts.length} accounts`);
+    }
+    /**
+     * Get the current SKR type
+     */
+    getSKRType() {
+        return this.skrType;
+    }
+    /**
+     * Set the active SKR type
+     */
+    setSKRType(skrType) {
+        this.skrType = skrType;
+    }
+    /**
+     * Get account by number
+     */
+    async getAccountByNumber(accountNumber) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        return await Account.getAccountByNumber(accountNumber, this.skrType);
+    }
+    /**
+     * Get accounts by class
+     */
+    async getAccountsByClass(accountClass) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        return await Account.getAccountsByClass(accountClass, this.skrType);
+    }
+    /**
+     * Get accounts by type
+     */
+    async getAccountsByType(accountType) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        return await Account.getAccountsByType(accountType, this.skrType);
+    }
+    /**
+     * Create a custom account
+     */
+    async createCustomAccount(accountData) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        // Ensure the account uses the current SKR type
+        const fullAccountData = {
+            accountNumber: accountData.accountNumber || '',
+            accountName: accountData.accountName || '',
+            accountClass: accountData.accountClass || 0,
+            accountType: accountData.accountType || 'asset',
+            skrType: this.skrType,
+            description: accountData.description,
+            vatRate: accountData.vatRate,
+            isActive: accountData.isActive !== undefined ? accountData.isActive : true,
+        };
+        // Validate account number doesn't already exist
+        const existing = await this.getAccountByNumber(fullAccountData.accountNumber);
+        if (existing) {
+            throw new Error(`Account ${fullAccountData.accountNumber} already exists`);
+        }
+        return await Account.createAccount(fullAccountData);
+    }
+    /**
+     * Update an existing account
+     */
+    async updateAccount(accountNumber, updates) {
+        const account = await this.getAccountByNumber(accountNumber);
+        if (!account) {
+            throw new Error(`Account ${accountNumber} not found`);
+        }
+        // Apply updates
+        if (updates.accountName !== undefined)
+            account.accountName = updates.accountName;
+        if (updates.description !== undefined)
+            account.description = updates.description;
+        if (updates.vatRate !== undefined)
+            account.vatRate = updates.vatRate;
+        if (updates.isActive !== undefined)
+            account.isActive = updates.isActive;
+        account.updatedAt = new Date();
+        await account.save();
+        return account;
+    }
+    /**
+     * Delete a custom account (only non-system accounts)
+     */
+    async deleteAccount(accountNumber) {
+        const account = await this.getAccountByNumber(accountNumber);
+        if (!account) {
+            throw new Error(`Account ${accountNumber} not found`);
+        }
+        if (account.isSystemAccount) {
+            throw new Error(`Cannot delete system account ${accountNumber}`);
+        }
+        // Check if account has transactions
+        const transactions = await Transaction.getTransactionsByAccount(accountNumber, account.skrType);
+        if (transactions.length > 0) {
+            throw new Error(`Cannot delete account ${accountNumber} with existing transactions`);
+        }
+        await account.delete();
+    }
+    /**
+     * Search accounts
+     */
+    async searchAccounts(searchTerm) {
+        return await Account.searchAccounts(searchTerm, this.skrType);
+    }
+    /**
+     * Get all accounts
+     */
+    async getAllAccounts(filter) {
+        const query = {};
+        if (this.skrType) {
+            query.skrType = this.skrType;
+        }
+        if (filter) {
+            if (filter.accountClass !== undefined)
+                query.accountClass = filter.accountClass;
+            if (filter.accountType !== undefined)
+                query.accountType = filter.accountType;
+            if (filter.isActive !== undefined)
+                query.isActive = filter.isActive;
+        }
+        const accounts = await Account.getInstances(query);
+        // Apply text search if provided
+        if (filter?.searchTerm) {
+            const lowerSearchTerm = filter.searchTerm.toLowerCase();
+            return accounts.filter((account) => account.accountNumber.includes(filter.searchTerm) ||
+                account.accountName.toLowerCase().includes(lowerSearchTerm) ||
+                account.description.toLowerCase().includes(lowerSearchTerm));
+        }
+        return accounts;
+    }
+    /**
+     * Post a simple transaction
+     */
+    async postTransaction(transactionData) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        // Ensure the transaction uses the current SKR type
+        const fullTransactionData = {
+            ...transactionData,
+            skrType: this.skrType,
+        };
+        return await Transaction.createTransaction(fullTransactionData);
+    }
+    /**
+     * Post a journal entry
+     */
+    async postJournalEntry(journalData) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        // Ensure the journal entry uses the current SKR type
+        const fullJournalData = {
+            ...journalData,
+            skrType: this.skrType,
+        };
+        const journalEntry = await JournalEntry.createJournalEntry(fullJournalData);
+        await journalEntry.post();
+        return journalEntry;
+    }
+    /**
+     * Get transactions for an account
+     */
+    async getAccountTransactions(accountNumber) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        return await Transaction.getTransactionsByAccount(accountNumber, this.skrType);
+    }
+    /**
+     * Get transactions by filter
+     */
+    async getTransactions(filter) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        const query = {
+            skrType: this.skrType,
+            status: 'posted',
+        };
+        if (filter) {
+            if (filter.dateFrom || filter.dateTo) {
+                query.date = {};
+                if (filter.dateFrom)
+                    query.date.$gte = filter.dateFrom;
+                if (filter.dateTo)
+                    query.date.$lte = filter.dateTo;
+            }
+            if (filter.accountNumber) {
+                query.$or = [
+                    { debitAccount: filter.accountNumber },
+                    { creditAccount: filter.accountNumber },
+                ];
+            }
+            if (filter.minAmount || filter.maxAmount) {
+                query.amount = {};
+                if (filter.minAmount)
+                    query.amount.$gte = filter.minAmount;
+                if (filter.maxAmount)
+                    query.amount.$lte = filter.maxAmount;
+            }
+        }
+        const transactions = await Transaction.getInstances(query);
+        // Apply text search if provided
+        if (filter?.searchTerm) {
+            const lowerSearchTerm = filter.searchTerm.toLowerCase();
+            return transactions.filter((transaction) => transaction.description.toLowerCase().includes(lowerSearchTerm) ||
+                transaction.reference.toLowerCase().includes(lowerSearchTerm));
+        }
+        return transactions;
+    }
+    /**
+     * Reverse a transaction
+     */
+    async reverseTransaction(transactionId) {
+        const transaction = await Transaction.getTransactionById(transactionId);
+        if (!transaction) {
+            throw new Error(`Transaction ${transactionId} not found`);
+        }
+        return await transaction.reverseTransaction();
+    }
+    /**
+     * Get account class description
+     */
+    getAccountClassDescription(accountClass) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        const classes = this.skrType === 'SKR03' ? SKR03_ACCOUNT_CLASSES : SKR04_ACCOUNT_CLASSES;
+        return (classes[accountClass] || `Class ${accountClass}`);
+    }
+    /**
+     * Import accounts from CSV
+     */
+    async importAccountsFromCSV(csvContent) {
+        if (!this.skrType) {
+            throw new Error('SKR type not set. Initialize SKR03 or SKR04 first.');
+        }
+        const lines = csvContent.split('\n').filter((line) => line.trim());
+        let importedCount = 0;
+        for (const line of lines) {
+            // Parse CSV line (expecting format: "account";"name";"description";"type";"active")
+            const parts = line
+                .split(';')
+                .map((part) => part.replace(/"/g, '').trim());
+            if (parts.length >= 5) {
+                const accountData = {
+                    accountNumber: parts[0],
+                    accountName: parts[1],
+                    accountClass: parseInt(parts[0][0]),
+                    accountType: parts[3],
+                    skrType: this.skrType,
+                    description: parts[2],
+                    isActive: parts[4].toLowerCase() === 'standard' ||
+                        parts[4].toLowerCase() === 'active',
+                };
+                try {
+                    await this.createCustomAccount(accountData);
+                    importedCount++;
+                }
+                catch (error) {
+                    this.logger.log('warn', `Failed to import account ${parts[0]}: ${error.message}`);
+                }
+            }
+        }
+        return importedCount;
+    }
+    /**
+     * Export accounts to CSV
+     */
+    async exportAccountsToCSV() {
+        const accounts = await this.getAllAccounts();
+        const csvLines = [];
+        csvLines.push('"Account";"Name";"Description";"Type";"Active"');
+        for (const account of accounts) {
+            csvLines.push(`"${account.accountNumber}";"${account.accountName}";"${account.description}";"${account.accountType}";"${account.isActive ? 'Active' : 'Inactive'}"`);
+        }
+        return csvLines.join('\n');
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        await closeDb();
+        this.initialized = false;
+        this.logger.log('info', 'ChartOfAccounts closed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.classes.chartofaccounts.js","sourceRoot":"","sources":["../ts/skr.classes.chartofaccounts.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,33 @@
+import * as plugins from './plugins.js';
+import type { TSKRType, IJournalEntry, IJournalEntryLine } from './skr.types.js';
+declare const SmartDataDbDoc: typeof plugins.smartdata.SmartDataDbDoc;
+export declare class JournalEntry extends SmartDataDbDoc<JournalEntry, JournalEntry> {
+    id: string;
+    journalNumber: string;
+    date: Date;
+    description: string;
+    reference: string;
+    lines: IJournalEntryLine[];
+    skrType: TSKRType;
+    totalDebits: number;
+    totalCredits: number;
+    isBalanced: boolean;
+    status: 'draft' | 'posted' | 'reversed';
+    transactionIds: string[];
+    period: string;
+    fiscalYear: number;
+    createdAt: Date;
+    postedAt: Date;
+    createdBy: string;
+    constructor(data?: Partial<IJournalEntry>);
+    private generateJournalNumber;
+    private calculateTotals;
+    static createJournalEntry(data: IJournalEntry): Promise<JournalEntry>;
+    addLine(line: IJournalEntryLine): void;
+    removeLine(index: number): void;
+    validate(): Promise<void>;
+    post(): Promise<void>;
+    reverse(): Promise<JournalEntry>;
+    beforeSave(): Promise<void>;
+}
+export {};