ORV2-3701: Use LOAs for Term Permit Applications and Amendments (#1925)

Author: zgong-gov

frontend/src/features/permits/helpers/permitLOA.ts

@@ -2,7 +2,7 @@ import dayjs, { Dayjs } from "dayjs";
 
 import { LOADetail } from "../../settings/types/LOADetail";
 import { PermitType } from "../types/PermitType";
-import { getEndOfDate, toLocalDayjs } from "../../../common/helpers/formatDate";
+import { getEndOfDate, getStartOfDate, toLocalDayjs } from "../../../common/helpers/formatDate";
 import { Nullable } from "../../../common/types/common";
 import { Application, ApplicationFormData } from "../types/application";
 import { getDefaultRequiredVal } from "../../../common/helpers/util";
@@ -80,21 +80,30 @@ export const getUpdatedLOASelection = (
   upToDateLOAs: LOADetail[],
   prevSelectedLOAs: PermitLOA[],
   minPermitExpiryDate: Dayjs,
+  permitStartDate: Dayjs,
 ) => {
   // Each LOA should only be selected once, but there's a chance that an up-to-date LOA is also a previously selected LOA,
   // which means that LOA should only be shown once.
   // Thus, any overlapping LOA between the up-to-date LOAs and previously selected LOAs should only be included once,
   // and all non-overlapping LOAs that are not part of the up-to-date LOAs should be removed
   const prevSelectedLOANumbers = new Set([...prevSelectedLOAs.map(loa => loa.loaNumber)]);
 
-  return upToDateLOAs.map(loa => {
+  // Updated selection for LOAs, not including empty selection option "None"
+  const updatedSelection = upToDateLOAs.map(loa => {
     const wasSelected = prevSelectedLOANumbers.has(loa.loaNumber);
     const isExpiringBeforeMinPermitExpiry = Boolean(loa.expiryDate)
       && minPermitExpiryDate.isAfter(getEndOfDate(dayjs(loa.expiryDate)));
 
-    // Deselect and disable any LOAs expiring before min permit expiry date
-    const isSelected = wasSelected && !isExpiringBeforeMinPermitExpiry;
-    const isEnabled = !isExpiringBeforeMinPermitExpiry;
+    const isStartingAfterPermitStartDate =
+      permitStartDate.isBefore(getStartOfDate(dayjs(loa.startDate)));
+
+    // Deselect and disable any LOAs expiring before min permit expiry date,
+    // or hasn't started yet (ie. LOA starts after permit start date)
+    const isSelected = wasSelected
+      && !isExpiringBeforeMinPermitExpiry
+      && !isStartingAfterPermitStartDate;
+    
+    const isEnabled = !isExpiringBeforeMinPermitExpiry && !isStartingAfterPermitStartDate;
 
     return {
       loa: {
@@ -113,14 +122,23 @@ export const getUpdatedLOASelection = (
       disabled: !isEnabled,
     };
   });
+
+  // Empty LOA selection state
+  const emptyLOASelection = {
+    loa: null,
+    checked: updatedSelection.filter(({ checked }) => checked).length === 0,
+    disabled: false,
+  };
+
+  return [emptyLOASelection, ...updatedSelection];
 };
 
 /**
  * Get updated vehicle details and options based on selected LOAs.
  * @param selectedLOAs Selected LOAs for the permit
  * @param vehicleOptions Provided vehicle options for selection
  * @param prevSelectedVehicle Previously selected vehicle details in the permit form
- * @param eligibleSubtypes Set of eligible vehicle subtypes
+ * @param eligibleSubtypes Set of all possible eligible vehicle subtypes
  * @param vehicleRestrictions Restriction rules that each vehicle must meet
  * @returns Updated vehicle details and filtered vehicle options
  */
@@ -131,36 +149,46 @@ export const getUpdatedVehicleDetailsForLOAs = (
   eligibleSubtypes: Set<string>,
   vehicleRestrictions: ((vehicle: Vehicle) => boolean)[],
 ) => {
+  const isLOAUsed = selectedLOAs.length > 0;
+
   const filteredVehicles = getAllowedVehicles(
     vehicleOptions,
     eligibleSubtypes,
     selectedLOAs,
     vehicleRestrictions,
   );
-  
-  const filteredVehicleIds = filteredVehicles.map(filteredVehicle => ({
-    filteredVehicleType: filteredVehicle.vehicleType,
-    filteredVehicleId: filteredVehicle.vehicleType === VEHICLE_TYPES.TRAILER
-      ? (filteredVehicle as Trailer).trailerId
-      : (filteredVehicle as PowerUnit).powerUnitId,
-  }));
-
-  // If vehicle selected is an existing vehicle but is not in list of vehicle options
-  // Clear the selected vehicle
-  const { vehicleId, vehicleType } = prevSelectedVehicle;
-  if (vehicleId && !filteredVehicleIds.some(({
-    filteredVehicleType,
-    filteredVehicleId,
-  }) => filteredVehicleType === vehicleType && filteredVehicleId === vehicleId)) {
+
+  // If an LOA is used, then the only allowable subtype is the one defined by the LOA
+  // Otherwise, the allowable subtypes are the ones originally belonging to the permit type
+  const allAllowableSubtypes = isLOAUsed
+    ? new Set<string>([selectedLOAs[0].vehicleSubType])
+    : eligibleSubtypes;
+
+  // If vehicle selected is an existing vehicle (was originally chosen from inventory),
+  // but its subtype is no longer valid, then clear the selected vehicle
+  const { vehicleId, vehicleSubType } = prevSelectedVehicle;
+  if (vehicleId && !allAllowableSubtypes.has(vehicleSubType)) {
+    const defaultVehicleDetails = getDefaultVehicleDetails();
+
     return {
       filteredVehicleOptions: filteredVehicles,
-      updatedVehicle: getDefaultVehicleDetails(),
+      // If an LOA is used, fill the vehicle type and subtype with the LOA's vehicle type/subtype
+      // Otherwise, simply clear the vehicle details and fill with default empty values
+      updatedVehicle: isLOAUsed ? {
+        ...defaultVehicleDetails,
+        vehicleType: selectedLOAs[0].vehicleType,
+        vehicleSubType: selectedLOAs[0].vehicleSubType,
+      } : defaultVehicleDetails,
     };
   }
 
   return {
     filteredVehicleOptions: filteredVehicles,
-    updatedVehicle: prevSelectedVehicle,
+    updatedVehicle: isLOAUsed ? {
+      ...prevSelectedVehicle,
+      vehicleType: selectedLOAs[0].vehicleType,
+      vehicleSubType: selectedLOAs[0].vehicleSubType,
+    } : prevSelectedVehicle,
   };
 };
 
@@ -203,9 +231,10 @@ export const applyUpToDateLOAsToApplication = <T extends Nullable<ApplicationFor
     applicableLOAs,
     prevSelectedLOAs,
     minPermitExpiryDate,
+    applicationData.permitData.startDate,
   )
-    .filter(({ checked }) => checked)
-    .map(({ loa }) => loa);
+    .filter(({ checked, loa }) => checked && Boolean(loa))
+    .map(({ loa }) => loa) as PermitLOA[];
 
   // Update duration in permit if selected LOAs changed
   const durationOptions = getAvailableDurationOptions(

frontend/src/features/permits/helpers/vehicles/getAllowedVehicles.ts

@@ -21,22 +21,24 @@ export const getAllowedVehicles = (
   restrictions: ((vehicle: Vehicle) => boolean)[],
 ) => {
   return vehicles.filter((vehicle) => {
+    const isLOAUsed = loas.length > 0;
+
     if (vehicle.vehicleType === VEHICLE_TYPES.TRAILER) {
       const trailer = vehicle as Trailer;
-      return loas.some(loa => (
+      return isLOAUsed ? loas.some(loa => (
         trailer.vehicleType === loa.vehicleType
         && trailer.trailerTypeCode === loa.vehicleSubType
-      )) || (
+      )) : (
         eligibleSubtypes.has(trailer.trailerTypeCode)
           && restrictions.every(restriction => restriction(trailer))
       );
     }
 
     const powerUnit = vehicle as PowerUnit;
-    return loas.some(loa => (
+    return isLOAUsed ? loas.some(loa => (
       powerUnit.vehicleType === loa.vehicleType
       && powerUnit.powerUnitTypeCode === loa.vehicleSubType
-    )) || (
+    )) : (
       eligibleSubtypes.has(powerUnit.powerUnitTypeCode)
         && restrictions.every(restriction => restriction(powerUnit))
     );

frontend/src/features/permits/helpers/vehicles/subtypes/getEligibleSubtypeOptions.ts

@@ -65,8 +65,9 @@ export const getEligibleSubtypeOptions = (
     getSubtypeOptions(vehicleType, powerUnitSubtypes, trailerSubtypes),
   );
 
+  const isLOAUsed = allowedLOASubtypeCodes.size > 0;
   return getAllowedVehicleSubtypes(
     sortedVehicleSubtypes,
-    new Set([...eligibleSubtypesCodes, ...allowedLOASubtypeCodes]),
+    isLOAUsed ? allowedLOASubtypeCodes : eligibleSubtypesCodes,
   );
 };

frontend/src/features/permits/helpers/vehicles/subtypes/shouldOverridePolicyInvalidSubtype.ts

@@ -0,0 +1,26 @@
+import { Nullable } from "../../../../../common/types/common";
+import { PermitLOA } from "../../../types/PermitLOA";
+
+/**
+ * Determines whether or not a vehicle subtype considered invalid by policy engine
+ * is in fact valid (eg. due to LOA).
+ * @param policyViolations Policy engine violations, with key being name of invalid field
+ * @param vehicleSubtype Current vehicle subtype in the form
+ * @param selectedLOAs Currently selected LOAs, if any
+ * @returns true if vehicle subtype is indeed valid, false otherwise
+ */
+export const shouldOverridePolicyInvalidSubtype = (
+  policyViolations: Record<string, string>,
+  vehicleSubtype: string,
+  selectedLOAs?: Nullable<PermitLOA[]>,
+) => {
+  // By default, if policy violations don't include subtype,
+  // it's safe to assume that subtype is valid and hence should let it pass
+  if (!Object.keys(policyViolations).includes("permitData.vehicleDetails.vehicleSubType"))
+    return true;
+
+  // If no LOAs were selected, then an invalid subtype stays invalid
+  if (!selectedLOAs || selectedLOAs.length === 0) return false;
+
+  return selectedLOAs[0].vehicleSubType === vehicleSubtype;
+};

frontend/src/features/permits/hooks/form/useApplicationFormContext.ts

@@ -1,4 +1,4 @@
-import { useContext } from "react";
+import { useCallback, useContext } from "react";
 import { Policy } from "onroute-policy-engine";
 
 import { ApplicationFormContext } from "../../context/ApplicationFormContext";
@@ -15,6 +15,7 @@ import { useVehicleConfiguration } from "../useVehicleConfiguration";
 import { useApplicationFormUpdateMethods } from "./useApplicationFormUpdateMethods";
 import { usePermittedCommodity } from "../usePermittedCommodity";
 import { DEFAULT_EMPTY_SELECT_VALUE } from "../../../../common/constants/constants";
+import { PermitVehicleDetails } from "../../types/PermitVehicleDetails";
 
 export const useApplicationFormContext = () => {
   const applicationFormContextData = useContext(ApplicationFormContext);
@@ -138,14 +139,34 @@ export const useApplicationFormContext = () => {
     onSetConditions,
   );
 
+  const handleClearVehicle = useCallback((saveVehicle: boolean) => {
+    onClearVehicle(
+      Boolean(saveVehicle),
+      currentSelectedLOAs.length > 0 ? {
+        vehicleType: currentSelectedLOAs[0].vehicleType,
+        vehicleSubtype: currentSelectedLOAs[0].vehicleSubType,
+      } : undefined,
+    );
+  }, [currentSelectedLOAs]);
+
+  const handleSetVehicle = useCallback((vehicleDetails: PermitVehicleDetails) => {
+    onSetVehicle({
+      ...vehicleDetails,
+      vehicleType: currentSelectedLOAs.length > 0 ?
+        currentSelectedLOAs[0].vehicleType : vehicleDetails.vehicleType,
+      vehicleSubType: currentSelectedLOAs.length > 0 ?
+        currentSelectedLOAs[0].vehicleSubType : vehicleDetails.vehicleSubType,
+    });
+  }, [currentSelectedLOAs]);
+
   const {
     commodityOptions,
     onChangeCommodityType,
   } = usePermittedCommodity(
     policyEngine,
     permitType,
     onSetCommodityType,
-    () => onClearVehicle(Boolean(vehicleFormData.saveVehicle)),
+    () => handleClearVehicle(Boolean(vehicleFormData.saveVehicle)),
     onClearVehicleConfig,
     permittedCommodity?.commodityType,
   );
@@ -164,7 +185,6 @@ export const useApplicationFormContext = () => {
     selectedLOAs: currentSelectedLOAs,
     powerUnitSubtypeNamesMap,
     trailerSubtypeNamesMap,
-    onClearVehicle: () => onClearVehicle(Boolean(vehicleFormData.saveVehicle)),
     selectedCommodity: permittedCommodity?.commodityType,
   });
 
@@ -253,8 +273,8 @@ export const useApplicationFormContext = () => {
     onSetExpiryDate,
     onSetConditions,
     onToggleSaveVehicle,
-    onSetVehicle,
-    onClearVehicle,
+    onSetVehicle: handleSetVehicle,
+    onClearVehicle: handleClearVehicle,
     onUpdateLOAs,
     onUpdateHighwaySequence,
     onUpdateTripOrigin,

frontend/src/features/permits/hooks/form/useApplicationFormUpdateMethods.ts

@@ -9,8 +9,9 @@ import { EMPTY_VEHICLE_DETAILS, PermitVehicleDetails } from "../../types/PermitV
 import { ApplicationFormData } from "../../types/application";
 import { getDefaultVehicleConfiguration } from "../../helpers/vehicles/configuration/getDefaultVehicleConfiguration";
 import { PermitType } from "../../types/PermitType";
-import { RequiredOrNull } from "../../../../common/types/common";
+import { Nullable, RequiredOrNull } from "../../../../common/types/common";
 import { ThirdPartyLiability } from "../../types/ThirdPartyLiability";
+import { VehicleType } from "../../../manageVehicles/types/Vehicle";
 
 /**
  * Hook that returns custom methods that update specific values in the application form.
@@ -39,15 +40,67 @@ export const useApplicationFormUpdateMethods = () => {
     setValue("permitData.vehicleDetails.saveVehicle", saveVehicle);
   }, [setValue]);
 
+  const onSetVin = useCallback((vin: string) => {
+    setValue("permitData.vehicleDetails.vin", vin);
+  }, [setValue]);
+
+  const onSetPlate = useCallback((plate: string) => {
+    setValue("permitData.vehicleDetails.plate", plate);
+  }, [setValue]);
+
+  const onSetMake = useCallback((make: string) => {
+    setValue("permitData.vehicleDetails.make", make);
+  }, [setValue]);
+
+  const onSetYear = useCallback((year: Nullable<number>) => {
+    setValue("permitData.vehicleDetails.year", year);
+  }, [setValue]);
+  
+  const onSetCountryCode = useCallback((countryCode: string) => {
+    setValue("permitData.vehicleDetails.countryCode", countryCode);
+  }, [setValue]);
+  
+  const onSetProvinceCode = useCallback((provinceCode: string) => {
+    setValue("permitData.vehicleDetails.provinceCode", provinceCode);
+  }, [setValue]);
+  
+  const onSetVehicleType = useCallback((vehicleType: string) => {
+    setValue("permitData.vehicleDetails.vehicleType", vehicleType);
+  }, [setValue]);
+  
+  const onSetVehicleSubtype = useCallback((vehicleSubtype: string) => {
+    setValue("permitData.vehicleDetails.vehicleSubType", vehicleSubtype);
+  }, [setValue]);
+  
+  const onSetUnitNumber = useCallback((unitNumber: Nullable<string>) => {
+    setValue("permitData.vehicleDetails.unitNumber", unitNumber);
+  }, [setValue]);
+
+  const onSetVehicleId = useCallback((vehicleId: Nullable<string>) => {
+    setValue("permitData.vehicleDetails.vehicleId", vehicleId);
+  }, [setValue]);
+
+  const onSetLicensedGVW = useCallback((licensedGVW?: Nullable<number>) => {
+    setValue("permitData.vehicleDetails.licensedGVW", licensedGVW);
+  }, [setValue]);
+
   const onSetVehicle = useCallback((vehicleDetails: PermitVehicleDetails) => {
     setValue("permitData.vehicleDetails", {
       ...vehicleDetails,
     });
   }, [setValue]);
 
-  const onClearVehicle = useCallback((saveVehicle: boolean) => {
+  const onClearVehicle = useCallback((
+    saveVehicle: boolean,
+    defaultTypes?: Nullable<{
+      vehicleType: VehicleType;
+      vehicleSubtype: string;
+    }>,
+  ) => {
     setValue("permitData.vehicleDetails", {
       ...EMPTY_VEHICLE_DETAILS,
+      vehicleType: defaultTypes ? defaultTypes.vehicleType : EMPTY_VEHICLE_DETAILS.vehicleType,
+      vehicleSubType: defaultTypes ? defaultTypes.vehicleSubtype : EMPTY_VEHICLE_DETAILS.vehicleSubType,
       saveVehicle,
     });
   }, [setValue]);
@@ -133,6 +186,17 @@ export const useApplicationFormUpdateMethods = () => {
     onSetExpiryDate,
     onSetConditions,
     onToggleSaveVehicle,
+    onSetVin,
+    onSetPlate,
+    onSetMake,
+    onSetYear,
+    onSetCountryCode,
+    onSetProvinceCode,
+    onSetVehicleType,
+    onSetVehicleSubtype,
+    onSetUnitNumber,
+    onSetVehicleId,
+    onSetLicensedGVW,
     onSetVehicle,
     onClearVehicle,
     onUpdateLOAs,