n8n-nodes-ume-v4 4.0.0

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

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

package/dist/nodes/UmeSocialSeeding/UmeSocialSeeding.node.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UmeSocialSeeding = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const UmeSocialSeedingHelpers_1 = require("./UmeSocialSeedingHelpers");
+const services_data_json_1 = __importDefault(require("./services-data.json"));
+const BASE_URL = "https://ume.com.vn/api";
+// Function to extract UID from Facebook URL
+function extractUidFromUrl(input) {
+    // If input is already a number, return as is
+    if (/^\d+$/.test(input)) {
+        return input;
+    }
+    // Facebook URL patterns
+    const facebookPatterns = [
+        /facebook\.com\/.*\/posts\/pfbid([A-Za-z0-9]+)/, // For posts with pfbid
+        /facebook\.com\/.*\/posts\/(\d+)/, // For posts with numeric ID
+        /facebook\.com\/.*\/photo\/\?fbid=([\d]+)/, // Photo fbid
+        /facebook\.com\/.*\/permalink\.php\?story_fbid=([\d]+)/, // Story fbid
+        /facebook\.com\/(\d+)/, // Direct numeric ID
+        /facebook\.com\/pages\/[^\/]+\/(\d+)/, // Page with numeric ID
+        /facebook\.com\/([^\/\?]+)/, // Username (e.g., neversaynever504)
+        /pfbid([A-Za-z0-9]+)/, // Standalone pfbid
+        /story_fbid=([\d]+)/, // Story fbid param
+        /fbid=([\d]+)/, // General fbid param
+    ];
+    for (const pattern of facebookPatterns) {
+        const match = input.match(pattern);
+        if (match && match[1]) {
+            // For the posts/pfbid pattern, we need to reconstruct the full ID
+            if (pattern.toString().includes('posts\\/pfbid')) {
+                return 'pfbid' + match[1];
+            }
+            // For standalone pfbid pattern
+            else if (pattern.toString().includes('pfbid')) {
+                return 'pfbid' + match[1];
+            }
+            return match[1];
+        }
+    }
+    // Special handling for Facebook usernames (only if no patterns matched)
+    if (input.includes('facebook.com/') && !input.includes('/posts/') && !input.includes('/photo/') && !input.includes('permalink.php')) {
+        const usernameMatch = input.match(/facebook\.com\/([^\/\?]+)/);
+        if (usernameMatch && usernameMatch[1]) {
+            // Return username for Facebook pages (most APIs accept usernames)
+            return usernameMatch[1];
+        }
+    }
+    // If no pattern matches, return original input
+    return input;
+}
+function getPlatformDisplayName(platform) {
+    const platformNames = {
+        'facebook': 'Facebook',
+        'instagram': 'Instagram',
+        'tiktok': 'TikTok',
+        'youtube': 'YouTube',
+        'telegram': 'Telegram',
+        'twitter': 'Twitter/X',
+        'threads': 'Threads',
+        'shopee': 'Shopee',
+    };
+    return platformNames[platform] || platform.toUpperCase();
+}
+class UmeSocialSeeding {
+    constructor() {
+        this.description = {
+            displayName: "UME Social Seeding",
+            name: "umeSocialSeeding",
+            group: ["transform"],
+            version: 1,
+            subtitle: '={{$parameter["platform"]}} - {{$parameter["service"]}}',
+            description: "Hệ thống seeding mạng xã hội UME.COM.VN - Tăng Like, Sub, View cho các nền tảng mạng xã hội",
+            icon: "file:reaction.png",
+            defaults: {
+                name: "UME Social Seeding",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "umeApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Nền tảng",
+                    name: "platform",
+                    type: "options",
+                    noDataExpression: true,
+                    options: Object.keys(services_data_json_1.default).map(key => ({
+                        name: getPlatformDisplayName(key),
+                        value: key,
+                        description: `Các dịch vụ tăng tương tác cho ${getPlatformDisplayName(key)}`,
+                    })),
+                    default: "facebook",
+                    description: "Chọn nền tảng mạng xã hội cần seeding",
+                },
+                ...(0, UmeSocialSeedingHelpers_1.getDynamicProperties)(),
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c;
+        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).replace(/\/+$/, "");
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+            const platform = this.getNodeParameter("platform", itemIndex);
+            const serviceName = this.getNodeParameter("service", itemIndex);
+            const platformData = services_data_json_1.default[platform];
+            if (!platformData) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid platform: ${platform}`, { itemIndex });
+            }
+            const serviceData = platformData[serviceName];
+            if (!serviceData) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid service: ${serviceName}`, { itemIndex });
+            }
+            // Build form data
+            const formBody = {
+                token: credentials.token,
+            };
+            // Add service-specific parameters
+            for (const parameter of serviceData.parameters) {
+                if (parameter.type === 'string') {
+                    const value = this.getNodeParameter(parameter.name, itemIndex, "");
+                    if (parameter.name === 'uid') {
+                        // Extract UID from URL for Facebook services
+                        const extractedValue = extractUidFromUrl(value.trim() || '');
+                        formBody[parameter.name] = extractedValue;
+                    }
+                    else if (parameter.name === 'link') {
+                        // For Instagram, TikTok, YouTube - send the URL as-is without extraction
+                        formBody[parameter.name] = value.trim();
+                    }
+                    else if (parameter.name === 'note') {
+                        // Set default note if empty
+                        formBody[parameter.name] = value.trim() || "Auto-generated by n8n UME Social Seeding";
+                    }
+                    else if (value && value.trim() !== "") {
+                        formBody[parameter.name] = value.trim();
+                    }
+                }
+                else if (parameter.type === 'number') {
+                    const value = this.getNodeParameter(parameter.name, itemIndex);
+                    if (value !== undefined && value !== null && !isNaN(Number(value))) {
+                        formBody[parameter.name] = Number(value).toString();
+                    }
+                }
+                else if (parameter.type === 'options') {
+                    const value = this.getNodeParameter(parameter.name, itemIndex, "");
+                    if (value && value.trim() !== "") {
+                        formBody[parameter.name] = value.trim();
+                    }
+                }
+            }
+            // Make API request
+            const endpoint = serviceData.endpoint.replace(/^\/+/, "");
+            const requestOptions = {
+                method: "POST",
+                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 };
+            // Add service metadata to response
+            responseObject._umeService = {
+                platform,
+                service: serviceName,
+                description: ((_c = (_b = serviceData.parameters) === null || _b === void 0 ? void 0 : _b.find((p) => p.name === 'uid' || p.name === 'link')) === null || _c === void 0 ? void 0 : _c.description) || '',
+                endpoint: serviceData.endpoint,
+            };
+            returnData.push({
+                json: responseObject,
+                pairedItem: {
+                    item: itemIndex,
+                },
+            });
+        }
+        return [returnData];
+    }
+}
+exports.UmeSocialSeeding = UmeSocialSeeding;

