@limetech/n8n-nodes-lime 0.2.9 → 0.3.0

package/nodes/lime-crm/resources/erpConnector/operations/createOrUpdateObjects.operation.ts

@@ -0,0 +1,69 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { startCreateOrUpdateObjectsTask } from '../../../transport';
+import { ERP_CONNECTOR_RESOURCE } from '../../../commons';
+import { LimeCrmData } from '../transform';
+import { waitForTaskCompletion } from '../../../commons/task';
+
+export const description = {
+    name: 'Create Or Update Objects Task',
+    value: 'createOrUpdateObjects',
+    description: 'Sync data between ERP and Lime CRM',
+    action: 'Create or Update Objects',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Data',
+        name: 'data',
+        type: 'json',
+        default: '',
+        description: 'Provide payload',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['createOrUpdateObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Poll Interval',
+        name: 'pollInterval',
+        type: 'number',
+        default: 2,
+        description: 'Seconds between polls',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['createOrUpdateObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Timeout',
+        name: 'timeout',
+        type: 'number',
+        default: 60,
+        description: 'Max total wait time in seconds',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['createOrUpdateObjects'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const data = this.getNodeParameter('data', i) as LimeCrmData;
+    const pollInterval =
+        (this.getNodeParameter('pollInterval', i) as number) * 1000;
+    const timeout = (this.getNodeParameter('timeout', i) as number) * 1000;
+
+    const response = await startCreateOrUpdateObjectsTask(this, data);
+
+    if (!response.success) return response;
+
+    const taskId = response.data.id;
+    return await waitForTaskCompletion(this, taskId, pollInterval, timeout);
+}

package/nodes/lime-crm/resources/erpConnector/operations/transform.operation.ts

@@ -0,0 +1,274 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    INodePropertyCollection,
+} from 'n8n-workflow';
+
+import {
+    CustomLimeTypeNames,
+    Entity,
+    ErpData,
+    ErpSystem,
+    SearchParameters,
+    transform,
+} from '../transform';
+import { ERP_CONNECTOR_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Transform ERP Data',
+    value: 'transformErpData',
+    description:
+        'Transform and map ERP data into the structure required by Lime CRM',
+    action: 'Transform',
+};
+
+type PropertyMappingItem = {
+    defaultPropertyName: string;
+    customPropertyName: string;
+};
+
+type Properties = {
+    properties: PropertyMappingItem[];
+};
+
+type CustomPropertiesMapping = {
+    [key in Entity]: Properties;
+};
+
+const defaults: { [key in Entity]: string[] } = {
+    invoice: [
+        'invoice_number',
+        'company',
+        'customerid',
+        'customer_reference',
+        'coworker',
+        'invoice_type',
+        'invoice_date',
+        'invoice_expires',
+        'currency',
+        'conversionrate',
+        'invoice_sum',
+        'invoice_vat',
+        'invoice_total_sum',
+        'invoice_balance',
+        'paid',
+        'paid_date',
+        'invoice_shredded',
+    ],
+    invoicerow: [
+        'company',
+        'invoice',
+        'item',
+        'description',
+        'units',
+        'row_margin',
+        'row_value',
+        'rowid',
+    ],
+    company: ['erp_id'],
+    coworker: ['name'],
+};
+
+function getLimeTypesPropertiesMapping(): INodeProperties[] {
+    return Object.keys(defaults).map((key) => ({
+        displayName: key,
+        name: key,
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        options: getPropertiesMapping(key as Entity),
+    }));
+}
+
+function getPropertiesMapping(limeType: Entity): INodePropertyCollection[] {
+    return [
+        {
+            displayName: 'Properties',
+            name: 'properties',
+            values: [
+                {
+                    displayName: 'Property',
+                    name: 'defaultPropertyName',
+                    type: 'options',
+                    default: '',
+                    description: 'Name of the property',
+                    options: defaults[limeType]?.map((property) => ({
+                        name: property,
+                        value: property,
+                    })),
+                },
+                {
+                    displayName: 'Custom Property Name',
+                    name: 'customPropertyName',
+                    type: 'string',
+                    default: '',
+                    description: 'Custom name of the property in your Lime CRM',
+                },
+            ],
+        },
+    ];
+}
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'ERP System',
+        name: 'erpSystem',
+        type: 'options',
+        options: [
+            {
+                name: 'Fortnox',
+                value: 'fortnox',
+            },
+        ],
+        required: true,
+        default: '',
+        description: '',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['transformErpData'],
+            },
+        },
+    },
+    {
+        displayName: 'Entity',
+        name: 'entity',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getEntitiesForErpSystem',
+            loadOptionsDependsOn: ['erpSystem'],
+        },
+        required: true,
+        default: '',
+        description: 'Type of entity to sync',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['transformErpData'],
+            },
+        },
+    },
+    {
+        displayName: 'Search Parameters',
+        name: 'searchParameters',
+        type: 'collection',
+        placeholder: 'Add search criteria',
+        default: {},
+        options: [
+            {
+                displayName: 'Search Property',
+                name: 'property',
+                type: 'string',
+                default: '',
+                description: 'Property to search the object by',
+            },
+            {
+                displayName: 'Search Value',
+                name: 'value',
+                type: 'string',
+                default: '',
+                description: 'Value of the search property',
+            },
+            {
+                displayName: 'Create',
+                name: 'create',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to create a new object',
+            },
+        ],
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['transformErpData'],
+            },
+        },
+    },
+    {
+        displayName: 'Custom Lime Type Name',
+        name: 'customLimeTypeNames',
+        type: 'collection',
+        default: {},
+        description: 'Optional custom name for the Lime CRM types.',
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['transformErpData'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Invoice',
+                name: 'invoice',
+                type: 'string',
+                default: 'invoice',
+            },
+            {
+                displayName: 'Invoice Row',
+                name: 'invoicerow',
+                type: 'string',
+                default: 'invoicerow',
+            },
+        ],
+    },
+    {
+        displayName: 'Custom Properties Mapping',
+        name: 'customPropertiesMapping',
+        type: 'collection',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+                operation: ['transformErpData'],
+            },
+        },
+        description: 'Select Lime Type',
+        options: getLimeTypesPropertiesMapping(),
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const data = this.getInputData(i);
+
+    const erpSystem = this.getNodeParameter('erpSystem', i) as ErpSystem;
+    const entity = this.getNodeParameter('entity', i) as Entity;
+    const searchParameters = this.getNodeParameter(
+        'searchParameters',
+        i
+    ) as SearchParameters;
+    const customLimeTypeNames = this.getNodeParameter(
+        'customLimeTypeNames',
+        i
+    ) as CustomLimeTypeNames;
+    const customPropertiesMapping = this.getNodeParameter(
+        'customPropertiesMapping',
+        i
+    ) as CustomPropertiesMapping;
+
+    const customPropertiesNames = Object.fromEntries(
+        Object.entries(customPropertiesMapping).map(
+            ([limeType, { properties }]) => [
+                limeType,
+                Object.fromEntries(
+                    properties.map(
+                        ({ defaultPropertyName, customPropertyName }) => [
+                            defaultPropertyName,
+                            customPropertyName,
+                        ]
+                    )
+                ),
+            ]
+        )
+    );
+
+    return transform(
+        erpSystem,
+        entity,
+        data[0].json as ErpData,
+        searchParameters,
+        customLimeTypeNames,
+        customPropertiesNames
+    );
+}

