@necrolab/dashboard 0.4.3

package/backend/batching.js

@@ -0,0 +1,43 @@
+class Batcher {
+    constructor(callOnBatch, maxSize, maxWaitTime) {
+        this.maxSize = maxSize || 10;
+        this.maxWaitTime = maxWaitTime || 1000;
+        this.lastBatchSent = Date.now();
+        this.inMessages = [];
+        this.callOnBatch = callOnBatch;
+
+        this.checkIfTimeHasPassed();
+    }
+
+    add(msg) {
+        if (msg.type == "task-update") this.inMessages = this.inMessages.filter((t) => t.id != msg.taskId);
+        else if (msg.type == "console" && !msg.log) return;
+
+        this.inMessages.push(msg);
+
+        // Enough messages for new batch
+        if (this.inMessages.length >= this.maxSize) {
+            this.lastBatchSent = Date.now();
+            this.callOnBatch([...this.inMessages]);
+            this.inMessages = [];
+        }
+    }
+
+    checkIfTimeHasPassed() {
+        const loop = async (delay) => {
+            if (Date.now() > this.lastBatchSent + this.maxWaitTime) {
+                // If there is nothing to send, return
+                if (this.inMessages.length !== 0) {
+                    this.callOnBatch([...this.inMessages]);
+                    this.lastBatchSent = Date.now();
+                    this.inMessages = [];
+                }
+            }
+            setTimeout(() => loop(delay), delay);
+        };
+
+        loop(this.maxWaitTime);
+    }
+}
+
+module.exports = Batcher;

package/backend/endpoints.js