package/dist/nodes/UmeSocialSeeding/UmeSocialSeedingHelpers.d.ts

@@ -0,0 +1,4 @@
+import type { INodeProperties } from "n8n-workflow";
+export declare function getDynamicProperties(): INodeProperties[];
+export declare function extractIdFromUrl(url: string, serviceKey?: string): string;
+export declare function generateAutoNote(serviceName: string, platform: string, inputData: any): string;

package/dist/nodes/UmeSocialSeeding/UmeSocialSeedingHelpers.js

@@ -0,0 +1,382 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamicProperties = getDynamicProperties;
+exports.extractIdFromUrl = extractIdFromUrl;
+exports.generateAutoNote = generateAutoNote;
+const services_data_json_1 = __importDefault(require("./services-data.json"));
+function getServerDetails(serviceData, serverId) {
+    if (!serviceData || !serviceData.servers) {
+        return "Không có thông tin chi tiết";
+    }
+
+    const server = serviceData.servers.find(s => s.id === serverId || s.server_id === serverId);
+    if (!server) {
+        return "Không tìm thấy thông tin server";
+    }
+
+    let details = [];
+
+    // Only show features, not price/quantity/status
+    if (server.features && server.features.length > 0) {
+        details.push("Features:");
+        server.features.forEach(feature => {
+            // Remove bullet points and add proper formatting
+            const cleanFeature = feature.replace(/^[-*]\s*/, '').trim();
+            details.push(`• ${cleanFeature}`);
+        });
+    } else {
+        details.push("Không có features đặc biệt");
+    }
+
+    return details.join('\n');
+}
+
+function getDynamicProperties() {
+    var _a, _b, _c;
+    const properties = [];
+    // Generate service options for each platform
+    for (const [platformKey, platformData] of Object.entries(services_data_json_1.default)) {
+        const platformServices = platformData;
+        const serviceOptions = Object.keys(platformServices).map(serviceName => ({
+            name: getServiceDisplayName(platformKey, serviceName),
+            value: serviceName,
+        }));
+        properties.push({
+            displayName: "Dịch vụ",
+            name: "service",
+            type: "options",
+            noDataExpression: true,
+            options: serviceOptions,
+            default: ((_a = serviceOptions[0]) === null || _a === void 0 ? void 0 : _a.value) || "",
+            displayOptions: {
+                show: {
+                    platform: [platformKey],
+                },
+            },
+            description: `Chọn dịch vụ ${getPlatformDisplayName(platformKey)} cần sử dụng`,
+        });
+        // Add service-specific parameters
+        for (const [serviceName, serviceData] of Object.entries(platformServices)) {
+            const serviceParameters = [];
+            // Add server options from services data
+            const serverParam = (_b = serviceData.parameters) === null || _b === void 0 ? void 0 : _b.find((p) => p.name === 'server');
+            if (serverParam === null || serverParam === void 0 ? void 0 : serverParam.options) {
+                serviceParameters.push({
+                    displayName: "Server",
+                    name: "server",
+                    type: "options",
+                    default: serverParam.default || ((_c = serverParam.options[0]) === null || _c === void 0 ? void 0 : _c.value) || "",
+                    options: serverParam.options,
+                    displayOptions: {
+                        show: {
+                            platform: [platformKey],
+                            service: [serviceName],
+                        },
+                    },
+                    description: "Chọn server để sử dụng dịch vụ",
+                });
+                // Add server-specific details for each server
+                serverParam.options.forEach((serverOption) => {
+                    serviceParameters.push({
+                        displayName: `Chi tiết ${serverOption.name}`,
+                        name: `server_details_${serverOption.value}`,
+                        type: "string",
+                        default: getServerDetails(serviceData, serverOption.value),
+                        typeOptions: {
+                            rows: 8,
+                        },
+                        displayOptions: {
+                            show: {
+                                platform: [platformKey],
+                                service: [serviceName],
+                                server: [serverOption.value],
+                            },
+                        },
+                        description: "Thông tin chi tiết về server đã chọn",
+                        noDataExpression: true,
+                    });
+                });
+            }
+            // Add all service parameters except server (which we already added)
+            const serviceParametersData = serviceData.parameters || [];
+            for (const parameter of serviceParametersData) {
+                if (parameter.name !== 'server') {
+                    const paramProperty = {
+                        ...parameter,
+                        displayOptions: {
+                            show: {
+                                platform: [platformKey],
+                                service: [serviceName],
+                            },
+                        },
+                    };
+                    serviceParameters.push(paramProperty);
+                }
+            }
+            // Add general note if available
+            serviceParameters.push({
+                displayName: "Lưu ý chung",
+                name: `${serviceName}_general_note`,
+                type: "string",
+                default: getGeneralNote(platformKey, serviceName),
+                typeOptions: {
+                    rows: 10,
+                },
+                displayOptions: {
+                    show: {
+                        platform: [platformKey],
+                        service: [serviceName],
+                    },
+                },
+                description: "Lưu ý quan trọng khi sử dụng dịch vụ",
+                noDataExpression: true,
+            });
+            properties.push(...serviceParameters);
+        }
+    }
+    return properties;
+}
+function getGeneralNote(platform, serviceName) {
+    const servicesData = require('./services-data.json');
+    const platformData = servicesData[platform];
+    const serviceData = platformData && platformData[serviceName];
+
+    if (serviceData && serviceData.warnings && serviceData.warnings.length > 0) {
+        return serviceData.warnings.map((warning, index) => (index + 1) + '. ' + warning).join('\n');
+    }
+
+    // Fallback for services without specific warnings
+    if (platform === 'facebook') {
+        return `Lưu ý khi sử dụng dịch vụ Facebook:
+
+• Hướng dẫn lấy link - Một số lỗi phổ biến:
+  - Link avatar, bìa (và nhớ bật nút Like)
+  - Link dạng post cho video (link chứa từ "post")
+  - Link bài chia sẻ (share bài viết và share video)
+
+• Mỗi UID có thể mua tối đa 30-60 lần tùy server
+
+• Nếu tăng video trong album, vui lòng sử dụng server thích hợp
+
+• Tất cả server không bảo hành tương tác khi bị tụt
+
+• Các trường hợp hủy gói và không lên tương tác:
+  - Bài viết là avatar hoặc ảnh bìa
+  - Tương tác group công khai, video và livestream
+  - Bài viết có link sai hoặc tag người dùng bị chặn
+  - Các UID bị lỗi do không công khai hoặc chưa bật nút Like`;
+    }
+
+    // Default note for other platforms
+    return `Lưu ý khi sử dụng dịch vụ:
+
+• Chỉ hỗ trợ link/dữ liệu công khai
+
+• Đảm bảo link/dữ liệu hợp lệ và hoạt động
+
+• Kiểm tra kỹ trước khi đặt đơn số lượng lớn`;
+}
+
+
+
+
+function getServiceDisplayName(platform, serviceName) {
+    const servicesData = require('./services-data.json');
+    const platformData = servicesData[platform];
+    const serviceData = platformData && platformData[serviceName];
+
+    if (serviceData && serviceData.displayName) {
+        return serviceData.displayName;
+    }
+
+    // Fallback for services without display names
+    return serviceName.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+}
+
+
+function getPlatformDisplayName(platform) {
+    const platformNames = {
+        'facebook': 'Facebook',
+        'instagram': 'Instagram',
+        'tiktok': 'TikTok',
+        'youtube': 'YouTube',
+        'telegram': 'Telegram',
+        'twitter': 'Twitter/X',
+        'threads': 'Threads',
+        'shopee': 'Shopee',
+    };
+    return platformNames[platform] || platform.toUpperCase();
+}
+
+// List of service keys that require UID (URL-to-ID conversion applies)
+const UID_REQUIRED_SERVICES = [
+    'like_speed',
+    'reactions',
+    'follow',
+    'like_page',
+    'like_comment',
+    'comment',
+    'share',
+    'buff_group',
+    'share_group',
+    'review',
+    'view_100k_reel'
+];
+
+// Extract ID from various platform URLs - ONLY for services that need UID
+function extractIdFromUrl(url, serviceKey) {
+    if (!url || typeof url !== 'string') {
+        return url; // Return as-is if not a valid URL
+    }
+
+    // Only apply URL-to-ID conversion for services that require UID
+    if (!UID_REQUIRED_SERVICES.includes(serviceKey)) {
+        return url; // Return original URL for services that need URL
+    }
+
+    // Facebook URLs
+    if (url.includes('facebook.com')) {
+        // Extract pfbid from posts
+        const pfbidMatch = url.match(/pfbid([a-zA-Z0-9]+)/);
+        if (pfbidMatch) return 'pfbid' + pfbidMatch[1];
+
+        // Extract post ID
+        const postMatch = url.match(/\/posts\/([a-zA-Z0-9]+)/);
+        if (postMatch) return postMatch[1];
+
+        // Extract video ID
+        const videoMatch = url.match(/\/videos\/([a-zA-Z0-9]+)/);
+        if (videoMatch) return videoMatch[1];
+
+        // Extract story ID
+        const storyMatch = url.match(/\/stories\/[^\/]+\/([a-zA-Z0-9]+)/);
+        if (storyMatch) return storyMatch[1];
+
+        // Extract from permalink
+        const permalinkMatch = url.match(/permalink\/([a-zA-Z0-9]+)/);
+        if (permalinkMatch) return permalinkMatch[1];
+
+        // Extract numeric ID from username/profile
+        const profileMatch = url.match(/facebook\.com\/([^\/\?]+)/);
+        if (profileMatch && !profileMatch[1].includes('pages')) {
+            return profileMatch[1];
+        }
+    }
+
+    // Instagram URLs
+    if (url.includes('instagram.com')) {
+        // Extract post ID from /p/ or /reel/
+        const postMatch = url.match(/instagram\.com\/(p|reel)\/([a-zA-Z0-9-_]+)/);
+        if (postMatch) return postMatch[2];
+
+        // Extract username from profile
+        const profileMatch = url.match(/instagram\.com\/([^\/\?]+)/);
+        if (profileMatch) return profileMatch[1];
+    }
+
+    // TikTok URLs
+    if (url.includes('tiktok.com')) {
+        // Extract video ID
+        const videoMatch = url.match(/\/video\/([a-zA-Z0-9]+)/);
+        if (videoMatch) return videoMatch[1];
+
+        // Extract username
+        const profileMatch = url.match(/tiktok\.com\/@([^\/\?]+)/);
+        if (profileMatch) return profileMatch[1];
+    }
+
+    // YouTube URLs
+    if (url.includes('youtube.com') || url.includes('youtu.be')) {
+        // Extract video ID from youtu.be
+        const shortMatch = url.match(/youtu\.be\/([a-zA-Z0-9_-]+)/);
+        if (shortMatch) return shortMatch[1];
+
+        // Extract video ID from youtube.com/watch
+        const watchMatch = url.match(/[?&]v=([a-zA-Z0-9_-]+)/);
+        if (watchMatch) return watchMatch[1];
+
+        // Extract channel ID or custom name
+        const channelMatch = url.match(/youtube\.com\/(?:channel\/|c\/|@)?([^\/\?]+)/);
+        if (channelMatch) return channelMatch[1];
+    }
+
+    // Twitter/X URLs
+    if (url.includes('twitter.com') || url.includes('x.com')) {
+        // Extract tweet ID
+        const tweetMatch = url.match(/\/status\/([a-zA-Z0-9]+)/);
+        if (tweetMatch) return tweetMatch[1];
+
+        // Extract username
+        const profileMatch = url.match(/(?:twitter|x)\.com\/([^\/\?]+)/);
+        if (profileMatch) return profileMatch[1];
+    }
+
+    // Threads URLs
+    if (url.includes('threads.net')) {
+        // Extract post ID
+        const postMatch = url.match(/\/post\/([a-zA-Z0-9]+)/);
+        if (postMatch) return postMatch[1];
+
+        // Extract username
+        const profileMatch = url.match(/threads\.net\/@([^\/\?]+)/);
+        if (profileMatch) return profileMatch[1];
+    }
+
+    // Telegram URLs
+    if (url.includes('t.me')) {
+        // Extract post ID
+        const postMatch = url.match(/t\.me\/[^\/]+\/([a-zA-Z0-9]+)/);
+        if (postMatch) return postMatch[1];
+
+        // Extract channel/group name
+        const channelMatch = url.match(/t\.me\/([^\/\?]+)/);
+        if (channelMatch) return channelMatch[1];
+    }
+
+    // Shopee URLs
+    if (url.includes('shopee.vn')) {
+        // Extract product ID
+        const productMatch = url.match(/product\/([a-zA-Z0-9]+)/);
+        if (productMatch) return productMatch[1];
+
+        // Extract shop ID
+        const shopMatch = url.match(/shopee\.vn\/([^\/\?]+)/);
+        if (shopMatch) return shopMatch[1];
+    }
+
+    // Return original URL if no pattern matches
+    return url;
+}
+
+// Generate auto note from n8n execution context
+function generateAutoNote(serviceName, platform, inputData) {
+    const timestamp = new Date().toISOString();
+    const date = new Date().toLocaleDateString('vi-VN');
+    const time = new Date().toLocaleTimeString('vi-VN');
+
+    let note = `🤖 Generated from n8n UME node\n`;
+    note += `📅 ${date} ${time}\n`;
+    note += `🌐 Platform: ${platform}\n`;
+    note += `⚡ Service: ${serviceName}`;
+
+    // Add relevant info based on input data
+    if (inputData.uid) {
+        note += `\n📍 Target: ${inputData.uid}`;
+    }
+    if (inputData.count) {
+        note += `\n🔢 Quantity: ${inputData.count}`;
+    }
+    if (inputData.server) {
+        note += `\n🖥️ Server: ${inputData.server}`;
+    }
+    if (inputData.reaction) {
+        note += `\n❤️ Reaction: ${inputData.reaction}`;
+    }
+
+    note += `\n🆔 Order ID: AUTO-${Date.now()}`;
+
+    return note;
+}