n8n-nodes-ume-v4 4.0.0

package/dist/nodes/Ume/Ume.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
+export declare class Ume implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Ume/Ume.node.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ume = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const operations_data_json_1 = __importDefault(require("./operations-data.json"));
+const BASE_URL_FALLBACK = "https://ume.com.vn/api";
+const resources = operations_data_json_1.default
+    .filter((resource) => Array.isArray(resource.operations) && resource.operations.length > 0);
+const resourceOptions = resources.map((resource) => ({
+    name: resource.name,
+    value: resource.value,
+}));
+const operationIndex = {};
+const dynamicProperties = [];
+function toDisplayLabel(name) {
+    return name
+        .replace(/_/g, " ")
+        .replace(/\s+/g, " ")
+        .replace(/\b\w/g, (char) => char.toUpperCase())
+        .trim();
+}
+for (const resource of resources) {
+    const operations = Array.isArray(resource.operations) ? resource.operations : [];
+    if (operations.length === 0) {
+        continue;
+    }
+    if (resource.info) {
+        const infoRows = Math.min(15, resource.info.split(/\r?\n/).length + 1);
+        dynamicProperties.push({
+            displayName: 'Notes',
+            name: `${resource.value}Info`,
+            type: 'string',
+            default: resource.info,
+            description: 'Reference only; this text is not sent to the API.',
+            typeOptions: {
+                rows: infoRows,
+            },
+            displayOptions: {
+                show: {
+                    resource: [resource.value],
+                },
+            },
+            noDataExpression: true,
+        });
+    }
+    dynamicProperties.push({
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        options: operations.map((operation) => ({
+            name: operation.displayName || toDisplayLabel(operation.name),
+            value: operation.value,
+            description: operation.description,
+        })),
+        default: (_b = (_a = operations[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : "",
+        displayOptions: {
+            show: {
+                resource: [resource.value],
+            },
+        },
+        description: "Select the UME API action to perform.",
+    });
+    for (const operation of operations) {
+        operationIndex[operation.value] = {
+            ...operation,
+            resource: resource.value,
+        };
+        const parameters = Array.isArray(operation.parameters) ? operation.parameters : [];
+        for (const parameter of parameters) {
+            const optionValues = Array.isArray(parameter.options)
+                ? parameter.options.filter((value) => value.trim().length > 0)
+                : [];
+            const property = {
+                displayName: toDisplayLabel(parameter.name),
+                name: parameter.name,
+                type: optionValues.length > 1 ? "options" : "string",
+                default: (_c = parameter.defaultValue) !== null && _c !== void 0 ? _c : (optionValues.length === 1 ? optionValues[0] : ""),
+                displayOptions: {
+                    show: {
+                        resource: [resource.value],
+                        operation: [operation.value],
+                    },
+                },
+                required: false,
+            };
+            if (optionValues.length > 1) {
+                property.options = optionValues.map((value) => ({
+                    name: value,
+                    value,
+                }));
+                property.default = (_d = parameter.defaultValue) !== null && _d !== void 0 ? _d : optionValues[0];
+                property.description = "Choices: " + optionValues.join(", ");
+            }
+            dynamicProperties.push(property);
+        }
+    }
+}
+const additionalParametersProperty = {
+    displayName: "Additional Parameters",
+    name: "additionalParameters",
+    type: "fixedCollection",
+    typeOptions: {
+        multipleValues: true,
+    },
+    placeholder: "Add Parameter",
+    default: {},
+    description: "Send extra form fields that are not listed above.",
+    options: [
+        {
+            displayName: "Parameter",
+            name: "parameter",
+            values: [
+                {
+                    displayName: "Key",
+                    name: "key",
+                    type: "string",
+                    default: "",
+                    required: true,
+                },
+                {
+                    displayName: "Value",
+                    name: "value",
+                    type: "string",
+                    default: "",
+                },
+            ],
+        },
+    ],
+};
+class Ume {
+    constructor() {
+        var _a, _b;
+        this.description = {
+            displayName: "UME",
+            name: "ume",
+            group: ["transform"],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: "Automate actions against the UME social service API.",
+            defaults: {
+                name: "UME",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "umeApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Resource",
+                    name: "resource",
+                    type: "options",
+                    noDataExpression: true,
+                    options: resourceOptions,
+                    default: (_b = (_a = resourceOptions[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : "",
+                    description: "Social platform to target.",
+                },
+                ...dynamicProperties,
+                additionalParametersProperty,
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b;
+        const returnData = [];
+        const items = this.getInputData();
+        const credentials = (await this.getCredentials("umeApi"));
+        if (!credentials || !credentials.token) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "API token is missing in the UME credentials.");
+        }
+        const baseUrl = ((_a = credentials.baseUrl) !== null && _a !== void 0 ? _a : BASE_URL_FALLBACK).replace(/\/+$/, "");
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+            const operationValue = this.getNodeParameter("operation", itemIndex);
+            const operation = operationIndex[operationValue];
+            if (!operation) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operationValue}`, {
+                    itemIndex,
+                });
+            }
+            const parameters = Array.isArray(operation.parameters) ? operation.parameters : [];
+            const formBody = {
+                token: credentials.token,
+            };
+            for (const parameter of parameters) {
+                const value = this.getNodeParameter(parameter.name, itemIndex, "");
+                if (value !== "" && value !== undefined && value !== null) {
+                    const resolvedValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+                    formBody[parameter.name] = resolvedValue;
+                }
+            }
+            if (operation.staticParams) {
+                for (const [key, staticValue] of Object.entries(operation.staticParams)) {
+                    formBody[key] = staticValue;
+                }
+            }
+            const additionalParameters = this.getNodeParameter("additionalParameters", itemIndex, {});
+            if (Array.isArray(additionalParameters.parameter)) {
+                for (const entry of additionalParameters.parameter) {
+                    if (!entry || !entry.key) {
+                        continue;
+                    }
+                    const entryValue = (_b = entry.value) !== null && _b !== void 0 ? _b : "";
+                    formBody[entry.key] = String(entryValue);
+                }
+            }
+            const endpoint = operation.path.replace(/^\/+/, "");
+            const requestOptions = {
+                method: operation.method,
+                uri: `${baseUrl}/${endpoint}`,
+                form: formBody,
+                json: true,
+            };
+            let responseData;
+            try {
+                responseData = await this.helpers.request(requestOptions);
+            }
+            catch (error) {
+                if (error instanceof n8n_workflow_1.NodeOperationError) {
+                    throw error;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });
+            }
+            const responseObject = typeof responseData === "object" && responseData !== null
+                ? responseData
+                : { data: responseData };
+            returnData.push({
+                json: responseObject,
+                pairedItem: {
+                    item: itemIndex,
+                },
+            });
+        }
+        return [returnData];
+    }
+}
+exports.Ume = Ume;