@klardaten/n8n-nodes-datevconnect 1.0.2 → 1.0.3

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessPartnersResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Business Partners operations
+ * Manages operations related to debitors (customers) and creditors (suppliers)
+ */
+class BusinessPartnersResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    constructor(context, itemIndex) {
+        super(context, itemIndex);
+    }
+    validateRequiredParameters(requestContext) {
+        if (!requestContext.clientId || !requestContext.fiscalYearId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), 'Client ID and Fiscal Year ID are required for business partner operations', {
+                itemIndex: this.itemIndex,
+            });
+        }
+    }
+    async execute(operation, requestContext, returnData) {
+        switch (operation) {
+            case "getDebitors":
+                await this.handleGetDebitors(requestContext, returnData);
+                break;
+            case "getDebitor":
+                await this.handleGetDebitor(requestContext, returnData);
+                break;
+            case "createDebitor":
+                await this.handleCreateDebitor(requestContext, returnData);
+                break;
+            case "updateDebitor":
+                await this.handleUpdateDebitor(requestContext, returnData);
+                break;
+            case "getNextAvailableDebitor":
+                await this.handleGetNextAvailableDebitor(requestContext, returnData);
+                break;
+            case "getCreditors":
+                await this.handleGetCreditors(requestContext, returnData);
+                break;
+            case "getCreditor":
+                await this.handleGetCreditor(requestContext, returnData);
+                break;
+            case "createCreditor":
+                await this.handleCreateCreditor(requestContext, returnData);
+                break;
+            case "updateCreditor":
+                await this.handleUpdateCreditor(requestContext, returnData);
+                break;
+            case "getNextAvailableCreditor":
+                await this.handleGetNextAvailableCreditor(requestContext, returnData);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unknown operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    // New handle methods for the converted pattern
+    async handleGetDebitors(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            if (!requestContext.clientId || !requestContext.fiscalYearId) {
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), 'Client ID and Fiscal Year ID are required for this operation', {
+                    itemIndex: this.itemIndex,
+                });
+            }
+            const queryParams = this.buildQueryParams();
+            const debitors = await accountingClient_1.datevConnectClient.accounting.getDebitors(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(debitors);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetDebitor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const id = this.context.getNodeParameter("debitorId", this.itemIndex);
+            const queryParams = this.buildQueryParams();
+            const debitor = await accountingClient_1.datevConnectClient.accounting.getDebitor(this.context, requestContext.clientId, requestContext.fiscalYearId, id, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(debitor);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleCreateDebitor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const debitorDataRaw = this.context.getNodeParameter("debitorData", this.itemIndex);
+            const debitorData = this.parseJsonParameter(debitorDataRaw, "debitorData");
+            if (debitorData === undefined) {
+                throw new Error("debitorData is required for creating debitor");
+            }
+            const result = await accountingClient_1.datevConnectClient.accounting.createDebitor(this.context, requestContext.clientId, requestContext.fiscalYearId, debitorData);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(result);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleUpdateDebitor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const debitorId = this.getRequiredString("debitorId");
+            const debitorDataRaw = this.context.getNodeParameter("debitorData", this.itemIndex);
+            const debitorData = this.parseJsonParameter(debitorDataRaw, "debitorData");
+            if (debitorData === undefined) {
+                throw new Error("debitorData is required for updating debitor");
+            }
+            const result = await accountingClient_1.datevConnectClient.accounting.updateDebitor(this.context, requestContext.clientId, requestContext.fiscalYearId, debitorId, debitorData);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(result);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetNextAvailableDebitor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const queryParams = this.buildQueryParams();
+            const nextAvailable = await accountingClient_1.datevConnectClient.accounting.getNextAvailableDebitor(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(nextAvailable);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetCreditors(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const queryParams = this.buildQueryParams();
+            const creditors = await accountingClient_1.datevConnectClient.accounting.getCreditors(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(creditors);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetCreditor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const creditorId = this.getRequiredString("creditorId");
+            const queryParams = this.buildQueryParams();
+            const creditor = await accountingClient_1.datevConnectClient.accounting.getCreditor(this.context, requestContext.clientId, requestContext.fiscalYearId, creditorId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(creditor);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleCreateCreditor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const creditorDataRaw = this.context.getNodeParameter("creditorData", this.itemIndex);
+            const creditorData = this.parseJsonParameter(creditorDataRaw, "creditorData");
+            if (creditorData === undefined) {
+                throw new Error("creditorData is required for creating creditor");
+            }
+            const result = await accountingClient_1.datevConnectClient.accounting.createCreditor(this.context, requestContext.clientId, requestContext.fiscalYearId, creditorData);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(result);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleUpdateCreditor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const creditorId = this.getRequiredString("creditorId");
+            const creditorDataRaw = this.context.getNodeParameter("creditorData", this.itemIndex);
+            const creditorData = this.parseJsonParameter(creditorDataRaw, "creditorData");
+            if (creditorData === undefined) {
+                throw new Error("creditorData is required for updating creditor");
+            }
+            const result = await accountingClient_1.datevConnectClient.accounting.updateCreditor(this.context, requestContext.clientId, requestContext.fiscalYearId, creditorId, creditorData);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(result);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetNextAvailableCreditor(requestContext, returnData) {
+        this.validateRequiredParameters(requestContext);
+        try {
+            const queryParams = this.buildQueryParams();
+            const nextAvailable = await accountingClient_1.datevConnectClient.accounting.getNextAvailableCreditor(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(nextAvailable);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.BusinessPartnersResourceHandler = BusinessPartnersResourceHandler;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientResourceHandler = 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 client-related operations
+ */
+class ClientResourceHandler 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();
+                    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 "client".`, { itemIndex: this.itemIndex });
+            }
+            sendSuccess(response);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetAll() {
+        const top = this.getNumberParameter("top", 100);
+        const skip = this.getNumberParameter("skip", 0);
+        const select = this.getOptionalString("select");
+        const filter = this.getOptionalString("filter");
+        return await accountingClient_1.datevConnectClient.accounting.getClients(this.context, {
+            top,
+            skip,
+            select,
+            filter,
+        });
+    }
+    async handleGet(requestContext) {
+        const clientId = this.getRequiredString("clientId");
+        const select = this.getOptionalString("select");
+        return await accountingClient_1.datevConnectClient.accounting.getClient(this.context, clientId, {
+            ...requestContext,
+            select: select,
+        });
+    }
+}
+exports.ClientResourceHandler = ClientResourceHandler;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostCenterPropertiesResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Cost Center Properties operations
+ * Manages operations related to cost center property management
+ */
+class CostCenterPropertiesResourceHandler 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 costSystemId = this.getRequiredString("costSystemId");
+            const queryParams = this.buildQueryParams();
+            const costCenterProperties = await accountingClient_1.datevConnectClient.accounting.getCostCenterProperties(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costCenterProperties);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const costSystemId = this.getRequiredString("costSystemId");
+            const costCenterPropertyId = this.getRequiredString("costCenterPropertyId");
+            const queryParams = this.buildQueryParams();
+            const costCenterProperty = await accountingClient_1.datevConnectClient.accounting.getCostCenterProperty(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, costCenterPropertyId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costCenterProperty);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.CostCenterPropertiesResourceHandler = CostCenterPropertiesResourceHandler;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostCentersUnitsResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Cost Centers/Units operations
+ * Manages operations related to cost center and cost unit management
+ */
+class CostCentersUnitsResourceHandler 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 costSystemId = this.getRequiredString("costSystemId");
+            const queryParams = this.buildQueryParams();
+            const costCenters = await accountingClient_1.datevConnectClient.accounting.getCostCenters(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costCenters);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const costSystemId = this.getRequiredString("costSystemId");
+            const costCenterId = this.getRequiredString("costCenterId");
+            const queryParams = this.buildQueryParams();
+            const costCenter = await accountingClient_1.datevConnectClient.accounting.getCostCenter(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, costCenterId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costCenter);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.CostCentersUnitsResourceHandler = CostCentersUnitsResourceHandler;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostSequencesResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Cost Sequences operations
+ * Manages operations related to cost accounting sequences
+ */
+class CostSequencesResourceHandler 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 "create":
+                await this.handleCreate(requestContext, returnData);
+                break;
+            case "getCostAccountingRecords":
+                await this.handleGetCostAccountingRecords(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 costSystemId = this.getRequiredString("costSystemId");
+            const queryParams = this.buildQueryParams();
+            const costSequences = await accountingClient_1.datevConnectClient.accounting.getCostSequences(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costSequences);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const costSystemId = this.getRequiredString("costSystemId");
+            const costSequenceId = this.getRequiredString("costSequenceId");
+            const queryParams = this.buildQueryParams();
+            const costSequence = await accountingClient_1.datevConnectClient.accounting.getCostSequence(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, costSequenceId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costSequence);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleCreate(requestContext, returnData) {
+        try {
+            const costSystemId = this.getRequiredString("costSystemId");
+            const costSequenceId = this.getRequiredString("costSequenceId");
+            const costSequenceDataRaw = this.context.getNodeParameter("costSequenceData", this.itemIndex);
+            const costSequenceData = this.parseJsonParameter(costSequenceDataRaw, "costSequenceData");
+            const result = await accountingClient_1.datevConnectClient.accounting.createCostSequence(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, costSequenceId, costSequenceData);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(result);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetCostAccountingRecords(requestContext, returnData) {
+        try {
+            const costSystemId = this.getRequiredString("costSystemId");
+            const costSequenceId = this.getRequiredString("costSequenceId");
+            const queryParams = this.buildQueryParams();
+            const costAccountingRecords = await accountingClient_1.datevConnectClient.accounting.getCostAccountingRecords(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, costSequenceId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costAccountingRecords);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.CostSequencesResourceHandler = CostSequencesResourceHandler;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostSystemsResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for Cost Systems operations
+ * Manages operations related to cost accounting system configurations
+ */
+class CostSystemsResourceHandler 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 {
+            this.validateRequiredParameters(requestContext);
+            const queryParams = this.buildQueryParams();
+            const costSystems = await accountingClient_1.datevConnectClient.accounting.getCostSystems(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costSystems);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            this.validateRequiredParameters(requestContext);
+            const costSystemId = this.getRequiredString("costSystemId");
+            const queryParams = this.buildQueryParams();
+            const costSystem = await accountingClient_1.datevConnectClient.accounting.getCostSystem(this.context, requestContext.clientId, requestContext.fiscalYearId, costSystemId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(costSystem);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    validateRequiredParameters(requestContext) {
+        if (!requestContext.clientId || !requestContext.fiscalYearId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "Client ID and Fiscal Year ID are required for this operation", {
+                itemIndex: this.itemIndex,
+            });
+        }
+    }
+}
+exports.CostSystemsResourceHandler = CostSystemsResourceHandler;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiscalYearResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+class FiscalYearResourceHandler 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 "fiscalYear".`, { itemIndex: this.itemIndex });
+            }
+            sendSuccess(response);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetAll(requestContext) {
+        if (!requestContext.clientId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), 'Client ID is required for this operation', {
+                itemIndex: this.itemIndex,
+            });
+        }
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getFiscalYears(this.context, requestContext.clientId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+    async handleGet(requestContext) {
+        if (!requestContext.clientId || !requestContext.fiscalYearId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), 'Client ID and Fiscal Year ID are required for this operation', {
+                itemIndex: this.itemIndex,
+            });
+        }
+        const queryParams = this.buildQueryParams();
+        const result = await accountingClient_1.datevConnectClient.accounting.getFiscalYear(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+        return result !== null && result !== void 0 ? result : null;
+    }
+}
+exports.FiscalYearResourceHandler = FiscalYearResourceHandler;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralLedgerAccountsResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const accountingClient_1 = require("../../../src/services/accountingClient");
+/**
+ * Handler for General Ledger Accounts operations
+ * Manages operations related to chart of accounts
+ */
+class GeneralLedgerAccountsResourceHandler 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 "getUtilized":
+                await this.handleGetUtilized(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 accounts = await accountingClient_1.datevConnectClient.accounting.getGeneralLedgerAccounts(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accounts);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGet(requestContext, returnData) {
+        try {
+            const generalLedgerAccountId = this.getRequiredString("generalLedgerAccountId");
+            const queryParams = this.buildQueryParams();
+            const account = await accountingClient_1.datevConnectClient.accounting.getGeneralLedgerAccount(this.context, requestContext.clientId, requestContext.fiscalYearId, generalLedgerAccountId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(account);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+    async handleGetUtilized(requestContext, returnData) {
+        try {
+            const queryParams = this.buildQueryParams();
+            const accounts = await accountingClient_1.datevConnectClient.accounting.getUtilizedGeneralLedgerAccounts(this.context, requestContext.clientId, requestContext.fiscalYearId, queryParams);
+            const sendSuccess = this.createSendSuccess(returnData);
+            sendSuccess(accounts);
+        }
+        catch (error) {
+            this.handleError(error, returnData);
+        }
+    }
+}
+exports.GeneralLedgerAccountsResourceHandler = GeneralLedgerAccountsResourceHandler;