@@ -0,0 +1,343 @@
+const { createLogger } = require("./mock-src/classes/logger");
+const TicketMaster = require("./mock-src/ticketmaster");
+const utils = require("./mock-src/classes/utils");
+
+const validateTaskData = require("./validator");
+const logger = createLogger("WEB UI");
+
+const none = (v) => {
+    return v === undefined;
+};
+
+const continueTask = async (data) => {
+    const taskId = data.id;
+    const continueType = data.type;
+
+    if (!continueType)
+        return {
+            error: "continueType cannot be empty"
+        };
+    if (!Bot.Tasks[taskId])
+        return {
+            error: "task does not exist"
+        };
+
+    // Add logic that checks if the task is actually paused
+    if (Bot.Tasks[taskId].status !== "Waiting")
+        return {
+            error: "task is not waiting"
+        };
+
+    Bot.Tasks[taskId].continueType = continueType;
+    return {};
+};
+
+const tasksOpen = async (data) => {
+    const taskId = data.id;
+    if (!Bot.Tasks[taskId])
+        return {
+            error: "task does not exist"
+        };
+    Bot.Tasks[taskId].openBrowser(); // TODO use cookies from task in subprocess
+    return {};
+};
+
+function getStrippedTasks() {
+    var result = {};
+    var entries = Object.entries(Bot.Tasks);
+    for (var i = 0; i < entries.length; i++) result[entries[i][0]] = entries[i][1].stripDown();
+    return result;
+}
+
+const getTasks = async () => {
+    return getStrippedTasks();
+};
+
+const tasksLoadPresale = async (data) => {
+    var { eventId, ticketQty } = data;
+    await createPresaleModeTasks(eventId, ticketQty);
+    return {};
+};
+
+const startTask = async (data) => {
+    const taskId = data.id;
+
+    if (!Bot.Tasks[taskId])
+        return {
+            error: `${taskId} is not a valid taskId`
+        };
+
+    if (Bot.Tasks[taskId].active === true)
+        return {
+            error: "task is already running"
+        };
+
+    if (Bot.Tasks[taskId].status == "Stopped")
+        Bot.Tasks[taskId] = new TicketMaster({
+            taskId: Bot.Tasks[taskId].taskId,
+            ...Bot.Tasks[taskId]
+        });
+    Bot.Tasks[taskId].start();
+    return {};
+};
+
+const stopTask = async (data) => {
+    const taskId = data.id;
+
+    if (!Bot.Tasks[taskId])
+        return {
+            error: `${taskId} is not a valid task`
+        };
+    else if (!Bot.Tasks[taskId].active)
+        return {
+            error: "task is already stopped"
+        };
+
+    Bot.Tasks[taskId].stop();
+    return {};
+};
+
+const deleteTask = async (data) => {
+    const taskId = data.id;
+    if (!Bot.Tasks[taskId])
+        return {
+            error: "task does not exist"
+        };
+
+    Bot.Tasks[taskId].destroy();
+    return {};
+};
+
+const addTask = async (data) => {
+    // Validate task data
+    if (none(data))
+        return {
+            error: "No JSON body"
+        };
+
+    const taskQuantity = data.taskQuantity || 1;
+    for (let c = 0; c < taskQuantity; c++) {
+        let task = JSON.parse(JSON.stringify(data));
+
+        task = await validateTaskData(task);
+        if (typeof task == "string")
+            return {
+                error: task
+            };
+
+        var taskObj = new TicketMaster(task);
+        taskObj.data.openerLink =
+            "necro://eyJzbHVnIjoiaHRKQnR1aTRMMzFmU3BtaVVDQngiLCJjb25maWciOnsib3ZlcndyaXRlUHJveHkiOm51bGwsImRlYnVnIjp0cnVlfX0=";
+        taskObj.data.siteId = data.siteId;
+
+        // if (!Object.values(Bot.Tasks).find((t) => t.email == taskObj.email))
+        Bot.Tasks[taskObj.taskId] = taskObj;
+    }
+    return {};
+};
+const massEditPresaleCode = async (data) => {
+    const { eventId, presaleCode } = data;
+
+    if (!eventId)
+        return {
+            error: "Event ID can not be empty"
+        };
+
+    let exists = !!Object.values(Bot.Tasks).find((t) => t.eventId == eventId);
+    if (!exists)
+        return {
+            error: "Event ID does not exist"
+        };
+
+    await utils.massEditPresaleCode(eventId, presaleCode);
+    pushWSUpdate({
+        event: "edit-presale-code",
+        data: {
+            presaleCode: presaleCode
+        }
+    });
+    return {};
+};
+const scrapeMap = async (data) => {
+    const { eventId, presaleCode } = data;
+
+    if (!eventId)
+        return {
+            error: "Event ID can not be empty"
+        };
+
+    var taskObj = new TicketMaster({
+        taskId: "SCRAPER-" + eventId,
+        account: utils.pickAccount(),
+        eventId: eventId,
+        incapsulaBypass: true,
+        hidden: true,
+        presaleCode: presaleCode
+    });
+    taskObj.scrapeVenue();
+    return {};
+};
+const checkStock = async (data) => {
+    const { eventId } = data;
+
+    if (!eventId)
+        return {
+            error: "Event ID can not be empty"
+        };
+
+    var taskObj = new TicketMaster({
+        taskId: "SCRAPER-" + eventId,
+        eventId: eventId,
+        incapsulaBypass: true,
+        hidden: true
+    });
+    taskObj.scrapeSeats();
+    return {};
+};
+
+async function createPresaleModeTasks(eventId, ticketQty) {
+    const presaleModeSettings = {
+        incapsulaBypass: false,
+        agedAccount: false,
+        manual: false,
+        openCart: false,
+        doNotPay: false,
+        loginAfterCart: false,
+        smartTimer: false
+    };
+
+    var raffleWins = await utils.getCodes();
+
+    var created = false,
+        done = 0;
+
+    while (raffleWins.length != 0) {
+        if (raffleWins.length == 0) {
+            if (done > 0) return logger.Success("Tasks created for all wins:", done);
+            else return logger.Yellow("No tasks to create");
+        }
+
+        var raffleWin = raffleWins.shift();
+
+        if (raffleWin.code != "" && Object.values(Bot.Tasks).find((t) => t.presaleCode == raffleWin.code)) continue;
+
+        var account = Bot.TM.Accounts.find((t) => t.email == raffleWin.email);
+
+        var taskObj = new TicketMaster({
+            account: account || undefined,
+            email: account ? undefined : raffleWin.email,
+            password: account ? undefined : raffleWin.password,
+            eventId: eventId,
+            quantity: ticketQty || 4,
+            presaleMode: true,
+            presaleCode: raffleWin.code == "" ? undefined : raffleWin.code,
+            ...presaleModeSettings
+        });
+
+        Bot.Tasks[taskObj.taskId] = taskObj;
+        created = true;
+        done++;
+    }
+    if (created) logger.Success("Tasks created for all accounts:", done);
+    else return logger.Yellow("No tasks to create");
+}
+
+const createAccounts = async () => {};
+
+const saveAccount = async (account) => {
+    const user = account.user;
+    user.tags = [user.name];
+    Bot[account.module].Accounts.push(account);
+    pushWSUpdate({ event: "add-account", account: account });
+    return {};
+};
+
+const saveProfile = async (profile) => {
+    const user = profile.user;
+
+    let newTags = [];
+    if (!profile.tags.includes(user.name)) newTags.push(user.name);
+
+    profile.tags = profile.tags.filter((t) => !["visa", "amex", "master", user.name].includes(t));
+    profile.profileName = profile.profileName.replace(/\[\w+\]$/, "") + ` [${user.name.toUpperCase()}]`;
+
+    const cn = profile.cardNumber;
+    if (cn.startsWith("4")) newTags.push("visa");
+    else if (cn.startsWith("3")) newTags.push("amex");
+    else if (cn.startsWith("5")) newTags.push("master");
+
+    newTags = [...newTags, ...profile.tags];
+    profile.tags = newTags;
+
+    Bot.Profiles.push(profile);
+    pushWSUpdate({ event: "add-profile", profile: profile });
+    return {};
+};
+
+const deleteProfile = async (profile) => {
+    const { _id } = profile;
+    Bot.Profiles = Bot.Profiles.filter((p) => p._id !== profile._id);
+    pushWSUpdate({ event: "delete-profile", profile: { _id: _id } });
+};
+
+async function handleWebsocketMessage(msg) {
+    const { data } = msg;
+    switch (msg.event) {
+        case "tasks/continue":
+            return await continueTask(data);
+        case "tasks/open":
+            return await tasksOpen(data);
+        case "tasks/delete":
+            return await deleteTask(data);
+        case "tasks/get":
+            return await getTasks();
+        case "tasks/load-presale":
+            return await tasksLoadPresale(data);
+        case "tasks/start":
+            return await startTask(data);
+        case "tasks/stop":
+            return await stopTask(data);
+        case "tasks/add": {
+            pushWSUpdate({ event: "set-button-disabled", button: "add-tasks", value: true });
+            await utils.sleep(1000);
+            const res = await addTask(data);
+            pushWSUpdate({ event: "set-button-disabled", button: "add-tasks", value: false });
+            return res;
+        }
+        case "mass-edit-presale-code":
+            return await massEditPresaleCode(data);
+        case "scrape-map":
+            return await scrapeMap(data);
+        case "check-stock":
+            return await checkStock(data);
+        case "profiles/save":
+            return await saveProfile(data);
+        case "profiles/delete":
+            return await deleteProfile(data);
+        case "accounts/save":
+            return await saveAccount(data);
+        case "accounts/create":
+            return await createAccounts(data);
+        default:
+            logger.Error("Unknown websocket request:", msg);
+            return {
+                error: "unknown event"
+            };
+    }
+}
+
+module.exports = {
+    continueTask,
+    tasksOpen,
+    deleteTask,
+    getTasks,
+    tasksLoadPresale,
+    startTask,
+    stopTask,
+    addTask,
+    massEditPresaleCode,
+    scrapeMap,
+    checkStock,
+    handleWebsocketMessage,
+    getStrippedTasks
+};

