@hmcts/ccd-case-ui-toolkit 7.3.54-pofcc-131 → 7.3.54-polling

package/fesm2022/hmcts-ccd-case-ui-toolkit.mjs

@@ -8,11 +8,10 @@ import * as i1$1 from '@angular/router';
 import { RouterModule, NavigationStart, NavigationEnd } from '@angular/router';
 import * as i4 from '@angular/forms';
 import { NG_VALUE_ACCESSOR, NG_VALIDATORS, FormArray, FormGroup, FormControl, Validators, ReactiveFormsModule, FormsModule } from '@angular/forms';
-import { BehaviorSubject, throwError, Subject, EMPTY, Observable, skip, of, timer, forkJoin, fromEvent, Subscription, combineLatest } from 'rxjs';
+import { BehaviorSubject, throwError, Subject, EMPTY, concat, defer, timer, Observable, skip, of, forkJoin, fromEvent, Subscription, combineLatest } from 'rxjs';
+import { distinctUntilChanged, catchError, map, switchMap, repeat, retry, publish, refCount, debounceTime, delay, finalize, timeout, mergeMap, retryWhen, tap, delayWhen, publishReplay, take, first, takeUntil, filter } from 'rxjs/operators';
 import * as i1$2 from '@angular/common/http';
 import { HttpErrorResponse, HttpHeaders, HttpParams } from '@angular/common/http';
-import { distinctUntilChanged, catchError, map, publish, refCount, switchMap, debounceTime, delay, finalize, timeout, mergeMap, retryWhen, tap, delayWhen, publishReplay, take, first, takeUntil, filter } from 'rxjs/operators';
-import { polling } from 'rx-polling-hmcts';
 import { Type, Exclude, Expose, plainToClassFromExist, plainToClass } from 'class-transformer';
 import moment from 'moment';
 import { __decorate, __metadata } from 'tslib';
@@ -1264,12 +1263,6 @@ class AbstractAppConfig {
             return 'ithc';
         return 'prod';
     }
-    getWASupportedRoleCategories() {
-        return [];
-    }
-    getWASupportedRoleTypes() {
-        return [];
-    }
     getCamRoleAssignmentsApiUrl() {
         return undefined;
     }
