DEVOPS-43: Responder Portal Support Limits

ess/src/API/EMBC.ESS/Resources/Tasks/Contract.cs

@@ -47,11 +47,15 @@ public record EssTask : Task
     public bool RemoteExtensionsEnabled { get; set; }
     public bool SelfServeEnabled { get; set; }
     public IEnumerable<SupportConfiguration> EnabledSupports { get; set; } = [];
+    public IEnumerable<SupportConfiguration> SupportLimits { get; set; } = [];
 }
 
 public record SupportConfiguration
 {
     public SupportType SupportType { get; set; }
+    public DateTime SupportLimitStartDate { get; set; }
+    public DateTime SupportLimitEndDate { get; set; }
+    public bool ExtensionAvailable { get; set; }
 }
 
 public enum SupportType

ess/src/API/EMBC.ESS/Resources/Tasks/Mappings.cs

@@ -20,10 +20,28 @@ public Mappings()
             .ForMember(d => d.SelfServeEnabled, opts => opts.MapFrom(s => s.era_selfservetoggle))
             .ForMember(d => d.AutoApprovedEnabled, opts => opts.Ignore())
             .ForMember(d => d.EnabledSupports, opts => opts.MapFrom(s => s.era_era_task_era_selfservesupportlimits_Task.Where(sl => sl.statuscode == 1)))
+            .ForMember(d => d.SupportLimits, opts => opts.MapFrom(s => s.era_era_task_era_supportlimit_Task.Where(sl => sl.statuscode == 1)))
             ;
 
         CreateMap<era_selfservesupportlimits, SupportConfiguration>()
             .ForMember(d => d.SupportType, opts => opts.MapFrom(s => s.era_supporttypeoption))
+            .ForMember(d => d.ExtensionAvailable, opts => opts.MapFrom(s => s.era_extensionavailable))
+            .ForMember(d => d.SupportLimitStartDate, opts => opts.MapFrom(s => s.era_supportlimitstartdate.HasValue ? s.era_supportlimitstartdate.Value.UtcDateTime : (DateTime?)null))
+            .ForMember(d => d.SupportLimitEndDate, opts => opts.MapFrom(s => s.era_supportlimitenddate.HasValue ? s.era_supportlimitenddate.Value.UtcDateTime : (DateTime?)null))
             ;
+
+        CreateMap<era_supportlimit, SupportConfiguration>()
+            .ForMember(d => d.SupportType, opts => opts.MapFrom(s => s.era_supporttypeoption))
+            .ForMember(d => d.ExtensionAvailable, opts => opts.MapFrom(s => s.era_extensionavailable))
+            .ForMember(d => d.SupportLimitStartDate, opts => opts.MapFrom(s => s.era_supportlimitstartdate.HasValue ? s.era_supportlimitstartdate.Value.UtcDateTime : (DateTime?)null))
+            .ForMember(d => d.SupportLimitEndDate, opts => opts.MapFrom(s => s.era_supportlimitenddate.HasValue ? s.era_supportlimitenddate.Value.UtcDateTime : (DateTime?)null))
+        ;
+
+        CreateMap<EMBC.ESS.Resources.Tasks.SupportConfiguration, EMBC.ESS.Shared.Contracts.Events.SupportLimits>()
+            .ForMember(dest => dest.SupportType, opts => opts.MapFrom(src => src.SupportType))
+            .ForMember(dest => dest.SupportLimitStartDate, opts => opts.MapFrom(src => src.SupportLimitStartDate))
+            .ForMember(dest => dest.SupportLimitEndDate, opts => opts.MapFrom(src => src.SupportLimitEndDate))
+            .ForMember(dest => dest.ExtensionAvailable, opts => opts.MapFrom(src => src.ExtensionAvailable))
+        ;
     }
 }

ess/src/API/EMBC.ESS/Resources/Tasks/TaskRepository.cs

@@ -65,13 +65,17 @@ private async Task<IEnumerable<era_task>> QueryTasks(TaskQuery query, Cancellati
                    essContext.era_tasks
                    .Expand(t => t.era_JurisdictionID)
                    .Expand(t => t.era_era_task_era_selfservesupportlimits_Task)
+                   .Expand(t => t.era_era_task_era_supportlimit_Task)
                    .Where(t => t.era_name == query.ById)
                    .GetAllPagesAsync(ct)).ToList();
 
             await Parallel.ForEachAsync(tasks, ct, async (t, ct1) =>
             {
                 var selfServeSupports = (await essContext.era_selfservesupportlimitses.Expand(sl => sl.era_SupportType).Where(sl => sl._era_task_value == t.era_taskid).GetAllPagesAsync(ct1)).ToList();
                 t.era_era_task_era_selfservesupportlimits_Task = new System.Collections.ObjectModel.Collection<era_selfservesupportlimits>(selfServeSupports);
+
+                var supportLimits = (await essContext.era_supportlimits.Expand(sl => sl.era_SupportType).Where(sl => sl._era_task_value == t.era_taskid).GetAllPagesAsync(ct1)).ToList();
+                t.era_era_task_era_supportlimit_Task = new System.Collections.ObjectModel.Collection<era_supportlimit>(supportLimits);
             });
 
             return tasks;