package/backend/index.js

@@ -0,0 +1,23 @@
+const { users, profiles, tmAccounts, axsAccounts } = require("./mock-data");
+
+const Bot = {};
+
+Bot.ConsoleBuffer = [];
+Bot.Tasks = {};
+Bot.CurrentTaskId = 0;
+Bot.Settings = { DebugMode: true };
+Bot.Monitors = {};
+Bot.Users = users;
+Bot.Profiles = profiles;
+
+global.Bot = Bot;
+
+Bot.TM = {
+    Accounts: tmAccounts
+};
+
+Bot.AXS = {
+    Accounts: axsAccounts
+};
+
+module.exports = require("./api");

package/backend/mock-data.js

@@ -0,0 +1,66 @@
+const users = [
+    {
+        event: "auth",
+        botChannels: {
+            splash: "950761407119511582",
+            carts: "961558093832011807",
+            checkouts: "1025407596120776794",
+            declines: "1027868055696572508",
+            stockChecker: "1099079655962722375",
+            venueMaps: "1099125114450214973"
+        },
+        _id: "641a5292b561088b64fe390b",
+        name: "admin",
+        password: "admin",
+        profilePicture: "https://avatars.githubusercontent.com/u/202437892?s=128",
+        admin: true,
+        proxyList: { checkout: "admin-proxies" },
+        profileTags: ["Amex", "Citi", "Mercury", "Slash"],
+        accountTags: ["admin"]
+    }
+];
+
+const profile = {
+    _id: "645a82606ef8b7201b728805",
+    enabled: false,
+    profileName: "Master US 43725 [admin]",
+    address: "88081 Piper Ways",
+    city: "Gilbert",
+    state: "MN",
+    country: "US",
+    zipCode: "55741",
+    cardNumber: "4111111111111111",
+    expMonth: "05",
+    expYear: "2027",
+    cvv: "136",
+    totalSpent: 905.75,
+    orders: ["sandersonsandezomar1239@gmail.com - 35-57435/NCA - 1C005E7E94D81D8A - 1684344138367 - Melanie Martinez"],
+    tags: ["admin", "master", "slash"],
+    checkouts: 1,
+    declines: 0,
+    createdBy: "admin"
+};
+
+const profiles = [];
+for (let i = 0; i < 1000; i++) profiles.push({ ...profile, _id: i });
+
+module.exports = {
+    users,
+    profiles,
+    tmAccounts: [
+        {
+            tags: ["admin"],
+            _id: 1,
+            password: "123",
+            email: "tm@tm.com"
+        }
+    ],
+    axsAccounts: [
+        {
+            tags: ["admin"],
+            _id: 2,
+            password: "123",
+            email: "axs@axs.com"
+        }
+    ]
+};

