Merge branch 'master' into bug/EUI-2057-multiple-session-fail-tasks

RELEASE-NOTES.md

@@ -1,5 +1,8 @@
 ## RELEASE NOTES 
 
+### Version 7.0.65
+**EXUI-2320** Intermittent missing call of search for completable
+
 ### Version 7.0.64
 **EXUI-2086** Within case file view
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmcts/ccd-case-ui-toolkit",
-  "version": "7.0.64-srt-17-september-24",
+  "version": "7.0.65-srt-17-september-24",
   "engines": {
     "node": ">=18.19.0"
   },

projects/ccd-case-ui-toolkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmcts/ccd-case-ui-toolkit",
-  "version": "7.0.64-srt-17-september-24",
+  "version": "7.0.65-srt-17-september-24",
   "engines": {
     "node": ">=18.19.0"
   },

projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/event-guard/event-start.guard.spec.ts

@@ -6,6 +6,7 @@ import { UserInfo } from '../../../domain/user/user-info.model';
 import { SessionStorageService } from '../../../services';
 import { WorkAllocationService } from '../../case-editor';
 import { EventStartGuard } from './event-start.guard';
+import { AbstractAppConfig } from '../../../../app.config';
 
 describe('EventStartGuard', () => {
   const tasks: any[] = [
@@ -29,18 +30,21 @@ describe('EventStartGuard', () => {
   let service: jasmine.SpyObj<WorkAllocationService>;
   let router: jasmine.SpyObj<Router>;
   let sessionStorageService: jasmine.SpyObj<SessionStorageService>;
+  let mockAbstractConfig: jasmine.SpyObj<AbstractAppConfig>;
 
   beforeEach(() => {
     service = jasmine.createSpyObj('WorkAllocationService', ['getTasksByCaseIdAndEventId']);
     router = jasmine.createSpyObj('Router', ['navigate']);
     sessionStorageService = jasmine.createSpyObj('SessionStorageService', ['getItem', 'setItem', 'removeItem']);
+    mockAbstractConfig = jasmine.createSpyObj('AbstractAppConfig', ['logMessage']);
 
     TestBed.configureTestingModule({
       providers: [
         EventStartGuard,
         { provide: WorkAllocationService, useValue: service },
         { provide: Router, useValue: router },
-        { provide: SessionStorageService, useValue: sessionStorageService }
+        { provide: SessionStorageService, useValue: sessionStorageService },
+        { provide: AbstractAppConfig, useValue: mockAbstractConfig }
       ]
     });
 
@@ -60,6 +64,26 @@ describe('EventStartGuard', () => {
     });
   });
 
+  it('should log a message and not call getTasksByCaseIdAndEventId when caseInfo is not available', () => {
+    sessionStorageService.getItem.and.returnValue(null);
+    const route = createActivatedRouteSnapshot('caseId', 'eventId');
+    const payload: TaskPayload = { task_required_for_event: true } as TaskPayload;
+    service.getTasksByCaseIdAndEventId.and.returnValue(of(payload));
+    const result$ = guard.canActivate(route);
+    expect(service.getTasksByCaseIdAndEventId).not.toHaveBeenCalled();
+    expect(mockAbstractConfig.logMessage).toHaveBeenCalledWith(`EventStartGuard: caseInfo details not available in session storage for caseId`);
+  });
+
+  it('should log a message and not call getTasksByCaseIdAndEventId when caseId not matched with caseInfo caseId', () => {
+    sessionStorageService.getItem.and.returnValue(JSON.stringify({ cid: 'caseId123' }));
+    const route = createActivatedRouteSnapshot('caseId', 'eventId');
+    const payload: TaskPayload = { task_required_for_event: true } as TaskPayload;
+    service.getTasksByCaseIdAndEventId.and.returnValue(of(payload));
+    const result$ = guard.canActivate(route);
+    expect(service.getTasksByCaseIdAndEventId).not.toHaveBeenCalled();
+    expect(mockAbstractConfig.logMessage).toHaveBeenCalledWith(`EventStartGuard: caseId caseId123 in caseInfo not matched with the route parameter caseId caseId`);
+  });
+
   it('canActivate should navigate to event-start if task is required for event', () => {
     sessionStorageService.getItem.and.returnValue(JSON.stringify({ cid: 'caseId' }));
     const route = createActivatedRouteSnapshot('caseId', 'eventId');

projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/event-guard/event-start.guard.ts

@@ -2,19 +2,21 @@ import { Injectable } from '@angular/core';
 import { ActivatedRouteSnapshot, CanActivate, Router } from '@angular/router';
 import { Observable, of } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
+
+import { AbstractAppConfig } from '../../../../app.config';
+import { TaskEventCompletionInfo } from '../../../domain/work-allocation/Task';
 import { TaskPayload } from '../../../domain/work-allocation/TaskPayload';
 import { SessionStorageService } from '../../../services';
 import { WorkAllocationService } from '../../case-editor';
-import { UserInfo } from '../../../domain/user/user-info.model';
-import { TaskEventCompletionInfo } from '../../../domain/work-allocation/Task';
 
 @Injectable()
 export class EventStartGuard implements CanActivate {
   public static readonly CLIENT_CONTEXT = 'clientContext';
 
   constructor(private readonly workAllocationService: WorkAllocationService,
     private readonly router: Router,
-    private readonly sessionStorageService: SessionStorageService) {
+    private readonly sessionStorageService: SessionStorageService,
+    private readonly abstractConfig: AbstractAppConfig) {
   }
 
   public canActivate(route: ActivatedRouteSnapshot): Observable<boolean> {
@@ -35,7 +37,11 @@ export class EventStartGuard implements CanActivate {
           .pipe(
             switchMap((payload: TaskPayload) => this.checkForTasks(payload, caseId, eventId, taskId, userId))
           );
+      } else {
+        this.abstractConfig.logMessage(`EventStartGuard: caseId ${caseInfo.cid} in caseInfo not matched with the route parameter caseId ${caseId}`);
       }
+    } else {
+      this.abstractConfig.logMessage(`EventStartGuard: caseInfo details not available in session storage for ${caseId}`);
     }
     return of(false);
   }

projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/resolvers/event-tasks-resolver.service.spec.ts

@@ -7,6 +7,7 @@ import { HttpErrorService, HttpService, SessionStorageService } from '../../../s
 import { WorkAllocationService } from '../../case-editor';
 import { EventTasksResolverService } from './event-tasks-resolver.service';
 import createSpyObj = jasmine.createSpyObj;
+import { AbstractAppConfig } from '../../../../app.config';
 
 describe('EventTaskResolverService', () => {
   // tslint:disable-next-line: prefer-const
@@ -15,6 +16,7 @@ describe('EventTaskResolverService', () => {
   let errorService: any;
   let workAllocationService: WorkAllocationService;
   let alertService: any;
+  let mockAbstractConfig: any;
 
   const taskPayload: TaskPayload = {
     task_required_for_event: true,
@@ -54,12 +56,14 @@ describe('EventTaskResolverService', () => {
   const sessionStorageService = createSpyObj('sessionStorageService', ['getItem']);
   sessionStorageService.getItem.and.returnValue(JSON.stringify({cid: '1620409659381330', caseType: 'caseType', jurisdiction: 'IA'}));
   workAllocationService = new WorkAllocationService(httpService, appConfig, errorService, alertService, sessionStorageService);
+  mockAbstractConfig = createSpyObj('abstractConfig', ['logMessage']);
 
   beforeEach(() => TestBed.configureTestingModule({
     providers: [
       EventTasksResolverService,
       { provide: WorkAllocationService, useValue: workAllocationService },
-      { provide: SessionStorageService, useValue: sessionStorageService }
+      { provide: SessionStorageService, useValue: sessionStorageService },
+      { provide: AbstractAppConfig, useValue: mockAbstractConfig }
     ]
   }));
 
@@ -82,4 +86,21 @@ describe('EventTaskResolverService', () => {
         expect(workAllocationService.getTasksByCaseIdAndEventId).toHaveBeenCalled();
       });
   }));
+
+  it('should log a message and not call getTasksByCaseIdAndEventId when caseInfo is not available', waitForAsync(() => {
+    const service = TestBed.inject(EventTasksResolverService);
+    const route = {
+      queryParamMap: {
+        get: (key: string) => {
+          const params = { eventId: 'event123', caseId: 'case123' } ;
+          return params[key];
+        }
+      }
+    } as ActivatedRouteSnapshot;
+    spyOn(workAllocationService, 'getTasksByCaseIdAndEventId').and.returnValue(of(taskPayload));
+    sessionStorageService.getItem.and.returnValue(null);
+    service.resolve(route);
+    expect(mockAbstractConfig.logMessage).toHaveBeenCalledWith('EventTasksResolverService: caseInfo details not available in session storage for case123');
+    expect(workAllocationService.getTasksByCaseIdAndEventId).not.toHaveBeenCalled();
+  }));
 });

projects/ccd-case-ui-toolkit/src/lib/shared/components/event-start/resolvers/event-tasks-resolver.service.ts

@@ -6,12 +6,14 @@ import { Task } from '../../../domain/work-allocation/Task';
 import { TaskPayload } from '../../../domain/work-allocation/TaskPayload';
 import { SessionStorageService } from '../../../services/session/session-storage.service';
 import { WorkAllocationService } from '../../case-editor/services/work-allocation.service';
+import { AbstractAppConfig } from '../../../../app.config';
 
 @Injectable()
 export class EventTasksResolverService implements Resolve<Task[]> {
 
   constructor(private readonly service: WorkAllocationService,
-              private readonly sessionStorageService: SessionStorageService) {
+              private readonly sessionStorageService: SessionStorageService,
+              private readonly abstractConfig: AbstractAppConfig) {
   }
 
   public resolve(route: ActivatedRouteSnapshot): Observable<Task[]> {
@@ -24,6 +26,8 @@ export class EventTasksResolverService implements Resolve<Task[]> {
       .pipe(
         map((payload: TaskPayload) => payload.tasks)
       );
+    } else {
+      this.abstractConfig.logMessage(`EventTasksResolverService: caseInfo details not available in session storage for ${caseId}`);
     }
   }
 }