@fdm-monster/server/dist/services/prusa-link/prusa-link-http-polling.adapter.js

FDM Monster is a bulk OctoPrint manager to set up, configure and monitor 3D printers. Our aim is to provide extremely optimized websocket performance and reliability.

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "PrusaLinkHttpPollingAdapter", {
    enumerable: true,
    get: function() {
        return PrusaLinkHttpPollingAdapter;
    }
});
const _printerapiinterface = require("../printer-api.interface");
const _errorutils = require("../../utils/error.utils");
const _prusalinkconstants = require("./constants/prusalink.constants");
const defaultLog = {
    adapter: "prusa-link"
};
class PrusaLinkHttpPollingAdapter {
    prusaLinkApi;
    eventEmitter2;
    configService;
    printerType;
    printerId;
    login;
    socketState;
    apiState;
    lastMessageReceivedTimestamp;
    refreshPrinterCurrentInterval;
    eventEmittingAllowed;
    constructor(loggerFactory, prusaLinkApi, eventEmitter2, configService){
        this.prusaLinkApi = prusaLinkApi;
        this.eventEmitter2 = eventEmitter2;
        this.configService = configService;
        this.printerType = _printerapiinterface.PrusaLinkType;
        this.eventEmittingAllowed = true;
        this.logger = loggerFactory(PrusaLinkHttpPollingAdapter.name);
    }
    allowEmittingEvents() {
        this.eventEmittingAllowed = true;
    }
    disallowEmittingEvents() {
        this.eventEmittingAllowed = false;
    }
    needsReopen() {
        return !this.refreshPrinterCurrentInterval;
    }
    needsSetup() {
        return !this.refreshPrinterCurrentInterval;
    }
    needsReauth() {
        throw new Error("Method not implemented.");
    }
    isClosedOrAborted() {
        throw new Error("Method not implemented.");
    }
    reauthSession() {
        throw new Error("Method not implemented.");
    }
    registerCredentials(socketLogin) {
        this.login = socketLogin.loginDto;
        this.printerId = socketLogin.printerId;
    }
    open() {
        this.startPolling();
    }
    close() {
        this.logger.debug("Polling adapter attempting stoppage.", this.logMeta());
        this.stopPolling();
    }
    setupSocketSession() {
        this.logger.warn("SetupSocketSession", defaultLog);
        return Promise.resolve();
    }
    resetSocketState() {
        this.logger.warn("ResetSocketState", defaultLog);
    }
    startPolling() {
        this.stopPolling();
        this.logger.debug("Polling adapter starting, setting interval.", this.logMeta());
        this.refreshPrinterCurrentInterval = setInterval(async ()=>{
            if (!this.printerId) {
                this.logger.warn("Printer ID is not set, skipping status check.", this.logMeta());
                this.stopPolling();
                return;
            }
            this.socketState = "opening";
            try {
                this.prusaLinkApi.login = {
                    printerURL: this.login.printerURL,
                    username: this.login.username,
                    password: this.login.password,
                    apiKey: "",
                    printerType: _printerapiinterface.PrusaLinkType
                };
                this.socketState = "authenticating";
                const printerState = await this.prusaLinkApi.getPrinterState();
                if (printerState.state.flags?.link_state && printerState.state.flags?.link_state !== "PRINTING") {
                    printerState.state.text = printerState.state.flags.link_state;
                }
                const jobState = await this.prusaLinkApi.getJobState();
                this.socketState = "authenticated";
                this.apiState = "responding";
                await this.emitEvent("current", {
                    ...printerState,
                    job: jobState.job,
                    progress: {
                        printTime: jobState.progress?.printTime,
                        printTimeLeft: jobState.progress?.printTimeLeft,
                        completion: jobState.progress?.completion * 100
                    }
                });
            } catch (error) {
                this.socketState = "error";
                this.logger.error(`Failed to fetch PrusaLink status ${(0, _errorutils.errorSummary)(error)}`, this.logMeta());
            }
        }, 5000);
    }
    stopPolling() {
        if (this.refreshPrinterCurrentInterval) {
            this.logger.debug("Polling adapter stopping, clearing interval.", this.logMeta());
            clearInterval(this.refreshPrinterCurrentInterval);
            this.refreshPrinterCurrentInterval = undefined;
            this.socketState = "closed";
        }
    }
    async emitEvent(event, payload) {
        if (!this.eventEmittingAllowed) {
            return;
        }
        this.logger.debug(`Emitting event ${(0, _prusalinkconstants.prusaLinkEvent)(event)}`, this.logMeta());
        await this.eventEmitter2.emitAsync((0, _prusalinkconstants.prusaLinkEvent)(event), {
            event,
            payload,
            printerId: this.printerId,
            printerType: _printerapiinterface.PrusaLinkType
        });
    }
    logMeta() {
        return defaultLog;
    }
}

//# sourceMappingURL=prusa-link-http-polling.adapter.js.map