@klardaten/n8n-nodes-datevconnect 1.0.1 → 1.0.3

package/dist/nodes/Accounting/handlers/AccountPostingResourceHandler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountPostingResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class AccountPostingResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async execute(operation, requestContext, returnData) {
+        const sendSuccess = this.createSendSuccess(returnData);
+        try {
+            let response;
+            switch (operation) {
+                case "getAll":
+                    response = await this.handleGetAll(requestContext);
+                    break;
+                case "get":
+                    response = await this.handleGet(requestContext);
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for resource "accountPosting".`, { itemIndex: this.itemIndex });
+            }
+            sendSuccess(response);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetAll(requestContext) {
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountPostings(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGet(requestContext) {
+        const accountPostingId = this.getRequiredString("accountPostingId");
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountPosting(this.context, requestContext.clientId, requestContext.fiscalYearId, accountPostingId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+}
+exports.AccountPostingResourceHandler = AccountPostingResourceHandler;

package/dist/nodes/Accounting/handlers/AccountingSequenceResourceHandler.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountingSequenceResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for all accounting sequence-related operations
+ */
+class AccountingSequenceResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async execute(operation, requestContext, returnData) {
+        const sendSuccess = this.createSendSuccess(returnData);
+        try {
+            let response;
+            switch (operation) {
+                case "create":
+                    response = await this.handleCreate(requestContext);
+                    break;
+                case "getAll":
+                    response = await this.handleGetAll(requestContext);
+                    break;
+                case "get":
+                    response = await this.handleGet(requestContext);
+                    break;
+                case "getAccountingRecords":
+                    response = await this.handleGetAccountingRecords(requestContext);
+                    break;
+                case "getAccountingRecord":
+                    response = await this.handleGetAccountingRecord(requestContext);
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for resource "accountingSequence".`, { itemIndex: this.itemIndex });
+            }
+            sendSuccess(response);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleCreate(requestContext) {
+        const accountingSequenceData = this.getRequiredString("accountingSequenceData");
+        const data = this.parseJsonParameter(accountingSequenceData, "accountingSequenceData");
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "Accounting sequence data must be a valid JSON object", { itemIndex: this.itemIndex });
+        }
+        const result = await accountingClient_1.datevConnectClient.accounting.createAccountingSequence(this.context, requestContext.clientId, requestContext.fiscalYearId, data);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGetAll(requestContext) {
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountingSequences(this.context, requestContext.clientId, requestContext.fiscalYearId);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGet(requestContext) {
+        const accountingSequenceId = this.getRequiredString("accountingSequenceId");
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountingSequence(this.context, requestContext.clientId, requestContext.fiscalYearId, accountingSequenceId);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGetAccountingRecords(requestContext) {
+        const accountingSequenceId = this.getRequiredString("accountingSequenceId");
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountingRecords(this.context, requestContext.clientId, requestContext.fiscalYearId, accountingSequenceId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGetAccountingRecord(requestContext) {
+        const accountingSequenceId = this.getRequiredString("accountingSequenceId");
+        const accountingRecordId = this.getRequiredString("accountingRecordId");
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountingRecord(this.context, requestContext.clientId, requestContext.fiscalYearId, accountingSequenceId, accountingRecordId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+}
+exports.AccountingSequenceResourceHandler = AccountingSequenceResourceHandler;

package/dist/nodes/Accounting/handlers/AccountingStatisticsResourceHandler.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountingStatisticsResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Accounting Statistics operations
+ * Manages operations related to accounting statistics data
+ */
+class AccountingStatisticsResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    constructor(context, itemIndex) {
+        super(context, itemIndex);
+    }
+    async execute(operation, requestContext, returnData) {
+        switch (operation) {
+            case "getAll":
+                await this.handleGetAll(requestContext, returnData);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unknown operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async handleGetAll(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const accountingStatistics = await accountingClient_1.datevConnectClient.accounting.getAccountingStatistics(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accountingStatistics);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.AccountingStatisticsResourceHandler = AccountingStatisticsResourceHandler;

package/dist/nodes/Accounting/handlers/AccountingSumsAndBalancesResourceHandler.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountingSumsAndBalancesResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Accounting Sums and Balances operations
+ * Manages operations related to accounting balance sheet and P&L data
+ */
+class AccountingSumsAndBalancesResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    constructor(context, itemIndex) {
+        super(context, itemIndex);
+    }
+    async execute(operation, requestContext, returnData) {
+        switch (operation) {
+            case "getAll":
+                await this.handleGetAll(requestContext, returnData);
+                break;
+            case "get":
+                await this.handleGet(requestContext, returnData);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unknown operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async handleGetAll(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const sumsAndBalances = await accountingClient_1.datevConnectClient.accounting.getAccountingSumsAndBalances(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(sumsAndBalances);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const accountingSumsAndBalancesId = this.getRequiredString("accountingSumsAndBalancesId");
+            const sumsAndBalances = await accountingClient_1.datevConnectClient.accounting.getAccountingSumsAndBalance(this.context, requestContext.clientId, requestContext.fiscalYearId, accountingSumsAndBalancesId);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(sumsAndBalances);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.AccountingSumsAndBalancesResourceHandler = AccountingSumsAndBalancesResourceHandler;

package/dist/nodes/Accounting/handlers/AccountingTransactionKeysResourceHandler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountingTransactionKeysResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Accounting Transaction Keys operations
+ * Manages operations related to transaction key management
+ */
+class AccountingTransactionKeysResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    constructor(context, itemIndex) {
+        super(context, itemIndex);
+    }
+    async execute(operation, requestContext, returnData) {
+        switch (operation) {
+            case "getAll":
+                await this.handleGetAll(requestContext, returnData);
+                break;
+            case "get":
+                await this.handleGet(requestContext, returnData);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unknown operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async handleGetAll(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const accountingTransactionKeys = await accountingClient_1.datevConnectClient.accounting.getAccountingTransactionKeys(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accountingTransactionKeys);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const accountingTransactionKeyId = this.getRequiredString("accountingTransactionKeyId");
+            const queryParams = this.buildQueryParams();
+            const accountingTransactionKey = await accountingClient_1.datevConnectClient.accounting.getAccountingTransactionKey(this.context, requestContext.clientId, requestContext.fiscalYearId, accountingTransactionKeyId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accountingTransactionKey);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.AccountingTransactionKeysResourceHandler = AccountingTransactionKeysResourceHandler;

package/dist/nodes/Accounting/handlers/AccountsPayableResourceHandler.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsPayableResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Accounts Payable operations
+ * Manages operations related to accounts payable (open items on the payable side)
+ */
+class AccountsPayableResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    constructor(context, itemIndex) {
+        super(context, itemIndex);
+    }
+    async execute(operation, requestContext, returnData) {
+        switch (operation) {
+            case "getAll":
+                await this.handleGetAll(requestContext, returnData);
+                break;
+            case "get":
+                await this.handleGet(requestContext, returnData);
+                break;
+            case "getCondensed":
+                await this.handleGetCondensed(requestContext, returnData);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unknown operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async handleGetAll(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const accountsPayable = await accountingClient_1.datevConnectClient.accounting.getAccountsPayable(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accountsPayable);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const accountsPayableId = this.getRequiredString("accountsPayableId");
+            const queryParams = this.buildQueryParams();
+            const accountPayable = await accountingClient_1.datevConnectClient.accounting.getAccountPayable(this.context, requestContext.clientId, requestContext.fiscalYearId, accountsPayableId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accountPayable);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetCondensed(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const condensedAccountsPayable = await accountingClient_1.datevConnectClient.accounting.getAccountsPayableCondensed(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(condensedAccountsPayable);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.AccountsPayableResourceHandler = AccountsPayableResourceHandler;

package/dist/nodes/Accounting/handlers/AccountsReceivableResourceHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsReceivableResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class AccountsReceivableResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async execute(operation, requestContext, returnData) {
+        const sendSuccess = this.createSendSuccess(returnData);
+        try {
+            let response;
+            switch (operation) {
+                case "getAll":
+                    response = await this.handleGetAll(requestContext);
+                    break;
+                case "get":
+                    response = await this.handleGet(requestContext);
+                    break;
+                case "getCondensed":
+                    response = await this.handleGetCondensed(requestContext);
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for resource "accountsReceivable".`, { itemIndex: this.itemIndex });
+            }
+            sendSuccess(response);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetAll(requestContext) {
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountsReceivable(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGet(requestContext) {
+        const accountsReceivableId = this.getRequiredString("accountsReceivableId");
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountReceivable(this.context, requestContext.clientId, requestContext.fiscalYearId, accountsReceivableId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGetCondensed(requestContext) {
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getAccountsReceivableCondensed(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+}
+exports.AccountsReceivableResourceHandler = AccountsReceivableResourceHandler;

package/dist/nodes/Accounting/handlers/BaseResourceHandler.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+/**
+ * Abstract base class for accounting resource handlers
+ * Provides common functionality for authentication, parameter parsing, and response handling
+ */
+class BaseResourceHandler {
+    constructor(context, itemIndex) {
+        this.context = context;
+        this.itemIndex = itemIndex;
+    }
+    /**
+     * Gets an optional string parameter
+     */
+    getOptionalString(name) {
+        const value = this.context.getNodeParameter(name, this.itemIndex, "");
+        return value || undefined;
+    }
+    /**
+     * Gets a required string parameter
+     */
+    getRequiredString(name) {
+        const value = this.context.getNodeParameter(name, this.itemIndex);
+        if (!value) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Parameter "${name}" is required`, { itemIndex: this.itemIndex });
+        }
+        return value;
+    }
+    /**
+     * Gets a number parameter with default value
+     */
+    getNumberParameter(name, defaultValue) {
+        const value = this.context.getNodeParameter(name, this.itemIndex, defaultValue);
+        return typeof value === 'number' ? value : defaultValue;
+    }
+    /**
+     * Parses a JSON parameter
+     */
+    parseJsonParameter(rawValue, parameterLabel) {
+        if (typeof rawValue === 'string') {
+            try {
+                return JSON.parse(rawValue);
+            }
+            catch {
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Invalid JSON in parameter "${parameterLabel}"`, { itemIndex: this.itemIndex });
+            }
+        }
+        return rawValue;
+    }
+    /**
+     * Builds query parameters for API calls
+     */
+    buildQueryParams(additionalParams = {}) {
+        const params = {};
+        // Add OData parameters
+        const top = this.getNumberParameter("top", 100);
+        const skip = this.getNumberParameter("skip", 0);
+        const select = this.getOptionalString("select");
+        const filter = this.getOptionalString("filter");
+        const expand = this.getOptionalString("expand");
+        if (top > 0) {
+            params.top = top;
+        }
+        if (skip > 0) {
+            params.skip = skip;
+        }
+        if (select) {
+            params.select = select;
+        }
+        if (filter) {
+            params.filter = filter;
+        }
+        if (expand && expand !== "") {
+            params.expand = expand === "all" ? "*" : expand;
+        }
+        return { ...params, ...additionalParams };
+    }
+    /**
+     * Creates a success response function that formats and adds data to returnData
+     */
+    createSendSuccess(returnData) {
+        return (payload) => {
+            const formattedData = this.normalizeToObjects(payload !== null && payload !== void 0 ? payload : { success: true });
+            const executionData = this.context.helpers.constructExecutionMetaData(this.context.helpers.returnJsonArray(formattedData), { itemData: { item: this.itemIndex } });
+            returnData.push(...executionData);
+        };
+    }
+    /**
+     * Normalizes JsonValue to IDataObject array for n8n
+     */
+    normalizeToObjects(value) {
+        if (value === null || value === undefined) {
+            return [{}];
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.normalizeToObjects(item)[0]);
+        }
+        if (typeof value === 'object') {
+            return [value];
+        }
+        return [{ value }];
+    }
+    /**
+     * Converts error to string message
+     */
+    toErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        if (error === null || error === undefined) {
+            return 'Unknown error';
+        }
+        return JSON.stringify(error);
+    }
+    /**
+     * Converts error to JsonObject for NodeApiError
+     */
+    toErrorObject(error) {
+        if (error && typeof error === "object") {
+            return error;
+        }
+        const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : "Unknown error");
+        return { message };
+    }
+    /**
+     * Handles errors according to continueOnFail setting
+     */
+    handleError(error, returnData) {
+        if (this.context.continueOnFail()) {
+            returnData.push({
+                json: {
+                    error: this.toErrorMessage(error),
+                },
+                pairedItem: { item: this.itemIndex },
+            });
+            return;
+        }
+        throw new n8n_workflow_1.NodeApiError(this.context.getNode(), this.toErrorObject(error), {
+            itemIndex: this.itemIndex,
+        });
+    }
+}
+exports.BaseResourceHandler = BaseResourceHandler;