@isaac-platform/isaac-integration-sdk/schedule/events/index.js

A Typescript SDK for integrating with ISAAC

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { IsaacEvent } from "./event.js";
import isaacConnection from "../../controller/isaac.js";
export class EventController {
    constructor() {
        this.knownEvents = new Map();
        this.localEvents = new Map();
        this.remoteEvents = new Map();
        /**
         * Retrieves list of events
         */
        this.getEvents = () => __awaiter(this, void 0, void 0, function* () {
            try {
                let eventObjects = [];
                let eventList = yield isaacConnection.getRequest(`events`);
                eventList.forEach((event) => {
                    eventObjects.push(new IsaacEvent(event));
                    if (this.knownEvents.has(event._id)) {
                        this.knownEvents.get(event._id).update(event);
                    }
                    else {
                        this.knownEvents.set(event._id, new IsaacEvent(event));
                    }
                });
                return eventObjects;
            }
            catch (error) {
                console.error('ISAAC SDK: Error getting events.', error);
                throw error;
            }
        });
        /**
         * Retrieves a single event by its externalRef or ISAAC internal ID.
         * @param identifier - The externalRef or ISAAC internal ID of the event to retrieve.
         * @param subsystemId - The ID of the subsystem to retrieve the event from. Defaults to the current subsystem ID.
         */
        this.getEvent = (identifier, subsystemId) => __awaiter(this, void 0, void 0, function* () {
            let path = null;
            let subsystemExternalId = subsystemId || isaacConnection.subsystemID;
            switch (typeof identifier) {
                case "string":
                    path = `events/${subsystemExternalId}/${identifier}`;
                    break;
                case "number":
                    path = `events/${identifier}`;
                    break;
            }
            if (path == null) {
                throw new Error("Invalid identifier type. Must be a string or number.");
            }
            try {
                return yield isaacConnection.getRequest(path);
            }
            catch (error) {
                console.error('ISAAC SDK: Error getting event.', error);
                throw error;
            }
        });
        /**
         * Syncs local events with remote events and updates "known events" accordingly.
         */
        this.syncEvents = () => __awaiter(this, void 0, void 0, function* () {
            let eventList = yield isaacConnection.getRequest(`events`);
            eventList.forEach((event) => {
                switch (this.remoteEvents.has(event._id)) {
                    case true:
                        //         ???
                        break;
                    case false:
                        this.remoteEvents.set(event._id, new IsaacEvent(event));
                        break;
                }
            });
        });
        /**
         * Registers an event on the remote ISAAC system if it does not exist.
         * @param newEvent is the definition of the event to be added
         * @returns new or existing IsaacEvent object.
         */
        this.registerEvent = (newEvent) => __awaiter(this, void 0, void 0, function* () {
            //TODO: Implement this.
        });
    }
    /**
     * Creates a new event on the remote ISAAC system.
     * @param newEvent is the definition of the event to be added
     * @returns new IsaacEvent object
     */
    createEvent(newEvent) {
        return __awaiter(this, void 0, void 0, function* () {
            //TODO: Implement this.
        });
    }
}