@klardaten/n8n-nodes-datevconnect 1.0.2 → 1.0.4

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;

package/dist/nodes/Accounting/handlers/BusinessPartnersResourceHandler.d.ts

@@ -0,0 +1,25 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+import { BaseResourceHandler } from "./BaseResourceHandler";
+import type { RequestContext } from "../types";
+type BusinessPartnersOperation = "getDebitors" | "getDebitor" | "createDebitor" | "updateDebitor" | "getNextAvailableDebitor" | "getCreditors" | "getCreditor" | "createCreditor" | "updateCreditor" | "getNextAvailableCreditor";
+/**
+ * Handler for Business Partners operations
+ * Manages operations related to debitors (customers) and creditors (suppliers)
+ */
+export declare class BusinessPartnersResourceHandler extends BaseResourceHandler {
+    constructor(context: IExecuteFunctions, itemIndex: number);
+    private validateRequiredParameters;
+    execute(operation: BusinessPartnersOperation, requestContext: RequestContext, returnData: INodeExecutionData[]): Promise<void>;
+    private handleGetDebitors;
+    private handleGetDebitor;
+    private handleCreateDebitor;
+    private handleUpdateDebitor;
+    private handleGetNextAvailableDebitor;
+    private handleGetCreditors;
+    private handleGetCreditor;
+    private handleCreateCreditor;
+    private handleUpdateCreditor;
+    private handleGetNextAvailableCreditor;
+}
+export {};
+//# sourceMappingURL=BusinessPartnersResourceHandler.d.ts.map

package/dist/nodes/Accounting/handlers/BusinessPartnersResourceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BusinessPartnersResourceHandler.d.ts","sourceRoot":"","sources":["../../../../nodes/Accounting/handlers/BusinessPartnersResourceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAE1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,KAAK,yBAAyB,GAC1B,aAAa,GACb,YAAY,GACZ,eAAe,GACf,eAAe,GACf,yBAAyB,GACzB,cAAc,GACd,aAAa,GACb,gBAAgB,GAChB,gBAAgB,GAChB,0BAA0B,CAAC;AAE/B;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,mBAAmB;gBAC1D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM;IAIzD,OAAO,CAAC,0BAA0B;IAQ5B,OAAO,CACX,SAAS,EAAE,yBAAyB,EACpC,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;YAwCF,iBAAiB;YAwBjB,gBAAgB;YAoBhB,mBAAmB;YAuBnB,mBAAmB;YAyBnB,6BAA6B;YAkB7B,kBAAkB;YAkBlB,iBAAiB;YAoBjB,oBAAoB;YAuBpB,oBAAoB;YAyBpB,8BAA8B;CAiB7C"}

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.d.ts

@@ -0,0 +1,12 @@
+import { type INodeExecutionData } from "n8n-workflow";
+import type { RequestContext } from "../types";
+import { BaseResourceHandler } from "./BaseResourceHandler";
+/**
+ * Handler for all accounting client-related operations
+ */
+export declare class ClientResourceHandler extends BaseResourceHandler {
+    execute(operation: string, requestContext: RequestContext, returnData: INodeExecutionData[]): Promise<void>;
+    private handleGetAll;
+    private handleGet;
+}
+//# sourceMappingURL=ClientResourceHandler.d.ts.map

package/dist/nodes/Accounting/handlers/ClientResourceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientResourceHandler.d.ts","sourceRoot":"","sources":["../../../../nodes/Accounting/handlers/ClientResourceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAG3E,OAAO,KAAK,EAAE,cAAc,EAAmB,MAAM,UAAU,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,mBAAmB;IACtD,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;YA2BF,YAAY;YAiBZ,SAAS;CAaxB"}

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.d.ts

