@necrolab/dashboard 0.4.3

package/src/stores/connection.js

@@ -0,0 +1,399 @@
+import { useUIStore } from "@/stores/ui";
+import WebsocketHeartbeatJs from "websocket-heartbeat-js";
+import { decode } from "@msgpack/msgpack";
+import router from "@/router/index";
+import { sortTaskIds } from "@/stores/utils";
+
+export class ConnectionHandler {
+    handleWebsocketMessages(msg) {
+        switch (msg.event) {
+            case "startup":
+                if (msg.done) {
+                    this.ui.hideSpinner();
+                    this.ui.setBotVersion(msg.version || "-");
+                } else this.ui.startSpinner(msg.message || "Starting Bot");
+                break;
+
+            case "stop-all":
+                for (const value of Object.values(this.ui.tasks)) {
+                    value.active = false;
+                }
+                this.ui.showSuccess("Stopped all tasks!");
+                break;
+
+            case "start-all":
+                for (const value of Object.values(this.ui.tasks)) {
+                    value.active = true;
+                }
+                this.ui.showSuccess("Started all tasks!");
+                break;
+
+            case "delete-all":
+                this.ui.tasks = {};
+                this.ui.taskIdOrder = [];
+                this.ui.showSuccess("Deleted all tasks!");
+                break;
+
+            case "init-tasks":
+                var oldOrder = [...this.ui.taskIdOrder];
+                this.ui.tasks = msg.tasks;
+                var newIds = Object.keys(msg.tasks);
+
+                var existingIds = oldOrder.filter((id) => newIds.includes(id));
+                var missingTaskIds = newIds.filter((id) => !oldOrder.includes(id));
+                missingTaskIds.sort(sortTaskIds);
+
+                this.ui.taskIdOrder = [...existingIds, ...missingTaskIds];
+                this.ui.refreshQueueStats();
+                this.ui.hideSpinner();
+                break;
+
+            case "init-profiles":
+                this.ui.setProfiles(msg.profiles);
+                this.ui.hideSpinner();
+                break;
+
+            case "init-proxies":
+                this.ui.setProxies(msg.proxies);
+                this.ui.hideSpinner();
+                break;
+
+            case "init-tm-accounts":
+                this.ui.setAccounts(msg.accounts.map((acc) => ({ ...acc, module: "TM" })));
+                this.ui.hideSpinner();
+                break;
+
+            case "init-axs-accounts":
+                this.ui.setAccounts(msg.accounts.map((acc) => ({ ...acc, module: "AXS" })));
+                this.ui.hideSpinner();
+                break;
+
+            case "add-task":
+                this.ui.tasks[msg.task.taskId] = msg.task;
+
+                if (!this.ui.taskIdOrder.includes(msg.task.taskId)) {
+                    let pos = this.ui.taskIdOrder.length;
+                    for (let i = 0; i < this.ui.taskIdOrder.length; i++) {
+                        if (sortTaskIds(msg.task.taskId, this.ui.taskIdOrder[i]) < 0) {
+                            pos = i;
+                            break;
+                        }
+                    }
+                    this.ui.taskIdOrder.splice(pos, 0, msg.task.taskId);
+                }
+
+                this.ui.toggleSort();
+                this.ui.showSuccess("Created 1 task!");
+                this.ui.refreshQueueStats();
+                break;
+
+            case "add-tasks":
+                var batchTaskIds = Object.keys(msg.tasks).sort(sortTaskIds);
+
+                for (const id of batchTaskIds) {
+                    const value = msg.tasks[id];
+                    this.ui.tasks[id] = value;
+
+                    if (!this.ui.taskIdOrder.includes(id)) {
+                        let pos = this.ui.taskIdOrder.length;
+                        for (let i = 0; i < this.ui.taskIdOrder.length; i++) {
+                            if (sortTaskIds(id, this.ui.taskIdOrder[i]) < 0) {
+                                pos = i;
+                                break;
+                            }
+                        }
+                        this.ui.taskIdOrder.splice(pos, 0, id);
+                    }
+                }
+                this.ui.showSuccess(`Created ${batchTaskIds.length} tasks!`);
+                this.ui.refreshQueueStats();
+                break;
+
+            case "task-update":
+            case "task-setstatus":
+            case "task-setinfo":
+                if (msg?.task?.removed) {
+                    delete this.ui.tasks[msg.id];
+                    this.ui.taskIdOrder = this.ui.taskIdOrder.filter((i) => i !== msg.id);
+                } else if (msg.update) {
+                    try {
+                        Object.entries(msg.update).forEach((change) => (this.ui.tasks[msg.id][change[0]] = change[1]));
+                        // eslint-disable-next-line no-empty
+                    } catch {}
+                } else {
+                    if (!this.ui.tasks[msg.id]) this.ui.tasks[msg.id] = msg.task;
+                    if (!this.ui.taskIdOrder.includes(msg.id)) {
+                        this.ui.taskIdOrder.push(msg.id);
+                        this.ui.sortTasks();
+                    } else
+                        Object.keys(msg.task).forEach((key) => {
+                            this.ui.tasks[msg.id][key] = msg.task[key];
+                        });
+                }
+                this.ui.refreshQueueStats();
+                break;
+
+            case "edit-presale-code":
+                for (const value of Object.values(this.ui.tasks)) {
+                    if (value.eventId === msg.data.eventId) {
+                        value.presaleCode = msg.data.presaleCode;
+                    }
+                }
+                this.ui.showSuccess("Updated presale code!");
+                break;
+
+            case "login":
+                this.ui.hideSpinner();
+                router.push("/login");
+                break;
+
+            case "auth":
+                // redirect to / if on login page, but successfully logged in
+                if (router.currentRoute.value.name === "login") router.push("/");
+                this.ui.setProfile(msg);
+                break;
+
+            case "error":
+                this.ui.showError(msg.msg);
+                break;
+
+            case "set-button-disabled": {
+                const { button, value } = msg;
+                this.ui.disabledButtons[button] = value;
+                break;
+            }
+
+            case "add-account": {
+                const exists = this.ui.accounts.findIndex((p) => p._id === msg.account._id);
+                if (exists !== -1) {
+                    Object.keys(msg.account).forEach((k) => (this.ui.accounts[exists][k] = msg.account[k]));
+                } else this.ui.accounts.push(msg.account);
+                break;
+            }
+
+            case "add-profile": {
+                const exists = this.ui.profiles.findIndex((p) => p._id === msg.profile._id);
+                if (exists !== -1) {
+                    Object.keys(msg.profile).forEach((k) => (this.ui.profiles[exists][k] = msg.profile[k]));
+                } else this.ui.profiles.push(msg.profile);
+                break;
+            }
+
+            case "delete-profile":
+                this.ui.profiles = this.ui.profiles.filter((p) => p._id !== msg.profile._id);
+                break;
+
+            default:
+                this.ui.logger.Error("Unknown message type:", msg.event);
+                break;
+        }
+    }
+
+    sendMessage(msg) {
+        try {
+            if (msg?.data) msg.data.module = this.ui.currentModule;
+            this.socket.send(JSON.stringify(msg));
+        } catch {
+            this.ui.startSpinner("Reconnecting");
+        }
+    }
+
+    init(path) {
+        this.ui = useUIStore();
+        const url = (window.location.protocol === "http:" ? "ws://" : "wss://") + window.location.host + path;
+
+        this.socket = new WebsocketHeartbeatJs({ url, pingMsg: "ping" });
+
+        let hasShownDisconnect = false;
+        this.socket.onmessage = (event) => {
+            if (event.data === "pong") return;
+            if (hasShownDisconnect && this.ui.profile?.name) {
+                hasShownDisconnect = false;
+            }
+
+            // if event is not json but msgpack encoded, decode it
+            if (event.data instanceof Blob || event.data instanceof ArrayBuffer) {
+                event.data.arrayBuffer().then((buffer) => {
+                    const data = decode(new Uint8Array(buffer));
+                    data.forEach((d) => this.handleWebsocketMessages(d));
+                });
+            } else JSON.parse(event.data).forEach((e) => this.handleWebsocketMessages(e));
+        };
+
+        this.socket.onclose = () => {
+            this.ui.startSpinner("Reconnecting");
+            hasShownDisconnect = true;
+        };
+
+        this.socket.onerror = () => {
+            this.ui.startSpinner("Reconnecting");
+            hasShownDisconnect = true;
+        };
+
+        // this.socket.addEventListener('message', );
+    }
+
+    sendContinueTask(taskId, continueType) {
+        this.sendMessage({
+            event: "tasks/continue",
+            data: {
+                id: taskId,
+                type: continueType
+            }
+        });
+    }
+
+    sendTasksChange(taskId) {
+        this.sendMessage({
+            event: "tasks/change",
+            data: {
+                id: taskId
+            }
+        });
+    }
+
+    sendTasksOpen(taskId) {
+        this.sendMessage({
+            event: "tasks/open",
+            data: {
+                id: taskId
+            }
+        });
+    }
+
+    sendDeleteTask(taskId) {
+        this.sendMessage({
+            event: "tasks/delete",
+            data: {
+                id: taskId
+            }
+        });
+    }
+
+    sendGetTasks() {
+        this.sendMessage({
+            event: "tasks/get",
+            data: {}
+        });
+    }
+
+    sendStartTask(taskId) {
+        this.sendMessage({
+            event: "tasks/start",
+            data: {
+                id: taskId
+            }
+        });
+    }
+
+    sendStopTask(taskId) {
+        this.sendMessage({
+            event: "tasks/stop",
+            data: {
+                id: taskId
+            }
+        });
+    }
+
+    sendAddTask(task) {
+        this.sendMessage({
+            event: "tasks/add",
+            data: {
+                eventId: task.eventId,
+                presaleCode: task.presaleCode,
+                quantity: task.quantity,
+                email: task.email,
+                password: task.password,
+                proxy: task.proxy,
+                manual: Boolean(task.manual),
+                doNotPay: Boolean(task.doNotPay),
+                quickQueue: Boolean(task.quickQueue),
+                otpAccount: Boolean(task.otpAccount),
+                presaleMode: Boolean(task.presaleMode),
+                presaleStrict: Boolean(task.presaleStrict),
+                loginAfterCart: Boolean(task.loginAfterCart),
+                smartTimer: Boolean(task.smartTimer),
+                agedAccount: Boolean(task.agedAccount),
+                accountTag: task.accountTag,
+                profileTags: task.profileTags,
+                siteId: this.ui.currentCountry.siteId,
+                taskQuantity: task.taskQuantity,
+                clOrigin: task.clOrigin,
+                startOffset: parseInt(task.startOffset) || 0,
+                eventDid: task.eventDid
+            }
+        });
+    }
+
+    sendMassEditPresaleCode(eventId, presaleCode) {
+        this.sendMessage({
+            event: "mass-edit-presale-code",
+            data: {
+                eventId: eventId,
+                presaleCode: presaleCode
+            }
+        });
+        this.ui.showSuccess("Editing presale codes");
+    }
+
+    sendScrapeMap(eventId) {
+        this.sendMessage({
+            event: "scrape-map",
+            data: {
+                eventId: eventId,
+                siteId: this.ui.currentCountry.siteId
+            }
+        });
+        this.ui.showSuccess("Scraping map");
+    }
+
+    sendCheckStock(eventId, presaleCode, eventDid, clOrigin) {
+        this.sendMessage({
+            event: "check-stock",
+            data: {
+                eventId: eventId,
+                eventDid: eventDid,
+                clOrigin: clOrigin,
+                presaleCode: presaleCode,
+                siteId: this.ui.currentCountry.siteId
+            }
+        });
+        this.ui.showSuccess("Checked stock");
+    }
+
+    sendSaveProfile(profile) {
+        this.sendMessage({
+            event: "profiles/save",
+            data: profile
+        });
+        this.ui.showSuccess("Saved Profile");
+    }
+
+    sendSaveAccount(account) {
+        this.sendMessage({
+            event: "accounts/save",
+            data: account
+        });
+        this.ui.showSuccess("Saved Account");
+    }
+
+    sendDeleteProfile(id) {
+        this.sendMessage({
+            event: "profiles/delete",
+            data: { _id: id }
+        });
+    }
+
+    sendCreateAccounts(config) {
+        this.sendMessage({
+            event: "accounts/create",
+            data: {
+                ...config,
+                emails: config.emails
+                    ?.trim()
+                    ?.split("\n")
+                    .map((e) => e.trim())
+            }
+        });
+    }
+}

