@robotical/webapp-types 3.10.2 → 3.11.0

package/dist-types/src/application/RAFTs/Marty/notifications-manager/RICNotificationsManager.js

@@ -0,0 +1,498 @@
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import InBtButAPressedModalContent from "../../../../components/modals/InBtButAPressed";
+import modalState from "../../../../state-observables/modal/ModalState";
+import { createElement } from "react";
+import RICServoFaultDetector from "@robotical/ricjs/dist/RICServoFaultDetector";
+import { toast } from "react-toastify";
+import { ReportedWarningsState } from "./ReportedWarningsState";
+import { createTicket, isSerialNumberRegistered } from "../../../../utils/warranty-service/warranty-service-utils";
+import { RICHWElemList_Str } from "@robotical/roboticaljs";
+import Logger from "../../../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "RICNotificationsManager";
+var USER_WARNING_MESSAGE = {
+    registeredUser: "Don't worry, we've logged the issue and our support team will contact you soon. Thanks for your patience!",
+    unregisteredUser: "To get things sorted, head over to our 'Help' section and register your Marty for our Warranty Service Program.",
+};
+var CacheManager = /** @class */ (function () {
+    function CacheManager() {
+    }
+    CacheManager.getInstance = function (key, maxTime) {
+        if (!CacheManager.instances.has(key)) {
+            CacheManager.instances.set(key, new LastReportedCache(maxTime));
+        }
+        return CacheManager.instances.get(key);
+    };
+    CacheManager.HW_STATUS_KEY = 'HW_STATUS';
+    CacheManager.HW_ELEMS_KEY = 'HW_ELEMS';
+    CacheManager.SYSTEM_INFO_KEY = 'SYSTEM_INFO';
+    CacheManager.instances = new Map();
+    return CacheManager;
+}());
+var LastReportedCache = /** @class */ (function () {
+    function LastReportedCache(maxTime) {
+        this.maxTime = maxTime;
+        this.lastReported = null;
+        this.lastReportedTime = 0;
+    }
+    LastReportedCache.prototype.setLastReported = function (data) {
+        if (typeof data === "string") {
+            return;
+        }
+        this.lastReported = data;
+        this.lastReportedTime = Date.now();
+    };
+    LastReportedCache.prototype.getLastReported = function () {
+        if (Date.now() - this.lastReportedTime > this.maxTime) {
+            return null;
+        }
+        return this.lastReported;
+    };
+    return LastReportedCache;
+}());
+var RICNotificationsManager = /** @class */ (function () {
+    function RICNotificationsManager(marty) {
+        this.marty = marty;
+    }
+    RICNotificationsManager.prototype.msgBodyDecider = function (report, hwElems) {
+        Logger.info(SHOW_LOGS, TAG, "msgBodyDecider", report, hwElems);
+        switch (report.msgBody) {
+            case "overCurrentDet":
+                if (!report.hasOwnProperty("IDNo"))
+                    break;
+                var motor = report.IDNo;
+                var motorElem = hwElems.find(function (_a) {
+                    var IDNo = _a.IDNo;
+                    return IDNo === report.IDNo;
+                });
+                if (motorElem !== undefined) {
+                    motor = motorElem.name;
+                }
+                // TODO: add warnings manager to display warnings to user
+                // adding warning to the manager where the warning message to
+                // be displayed is decided
+                // const ocwm = OverCurrentWarningManager.getInstanceOrInstantiate();
+                // const warning = new OverCurrentWarning(motor);
+                // ocwm.addWarning(warning);
+                break;
+            case "freefallDet":
+                // this.emit(INCREMENT_FREE_FALL_WARNINGS);
+                break;
+            // Button A pressed Case
+            case "btnAPressed":
+                modalState.setModal(createElement(InBtButAPressedModalContent), "Warning!");
+                break;
+        }
+    };
+    // REPORT notifications are messages generated by RIC in response to certain events, including raw i2c events and motor safeties
+    RICNotificationsManager.prototype.reportNofication = function (report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hwElemsCached_str, hwElems, hwElems_str;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        Logger.info(SHOW_LOGS, TAG, "reportNotification Report callback", report);
+                        hwElemsCached_str = CacheManager.getInstance(CacheManager.HW_ELEMS_KEY, 30000).getLastReported();
+                        if (!hwElemsCached_str) return [3 /*break*/, 1];
+                        Logger.info(SHOW_LOGS, TAG, "got hw elems from cache", hwElemsCached_str);
+                        hwElems = RICHWElemList_Str.expand(hwElemsCached_str);
+                        return [3 /*break*/, 3];
+                    case 1:
+                        Logger.info(SHOW_LOGS, TAG, "getting hw elems from rest");
+                        return [4 /*yield*/, this.marty.sendRestMessage("hwstatus/strstat")];
+                    case 2:
+                        hwElems_str = _a.sent();
+                        CacheManager.getInstance(CacheManager.HW_ELEMS_KEY, 30000).setLastReported(hwElems_str);
+                        hwElems = RICHWElemList_Str.expand(hwElems_str);
+                        _a.label = 3;
+                    case 3:
+                        Logger.info(SHOW_LOGS, TAG, "hw elems: ", hwElems);
+                        if (report.hasOwnProperty("msgType")) {
+                            if (report.msgType === "raw") {
+                                this.handleServoFaultRawMsg(report);
+                                return [2 /*return*/];
+                            }
+                            if (report.msgType === "warn" && report.hasOwnProperty("msgBody")) {
+                                if (report.msgBody === "servoFaultDet") {
+                                    // if there is a servo fault, we want to get the servo fault data using the servo fault detector
+                                    Logger.info(SHOW_LOGS, TAG, "servo fault detected, sending atomic read operation");
+                                    // this.handleServoFaultRawMsg(report); // DEBUGGING ONLY
+                                    this.marty.sendAtomicReadOperation(); // this will trigger reportMsgCallback, and so the above code will be executed
+                                }
+                                else if (report.msgBody === "elemCommsFailDet") {
+                                    this.handleElemCommsFailDet(report);
+                                }
+                                else if (report.msgBody === "busFailDet") {
+                                    this.handleBusFailDet(report);
+                                }
+                                else {
+                                    Logger.info(SHOW_LOGS, TAG, "Unknown msgBody", report.msgBody);
+                                }
+                                ///////
+                                this.msgBodyDecider(report, hwElems.hw);
+                            }
+                            else {
+                                Logger.debug(SHOW_LOGS, TAG, "Either msgType or msgBody not found in report", report.msgType, report.msgBody);
+                            }
+                        }
+                        else {
+                            Logger.debug(SHOW_LOGS, TAG, "Didn't find msgType in report", report);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RICNotificationsManager.prototype.getHwStatus = function (stringify, maxRetries, delayMs) {
+        if (stringify === void 0) { stringify = true; }
+        if (maxRetries === void 0) { maxRetries = 10; }
+        if (delayMs === void 0) { delayMs = 1000; }
+        return __awaiter(this, void 0, void 0, function () {
+            var i, cachedHwStatus, hwStatusResponse, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < maxRetries)) return [3 /*break*/, 11];
+                        cachedHwStatus = CacheManager.getInstance(CacheManager.HW_STATUS_KEY, 30000).getLastReported();
+                        if (cachedHwStatus) {
+                            Logger.info(SHOW_LOGS, TAG, "got hw status from cache");
+                            return [2 /*return*/, stringify ? JSON.stringify(cachedHwStatus.hw) : cachedHwStatus.hw];
+                        }
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 7, , 10]);
+                        return [4 /*yield*/, this.marty.sendRestMessage('hwstatus')];
+                    case 3:
+                        hwStatusResponse = _a.sent();
+                        if (!((hwStatusResponse === null || hwStatusResponse === void 0 ? void 0 : hwStatusResponse.rslt) === 'ok' && (hwStatusResponse === null || hwStatusResponse === void 0 ? void 0 : hwStatusResponse.hw))) return [3 /*break*/, 4];
+                        CacheManager.getInstance(CacheManager.HW_STATUS_KEY, 30000).setLastReported(hwStatusResponse);
+                        Logger.info(SHOW_LOGS, TAG, "got hw status from rest");
+                        return [2 /*return*/, stringify ? JSON.stringify(hwStatusResponse.hw) : hwStatusResponse.hw];
+                    case 4:
+                        Logger.info(SHOW_LOGS, TAG, "Couldn't get hwstatus: retrying...");
+                        if (!(i < maxRetries - 1)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, delayMs); })];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [3 /*break*/, 10];
+                    case 7:
+                        err_1 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Error getting hwstatus: ".concat(err_1, ", retrying..."));
+                        if (!(i < maxRetries - 1)) return [3 /*break*/, 9];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, delayMs); })];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9: return [3 /*break*/, 10];
+                    case 10:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 11:
+                        Logger.info(SHOW_LOGS, TAG, "Couldn't get hwstatus: returning empty array");
+                        return [2 /*return*/, stringify ? "[]" : []];
+                }
+            });
+        });
+    };
+    RICNotificationsManager.prototype.getHWNameGivenIdNo = function (hwStatusArr, IDNo) {
+        var convertedIdNo = Number(IDNo);
+        if (isNaN(convertedIdNo)) {
+            return null;
+        }
+        for (var _i = 0, hwStatusArr_1 = hwStatusArr; _i < hwStatusArr_1.length; _i++) {
+            var device = hwStatusArr_1[_i];
+            var convertedHwIdNo = Number(device.IDNo);
+            if (convertedHwIdNo === convertedIdNo) {
+                return device.name;
+            }
+        }
+        return convertedIdNo;
+    };
+    RICNotificationsManager.prototype.getHwRevAndVersion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cachedSystemInfo, vResponse, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cachedSystemInfo = CacheManager.getInstance(CacheManager.SYSTEM_INFO_KEY, 1800000).getLastReported();
+                        if (!cachedSystemInfo) return [3 /*break*/, 1];
+                        return [2 /*return*/, "Versions info: ".concat(JSON.stringify(cachedSystemInfo))];
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.marty.sendRestMessage('v')];
+                    case 2:
+                        vResponse = _a.sent();
+                        if ((vResponse === null || vResponse === void 0 ? void 0 : vResponse.rslt) === 'ok') {
+                            CacheManager.getInstance(CacheManager.SYSTEM_INFO_KEY, 1800000).setLastReported(vResponse);
+                            Logger.info(SHOW_LOGS, TAG, "got versions info from rest");
+                            return [2 /*return*/, "Versions info: ".concat(JSON.stringify(vResponse))];
+                        }
+                        else {
+                            Logger.info(SHOW_LOGS, TAG, "Couldn't get versions info");
+                            return [2 /*return*/, "Couldn't get versions info"];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Error getting hwstatus:", err_2);
+                        return [2 /*return*/, "Couldn't get versions info"];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RICNotificationsManager.prototype.martyNameStr = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var nameString, fetchedName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nameString = 'Robot Name: ';
+                        if (this.marty.getFriendlyName())
+                            return [2 /*return*/, nameString + this.marty.getFriendlyName()];
+                        return [4 /*yield*/, this.marty.getRaftName()];
+                    case 1:
+                        fetchedName = _a.sent();
+                        if (fetchedName) {
+                            return [2 /*return*/, nameString + fetchedName];
+                        }
+                        else {
+                            return [2 /*return*/, nameString + 'Unknown'];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RICNotificationsManager.prototype.handleServoFaultRawMsg = function (report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var detectedServoFaults, humanReadableServoFaults, hwStatusArr, hwStatus, elemName, martyNameStr, appVersion, versionsInfo, _a, _b, _c, _i, servoFaultKey, simpleDescription, enhancedDescription, isSeNoRegistered, userInfo, err_3;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        Logger.info(SHOW_LOGS, TAG, "Handling servo fault raw msg", report);
+                        detectedServoFaults = RICServoFaultDetector.interpretReportMsg(report);
+                        humanReadableServoFaults = {
+                            intermittentConnection: "Intermittent Sensor Connection",
+                            noConnection: "No Sensor Connection",
+                            faultyConnection: "Faulty Drive Connection",
+                            servoHornPositionError: "Servo Horn Position Error",
+                        };
+                        if (!detectedServoFaults) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.getHwStatus(false)];
+                    case 1:
+                        hwStatusArr = _d.sent();
+                        hwStatus = JSON.stringify(hwStatusArr);
+                        elemName = this.getHWNameGivenIdNo(hwStatusArr, report.IDNo);
+                        return [4 /*yield*/, this.martyNameStr()];
+                    case 2:
+                        martyNameStr = _d.sent();
+                        appVersion = "webapp";
+                        return [4 /*yield*/, this.getHwRevAndVersion()];
+                    case 3:
+                        versionsInfo = _d.sent();
+                        _a = detectedServoFaults;
+                        _b = [];
+                        for (_c in _a)
+                            _b.push(_c);
+                        _i = 0;
+                        _d.label = 4;
+                    case 4:
+                        if (!(_i < _b.length)) return [3 /*break*/, 9];
+                        _c = _b[_i];
+                        if (!(_c in _a)) return [3 /*break*/, 8];
+                        servoFaultKey = _c;
+                        if (!detectedServoFaults[servoFaultKey]) return [3 /*break*/, 8];
+                        simpleDescription = "".concat(elemName, " Servo Fault Detected: ").concat(humanReadableServoFaults[servoFaultKey]);
+                        enhancedDescription = "".concat(simpleDescription, "\n\n").concat(martyNameStr, "\n\n").concat(appVersion, "\n\n").concat(versionsInfo, "\n\nHwStatus: ").concat(hwStatus);
+                        _d.label = 5;
+                    case 5:
+                        _d.trys.push([5, 7, , 8]);
+                        ReportedWarningsState.getInstanceOrInstantiate().addCachedWarning(simpleDescription);
+                        return [4 /*yield*/, isSerialNumberRegistered(this.marty.getSerialNumber())];
+                    case 6:
+                        isSeNoRegistered = _d.sent();
+                        if (isSeNoRegistered) {
+                            if (
+                            // report the warning if it should not be ignored
+                            !ReportedWarningsState.shouldIgnoreWarning(simpleDescription) &&
+                                // and the warning has been seen 3 times in the last 5 minutes
+                                ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(simpleDescription, 3, 5)) {
+                                createTicket(this.marty.getSerialNumber(), "Servo Fault: ".concat(elemName || report.IDNo), enhancedDescription, this.marty.getFriendlyName(), this.marty.type);
+                            }
+                        }
+                        if (
+                        // only show the toast if the warning hasn't already been reported
+                        !ReportedWarningsState.getInstanceOrInstantiate().warningExists(simpleDescription) &&
+                            // and the warning should not be ignored
+                            !ReportedWarningsState.shouldIgnoreWarning(simpleDescription) &&
+                            // and the warning has been seen 3 times in the last 5 minutes
+                            ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(simpleDescription, 3, 5)) {
+                            userInfo = isSeNoRegistered
+                                ? USER_WARNING_MESSAGE.registeredUser
+                                : USER_WARNING_MESSAGE.unregisteredUser;
+                            toast.error("Oops! We've detected that the servo ".concat(elemName || report.IDNo, " might be damaged. ").concat(userInfo), { autoClose: false });
+                            // add the warning to the reported warnings state
+                            ReportedWarningsState.getInstanceOrInstantiate().addWarning(simpleDescription);
+                        }
+                        return [3 /*break*/, 8];
+                    case 7:
+                        err_3 = _d.sent();
+                        Logger.error(SHOW_LOGS, TAG, err_3);
+                        return [3 /*break*/, 8];
+                    case 8:
+                        _i++;
+                        return [3 /*break*/, 4];
+                    case 9:
+                        Logger.info(SHOW_LOGS, TAG, "detected servo faults", detectedServoFaults);
+                        _d.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    RICNotificationsManager.prototype.handleElemCommsFailDet = function (report) {
+        var _this = this;
+        Logger.info(SHOW_LOGS, TAG, "Handling elemCommsFailDet", report);
+        // return;
+        // this is triggered if we get multiple occurrences of loss of comms with an addon
+        // An IDNo will be reported, this can be cross referenced against the
+        // hwstatus output to determine which element is giving the error, and hence which leg has a problem
+        var warningKey = "elemCommsFailDet ".concat(report.elemName || report.IDNo);
+        ReportedWarningsState.getInstanceOrInstantiate().addCachedWarning(warningKey);
+        isSerialNumberRegistered(this.marty.getSerialNumber())
+            .then(function (isSeNoRegistered) { return __awaiter(_this, void 0, void 0, function () {
+            var hwStatusArr, hwStatus, elemName, martyNameStr, appVersion, versionsInfo, enhancedDescription, userInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getHwStatus(false)];
+                    case 1:
+                        hwStatusArr = _a.sent();
+                        hwStatus = JSON.stringify(hwStatusArr);
+                        elemName = this.getHWNameGivenIdNo(hwStatusArr, report.IDNo);
+                        return [4 /*yield*/, this.martyNameStr()];
+                    case 2:
+                        martyNameStr = _a.sent();
+                        appVersion = "webapp";
+                        return [4 /*yield*/, this.getHwRevAndVersion()];
+                    case 3:
+                        versionsInfo = _a.sent();
+                        if (isSeNoRegistered) {
+                            enhancedDescription = "Element IDNo: ".concat(elemName || report.IDNo, "\n\n").concat(martyNameStr, "\n\n").concat(appVersion, "\n\n").concat(versionsInfo, "\n\nHwStatus: ").concat(hwStatus);
+                            if (
+                            // only create a ticket if the warning has been seen 3 times in the last 5 minutes
+                            ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(warningKey, 3, 5) &&
+                                // and if the warning should not be ignored
+                                !ReportedWarningsState.shouldIgnoreWarning(warningKey)) {
+                                createTicket(this.marty.getSerialNumber(), "Element Communication Failure at ".concat(elemName || report.IDNo), enhancedDescription, this.marty.getFriendlyName(), this.marty.type);
+                            }
+                        }
+                        if (
+                        // only show the toast if the warning hasn't already been reported
+                        !ReportedWarningsState.getInstanceOrInstantiate().warningExists(warningKey) &&
+                            // and has been seen 3 times in the last 5 minutes
+                            ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(warningKey, 3, 5) &&
+                            // and if the warning should not be ignored
+                            !ReportedWarningsState.shouldIgnoreWarning(warningKey)) {
+                            userInfo = isSeNoRegistered ? USER_WARNING_MESSAGE.registeredUser : USER_WARNING_MESSAGE.unregisteredUser;
+                            toast.error("Oops! We've detected that the cable for the ".concat(elemName || "element " + report.IDNo, " might be damaged. ").concat(userInfo), { autoClose: false });
+                            ReportedWarningsState.getInstanceOrInstantiate().addWarning(warningKey);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); }).catch(function (err) { return Logger.error(SHOW_LOGS, TAG, err); });
+    };
+    RICNotificationsManager.prototype.handleBusFailDet = function (report) {
+        var _this = this;
+        Logger.info(SHOW_LOGS, TAG, "Handling busFailDet", report);
+        // return;
+        // this is a bit of a catch all, which will trigger if we get multiple i2c bus failures.
+        // We won't be able to figure out which element is causing the failure from this, but it tells us something is up
+        var warningKey = "busFailDet ".concat(report.elemName || report.IDNo);
+        ReportedWarningsState.getInstanceOrInstantiate().addCachedWarning(warningKey);
+        isSerialNumberRegistered(this.marty.getSerialNumber())
+            .then(function (isSeNoRegistered) { return __awaiter(_this, void 0, void 0, function () {
+            var hwStatusArr, hwStatus, elemName, martyNameStr, appVersion, versionsInfo, enhancedDescription, userInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getHwStatus(false)];
+                    case 1:
+                        hwStatusArr = _a.sent();
+                        hwStatus = JSON.stringify(hwStatusArr);
+                        elemName = this.getHWNameGivenIdNo(hwStatusArr, report.IDNo);
+                        return [4 /*yield*/, this.martyNameStr()];
+                    case 2:
+                        martyNameStr = _a.sent();
+                        appVersion = "webapp";
+                        return [4 /*yield*/, this.getHwRevAndVersion()];
+                    case 3:
+                        versionsInfo = _a.sent();
+                        if (isSeNoRegistered) {
+                            enhancedDescription = "Bus Fail Detected at ".concat(elemName || report.IDNo, "\n\n").concat(martyNameStr, "\n\n").concat(appVersion, "\n\n").concat(versionsInfo, "\n\nHwStatus: ").concat(hwStatus);
+                            if (
+                            // only create a ticket if the warning has been seen 3 times in the last 5 minutes
+                            ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(warningKey, 3, 5) &&
+                                // and if the warning should not be ignored
+                                !ReportedWarningsState.shouldIgnoreWarning(warningKey)) {
+                                createTicket(this.marty.getSerialNumber(), "Bus Fail ".concat(elemName || report.IDNo), enhancedDescription, this.marty.getFriendlyName(), this.marty.type);
+                            }
+                        }
+                        if (
+                        // only show the toast if the warning hasn't already been reported 
+                        !ReportedWarningsState.getInstanceOrInstantiate().warningExists(warningKey) &&
+                            // and has been seen 3 times in the last 5 minutes
+                            ReportedWarningsState.getInstanceOrInstantiate().hasNumWarningsInLastMinutes(warningKey, 3, 5) &&
+                            // and if the warning should not be ignored
+                            !ReportedWarningsState.shouldIgnoreWarning(warningKey)) {
+                            userInfo = isSeNoRegistered ? USER_WARNING_MESSAGE.registeredUser : USER_WARNING_MESSAGE.unregisteredUser;
+                            toast.error("Oops! We've detected that the BUS communication system at ".concat(elemName || "element " + report.IDNo, " might be damaged. ").concat(userInfo), { autoClose: false });
+                            ReportedWarningsState.getInstanceOrInstantiate().addWarning(warningKey);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); }).catch(function (err) { return Logger.error(SHOW_LOGS, TAG, err); });
+    };
+    return RICNotificationsManager;
+}());
+export { RICNotificationsManager };

package/dist-types/src/application/RAFTs/Marty/notifications-manager/ReportedWarningsState.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The ReportedWarningsState class is used to store the reported warnings from Marty.
+ * One of the main purposes of this class is to prevent duplicate warnings from being
+ * displayed to the user.
+ */
+export declare class ReportedWarningsState {
+    private static instance;
+    private reportedWarnings;
+    private cachedWarnings;
+    private constructor();
+    static getInstanceOrInstantiate(): ReportedWarningsState;
+    static shouldIgnoreWarning(warning: string): boolean;
+    /**
+     * This method is used to add a warning to the reported warnings state.
+     * @param warning The warning to be added to the reported warnings state.
+     * @returns true if the warning was added to the reported warnings state, false otherwise.
+     */
+    addWarning(warning: string): boolean;
+    /**
+     * This method is used to remove a warning from the reported warnings state.
+     * @param warning The warning to be removed from the reported warnings state.
+     * @returns true if the warning was removed from the reported warnings state, false otherwise.
+     * */
+    removeWarning(warning: string): boolean;
+    /**
+     * This method is used to clear all warnings from the reported warnings state.
+     * */
+    clearWarnings(): void;
+    /**
+     * This method is used to get the reported warnings state.
+     * @returns The reported warnings state.
+     * */
+    getReportedWarnings(): Map<string, object>;
+    /**
+     * This method is used to set the reported warnings state.
+     * @param reportedWarnings The reported warnings state to be set.
+     * */
+    setReportedWarnings(reportedWarnings: Map<string, object>): void;
+    /**
+     * This method is used to check if a warning exists in the reported warnings state.
+     * @param warning The warning to be checked.
+     * @returns true if the warning exists in the reported warnings state, false otherwise.
+     * */
+    warningExists(warning: string): boolean;
+    /**
+     * This method is used to add a warning to the cached warnings state.
+     * @param warning The warning to be added to the cached warnings state.
+     * @returns true if the warning was added to the cached warnings state, false otherwise.
+     * */
+    addCachedWarning(warningsKey: string): boolean;
+    /**
+     * This method is used to check if there are x number of warnings let last y minutes.
+     * @param warningsKey The key to the cached warnings state.
+     * @param numWarnings The number of warnings to check for.
+     * @param minutes The number of minutes to check for.
+     * @returns true if there are x number of warnings let last y minutes, false otherwise.
+     * */
+    hasNumWarningsInLastMinutes(warningsKey: string, numWarnings: number, minutes: number): boolean;
+}