@@ -0,0 +1,16 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+import type { RequestContext } from "../types";
+import { BaseResourceHandler } from "./BaseResourceHandler";
+type CostCenterPropertiesOperation = "getAll" | "get";
+/**
+ * Handler for Cost Center Properties operations
+ * Manages operations related to cost center property management
+ */
+export declare class CostCenterPropertiesResourceHandler extends BaseResourceHandler {
+    constructor(context: IExecuteFunctions, itemIndex: number);
+    execute(operation: CostCenterPropertiesOperation, requestContext: RequestContext, returnData: INodeExecutionData[]): Promise<void>;
+    private handleGetAll;
+    private handleGet;
+}
+export {};
+//# sourceMappingURL=CostCenterPropertiesResourceHandler.d.ts.map

package/dist/nodes/Accounting/handlers/CostCenterPropertiesResourceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostCenterPropertiesResourceHandler.d.ts","sourceRoot":"","sources":["../../../../nodes/Accounting/handlers/CostCenterPropertiesResourceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,KAAK,6BAA6B,GAAG,QAAQ,GAAG,KAAK,CAAC;AAGtD;;;GAGG;AACH,qBAAa,mCAAoC,SAAQ,mBAAmB;gBAC9D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM;IAInD,OAAO,CACX,SAAS,EAAE,6BAA6B,EACxC,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;YAeF,YAAY;YAmBZ,SAAS;CAoBxB"}

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.d.ts

@@ -0,0 +1,16 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+import type { RequestContext } from "../types";
+import { BaseResourceHandler } from "./BaseResourceHandler";
+type CostCentersUnitsOperation = "getAll" | "get";
+/**
+ * Handler for Cost Centers/Units operations
+ * Manages operations related to cost center and cost unit management
+ */
+export declare class CostCentersUnitsResourceHandler extends BaseResourceHandler {
+    constructor(context: IExecuteFunctions, itemIndex: number);
+    execute(operation: CostCentersUnitsOperation, requestContext: RequestContext, returnData: INodeExecutionData[]): Promise<void>;
+    private handleGetAll;
+    private handleGet;
+}
+export {};
+//# sourceMappingURL=CostCentersUnitsResourceHandler.d.ts.map

package/dist/nodes/Accounting/handlers/CostCentersUnitsResourceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostCentersUnitsResourceHandler.d.ts","sourceRoot":"","sources":["../../../../nodes/Accounting/handlers/CostCentersUnitsResourceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,KAAK,yBAAyB,GAAG,QAAQ,GAAG,KAAK,CAAC;AAGlD;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,mBAAmB;gBAC1D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM;IAInD,OAAO,CACX,SAAS,EAAE,yBAAyB,EACpC,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;YAeF,YAAY;YAmBZ,SAAS;CAoBxB"}

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.d.ts

@@ -0,0 +1,18 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+import type { RequestContext } from "../types";
+import { BaseResourceHandler } from "./BaseResourceHandler";
+type CostSequencesOperation = "getAll" | "get" | "create" | "getCostAccountingRecords";
+/**
+ * Handler for Cost Sequences operations
+ * Manages operations related to cost accounting sequences
+ */
+export declare class CostSequencesResourceHandler extends BaseResourceHandler {
+    constructor(context: IExecuteFunctions, itemIndex: number);
+    execute(operation: CostSequencesOperation, requestContext: RequestContext, returnData: INodeExecutionData[]): Promise<void>;
+    private handleGetAll;
+    private handleGet;
+    private handleCreate;
+    private handleGetCostAccountingRecords;
+}
+export {};
+//# sourceMappingURL=CostSequencesResourceHandler.d.ts.map

package/dist/nodes/Accounting/handlers/CostSequencesResourceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostSequencesResourceHandler.d.ts","sourceRoot":"","sources":["../../../../nodes/Accounting/handlers/CostSequencesResourceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,KAAK,sBAAsB,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,0BAA0B,CAAC;AAGvF;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,mBAAmB;gBACvD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM;IAInD,OAAO,CACX,SAAS,EAAE,sBAAsB,EACjC,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;YAqBF,YAAY;YAmBZ,SAAS;YAqBT,YAAY;YAuBZ,8BAA8B;CAoB7C"}