package/nodes/lime-crm/resources/erpConnector/transform.ts

@@ -0,0 +1,49 @@
+import { FortnoxTransformer } from './transformers';
+
+export type Entity = 'invoice' | 'invoicerow' | 'company' | 'coworker';
+export type ErpSystem = 'fortnox';
+export type ErpData = Record<string, unknown>;
+
+export type CustomLimeTypeNames = Partial<Record<Entity, string>>;
+
+export type CustomPropertiesNames = Partial<
+    Record<Entity, Record<string, string>>
+>;
+
+export type SearchParameters = {
+    property?: string;
+    value?: string | number | boolean;
+    create?: boolean;
+};
+
+export type LimeCrmObjectData = {
+    [key: string]:
+        | LimeCrmData
+        | SearchParameters
+        | string
+        | number
+        | boolean
+        | null;
+};
+
+export type LimeCrmData = LimeCrmObjectData[];
+
+export function transform(
+    erpSystem: ErpSystem,
+    entity: Entity,
+    data: ErpData,
+    searchParameters: SearchParameters,
+    customLimeTypeNames?: CustomLimeTypeNames,
+    customPropertiesNames?: CustomPropertiesNames
+): LimeCrmData {
+    if (erpSystem === 'fortnox') {
+        return new FortnoxTransformer().transform(
+            entity,
+            data,
+            searchParameters,
+            customLimeTypeNames,
+            customPropertiesNames
+        );
+    }
+    throw new Error(`Unsupported ERP system: ${erpSystem}`);
+}

package/nodes/lime-crm/resources/erpConnector/transformers/baseTransformer.ts