responders/src/API/EMBC.Responders.API/Controllers/TasksController.cs

@@ -45,6 +45,7 @@ public async Task<ActionResult<ESSTask>> GetTask(string taskId)
             if (task == null) return NotFound(taskId);
             var mappedTask = mapper.Map<ESSTask>(task);
             mappedTask.Workflows = GetTaskWorkflows(task);
+            mappedTask.SupportLimits = GetTaskSupportLimits(task);
             return Ok(mappedTask);
         }
 
@@ -60,6 +61,24 @@ private static IEnumerable<TaskWorkflow> GetTaskWorkflows(IncidentTask incidentT
             return workflows;
         }
 
+        private static IEnumerable<SupportLimits> GetTaskSupportLimits(IncidentTask incidentTask)
+        {
+            if (incidentTask.SupportLimits == null || !incidentTask.SupportLimits.Any())
+            {
+                return Enumerable.Empty<SupportLimits>();
+            }
+
+            var supportLimits = incidentTask.SupportLimits.Select(sl => new SupportLimits
+            {
+                SupportType = sl.SupportType,
+                SupportLimitStartDate = sl.SupportLimitStartDate,
+                SupportLimitEndDate = sl.SupportLimitEndDate,
+                ExtensionAvailable = sl.ExtensionAvailable
+            });
+
+            return supportLimits;
+        }
+
         [HttpGet("{taskId}/suppliers")]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
         [ProducesResponseType(StatusCodes.Status200OK)]
@@ -96,6 +115,7 @@ public class ESSTask
         public string Description { get; set; }
         public string Status { get; set; }
         public IEnumerable<TaskWorkflow> Workflows { get; set; } = Array.Empty<TaskWorkflow>();
+        public IEnumerable<SupportLimits> SupportLimits { get; set; } = Array.Empty<SupportLimits>();
     }
 
     public class TaskWorkflow
@@ -125,7 +145,8 @@ public class TaskMapping : Profile
         public TaskMapping()
         {
             CreateMap<IncidentTask, ESSTask>()
-                .ForMember(d => d.Workflows, opts => opts.Ignore());
+                .ForMember(d => d.Workflows, opts => opts.Ignore())
+                .ForMember(d => d.SupportLimits, opts => opts.MapFrom(s => s.SupportLimits));
             CreateMap<SupplierDetails, SuppliersListItem>();
         }
     }

responders/src/UI/embc-responder/src/app/core/api/models/ess-task.ts

@@ -1,6 +1,7 @@
 /* tslint:disable */
 /* eslint-disable */
 import { TaskWorkflow } from '../models/task-workflow';