package/backend/mock-src/classes/logger.js

@@ -0,0 +1,112 @@
+const util = require("node:util");
+
+const zeroPadding = (num, length) => String(num).padStart(length, "0");
+
+const timestamp = () => {
+    const now = new Date();
+    const hours = zeroPadding(now.getHours(), 2);
+    const minutes = zeroPadding(now.getMinutes(), 2);
+    const seconds = zeroPadding(now.getSeconds(), 2);
+    const milli = zeroPadding(now.getMilliseconds(), 3);
+
+    const ts = `${hours}:${minutes}:${seconds}.${milli}`;
+    return ts;
+};
+
+const LOG_COLORS = {
+    error: "\x1B[91m",
+    success: "\x1B[92m",
+    info: "\x1B[96m",
+    debug: "\x1B[95m",
+    black: "\u001b[30m",
+    red: "\u001b[31m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    blue: "\u001b[34m",
+    magenta: "\u001b[35m",
+    cyan: "\u001b[36m",
+    white: "\u001b[37m",
+    reset: "\u001b[0m"
+};
+
+class Logger {
+    constructor() {
+        this.ENABLED = true;
+        this.URGENT = false;
+        this.originalLog = console.log;
+
+        this.user = null;
+        this.global = false;
+        this.siteId = null;
+        this.taskId = null;
+    }
+
+    logToWorker(...args) {
+        const formattedMessage = util.format(...args);
+        if (global.Bot) {
+            Bot.ConsoleBuffer?.push({
+                log: formattedMessage,
+                metadata: {
+                    global: this.global || !this.user,
+                    user: this.user,
+                    siteId: this.siteId,
+                    taskId: this.taskId
+                }
+            });
+        }
+        return this.originalLog(...args);
+    }
+
+    log(...args) {
+        if (!this.ENABLED) return;
+
+        let color = "\x1B[97m";
+        if (args[args.length - 1] in LOG_COLORS) {
+            color = LOG_COLORS[args.pop()];
+        }
+
+        if (this.defaultArgs) this.defaultArgs.forEach((t) => args.unshift(`${color}[${t}]\x1B[00m`));
+
+        args.unshift(`${color}[${timestamp()}]\x1B[00m`);
+
+        this.logToWorker(...args);
+    }
+
+    Error(...args) {
+        const formattedArgs = args.map((arg) => {
+            if (arg instanceof Error) return arg.stack || arg.toString();
+            else if (arg instanceof Object) return JSON.stringify(arg, null, 4);
+
+            return arg;
+        });
+        this.log(...formattedArgs, "error");
+    }
+
+    Success(...args) {
+        this.log(...args, "success");
+    }
+
+    Info(...args) {
+        if (!this.URGENT) this.log(...args, "info");
+    }
+
+    Debug(...args) {
+        if (!this.URGENT) this.log(...args, "debug");
+    }
+
+    Yellow(...args) {
+        if (!this.URGENT) this.log(...args, "yellow");
+    }
+
+    Disable() {
+        this.ENABLED = false;
+    }
+}
+
+module.exports = {
+    createLogger: (args) => {
+        const logger = new Logger();
+        logger.defaultArgs = typeof args == "string" ? [args] : typeof args == "object" ? args : undefined;
+        return logger;
+    }
+};

package/backend/mock-src/classes/utils.js

@@ -0,0 +1,42 @@
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const crypto = require("node:crypto");
+
+module.exports = {
+    pickAccount: () => {
+        return "demo@email.com";
+    },
+    pickProxy: () => {
+        return "127.0.0.1";
+    },
+
+    btoa: (i) => {
+        return btoa(i);
+    },
+
+    atob: (i) => {
+        return atob(i);
+    },
+    massEditPresaleCode: async (eventId, presaleCode) => {
+        for (const [, value] of Object.entries(Bot.Tasks)) {
+            if (value.eventId === eventId) {
+                value.presaleCode = presaleCode;
+            }
+        }
+    },
+    uuid: () => {
+        return crypto.randomUUID();
+    },
+    chunk: (arr, len) => {
+        let chunks = [],
+            i = 0,
+            n = arr.length;
+
+        while (i < n) {
+            chunks.push(arr.slice(i, (i += len)));
+        }
+
+        return chunks;
+    },
+    getCodes: () => {},
+    sleep
+};