@@ -0,0 +1,18 @@
+import {
+    CustomLimeTypeNames,
+    CustomPropertiesNames,
+    Entity,
+    ErpData,
+    LimeCrmData,
+    SearchParameters,
+} from '../transform';
+
+export abstract class BaseTransformer {
+    abstract transform(
+        entity: Entity,
+        data: ErpData,
+        searchParameters: SearchParameters,
+        customLimeTypeNames?: CustomLimeTypeNames,
+        customPropertiesNames?: CustomPropertiesNames
+    ): LimeCrmData;
+}

package/nodes/lime-crm/resources/erpConnector/transformers/fortnox.ts

@@ -0,0 +1,201 @@
+import { BaseTransformer } from './baseTransformer';
+import {
+    CustomLimeTypeNames,
+    CustomPropertiesNames,
+    Entity,
+    ErpData,
+    LimeCrmData,
+    LimeCrmObjectData,
+    SearchParameters,
+} from '../transform';
+
+export interface FortnoxInvoiceRowData extends ErpData {
+    ArticleNumber: string;
+    Description: string;
+    DeliveredQuantity: string;
+    ContributionPercent: string;
+    Total: number;
+    RowId: number;
+}
+
+export interface FortnoxInvoiceData extends ErpData {
+    DocumentNumber: string;
+    InvoiceType: string;
+    InvoiceDate: string;
+    DueDate: string;
+    Currency: string;
+    Net: number;
+    TotalVAT: number;
+    Total: number;
+    Balance: number;
+    FinalPayDate: string | null;
+    CustomerNumber: string;
+    YourReference: string;
+    OurReference: string;
+    InvoiceRows: FortnoxInvoiceRowData[];
+}
+
+export class FortnoxTransformer extends BaseTransformer {
+    readonly INVOICE_MAPPING: {
+        [key: string]: (
+            _data: FortnoxInvoiceData,
+            _customPropertiesNames?: CustomPropertiesNames
+        ) => string | number | boolean | object | null;
+    } = {
+        invoice_number: (_data, _customPropertiesNames) =>
+            _data['DocumentNumber'],
+        invoice_type: (_data, _customPropertiesNames) => _data['InvoiceType'],
+        invoice_date: (_data, _customPropertiesNames) => _data['InvoiceDate'],
+        invoice_expires: (_data, _customPropertiesNames) => _data['DueDate'],
+        currency: (_data, _customPropertiesNames) => _data['Currency'],
+        invoice_sum: (_data, _customPropertiesNames) => _data['Net'],
+        invoice_vat: (_data, _customPropertiesNames) => _data['TotalVAT'],
+        invoice_total_sum: (_data, _customPropertiesNames) => _data['Total'],
+        invoice_balance: (_data, _customPropertiesNames) => _data['Balance'],
+        paid: (_data, _customPropertiesNames) => _data['Balance'] === 0,
+        paid_date: (_data, _customPropertiesNames) => _data['FinalPayDate'],
+        invoice_shredded: (_data, _customPropertiesNames) => false,
+        customerid: (_data, _customPropertiesNames) => _data['CustomerNumber'],
+        customer_reference: (_data, _customPropertiesNames) =>
+            _data['YourReference'],
+        company: (_data, _customPropertiesNames) => ({
+            _search: {
+                property:
+                    _customPropertiesNames?.company?.['erp_id'] || 'erp_id',
+                value: _data['CustomerNumber'],
+                create: false,
+            },
+        }),
+        coworker: (_data, _customPropertiesNames) => ({
+            _search: {
+                property: _customPropertiesNames?.coworker?.['name'] || 'name',
+                value: _data['OurReference'],
+                create: false,
+            },
+        }),
+    };
+
+    readonly INVOICE_ROW_MAPPING: {
+        [key: string]: (
+            _data: FortnoxInvoiceRowData,
+            _customPropertiesNames?: CustomPropertiesNames
+        ) => string | number | boolean | object;
+    } = {
+        company: (_data, _customPropertiesNames) => ({
+            _search: {
+                property:
+                    _customPropertiesNames?.company?.['erp_id'] || 'erp_id',
+                value: _data['CustomerNumber'],
+                create: false,
+            },
+        }),
+        invoice: (_data, _customPropertiesNames) => ({
+            _search: {
+                property:
+                    _customPropertiesNames?.invoice?.['invoice_number'] ||
+                    'invoice_number',
+                value: _data['DocumentNumber'],
+                create: false,
+            },
+        }),
+        item: (_data, _customPropertiesNames) => _data['ArticleNumber'],
+        description: (_data, _customPropertiesNames) => _data['Description'],
+        units: (_data, _customPropertiesNames) => +_data['DeliveredQuantity'],
+        row_margin: (_data, _customPropertiesNames) =>
+            +_data['ContributionPercent'],
+        row_value: (_data, _customPropertiesNames) => +_data['Total'],
+        rowid: (_data, _customPropertiesNames) => _data['RowId'],
+    };
+
+    transform(
+        entity: Entity,
+        data: ErpData,
+        searchParameters: SearchParameters,
+        customLimeTypeNames?: CustomLimeTypeNames,
+        customPropertiesNames?: CustomPropertiesNames
+    ): LimeCrmData {
+        if (entity === 'invoice') {
+            {
+                return this._transformInvoice(
+                    data as FortnoxInvoiceData,
+                    searchParameters,
+                    customLimeTypeNames,
+                    customPropertiesNames
+                );
+            }
+        } else {
+            {
+                throw new Error(`Unsupported entity type: ${entity}`);
+            }
+        }
+    }
+
+    protected _transformInvoice(
+        data: FortnoxInvoiceData,
+        searchParameters: SearchParameters,
+        customLimeTypeNames?: CustomLimeTypeNames,
+        customPropertiesNames?: CustomPropertiesNames
+    ): LimeCrmData {
+        const limeCrmData: LimeCrmData = [];
+
+        const invoice: LimeCrmObjectData = {
+            _limetype: customLimeTypeNames?.invoice || 'invoice',
+            _search: searchParameters,
+        };
+
+        for (const [limeCrmKey, getLimeCrmValue] of Object.entries(
+            this.INVOICE_MAPPING
+        )) {
+            invoice[
+                customPropertiesNames?.invoice?.[limeCrmKey] || limeCrmKey
+            ] = getLimeCrmValue(data, customPropertiesNames);
+        }
+        limeCrmData.push(invoice);
+
+        for (const invoiceRow of data['InvoiceRows']) {
+            invoiceRow['DocumentNumber'] = data['DocumentNumber'];
+            invoiceRow['CustomerNumber'] = data['CustomerNumber'];
+            limeCrmData.push(
+                ...this._transformInvoiceRow(
+                    invoiceRow,
+                    {
+                        property:
+                            customPropertiesNames?.invoicerow?.['rowid'] ||
+                            'rowid',
+                        value: invoiceRow['RowId'],
+                        create: true,
+                    },
+                    customLimeTypeNames,
+                    customPropertiesNames
+                )
+            );
+        }
+
+        return limeCrmData;
+    }
+
+    protected _transformInvoiceRow(
+        data: FortnoxInvoiceRowData,
+        searchParameters: SearchParameters,
+        customLimeTypeNames?: CustomLimeTypeNames,
+        customPropertiesNames?: CustomPropertiesNames
+    ): LimeCrmData {
+        const limeCrmData: LimeCrmData = [];
+
+        const invoiceRow: LimeCrmObjectData = {
+            _limetype: customLimeTypeNames?.invoicerow || 'invoicerow',
+            _search: searchParameters,
+        };
+
+        for (const [limeCrmKey, getLimeCrmValue] of Object.entries(
+            this.INVOICE_ROW_MAPPING
+        )) {
+            invoiceRow[
+                customPropertiesNames?.invoicerow?.[limeCrmKey] || limeCrmKey
+            ] = getLimeCrmValue(data, customPropertiesNames);
+        }
+        limeCrmData.push(invoiceRow);
+
+        return limeCrmData;
+    }
+}