+import { SupportLimit } from './support-limit';
 export interface EssTask {
   communityCode?: string | null;
   description?: string | null;
@@ -9,4 +10,5 @@ export interface EssTask {
   startDate?: string;
   status?: string | null;
   workflows?: Array<TaskWorkflow> | null;
+  supportLimits?: Array<SupportLimit> | null;
 }

responders/src/UI/embc-responder/src/app/core/api/models/support-limit.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+import { SupportSubCategory } from './support-sub-category';
+export interface SupportLimit {
+    supportLimitStartDate: Date;
+    supportLimitEndDate: Date;
+    extensionAvailable: boolean;
+    supportType: SupportSubCategory
+}

responders/src/UI/embc-responder/src/app/feature-components/wizard/step-supports/step-supports.service.ts

@@ -31,6 +31,7 @@ import { DateConversionService } from 'src/app/core/services/utility/dateConvers
 import { ComputeRulesService } from 'src/app/core/services/computeRules.service';
 import { AppBaseService } from 'src/app/core/services/helper/appBase.service';
 import { EvacueeSessionService } from 'src/app/core/services/evacuee-session.service';
+import { SupportLimit } from 'src/app/core/api/models/support-limit';
 
 @Injectable({ providedIn: 'root' })
 export class StepSupportsService {
@@ -41,6 +42,8 @@ export class StepSupportsService {
   private supportDetailsVal: SupportDetailsModel;
   private supportDeliveryVal: SupportDeliveryModel;
   private selectedSupportDetailVal: Support;
+  private supportLimitsVal: BehaviorSubject<SupportLimit[]> = new BehaviorSubject<SupportLimit[]>([]);
+  private supportLimitsVal$: Observable<SupportLimit[]> = this.supportLimitsVal.asObservable();
 
   constructor(
     private essFileService: EssFileService,
@@ -89,6 +92,36 @@ export class StepSupportsService {
     return this.existingSupportListVal$;
   }
 
+  setStoredSupportLimits(supportLimits: SupportLimit[]): void {
+    this.supportLimitsVal.next(supportLimits);
+  }
+
+  getStoredSupportLimits(): Observable<SupportLimit[]> {
+    return this.supportLimitsVal$;
+  }
+
+  fetchSupportLimits(): Observable<SupportLimit[]> {
+    return this.taskService
+      .tasksGetTask({
+        taskId: this.userService?.currentProfile?.taskNumber
+      })
+      .pipe(
+        map((task) => {
+          const supportLimits: SupportLimit[] = task.supportLimits.map((supportLimit) => {
+            return {
+              supportLimitStartDate: supportLimit.supportLimitStartDate,
+              supportLimitEndDate: supportLimit.supportLimitEndDate,
+              extensionAvailable: supportLimit.extensionAvailable,
+              supportType: supportLimit.supportType
+            };
+          });
+
+          this.setStoredSupportLimits(supportLimits);
+          return supportLimits;
+        })
+      );
+  }
+
   set supportTypeToAdd(supportTypeToAddVal: Code) {
     this.supportTypeToAddVal = supportTypeToAddVal;
     this.cacheService.set('supportType', JSON.stringify(supportTypeToAddVal));

responders/src/UI/embc-responder/src/app/feature-components/wizard/support-components/support-details/support-details.component.html

@@ -377,38 +377,50 @@
                       </p>
                     </div>
                   </div>
-
-                  <div class="row">
-                    <div class="col-md-12">
-                      <mat-checkbox
-                        id="allMembers"
-                        [checked]="isChecked()"
-                        [indeterminate]="isIndeterminate()"
-                        (change)="$event ? selectAll($event) : null"
-                        ><span class="bold">All household members</span></mat-checkbox
-                      >
-                    </div>
+                  <div class="col-md-4" *ngIf="showLoader">
+                    <app-loader [strokeWidth]="3" [diameter]="25" [showLoader]="showLoader" [color]="color">
+                    </app-loader>
                   </div>
-                  @for (member of evacueeSessionService?.evacFile?.needsAssessment?.householdMembers; track member) {
+                  <div *ngIf="!showLoader">
                     <div class="row">
                       <div class="col-md-12">
                         <mat-checkbox
-                          (click)="$event.stopPropagation()"
-                          (change)="$event ? onChange($event, member) : null"
-                          [checked]="exists(member)"
-                        >
-                          {{ member.lastName | uppercase }}, {{ member.firstName | titlecase }}</mat-checkbox
+                          id="allMembers"
+                          [checked]="isChecked()"
+                          [indeterminate]="isIndeterminate()"
+                          (change)="selectAll($event)"
+                          ><span class="bold">All household members</span></mat-checkbox
                         >
                       </div>
                     </div>
-                  }
-                  @if (
-                    supportDetailsFormControl.members.invalid &&
-                    supportDetailsFormControl.members.hasError('noSelection')
-                  ) {
-                    <mat-error class="custom-mat-error"> Required</mat-error>
-                  }
-
+                    @for (member of evacueeSessionService?.evacFile?.needsAssessment?.householdMembers; track member) {
+                      <div class="row">
+                        <div class="col-md-12">
+                          <mat-checkbox
+                            (click)="$event.stopPropagation()"
+                            (change)="$event ? onChange($event, member) : null"
+                            [disabled]="!isHouseholdMemberEligibleForSupport(member)"
+                            [checked]="exists(member)"
+                          >
+                            {{ member.lastName | uppercase }}, {{ member.firstName | titlecase }}
+                          </mat-checkbox>
+                          <!-- Display error message if the checkbox is disabled -->
+                          @if (!isHouseholdMemberEligibleForSupport(member)) {
+                            <mat-error class="custom-mat-info">
+                              {{ member.firstName | titlecase }} {{ member.lastName | titlecase }} has already received
+                              this support. Extensions for this support are not available at this time.
+                            </mat-error>
+                          }
+                        </div>
+                      </div>
+                    }
+                    @if (
+                      supportDetailsFormControl.members.invalid &&
+                      supportDetailsFormControl.members.hasError('noSelection')
+                    ) {
+                      <mat-error class="custom-mat-error"> Required</mat-error>
+                    }
+                  </div>
                   <div>
                     @switch (stepSupportsService?.supportTypeToAdd?.value) {
                       <!-- Shelter-Allowance -->