@@ -1326,8 +1319,6 @@ class CaseEditorConfig {
     icp_jurisdictions;
     events_to_hide;
     enable_service_specific_multi_followups;
-    wa_supported_role_categories;
-    wa_supported_role_types;
 }
 
 class HttpError {
@@ -1837,8 +1828,7 @@ class ActivityPollingService {
         this.config = config;
         this.pollConfig = {
             interval: config.getActivityNexPollRequestMs(),
-            attempts: config.getActivityRetry(),
-            backgroundPolling: true
+            attempts: config.getActivityRetry()
         };
         this.batchCollectionDelayMs = config.getActivityBatchCollectionDelayMs();
         this.maxRequestsPerBatch = config.getActivityMaxRequestPerBatch();
@@ -1855,17 +1845,18 @@ class ActivityPollingService {
             subject.subscribe(done);
         }
         else {
+            // Only the first pending request should start the batch collection timer.
+            const wasEmpty = this.pendingRequests.size === 0;
             subject = new Subject();
             subject.subscribe(done);
-            this.pendingRequests.set(caseId, subject);
-        }
-        if (this.pendingRequests.size === 1) {
-            this.ngZone.runOutsideAngular(() => {
-                this.currentTimeoutHandle = setTimeout(() => this.ngZone.run(() => {
-                    // console.log('timeout: flushing requests')
-                    this.flushRequests();
-                }), this.batchCollectionDelayMs);
-            });
+            this.addPendingRequest(caseId, subject);
+            if (wasEmpty) {
+                this.ngZone.runOutsideAngular(() => {
+                    this.currentTimeoutHandle = setTimeout(() => this.ngZone.run(() => {
+                        this.flushRequests();
+                    }), this.batchCollectionDelayMs);
+                });
+            }
         }
         if (this.pendingRequests.size >= this.maxRequestsPerBatch) {
             // console.log('max pending hit: flushing requests');
@@ -1883,6 +1874,9 @@ class ActivityPollingService {
             clearTimeout(this.currentTimeoutHandle);
             this.currentTimeoutHandle = undefined;
         }
+        if (!this.pendingRequests.size) {
+            return;
+        }
         const requests = new Map(this.pendingRequests);
         this.pendingRequests.clear();
         this.performBatchRequest(requests);
@@ -1891,7 +1885,7 @@ class ActivityPollingService {
         if (!this.isEnabled) {
             return EMPTY;
         }
-        return polling(this.activityService.getActivities(...caseIds), this.pollConfig);
+        return this.polling(this.activityService.getActivities(...caseIds), this.pollConfig);
     }
     postViewActivity(caseId) {
         return this.postActivity(caseId, ActivityService.ACTIVITY_VIEW);
@@ -1904,17 +1898,19 @@ class ActivityPollingService {
         // console.log('issuing batch request for cases: ' + caseIds);
         this.ngZone.runOutsideAngular(() => {
             // run polling outside angular zone so it does not trigger change detection
-            this.pollActivitiesSubscription = this.pollActivities(caseIds).subscribe(
-            // process activity inside zone so it triggers change detection for activity.component.ts
-            (activities) => this.ngZone.run(() => {
-                activities.forEach((activity) => {
-                    // console.log('pushing activity: ' + activity.caseId);
-                    requests.get(activity.caseId).next(activity);
-                });
-            }, (err) => {
-                console.log(`error: ${err}`);
-                Array.from(requests.values()).forEach((subject) => subject.error(err));
-            }));
+            this.pollActivitiesSubscription = this.pollActivities(caseIds).subscribe({
+                // process activity inside zone so it triggers change detection for activity.component.ts
+                next: (activities) => this.ngZone.run(() => {
+                    activities.forEach((activity) => {
+                        // Ignore activities returned for cases outside this local batch.
+                        requests.get(activity.caseId)?.next(activity);
+                    });
+                }),
+                error: (err) => this.ngZone.run(() => {
+                    console.log(`error: ${err}`);
+                    Array.from(requests.values()).forEach((subject) => subject.error(err));
+                })
+            });
         });
     }
     postActivity(caseId, activityType) {
@@ -1925,7 +1921,42 @@ class ActivityPollingService {
             ...this.pollConfig,
             interval: 5000 // inline with CCD Backend
         };
-        return polling(this.activityService.postActivity(caseId, activityType), pollingConfig);
+        return this.polling(this.activityService.postActivity(caseId, activityType), pollingConfig);
+    }
+    addPendingRequest(caseId, subject) {
+        this.pendingRequests.set(caseId, subject);
+        // Components complete their returned Subject on destroy; remove it so a later same-case subscription gets a fresh Subject.
+        subject.subscribe({
+            complete: () => this.removePendingRequest(caseId, subject),
+            error: () => this.removePendingRequest(caseId, subject)
+        });
+    }
+    removePendingRequest(caseId, subject) {
+        if (this.pendingRequests.get(caseId) !== subject) {
+            return;
+        }
+        this.pendingRequests.delete(caseId);
+        if (!this.pendingRequests.size && this.currentTimeoutHandle) {
+            clearTimeout(this.currentTimeoutHandle);
+            this.currentTimeoutHandle = undefined;
+        }
+    }
+    polling(request$, options) {
+        const pollingOptions = {
+            interval: options.interval,
+            attempts: options.attempts ?? 9,
+            exponentialUnit: options.exponentialUnit ?? 1000
+        };
+        return concat(request$, defer(() => timer(pollingOptions.interval).pipe(switchMap(() => request$))).pipe(repeat())).pipe(
+        // Preserve consecutive-failure retry behaviour using the current RxJS retry config.
+        retry({
+            count: pollingOptions.attempts,
+            delay: (_error, retryCount) => timer(this.getExponentialRetryDelay(retryCount, pollingOptions.exponentialUnit)),
+            resetOnSuccess: true
+        }));
+    }
+    getExponentialRetryDelay(consecutiveErrorsCount, exponentialUnit) {
+        return Math.pow(2, consecutiveErrorsCount - 1) * exponentialUnit;
     }
     static ɵfac = function ActivityPollingService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ActivityPollingService)(i0.ɵɵinject(ActivityService), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(AbstractAppConfig)); };
     static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityPollingService, factory: ActivityPollingService.ɵfac });