@limetech/n8n-nodes-lime 0.3.8 → 0.5.0

package/nodes/lime-crm/resources/data/operations/getSingleFile.ts

@@ -0,0 +1,138 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+import { getFileContent, getFileContentByLimetype } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Single File',
+    value: 'getSingleFile',
+    description: 'Get the file data for one specific file',
+    action: 'Get single file',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Get by',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+            },
+        },
+        options: [
+            {
+                name: 'File ID',
+                value: 'byFile',
+                description: 'Get file by its ID',
+            },
+            {
+                name: 'Limeobject ID',
+                value: 'byLimeobject',
+                description: "Get file by it's associated Limeobject ID",
+            },
+        ],
+        default: 'byFile',
+    },
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the file or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+            },
+        },
+        placeholder: 'e.g., 12345',
+    },
+    {
+        displayName: 'File type property',
+        name: 'property',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getFileProperties',
+            loadOptionsDependsOn: ['limetype'],
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const source = this.getNodeParameter('source', i) as string;
+    const id = this.getNodeParameter('identifier', i) as string;
+
+    if (source == 'byFile') {
+        const fileResponse = await getFileContent(this, id);
+        if (!fileResponse.success) {
+            return { json: fileResponse };
+        }
+
+        return {
+            json: { success: fileResponse.success },
+            binary: { data: fileResponse.data },
+        };
+    }
+    if (source == 'byLimeobject') {
+        const limetype = this.getNodeParameter('limetype', i) as string;
+        const property = this.getNodeParameter('property', i) as string;
+
+        const fileResponse = await getFileContentByLimetype(
+            this,
+            limetype,
+            id,
+            property
+        );
+        if (!fileResponse.success) {
+            return { json: fileResponse };
+        }
+
+        return {
+            json: { success: fileResponse.success },
+            binary: {
+                data: fileResponse.data,
+            },
+        };
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

package/nodes/lime-crm/resources/data/operations/getSingleObject.ts

@@ -0,0 +1,83 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { getLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+import { getFileProperties, processFileResponse } from '../../../commons/files';
+
+export const description = {
+    name: 'Get Single Object',
+    value: 'getSingleObject',
+    description: 'Get one specific object',
+    action: 'Get single object',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+
+    {
+        displayName: 'Object ID',
+        name: 'objectId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the object to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+    {
+        displayName: 'Include file content',
+        name: 'includeFileContent',
+        type: 'boolean',
+        default: false,
+        description:
+            'Include file binary data if the Limetype has any file properties. ' +
+            'Keep performance in mind before activating this. ' +
+            'For Limetypes without any file properties, this setting is ignored.',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const objectId = this.getNodeParameter('objectId', i) as string;
+    const includeFileContent = this.getNodeParameter(
+        'includeFileContent',
+        i
+    ) as boolean;
+
+    const limeObjectResponse = await getLimeobject(this, limetype, objectId);
+    if (!limeObjectResponse.success) return { json: limeObjectResponse };
+
+    const fileProperties = await getFileProperties(this, limetype);
+    return processFileResponse(
+        this,
+        fileProperties,
+        limeObjectResponse.data,
+        includeFileContent
+    );
+}

package/nodes/lime-crm/resources/{limeObject/operations/update.operation.ts → data/operations/updateSingleObject.operation.ts}

@@ -1,30 +1,35 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { updateLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { updateLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+import {
+    getFileProperties,
+    processFileResponse,
+    setFileProperties,
+} from '../../../commons/files';
 
 // Input fields for update operation
 export const description = {
-    name: 'Update',
-    value: 'update',
-    description: 'Update an existing record',
-    action: 'Update a record',
+    name: 'Update Single Object',
+    value: 'updateSingleObject',
+    description: 'Update one specific object',
+    action: 'Update single object',
 };
 
 export const properties: INodeProperties[] = [
     {
-        displayName: 'LimeType',
-        name: 'limeType',
+        displayName: 'Limetype',
+        name: 'limetype',
         type: 'options',
         typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
+            loadOptionsMethod: 'getLimetypes',
         },
         required: true,
         default: '',
         description: 'The type of entity to update',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -37,8 +42,8 @@ export const properties: INodeProperties[] = [
         description: 'ID of the record to update',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -62,8 +67,8 @@ export const properties: INodeProperties[] = [
         description: 'How to input the data',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -80,8 +85,8 @@ export const properties: INodeProperties[] = [
         },
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
                 inputType: ['json'],
             },
         },
@@ -98,8 +103,8 @@ export const properties: INodeProperties[] = [
         default: {},
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
                 inputType: ['simple'],
             },
         },
@@ -113,8 +118,8 @@ export const properties: INodeProperties[] = [
                         name: 'fieldName',
                         type: 'options',
                         typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
+                            loadOptionsMethod: 'getLimetypeProperties',
+                            loadOptionsDependsOn: ['limetype'],
                         },
                         default: '',
                         description: 'The name of the field',
@@ -133,7 +138,7 @@ export const properties: INodeProperties[] = [
 ];
 
 export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
+    const limetype = this.getNodeParameter('limetype', i) as string;
     const id = this.getNodeParameter('id', i) as string;
     const inputType = this.getNodeParameter('inputType', i) as string;
 
@@ -153,5 +158,28 @@ export async function execute(this: IExecuteFunctions, i: number) {
         }
     }
 
-    return updateLimeObject(this, limeType, id, body);
+    const fileProperties = await getFileProperties(this, limetype);
+
+    const setFilePropertiesResponse = await setFileProperties(
+        this,
+        i,
+        fileProperties,
+        body
+    );
+    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
+
+    const updateLimeobjectResponse = await updateLimeobject(
+        this,
+        limetype,
+        id,
+        body
+    );
+    if (!updateLimeobjectResponse.success) return updateLimeobjectResponse;
+
+    const response = await processFileResponse(
+        this,
+        fileProperties,
+        updateLimeobjectResponse.data
+    );
+    return response.json;
 }

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

@@ -33,11 +33,11 @@ export async function erpConnectorOperations(
     { operation, i }: { operation: string; i: number }
 ) {
     if (operation === 'createOrUpdateObjects') {
-        return await createOrUpdateObjects.execute.call(this, i);
+        return { json: await createOrUpdateObjects.execute.call(this, i) };
     }
     if (operation === 'transformErpData') {
-        return await transform.execute.call(this, i);
+        return { json: await transform.execute.call(this, i) };
     }
 
-    return null;
+    throw new Error(`The operation "${operation}" is not supported!`);
 }

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

@@ -5,7 +5,7 @@ import {
 } from 'n8n-workflow';
 
 import {
-    CustomLimeTypeNames,
+    CustomLimetypeNames,
     Entity,
     ErpData,
     ErpSystem,
@@ -69,7 +69,7 @@ const defaults: { [key in Entity]: string[] } = {
     coworker: ['name'],
 };
 
-function getLimeTypesPropertiesMapping(): INodeProperties[] {
+function getLimetypesPropertiesMapping(): INodeProperties[] {
     return Object.keys(defaults).map((key) => ({
         displayName: key,
         name: key,
@@ -82,7 +82,7 @@ function getLimeTypesPropertiesMapping(): INodeProperties[] {
     }));
 }
 
-function getPropertiesMapping(limeType: Entity): INodePropertyCollection[] {
+function getPropertiesMapping(limetype: Entity): INodePropertyCollection[] {
     return [
         {
             displayName: 'Properties',
@@ -94,7 +94,7 @@ function getPropertiesMapping(limeType: Entity): INodePropertyCollection[] {
                     type: 'options',
                     default: '',
                     description: 'Name of the property',
-                    options: defaults[limeType]?.map((property) => ({
+                    options: defaults[limetype]?.map((property) => ({
                         name: property,
                         value: property,
                     })),
@@ -187,8 +187,8 @@ export const properties: INodeProperties[] = [
         },
     },
     {
-        displayName: 'Custom Lime Type Name',
-        name: 'customLimeTypeNames',
+        displayName: 'Custom Limetype Name',
+        name: 'customLimetypeNames',
         type: 'collection',
         default: {},
         description: 'Optional custom name for the Lime CRM types.',
@@ -224,8 +224,8 @@ export const properties: INodeProperties[] = [
                 operation: ['transformErpData'],
             },
         },
-        description: 'Select Lime Type',
-        options: getLimeTypesPropertiesMapping(),
+        description: 'Select Limetype',
+        options: getLimetypesPropertiesMapping(),
     },
 ];
 
@@ -238,10 +238,10 @@ export async function execute(this: IExecuteFunctions, i: number) {
         'searchParameters',
         i
     ) as SearchParameters;
-    const customLimeTypeNames = this.getNodeParameter(
-        'customLimeTypeNames',
+    const customLimetypeNames = this.getNodeParameter(
+        'customLimetypeNames',
         i
-    ) as CustomLimeTypeNames;
+    ) as CustomLimetypeNames;
     const customPropertiesMapping = this.getNodeParameter(
         'customPropertiesMapping',
         i
@@ -249,8 +249,8 @@ export async function execute(this: IExecuteFunctions, i: number) {
 
     const customPropertiesNames = Object.fromEntries(
         Object.entries(customPropertiesMapping).map(
-            ([limeType, { properties }]) => [
-                limeType,
+            ([limetype, { properties }]) => [
+                limetype,
                 Object.fromEntries(
                     properties.map(
                         ({ defaultPropertyName, customPropertyName }) => [
@@ -268,7 +268,7 @@ export async function execute(this: IExecuteFunctions, i: number) {
         entity,
         data[0].json as ErpData,
         searchParameters,
-        customLimeTypeNames,
+        customLimetypeNames,
         customPropertiesNames
     );
 }

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

@@ -4,7 +4,7 @@ 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 CustomLimetypeNames = Partial<Record<Entity, string>>;
 
 export type CustomPropertiesNames = Partial<
     Record<Entity, Record<string, string>>
@@ -33,7 +33,7 @@ export function transform(
     entity: Entity,
     data: ErpData,
     searchParameters: SearchParameters,
-    customLimeTypeNames?: CustomLimeTypeNames,
+    customLimetypeNames?: CustomLimetypeNames,
     customPropertiesNames?: CustomPropertiesNames
 ): LimeCrmData {
     if (erpSystem === 'fortnox') {
@@ -41,7 +41,7 @@ export function transform(
             entity,
             data,
             searchParameters,
-            customLimeTypeNames,
+            customLimetypeNames,
             customPropertiesNames
         );
     }

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

@@ -1,5 +1,5 @@
 import {
-    CustomLimeTypeNames,
+    CustomLimetypeNames,
     CustomPropertiesNames,
     Entity,
     ErpData,
@@ -12,7 +12,7 @@ export abstract class BaseTransformer {
         entity: Entity,
         data: ErpData,
         searchParameters: SearchParameters,
-        customLimeTypeNames?: CustomLimeTypeNames,
+        customLimetypeNames?: CustomLimetypeNames,
         customPropertiesNames?: CustomPropertiesNames
     ): LimeCrmData;
 }

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

@@ -1,6 +1,6 @@
 import { BaseTransformer } from './baseTransformer';
 import {
-    CustomLimeTypeNames,
+    CustomLimetypeNames,
     CustomPropertiesNames,
     Entity,
     ErpData,
@@ -111,7 +111,7 @@ export class FortnoxTransformer extends BaseTransformer {
         entity: Entity,
         data: ErpData,
         searchParameters: SearchParameters,
-        customLimeTypeNames?: CustomLimeTypeNames,
+        customLimetypeNames?: CustomLimetypeNames,
         customPropertiesNames?: CustomPropertiesNames
     ): LimeCrmData {
         if (entity === 'invoice') {
@@ -119,7 +119,7 @@ export class FortnoxTransformer extends BaseTransformer {
                 return this._transformInvoice(
                     data as FortnoxInvoiceData,
                     searchParameters,
-                    customLimeTypeNames,
+                    customLimetypeNames,
                     customPropertiesNames
                 );
             }
@@ -133,13 +133,13 @@ export class FortnoxTransformer extends BaseTransformer {
     protected _transformInvoice(
         data: FortnoxInvoiceData,
         searchParameters: SearchParameters,
-        customLimeTypeNames?: CustomLimeTypeNames,
+        customLimetypeNames?: CustomLimetypeNames,
         customPropertiesNames?: CustomPropertiesNames
     ): LimeCrmData {
         const limeCrmData: LimeCrmData = [];
 
         const invoice: LimeCrmObjectData = {
-            _limetype: customLimeTypeNames?.invoice || 'invoice',
+            _limetype: customLimetypeNames?.invoice || 'invoice',
             _search: searchParameters,
         };
 
@@ -165,7 +165,7 @@ export class FortnoxTransformer extends BaseTransformer {
                         value: invoiceRow['RowId'],
                         create: true,
                     },
-                    customLimeTypeNames,
+                    customLimetypeNames,
                     customPropertiesNames
                 )
             );
@@ -177,13 +177,13 @@ export class FortnoxTransformer extends BaseTransformer {
     protected _transformInvoiceRow(
         data: FortnoxInvoiceRowData,
         searchParameters: SearchParameters,
-        customLimeTypeNames?: CustomLimeTypeNames,
+        customLimetypeNames?: CustomLimetypeNames,
         customPropertiesNames?: CustomPropertiesNames
     ): LimeCrmData {
         const limeCrmData: LimeCrmData = [];
 
         const invoiceRow: LimeCrmObjectData = {
-            _limetype: customLimeTypeNames?.invoicerow || 'invoicerow',
+            _limetype: customLimetypeNames?.invoicerow || 'invoicerow',
             _search: searchParameters,
         };
 

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

@@ -0,0 +1,57 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import * as getSingleLimetype from './operations/getSingleLimetype';
+import * as getAllLimetypes from './operations/getAllLimetypes.operation';
+import * as getSingleFileMetadata from '../metadata/operations/getSingleFileMetadata';
+import { METADATA_RESOURCE } from '../../commons';
+
+export const metadataFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+            },
+        },
+        options: [
+            getAllLimetypes.description,
+            getSingleLimetype.description,
+            getSingleFileMetadata.description,
+        ],
+        default: 'listTypes',
+    },
+
+    ...getSingleLimetype.properties,
+    ...getSingleFileMetadata.properties,
+];
+
+export async function metadataOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+): Promise<INodeExecutionData> {
+    switch (operation) {
+        case 'getAllLimetypes': {
+            return { json: await getAllLimetypes.execute.call(this) };
+        }
+        case 'getSingleLimetype': {
+            return { json: await getSingleLimetype.execute.call(this, i) };
+        }
+        case 'getSingleFileMetadata': {
+            return { json: await getSingleFileMetadata.execute.call(this, i) };
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}

package/nodes/lime-crm/resources/metadata/operations/getAllLimetypes.operation.ts

@@ -0,0 +1,18 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+
+import { getLimetypesFromApi } from '../../../transport';
+import { Limetype } from '../../../model';
+import { NodeResponse } from '../../../../nodeResponse';
+
+export const description = {
+    name: 'Get all Limetypes',
+    value: 'getAllLimetypes',
+    description: 'Get a list of all available Limetypes',
+    action: 'Get all Limetypes',
+};
+
+export async function execute(
+    this: IExecuteFunctions
+): Promise<NodeResponse<Limetype[]>> {
+    return await getLimetypesFromApi(this);
+}