@limetech/n8n-nodes-lime 0.2.9 → 0.3.1

package/nodes/fortnox/FortnoxTrigger.node.ts

@@ -0,0 +1,196 @@
+import {
+    INodeType,
+    INodeTypeDescription,
+    ITriggerFunctions,
+    ITriggerResponse,
+    NodeConnectionType,
+    NodeOperationError,
+} from 'n8n-workflow';
+import WebSocket from 'ws';
+import { FORTNOX_API_CREDENTIAL_KEY } from './commons';
+
+interface Topic {
+    topic: string;
+    offset?: string | null;
+}
+
+interface Topics {
+    topics: Topic[];
+}
+
+export class FortnoxTrigger implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'Fortnox Trigger',
+        name: 'fortnoxTrigger',
+        icon: 'file:fortnoxLogo.svg',
+        group: ['trigger'],
+        version: 1,
+        description:
+            "Triggers workflows in real time by subscribing to Fortnox's WebSocket API for updates " +
+            'on selected topics like invoices or customers.',
+        defaults: {
+            name: 'Fortnox Trigger',
+        },
+        inputs: [],
+        outputs: [NodeConnectionType.Main],
+        credentials: [
+            {
+                name: FORTNOX_API_CREDENTIAL_KEY,
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Include Child Tenants',
+                name: 'includeChildTenants',
+                type: 'boolean',
+                required: true,
+                default: false,
+            },
+            {
+                displayName: 'Topics',
+                name: 'topicCollection',
+                required: true,
+                type: 'fixedCollection',
+                typeOptions: {
+                    multipleValues: true,
+                },
+                default: {},
+                placeholder: 'Add Topics',
+                description: 'Topics to subscribe to',
+                options: [
+                    {
+                        name: 'topics',
+                        displayName: 'Topics',
+                        values: [
+                            {
+                                displayName: 'Topic',
+                                name: 'topic',
+                                type: 'options',
+                                required: true,
+                                default: 'customers',
+                                options: [
+                                    {
+                                        name: 'Customers',
+                                        value: 'customers',
+                                    },
+                                    {
+                                        name: 'Invoices',
+                                        value: 'invoices',
+                                    },
+                                    {
+                                        name: 'Orders',
+                                        value: 'orders',
+                                    },
+                                ],
+                                description: 'Topic to subscribe to',
+                            },
+                            {
+                                displayName: 'Offset',
+                                name: 'offset',
+                                type: 'string',
+                                default: '',
+                                description:
+                                    'Offset to supply in order to get events replayed up to 14 days back',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+
+    async trigger(this: ITriggerFunctions): Promise<ITriggerResponse> {
+        const includeChildTenants = this.getNodeParameter(
+            'includeChildTenants'
+        ) as boolean;
+        const topicCollection = this.getNodeParameter(
+            'topicCollection',
+            {}
+        ) as Topics;
+
+        const credentials = await this.getCredentials('fortnoxApi');
+
+        if (!credentials.clientSecret) {
+            throw new NodeOperationError(
+                this.getNode(),
+                "Credential 'Client Secret' must be provided for the node to work properly"
+            );
+        }
+
+        const socket = new WebSocket('wss://ws.fortnox.se/topics-v1');
+
+        const startSocket = async () => {
+            const commands = {
+                'Add Tenants': 'add-tenants-v1',
+                'Add Topics': 'add-topics-v1',
+                Subscribe: 'subscribe-v1',
+            };
+
+            socket.on('open', () => {
+                socket.send(
+                    JSON.stringify({
+                        command: commands['Add Tenants'],
+                        includeChildTenants: includeChildTenants,
+                        clientSecret: credentials.clientSecret,
+                        accessTokens: [`Bearer ${credentials.token}`],
+                    })
+                );
+                const data = JSON.stringify({
+                    command: commands['Add Topics'],
+                    topics: topicCollection.topics,
+                });
+                socket.send(data);
+
+                socket.send(
+                    JSON.stringify({
+                        command: commands['Subscribe'],
+                    })
+                );
+            });
+
+            socket.on('message', (data: string) => {
+                const message = JSON.parse(data);
+
+                if (Object.values(commands).includes(message.response)) {
+                    if (message.result != 'ok') {
+                        this.emitError(
+                            new NodeOperationError(
+                                this.getNode(),
+                                `Unexpected response from Fortnox: ${JSON.stringify(message)}`
+                            )
+                        );
+                    }
+                } else {
+                    this.emit([this.helpers.returnJsonArray(message)]);
+                }
+            });
+
+            socket.on('error', (error: Error) => {
+                this.emitError(
+                    new NodeOperationError(
+                        this.getNode(),
+                        'Websocket Error: ' + error.message
+                    )
+                );
+            });
+        };
+
+        const closeFunction = async () => {
+            socket.close();
+        };
+
+        if (this.getMode() === 'manual') {
+            async function manualTriggerFunction() {
+                await startSocket();
+            }
+            return {
+                closeFunction,
+                manualTriggerFunction,
+            };
+        } else {
+            await startSocket();
+            return { closeFunction };
+        }
+    }
+}

package/nodes/fortnox/commons.ts

@@ -0,0 +1,94 @@
+import {
+    INodeProperties,
+    INodePropertyOptions,
+    INodePropertyTypeOptions,
+} from 'n8n-workflow';
+
+export const FORTNOX_API_CREDENTIAL_KEY = 'fortnoxApi';
+
+export type ParameterTypes = 'string' | 'boolean' | 'number';
+
+export type ParameterDefaultValueTypes = string | boolean | number;
+
+export type ParameterDefinition = [
+    displayName: string,
+    name: string,
+    parameterType: ParameterTypes,
+    defaultValue: ParameterDefaultValueTypes,
+    typeOptions: INodePropertyTypeOptions,
+];
+
+export type OptionParameterDefinition = {
+    displayName: string;
+    name: string;
+    parameters: Array<[string, string]>;
+};
+
+export type CollectionParameterDefinition = {
+    displayName: string;
+    name: string;
+    parameters: ParameterDefinition[];
+    multipleValues: boolean;
+};
+
+export const createParameter = (
+    displayName: string,
+    name: string,
+    parameterType: ParameterTypes,
+    defaultValue: ParameterDefaultValueTypes,
+    typeOptions: INodePropertyTypeOptions
+): INodeProperties => ({
+    displayName: displayName,
+    name: name,
+    type: parameterType,
+    default: defaultValue,
+    typeOptions: typeOptions,
+});
+
+export function createOptionParameter(
+    option: OptionParameterDefinition
+): INodeProperties {
+    const parameters: INodePropertyOptions[] = option.parameters.map(
+        ([parameterName, parameterValue]) => {
+            return {
+                name: parameterName,
+                value: parameterValue,
+            };
+        }
+    );
+
+    return {
+        displayName: option.displayName,
+        name: option.name,
+        type: 'options',
+        noDataExpression: true,
+        options: parameters,
+        default: parameters[0].value,
+    };
+}
+
+export function createCollectionParameter(
+    collection: CollectionParameterDefinition
+): INodeProperties {
+    const parameters: INodeProperties[] = collection.parameters.map(
+        ([displayName, name, parameterType, defaultValue, typeOptions]) =>
+            createParameter(
+                displayName,
+                name,
+                parameterType,
+                defaultValue,
+                typeOptions
+            )
+    );
+
+    return {
+        displayName: collection.displayName,
+        typeOptions: {
+            multipleValues: collection.multipleValues,
+        },
+        name: collection.name,
+        default: {},
+        type: 'collection',
+        options: parameters,
+    };
+}

package/nodes/fortnox/fortnoxLogo.svg

@@ -0,0 +1,15 @@
+<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1550 1550" width="1550" height="1550">
+	<title>fortnox-brand-symbol-svg</title>
+	<style>
+		.s0 { fill: #003824 } 
+		.s1 { fill: #007533 } 
+		.s2 { fill: #ffc200 } 
+		.s3 { fill: #00db33 } 
+	</style>
+	<path class="s0" d="m774.4 302.8h243.3c17.6 0 27.1 9.5 27.1 27.1v129.8c0 17.5-9.4 26.9-27.1 26.9h-243.3c-56.7 0-94.5 37.9-94.5 94.6v177h337.8c17.6 0 27.1 9.5 27.1 27v129.8c0 17.6-9.4 27.1-27.1 27.1h-337.8v252.6c0 17.6-9.5 27.1-27.1 27.1h-135.1c-17.6 0-27.1-9.4-27.1-27.1v-608.1c0-168.9 114.9-283.9 283.8-283.9"/>
+	<g>
+		<path class="s1" d="m774.8 1549.9c-148.3 0-294.9-42.5-421.6-124.7-157-101.7-271.7-256.7-323.1-436.3-51-177.8-36.9-367.9 39.6-535.2 12.3-26.8 44-38.6 70.8-26.3 26.7 12.2 38.6 43.9 26.2 70.7-65.9 144.2-78 308.2-34.1 461.5 44.3 154.8 143.3 288.5 278.6 376.2 160.5 104.1 358.5 134.3 543.2 82.8 28.4-7.8 57.8 8.8 65.7 37.1 7.8 28.4-8.8 57.8-37.1 65.6-68.5 19.2-138.5 28.5-208.3 28.5z"/>
+		<path class="s2" d="m1162.9 1436.8c-17.6 0-34.9-8.8-45-24.8-15.8-24.8-8.5-57.8 16.3-73.6 81.1-51.7 148.9-118.8 201.3-199.7 200.5-309.2 112.1-723.8-197-924.3-10.1-6.6-21.2-13.2-34.7-20.9-25.6-14.5-34.7-47-20.1-72.7 14.5-25.6 47-34.7 72.7-20.1 15.5 8.7 28.3 16.4 40.2 24.1 358.5 232.5 460.9 713.4 228.4 1071.9-60.8 93.8-139.4 171.7-233.5 231.6-8.9 5.7-18.8 8.4-28.6 8.4z"/>
+		<path class="s3" d="m234 350.8c-12.5 0-25.2-4.3-35.2-13.2-22.2-19.5-24.3-53.2-4.8-75.3 186.3-211.8 473.6-305.2 749.4-243.7 28.8 6.4 46.9 34.9 40.5 63.7-6.4 28.7-34.9 46.8-63.7 40.4-237.9-53-485.5 27.6-646.3 210-10.5 11.9-25.2 18.1-39.9 18.1z"/>
+	</g>
+</svg>

package/nodes/fortnox/model.ts

@@ -0,0 +1,25 @@
+import { IDataObject } from 'n8n-workflow';
+
+export interface ErrorInformationModel {
+    // fields in ErrorInformationModel can start with lowercase or uppercase,
+    code?: number;
+    Code?: number;
+    error?: number;
+    Error?: number;
+    message?: string;
+    Message?: string;
+}
+
+export interface ErrorResponseModel extends IDataObject {
+    ErrorInformation: ErrorInformationModel;
+}
+
+export interface MetaInformationModel {
+    '@TotalResources': number;
+    '@TotalPages': number;
+    '@CurrentPage': number;
+}
+
+export interface ResponseModel extends IDataObject {
+    MetaInformation: MetaInformationModel;
+}

package/nodes/fortnox/resources/customers/filterParameters.ts

@@ -0,0 +1,47 @@
+import { INodeProperties } from 'n8n-workflow';
+import {
+    createOptionParameter,
+    createParameter,
+    OptionParameterDefinition,
+    ParameterDefinition,
+} from '../../commons';
+
+const optionParametersDefinitions: OptionParameterDefinition[] = [
+    {
+        displayName: 'Activity',
+        name: 'filter',
+        parameters: [
+            ['Active', 'active'],
+            ['Inactive', 'inactive'],
+        ],
+    },
+];
+
+const parametersDefinitions: ParameterDefinition[] = [
+    ['Customer Number', 'customernumber', 'string', '', {}],
+    ['Name', 'name', 'string', '', {}],
+    ['ZIP Code', 'zipcode', 'string', '', {}],
+    ['City', 'city', 'string', '', {}],
+    ['Email', 'email', 'string', '', {}],
+    ['Phone', 'phone', 'string', '', {}],
+    ['Organisation Number', 'organisationnumber', 'string', '', {}],
+    ['GLN', 'gln', 'string', '', {}],
+    ['GLN Delivery', 'glndelivery', 'string', '', {}],
+    ['Last Modified', 'lastmodified', 'string', '', {}],
+];
+
+export const filterParameters: INodeProperties[] = [
+    ...optionParametersDefinitions.map((option) =>
+        createOptionParameter(option)
+    ),
+    ...parametersDefinitions.map(
+        ([displayName, name, filterType, defaultValue, typeOptions]) =>
+            createParameter(
+                displayName,
+                name,
+                filterType,
+                defaultValue,
+                typeOptions
+            )
+    ),
+];

package/nodes/fortnox/resources/customers/index.ts

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

package/nodes/fortnox/resources/customers/model.ts

@@ -0,0 +1,107 @@
+import { ResponseModel } from '../../model';
+
+export interface CustomerBase {
+    '@url': string;
+    Address1: string | null;
+    Address2: string | null;
+    City: string | null;
+    CustomerNumber: number;
+    Email: string | null;
+    Name: string;
+    OrganisationNumber: string;
+    Phone: string | null;
+    ZipCode: number | string | null;
+}
+
+export type DeliveryType = 'PRINT' | 'EMAIL' | 'PRINTSERVICE';
+
+export interface DefaultDeliveryTypes {
+    Invoice: DeliveryType;
+    Order: DeliveryType;
+    Offer: DeliveryType;
+}
+
+export interface DefaultTemplates {
+    Order: string | null;
+    Offer: string | null;
+    Invoice: string | null;
+    CashInvoice: string | null;
+}
+
+export interface CustomerDetails {
+    Address1: string | null;
+    Address2: string | null;
+    City: string | null;
+    Country: string | null;
+    Comments: string | null;
+    Currency: string;
+    CostCenter: string | null;
+    CountryCode: string | null;
+    Active: boolean;
+    CustomerNumber: string;
+    DefaultDeliveryTypes: DefaultDeliveryTypes;
+    DefaultTemplates: DefaultTemplates;
+    DeliveryAddress1: string | null;
+    DeliveryAddress2: string | null;
+    DeliveryCity: string | null;
+    DeliveryCountry: string | null;
+    DeliveryCountryCode: string | null;
+    DeliveryFax: string | null;
+    DeliveryName: string | null;
+    DeliveryPhone1: string | null;
+    DeliveryPhone2: string | null;
+    DeliveryZipCode: string | null;
+    Email: string | null;
+    EmailInvoice: string | null;
+    EmailInvoiceBCC: string | null;
+    EmailInvoiceCC: string | null;
+    EmailOffer: string | null;
+    EmailOfferBCC: string | null;
+    EmailOfferCC: string | null;
+    EmailOrder: string | null;
+    EmailOrderBCC: string | null;
+    EmailOrderCC: string | null;
+    ExternalReference: string | null;
+    Fax: string | null;
+    GLN: string | null;
+    GLNDelivery: string | null;
+    InvoiceAdministrationFee: number | null;
+    InvoiceDiscount: number | null;
+    InvoiceFreight: number | null;
+    InvoiceRemark: string | null;
+    Name: string;
+    OrganisationNumber: string;
+    OurReference: string | null;
+    Phone1: string | null;
+    Phone2: string | null;
+    PriceList: string | null;
+    Project: string | null;
+    SalesAccount: string | null;
+    ShowPriceVATIncluded: boolean;
+    TermsOfDelivery: string | null;
+    TermsOfPayment: string | null;
+    Type: 'PRIVATE' | 'COMPANY';
+    VATNumber: string | null;
+    VATType: 'SEVAT' | 'SEREVERSEDVAT' | 'EUREVERSEDVAT' | 'EUVAT' | 'EXPORT';
+    VisitingAddress: string | null;
+    VisitingCity: string | null;
+    VisitingCountry: string | null;
+    VisitingCountryCode: string | null;
+    VisitingZipCode: string | null;
+    WayOfDelivery: string | null;
+    WWW: string | null;
+    YourReference: string | null;
+    ZipCode: string | null;
+}
+
+export interface Customer extends CustomerDetails {
+    '@url': string;
+}
+
+export interface CustomersResponse extends ResponseModel {
+    Customers: CustomerBase[];
+}
+
+export interface CustomerResponse {
+    Customer: Customer;
+}