package/src/stores/countries.js

@@ -0,0 +1,88 @@
+export const countries = {
+    TM: [
+        {
+            url: "https://www.ticketmaster.com",
+            id: "US",
+            siteId: "TM_US"
+        },
+        {
+            url: "https://www.ticketmaster.co.uk",
+            id: "United Kingdom",
+            siteId: "TM_UK"
+        },
+        {
+            url: "https://www.ticketmaster.com.au",
+            id: "Australia",
+            siteId: "TM_AU"
+        },
+        {
+            url: "https://www.ticketmaster.at",
+            id: "Austria",
+            siteId: "TM_AT"
+        },
+        {
+            url: "https://www.ticketmaster.be",
+            id: "Belgium",
+            siteId: "TM_BE"
+        },
+        {
+            url: "https://www.ticketmaster.cz",
+            id: "Czech Rep.",
+            siteId: "TM_CZ"
+        },
+        {
+            url: "https://www.ticketmaster.dk",
+            id: "Denmark",
+            siteId: "TM_DK"
+        },
+        {
+            url: "https://www.ticketmaster.ae",
+            id: "Emirates",
+            siteId: "TM_AE"
+        },
+        {
+            url: "https://www.ticketmaster.de",
+            id: "Germany",
+            siteId: "TM_DE"
+        },
+        {
+            url: "https://www.ticketmaster.nl",
+            id: "Netherlands",
+            siteId: "TM_NL"
+        },
+        {
+            url: "https://www.ticketmaster.co.nz",
+            id: "New Zealand",
+            siteId: "TM_NZ"
+        },
+        {
+            url: "https://www.ticketmaster.no",
+            id: "Norway",
+            siteId: "TM_NO"
+        },
+        {
+            url: "https://www.ticketmaster.pl",
+            id: "Poland",
+            siteId: "TM_PL"
+        },
+        {
+            url: "https://www.ticketmaster.es",
+            id: "Spain",
+            siteId: "TM_ES"
+        },
+        {
+            url: "https://www.ticketmaster.se",
+            id: "Sweden",
+            siteId: "TM_SE"
+        },
+        {
+            url: "https://www.ticketmaster.ch",
+            id: "Switzerland",
+            siteId: "TM_CH"
+        }
+    ].sort((a, b) => a.siteId.localeCompare(b.siteId)),
+    AXS: [
+        { url: "https://www.axs.com/", id: "US", siteId: "AXS_US" },
+        { url: "https://www.axs.com/uk", id: "UK", siteId: "AXS_UK" }
+    ]
+};