package/nodes/lime-crm/resources/erpConnector/transformers/index.ts

@@ -0,0 +1 @@
+export { FortnoxTransformer } from './fortnox';

package/nodes/lime-crm/resources/limeObject/index.ts

@@ -0,0 +1,64 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+} from 'n8n-workflow';
+
+import * as create from './operations/create.operation';
+import * as get from './operations/get.operation';
+import * as update from './operations/update.operation';
+import * as delete_ from './operations/delete.operation';
+import * as search from './operations/search.operation';
+
+import { LIMEOBJECT_RESOURCE } from '../../commons';
+
+export const limeObjectFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+            },
+        },
+        options: [
+            create.description,
+            get.description,
+            update.description,
+            delete_.description,
+            search.description,
+        ],
+        default: 'search',
+    },
+
+    ...create.properties,
+    ...get.properties,
+    ...update.properties,
+    ...delete_.properties,
+    ...search.properties,
+];
+
+export async function limeObjectOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+) {
+    if (operation === 'create') {
+        return await create.execute.call(this, i);
+    }
+    if (operation === 'get') {
+        return await get.execute.call(this, i);
+    }
+    if (operation === 'update') {
+        return await update.execute.call(this, i);
+    }
+    if (operation === 'delete') {
+        return await delete_.execute.call(this, i);
+    }
+    if (operation === 'search') {
+        return await search.execute.call(this, i);
+    }
+
+    return null;
+}