n8n-nodes-soar 0.1.21 → 0.1.23

package/dist/nodes/Platform/Vulbox/api.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RESOURCES: function() {
+        return RESOURCES;
+    },
+    VulboxApi: function() {
+        return VulboxApi;
+    }
+});
+const _asynclock = /*#__PURE__*/ _interop_require_default(require("async-lock"));
+const _n8nworkflow = require("n8n-workflow");
+const _nodecache = /*#__PURE__*/ _interop_require_default(require("node-cache"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const cache = new _nodecache.default({
+    stdTTL: 60 * 24
+});
+const lock = new _asynclock.default();
+let lastRequestTime = Date.now();
+const REQUEST_INTERVAL = 2000;
+var RESOURCES;
+(function(RESOURCES) {
+    RESOURCES["TASK"] = "bugs/tasks";
+    RESOURCES["VULNERABILITY"] = "vulnerability";
+    RESOURCES["BUSINESS"] = "bugs/business";
+    RESOURCES["VPN"] = "project/vpn";
+})(RESOURCES || (RESOURCES = {}));
+const questionAnswer = {
+    1: 1,
+    2: 1,
+    3: 1,
+    4: [
+        0,
+        1
+    ],
+    5: 1,
+    6: 1,
+    7: 3,
+    8: 1,
+    9: [
+        0,
+        1
+    ],
+    10: 1,
+    11: 4,
+    12: 0,
+    13: 1,
+    14: 1,
+    15: 1,
+    16: 1,
+    18: 1,
+    19: 0,
+    20: 4,
+    21: [
+        0,
+        2
+    ],
+    22: [
+        0,
+        1,
+        2,
+        3
+    ],
+    23: 0
+};
+class NeedQuestionError extends Error {
+}
+class VulboxApiError extends _n8nworkflow.NodeApiError {
+}
+class VulboxApi {
+    async request(options) {
+        while(true){
+            const resp = await lock.acquire("vulboxApi", async ()=>{
+                if (options.cache) {
+                    const cacheKey = JSON.stringify(options);
+                    const cached = cache.get(cacheKey);
+                    if (cached) {
+                        return cached;
+                    }
+                }
+                if (Date.now() - lastRequestTime < REQUEST_INTERVAL) {
+                    await new Promise((resolve)=>setTimeout(resolve, REQUEST_INTERVAL));
+                }
+                this.func.logger.info(`Requesting ${options.url}`);
+                lastRequestTime = Date.now();
+                const resp = await this.func.helpers.httpRequestWithAuthentication.call(this.func, "vulboxApi", options);
+                this.func.logger.info(`Response ${JSON.stringify(resp)}`);
+                if (resp.code !== 200) {
+                    if (resp.code === 429) {} else if (resp.code === 550) {
+                        throw new NeedQuestionError();
+                    } else {
+                        throw new VulboxApiError(this.func.getNode(), resp, {
+                            message: `Vulbox API error response: ${JSON.stringify(resp)}`
+                        });
+                    }
+                }
+                if (options.cache) {
+                    const cacheKey = JSON.stringify(options);
+                    cache.set(cacheKey, resp);
+                }
+                return resp;
+            });
+            if (resp.code === 429) {
+                continue;
+            }
+            return resp.data;
+        }
+    }
+    async listIndustries() {
+        return this.request({
+            method: "GET",
+            url: "https://user.vulbox.com/api/hacker/common/industry",
+            cache: true
+        });
+    }
+    async listAreas() {
+        return this.request({
+            method: "GET",
+            url: "https://user.vulbox.com/api/hacker/common/area",
+            cache: true
+        });
+    }
+    async listBugTypes() {
+        return this.request({
+            method: "GET",
+            url: "https://user.vulbox.com/api/hacker/bugs/bug_type/list",
+            cache: true
+        });
+    }
+    async list(resource, full, options) {
+        const resp = await this.request({
+            method: "GET",
+            url: `https://user.vulbox.com/api/hacker/${resource}${resource === "bugs/business" ? "" : "/list"}`,
+            qs: options
+        });
+        if (full) {
+            return resp;
+        } else {
+            return resp.data;
+        }
+    }
+    async submitBug(request) {
+        try {
+            const resp = await this.request({
+                method: "POST",
+                url: "https://user.vulbox.com/api/hacker/bugs/bugs",
+                body: request
+            });
+            return {
+                code: 200,
+                msg: "success",
+                data: resp
+            };
+        } catch (e) {
+            if (e instanceof NeedQuestionError) {
+                await this.solveQuestion();
+                return await this.submitBug(request);
+            } else if (e instanceof VulboxApiError) {
+                return e.cause;
+            } else {
+                throw e;
+            }
+        }
+    }
+    async solveQuestion() {
+        const questions = await this.request({
+            method: "GET",
+            url: "https://user.vulbox.com/api/hacker/question"
+        });
+        const answers = questions.reduce((acc, cur)=>{
+            acc[cur.id] = questionAnswer[cur.id];
+            return acc;
+        }, {});
+        await this.request({
+            method: "POST",
+            url: "https://user.vulbox.com/api/hacker/question",
+            body: {
+                question_ids: answers
+            }
+        });
+    }
+    constructor(func){
+        _define_property(this, "func", void 0);
+        this.func = func;
+    }
+}

package/dist/nodes/Platform/Vulbox/methods.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "methods", {
+    enumerable: true,
+    get: function() {
+        return methods;
+    }
+});
+const _api = require("./api");
+const methods = {
+    listSearch: {
+        async listBusinesses (filter, paginationToken) {
+            const client = new _api.VulboxApi(this);
+            const page = paginationToken ? parseInt(paginationToken) : 1;
+            const resp = await client.list(_api.RESOURCES.BUSINESS, true, {
+                search_value: filter ?? "",
+                page: page
+            });
+            return {
+                results: resp.data.map((n)=>({
+                        name: `${n.bus_name}|${n.bus_url}`,
+                        url: n.bus_url,
+                        value: JSON.stringify(n)
+                    })),
+                paginationToken: page === resp.last_page ? undefined : page + 1
+            };
+        },
+        async listTasks (filter, paginationToken) {
+            const client = new _api.VulboxApi(this);
+            const page = paginationToken ? parseInt(paginationToken) : 1;
+            const resp = await client.list(_api.RESOURCES.TASK, true, {
+                search_value: filter ?? "",
+                page: page
+            });
+            return {
+                results: resp.data.map((n)=>({
+                        name: n.task_title,
+                        value: n.id
+                    })),
+                paginationToken: page === resp.last_page ? undefined : page + 1
+            };
+        }
+    },
+    loadOptions: {
+        async listAreas () {
+            const client = new _api.VulboxApi(this);
+            const resp = await client.listAreas();
+            return resp.flatMap(({ name: parentName, children })=>children.map(({ name })=>[
+                        parentName,
+                        name
+                    ])).map((v)=>({
+                    name: v.join("/"),
+                    value: v.join("/")
+                }));
+        },
+        async listIndustries () {
+            const client = new _api.VulboxApi(this);
+            const resp = await client.listIndustries();
+            return resp.map(({ title })=>title).map((v)=>({
+                    name: v,
+                    value: v
+                }));
+        },
+        async listIndustryCategories () {
+            const client = new _api.VulboxApi(this);
+            const resp = await client.listIndustries();
+            const industry = this.getNodeParameter("industry");
+            return resp.find(({ title })=>title === industry)?.children?.map(({ title })=>({
+                    name: title,
+                    value: title
+                })) ?? [];
+        },
+        async listTopLevelBugTypes () {
+            const client = new _api.VulboxApi(this);
+            const resp = await client.listBugTypes();
+            return resp.map((v)=>({
+                    name: v.title,
+                    value: v.title
+                }));
+        },
+        async listBugTypes () {
+            const client = new _api.VulboxApi(this);
+            const resp = await client.listBugTypes();
+            const flatBugTypes = [];
+            const topLevelBugType = this.getNodeParameter("bug_type_top");
+            const topLevelBugTypeObj = resp.find(({ title })=>title === topLevelBugType);
+            if (!topLevelBugTypeObj) {
+                return [];
+            }
+            function flatten(bugTypes = [], prefix = [], path = []) {
+                for (const { id, title, children } of bugTypes){
+                    if (!children) {
+                        flatBugTypes.push({
+                            name: [
+                                ...prefix,
+                                title
+                            ].join("/"),
+                            value: JSON.stringify([
+                                ...path,
+                                id
+                            ].map((v)=>v.toString()))
+                        });
+                    } else {
+                        flatten(children, [
+                            ...prefix,
+                            title
+                        ], [
+                            ...path,
+                            id
+                        ]);
+                    }
+                }
+            }
+            flatten(topLevelBugTypeObj.children ?? [], [
+                topLevelBugTypeObj.title
+            ], [
+                topLevelBugTypeObj.id
+            ]);
+            return flatBugTypes;
+        }
+    }
+};