package/src/stores/logger.js

@@ -0,0 +1,103 @@
+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);
+
+    return `${hours}:${minutes}:${seconds}.${milli}`;
+};
+
+const LOG_COLORS = {
+    error: "color: #ff4444; font-weight: bold", // Light red
+    success: "color: #00C851; font-weight: bold", // Green
+    info: "color: #33b5e5; font-weight: bold", // Light blue
+    debug: "color: #aa66cc; font-weight: bold", // Purple
+    yellow: "color: #ffbb33; font-weight: bold", // Yellow
+    reset: ""
+};
+class Logger {
+    constructor() {
+        this.ENABLED = true;
+        this.URGENT = false;
+        this.DEBUG = false;
+    }
+
+    log(...args) {
+        if (!this.ENABLED) return;
+
+        let style = "";
+        if (args[args.length - 1] in LOG_COLORS) {
+            style = LOG_COLORS[args.pop()];
+        }
+
+        const timestamp = `[${this.getTimestamp()}]`;
+
+        if (this.defaultArgs) {
+            this.defaultArgs.forEach((arg) => {
+                const defaultArg = `[${arg}]`;
+                args.unshift(defaultArg);
+            });
+        }
+
+        args.unshift(timestamp);
+
+        // Format objects for console output
+        const formattedArgs = args.map((arg) => {
+            if (typeof arg === "object" && arg !== null) {
+                console.log(arg._value ? arg._value : arg);
+                return arg;
+            }
+            return arg;
+        });
+
+        // For styled console output in browser
+        if (style) {
+            console.log(`%c${formattedArgs.join(" ")}`, style);
+        } else {
+            console.log(...formattedArgs);
+        }
+    }
+
+    getTimestamp() {
+        return timestamp();
+    }
+
+    Error(...args) {
+        const formattedArgs = args.map((arg) => {
+            if (arg instanceof Error) return arg.stack || arg.toString();
+            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.DEBUG) this.log(...args, "debug");
+    }
+
+    Yellow(...args) {
+        if (!this.URGENT) this.log(...args, "yellow");
+    }
+
+    Disable() {
+        this.ENABLED = false;
+    }
+}
+
+// Export as an object instead of using module.exports
+export const createLogger = (args) => {
+    const logger = new Logger();
+    logger.defaultArgs = typeof args === "string" ? [args] : Array.isArray(args) ? args : undefined;
+    return logger;
+};

package/src/stores/requests.js

@@ -0,0 +1,88 @@
+async function sendLogin(name, password) {
+    const options = {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ name, password }),
+        credentials: "include"
+    };
+
+    const res = await fetch("/api/login", options);
+    return res.json();
+}
+
+async function sendLogout() {
+    const options = {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        }
+    };
+
+    const res = await fetch("/api/logout", options);
+    return res.json();
+}
+
+async function sendQuickConfig(content) {
+    const s = JSON.stringify(content);
+
+    await fetch("/api/quickconfig", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: btoa(s) })
+    });
+}
+
+async function getQuickConfig() {
+    const resp = await fetch("/api/quickconfig");
+    return resp.json();
+}
+
+async function sendProxyList(value) {
+    const res = await fetch("/api/userconfig/set", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ field: "proxylist", value })
+    });
+    return res.json();
+}
+
+async function getProxyLists() {
+    const resp = await fetch("/api/userconfig/proxylists");
+    return resp.json();
+}
+
+async function getProxyFile(file) {
+    const res = await fetch("/api/proxies?file=" + file);
+    return res.text();
+}
+
+
+async function getBalances() {
+    const resp = await fetch("/api/userconfig/balances");
+    return resp.json();
+}
+
+async function sendSaveFilter(data) {
+    const resp = await fetch("/api/filter/save", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify(data)
+    });
+    return resp.text();
+}
+
+export {
+    sendLogin,
+    sendQuickConfig,
+    getQuickConfig,
+    sendProxyList,
+    getProxyLists,
+    getBalances,
+    sendLogout,
+    getProxyFile,
+    sendSaveFilter
+};