@hmcts/ccd-case-ui-toolkit 6.19.0-RetryCaseRetrievals.3 → 6.19.0-RetryCaseRetrievals.5

package/bundles/hmcts-ccd-case-ui-toolkit.umd.js

@@ -8086,32 +8086,48 @@
             }], null, null);
     })();
 
-    var RetryUtil = /** @class */ (function () {
-        function RetryUtil() {
+    var ArtificialDelayContext = /** @class */ (function () {
+        function ArtificialDelayContext(preferredDelay) {
+            this.preferredDelay = preferredDelay;
             this.artificialDelayOn = true;
-            this.artificialDelayPeriod = this.pickARandomValue();
+            this.selectedDelay = this.selectActualDelayTime();
         }
-        RetryUtil.prototype.switchArtificialDelays = function (status) {
+        ;
+        ArtificialDelayContext.prototype.switchArtificialDelays = function (status) {
             this.artificialDelayOn = status;
-            this.artificialDelayPeriod = this.pickARandomValue();
+            this.selectedDelay = this.selectActualDelayTime();
         };
-        RetryUtil.prototype.switchOnArtificialDelays = function () {
+        ArtificialDelayContext.prototype.turnOnArtificialDelays = function () {
             this.switchArtificialDelays(true);
         };
-        RetryUtil.prototype.switchOffArtificialDelays = function () {
+        ArtificialDelayContext.prototype.turnOffArtificialDelays = function () {
             this.switchArtificialDelays(false);
         };
-        RetryUtil.prototype.getArtificialDelayTime = function () {
-            return this.artificialDelayOn ? this.artificialDelayPeriod : 0;
+        ArtificialDelayContext.prototype.getActualDelay = function () {
+            return this.artificialDelayOn ? this.selectedDelay : 0;
+        };
+        ArtificialDelayContext.prototype.shouldApplyArtificialDelay = function () {
+            return this.preferredDelay > 0;
+        };
+        ArtificialDelayContext.prototype.selectActualDelayTime = function () {
+            return Date.now() % 2 == 0 ? this.preferredDelay : 1;
         };
-        RetryUtil.prototype.pipeTimeoutMechanismOn = function (in$, environment, timeoutPeriods) {
-            this.switchOnArtificialDelays();
+        return ArtificialDelayContext;
+    }());
+    var RetryUtil = /** @class */ (function () {
+        function RetryUtil() {
+        }
+        RetryUtil.prototype.pipeTimeoutMechanismOn = function (in$, preferredArtificialDelay, timeoutPeriods) {
+            var artificialDelayContext = new ArtificialDelayContext(preferredArtificialDelay);
+            console.info("Piping a retry mechanism with timeouts {" + timeoutPeriods + "}.");
+            console.info("Artificial delay will be applied: " + artificialDelayContext.shouldApplyArtificialDelay() + ".");
             var out$ = in$;
-            if (environment === 'aat') {
-                out$ = this.pipeArtificialDelayOn(out$);
+            if (artificialDelayContext.shouldApplyArtificialDelay()) {
+                console.info("Preferred artificial delay: " + preferredArtificialDelay + " seconds. Actual delay selected: " + artificialDelayContext.getActualDelay());
+                out$ = this.pipeArtificialDelayOn(out$, artificialDelayContext);
             }
             out$ = this.pipeTimeOutControlOn(out$, timeoutPeriods);
-            out$ = this.pipeRetryMechanismOn(out$);
+            out$ = this.pipeRetryMechanismOn(out$, artificialDelayContext);
             return out$;
         };
         RetryUtil.prototype.pipeTimeOutControlOn = function (in$, timeoutPeriods) {
@@ -8119,14 +8135,13 @@
             var out$ = in$.pipe(operators.timeout(timeOutAfterSeconds * 1000));
             return out$;
         };
-        RetryUtil.prototype.pipeRetryMechanismOn = function (in$) {
-            var _this = this;
+        RetryUtil.prototype.pipeRetryMechanismOn = function (in$, artificialDelayContext) {
             var retryStrategy = function (errors) {
                 return errors.pipe(operators.mergeMap(function (error, i) {
                     console.error("Mapping error " + (error === null || error === void 0 ? void 0 : error.name) + ", " + i);
                     console.error(error);
                     if ((error === null || error === void 0 ? void 0 : error.name) === 'TimeoutError' && i === 0) {
-                        _this.switchOffArtificialDelays();
+                        artificialDelayContext.turnOffArtificialDelays();
                         console.info('Will retry, after a timeout error.');
                     }
                     else {
@@ -8139,20 +8154,16 @@
             var out$ = in$.pipe(operators.retryWhen(retryStrategy));
             return out$;
         };
-        RetryUtil.prototype.pipeArtificialDelayOn = function (in$) {
-            var _this = this;
+        RetryUtil.prototype.pipeArtificialDelayOn = function (in$, artificialDelayContext) {
             var out$ = in$.pipe(operators.tap(function () {
-                console.log("Artificially delaying for " + _this.getArtificialDelayTime() + " seconds..");
+                console.log("Artificially delaying for " + artificialDelayContext.getActualDelay() + " seconds..");
             }));
-            out$ = out$.pipe(operators.delayWhen(function () { return rxjs.timer(_this.getArtificialDelayTime() * 1000); }));
+            out$ = out$.pipe(operators.delayWhen(function () { return rxjs.timer(artificialDelayContext.getActualDelay() * 1000); }));
             out$ = out$.pipe(operators.tap(function () {
-                console.log("Artificially delayed for " + _this.getArtificialDelayTime() + " seconds..");
+                console.log("Artificially delayed for " + artificialDelayContext.getActualDelay() + " seconds..");
             }));
             return out$;
         };
-        RetryUtil.prototype.pickARandomValue = function () {
-            return Date.now() % 2 == 0 ? 60 : 3;
-        };
         return RetryUtil;
     }());
     RetryUtil.ɵfac = function RetryUtil_Factory(t) { return new (t || RetryUtil)(); };
@@ -8757,30 +8768,24 @@
                 .set('Content-Type', 'application/json');
             var loadingToken = this.loadingService.register();
             var http$ = this.http.get(url, { headers: headers, observe: 'body' });
-            this.retryUtil.pipeTimeoutMechanismOn(http$, this.appConfig.getEnvironment(), this.appConfig.getCaseRetrievalTimeouts());
+            var artificialDelay = this.appConfig.getTimeoutsCaseRetrievalArtificialDelay();
+            http$ = this.retryUtil.pipeTimeoutMechanismOn(http$, artificialDelay, this.appConfig.getTimeoutsForCaseRetrieval());
             http$ = this.pipeErrorProcessor(http$);
             http$ = http$.pipe(operators.finalize(function () { return _this.finalizeGetCaseViewWith(caseId, loadingToken); }));
             return http$;
         };
         CasesService.prototype.pipeErrorProcessor = function (in$) {
             var _this = this;
-            var out$$ = in$.pipe(operators.catchError(function (error) {
+            var out$ = in$.pipe(operators.catchError(function (error) {
                 console.error("Error while getting case view with getCaseViewV2! Error type: '" + typeof error + ", Error name: '" + (error === null || error === void 0 ? void 0 : error.name) + "'");
                 console.error(error);
                 _this.errorService.setError(error);
                 return rxjs.throwError(error);
             }));
-            return out$$;
-        };
-        CasesService.prototype.syncWait = function (seconds) {
-            var end = Date.now() + seconds * 1000;
-            while (Date.now() < end)
-                continue;
+            return out$;
         };
         CasesService.prototype.finalizeGetCaseViewWith = function (caseId, loadingToken) {
             console.info("finalizeGetCaseViewWith started for " + caseId + ".");
-            // this.syncWait(15);
-            // throw new Error('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++');
             this.loadingService.unregister(loadingToken);
             console.info("finalizeGetCaseViewWith finished for " + caseId + ".");
         };