Merge pull request #2014 from bcgov/feature/ALCS-2404-2

QA Fix: Fix Admin Condition Type Code Check on Deleted Items
bcgov · Dec 12, 2024 · 0573c26 · 0573c26
2 parents 4ae5c7f + dd29074
commit 0573c26
Show file tree

Hide file tree

Showing 10 changed files with 98 additions and 27 deletions.
diff --git a/...end/src/app/features/admin/decision-condition-types/decision-condition-types.component.ts b/...end/src/app/features/admin/decision-condition-types/decision-condition-types.component.ts
@@ -29,6 +29,7 @@ export class DecisionConditionTypesComponent implements OnInit {
   destroy = new Subject<void>();
 
   decisionConditionTypeDtos: ApplicationDecisionConditionTypeDto[] | NoticeOfIntentDecisionConditionTypeDto[] = [];
+  decisionConditionTypeCodeDtos: string[] = [];
   displayedColumns: string[] = ['label', 'description', 'code', 'isActive', 'actions'];
 
   constructor(
@@ -43,6 +44,7 @@ export class DecisionConditionTypesComponent implements OnInit {
   async fetch() {
     if (!this.service) return;
     this.decisionConditionTypeDtos = await this.service.fetch();
+    this.decisionConditionTypeCodeDtos = await this.service.fetchCodesWithDeleted();
   }
 
   async onCreate() {
@@ -53,7 +55,7 @@ export class DecisionConditionTypesComponent implements OnInit {
       data: {
         service: this.service,
         conditionService: this.conditionService,
-        existingCodes: this.decisionConditionTypeDtos.map((dct) => dct.code),
+        existingCodes: this.decisionConditionTypeCodeDtos,
       },
     });
     dialog.beforeClosed().subscribe(async (result) => {
@@ -72,7 +74,7 @@ export class DecisionConditionTypesComponent implements OnInit {
         service: this.service,
         conditionService: this.conditionService,
         content: dto,
-        existingCodes: this.decisionConditionTypeDtos.map((dct) => dct.code),
+        existingCodes: this.decisionConditionTypeCodeDtos,
       },
     });
     dialog.beforeClosed().subscribe(async (result) => {

diff --git a/...tion/application-decision-condition-types/application-decision-condition-types.service.ts b/...tion/application-decision-condition-types/application-decision-condition-types.service.ts
@@ -26,6 +26,16 @@ export class ApplicationDecisionConditionTypesService {
     return [];
   }
 
+  async fetchCodesWithDeleted() {
+    try {
+      return await firstValueFrom(this.http.get<string[]>(`${this.url}/codes`));
+    } catch (err) {
+      console.error(err);
+      this.toastService.showErrorToast('Failed to fetch decision condition type codes');
+    }
+    return [];
+  }
+
   async create(createDto: ApplicationDecisionConditionTypeDto) {
     try {
       return await firstValueFrom(this.http.post<ApplicationDecisionConditionTypeDto>(`${this.url}`, createDto));

diff --git a/...e-of-intent-decision-condition-types/notice-of-intent-decision-condition-types.service.ts b/...e-of-intent-decision-condition-types/notice-of-intent-decision-condition-types.service.ts
@@ -11,7 +11,10 @@ import { NoticeOfIntentDecisionConditionTypeDto } from '../decision-v2/notice-of
 export class NoticeofIntentDecisionConditionTypesService {
   private url = `${environment.apiUrl}/noi-decision-condition-types`;
 
-  constructor(private http: HttpClient, private toastService: ToastService) {}
+  constructor(
+    private http: HttpClient,
+    private toastService: ToastService,
+  ) {}
 
   async fetch() {
     try {
@@ -23,6 +26,16 @@ export class NoticeofIntentDecisionConditionTypesService {
     return [];
   }
 
+  async fetchCodesWithDeleted() {
+    try {
+      return await firstValueFrom(this.http.get<string[]>(`${this.url}/codes`));
+    } catch (err) {
+      console.error(err);
+      this.toastService.showErrorToast('Failed to fetch decision condition type codes');
+    }
+    return [];
+  }
+
   async create(createDto: NoticeOfIntentDecisionConditionTypeDto) {
     try {
       return await firstValueFrom(this.http.post<NoticeOfIntentDecisionConditionTypeDto>(`${this.url}`, createDto));
@@ -36,7 +49,7 @@ export class NoticeofIntentDecisionConditionTypesService {
   async update(code: string, updateDto: NoticeOfIntentDecisionConditionTypeDto) {
     try {
       return await firstValueFrom(
-        this.http.patch<NoticeOfIntentDecisionConditionTypeDto>(`${this.url}/${code}`, updateDto)
+        this.http.patch<NoticeOfIntentDecisionConditionTypeDto>(`${this.url}/${code}`, updateDto),
       );
     } catch (e) {
       this.toastService.showErrorToast('Failed to update decision condition type');

diff --git a/...lication-decision-condition-types/application-decision-condition-types.controller.spec.ts b/...lication-decision-condition-types/application-decision-condition-types.controller.spec.ts
@@ -30,9 +30,7 @@ describe('ApplicationDecisionConditionTypesController', () => {
       imports: [ConfigModule],
     }).compile();
 
-    controller = module.get<ApplicationDecisionConditionTypesController>(
-      ApplicationDecisionConditionTypesController,
-    );
+    controller = module.get<ApplicationDecisionConditionTypesController>(ApplicationDecisionConditionTypesController);
   });
 
   it('should be defined', () => {
@@ -48,28 +46,28 @@ describe('ApplicationDecisionConditionTypesController', () => {
     expect(mockDecTypesService.fetch).toHaveBeenCalledTimes(1);
   });
 
+  it('should call out to service when fetching decision condition type codes', async () => {
+    mockDecTypesService.fetchCodesWithDeleted.mockResolvedValue([]);
+
+    const applicationDecisionConditionTypeCodes = await controller.fetchCodesWithDeleted();
+
+    expect(applicationDecisionConditionTypeCodes).toBeDefined();
+    expect(mockDecTypesService.fetchCodesWithDeleted).toHaveBeenCalledTimes(1);
+  });
+
   it('should call out to service when updating decision condition type', async () => {
-    mockDecTypesService.update.mockResolvedValue(
-      new ApplicationDecisionConditionType(),
-    );
+    mockDecTypesService.update.mockResolvedValue(new ApplicationDecisionConditionType());
 
-    const applicationDecisionConditionType = await controller.update(
-      'fake',
-      new ApplicationDecisionConditionType(),
-    );
+    const applicationDecisionConditionType = await controller.update('fake', new ApplicationDecisionConditionType());
 
     expect(applicationDecisionConditionType).toBeDefined();
     expect(mockDecTypesService.update).toHaveBeenCalledTimes(1);
   });
 
   it('should call out to service when creating decision condition type', async () => {
-    mockDecTypesService.create.mockResolvedValue(
-      new ApplicationDecisionConditionType(),
-    );
+    mockDecTypesService.create.mockResolvedValue(new ApplicationDecisionConditionType());
 
-    const applicationDecisionConditionType = await controller.create(
-      new ApplicationDecisionConditionType(),
-    );
+    const applicationDecisionConditionType = await controller.create(new ApplicationDecisionConditionType());
 
     expect(applicationDecisionConditionType).toBeDefined();
     expect(mockDecTypesService.create).toHaveBeenCalledTimes(1);

diff --git a/...n/application-decision-condition-types/application-decision-condition-types.controller.ts b/...n/application-decision-condition-types/application-decision-condition-types.controller.ts
@@ -36,4 +36,10 @@ export class ApplicationDecisionConditionTypesController {
   async create(@Body() createDto: ApplicationDecisionConditionTypeDto) {
     return await this.applicationDecisionConditionTypesService.create(createDto);
   }
+
+  @Get('/codes')
+  @UserRoles(AUTH_ROLE.ADMIN)
+  async fetchCodesWithDeleted() {
+    return (await this.applicationDecisionConditionTypesService.fetchCodesWithDeleted()).map((adct) => adct.code);
+  }
 }
diff --git a/...application-decision-condition-types/application-decision-condition-types.service.spec.ts b/...application-decision-condition-types/application-decision-condition-types.service.spec.ts
@@ -131,4 +131,13 @@ describe('ApplicationDecisionConditionTypesService', () => {
     expect(mockRepository.find).toBeCalledTimes(1);
     expect(result).toBeDefined();
   });
+
+  it('should successfully fetch decision condition type code', async () => {
+    mockRepository.find.mockResolvedValue([type]);
+
+    const result = await service.fetchCodesWithDeleted();
+
+    expect(mockRepository.find).toHaveBeenCalledTimes(1);
+    expect(result).toBeDefined();
+  });
 });
diff --git a/...dmin/application-decision-condition-types/application-decision-condition-types.service.ts b/...dmin/application-decision-condition-types/application-decision-condition-types.service.ts
@@ -20,7 +20,7 @@ export class ApplicationDecisionConditionTypesService {
     private applicationDecisionConditionTypeRepository: Repository<ApplicationDecisionConditionType>,
   ) {}
 
-  async fetch() {
+  async fetch(includeDeleted: boolean = false) {
     return await this.applicationDecisionConditionTypeRepository.find({
       order: { label: 'ASC' },
       select: {
@@ -43,6 +43,15 @@ export class ApplicationDecisionConditionTypesService {
     });
   }
 
+  async fetchCodesWithDeleted() {
+    return await this.applicationDecisionConditionTypeRepository.find({
+      select: {
+        code: true,
+      },
+      withDeleted: true,
+    });
+  }
+
   async getOneOrFail(code: string) {
     return await this.applicationDecisionConditionTypeRepository.findOneOrFail({
       where: { code },

diff --git a/...ent-decision-condition-types/notice-of-intent-decision-condition-types.controller.spec.ts b/...ent-decision-condition-types/notice-of-intent-decision-condition-types.controller.spec.ts
@@ -42,27 +42,36 @@ describe('NoticeofIntentDecisionConditionTypesController', () => {
   it('should call out to service when fetching decision condition type', async () => {
     mockDecTypesService.fetch.mockResolvedValue([]);
 
-    const applicationDecisionConditionTypes = await controller.fetch();
+    const noiDecisionConditionTypes = await controller.fetch();
 
-    expect(applicationDecisionConditionTypes).toBeDefined();
+    expect(noiDecisionConditionTypes).toBeDefined();
     expect(mockDecTypesService.fetch).toHaveBeenCalledTimes(1);
   });
 
+  it('should call out to service when fetching decision condition type codes', async () => {
+    mockDecTypesService.fetchCodesWithDeleted.mockResolvedValue([]);
+
+    const noiDecisionConditionTypeCodes = await controller.fetchCodesWithDeleted();
+
+    expect(noiDecisionConditionTypeCodes).toBeDefined();
+    expect(mockDecTypesService.fetchCodesWithDeleted).toHaveBeenCalledTimes(1);
+  });
+
   it('should call out to service when updating decision condition type', async () => {
     mockDecTypesService.update.mockResolvedValue(new NoticeOfIntentDecisionConditionType());
 
-    const applicationDecisionConditionType = await controller.update('fake', new NoticeOfIntentDecisionConditionType());
+    const noiDecisionConditionType = await controller.update('fake', new NoticeOfIntentDecisionConditionType());
 
-    expect(applicationDecisionConditionType).toBeDefined();
+    expect(noiDecisionConditionType).toBeDefined();
     expect(mockDecTypesService.update).toHaveBeenCalledTimes(1);
   });
 
   it('should call out to service when creating decision condition type', async () => {
     mockDecTypesService.create.mockResolvedValue(new NoticeOfIntentDecisionConditionType());
 
-    const applicationDecisionConditionType = await controller.create(new NoticeOfIntentDecisionConditionType());
+    const noiDecisionConditionType = await controller.create(new NoticeOfIntentDecisionConditionType());
 
-    expect(applicationDecisionConditionType).toBeDefined();
+    expect(noiDecisionConditionType).toBeDefined();
     expect(mockDecTypesService.create).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/...f-intent-decision-condition-types/notice-of-intent-decision-condition-types.controller.ts b/...f-intent-decision-condition-types/notice-of-intent-decision-condition-types.controller.ts
@@ -36,4 +36,10 @@ export class NoticeofIntentDecisionConditionTypesController {
   async create(@Body() createDto: NoticeOfIntentDecisionConditionTypeDto) {
     return await this.noiDecisionConditionTypesService.create(createDto);
   }
+
+  @Get('/codes')
+  @UserRoles(AUTH_ROLE.ADMIN)
+  async fetchCodesWithDeleted() {
+    return (await this.noiDecisionConditionTypesService.fetchCodesWithDeleted()).map((ndct) => ndct.code);
+  }
 }
diff --git a/...e-of-intent-decision-condition-types/notice-of-intent-decision-condition-types.service.ts b/...e-of-intent-decision-condition-types/notice-of-intent-decision-condition-types.service.ts
@@ -41,6 +41,15 @@ export class NoticeofIntentDecisionConditionTypesService {
     });
   }
 
+  async fetchCodesWithDeleted() {
+    return await this.noiDecisionConditionTypeRepository.find({
+      select: {
+        code: true,
+      },
+      withDeleted: true,
+    });
+  }
+
   async getOneOrFail(code: string) {
     return await this.noiDecisionConditionTypeRepository.findOneOrFail({
       where: { code },