First round of page-prerequesting-helper refactors for later pages in fmg where a lot of duplication

src/helpers/page-prerequisites-helper.spec.js

@@ -0,0 +1,641 @@
+import * as pagePrereqsHelper from "@/helpers/page-prerequisites-helper";
+import store from "@/store";
+import { AppointmentTypeStrings } from "@/constants/schedule-constants";
+import { coverageStatus } from "@/constants/insurance";
+
+jest.mock("@/helpers/debug-log-helper.js", () => ({
+    debugLog: jest.fn(),
+}));
+
+const { debugLog } = require("@/helpers/debug-log-helper.js");
+
+describe("page-prerequisites-helper.js", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe("logPagePrereqsStart", () => {
+        test("calls debugLog with source and forceLog when preReqResult is false", () => {
+            pagePrereqsHelper.logPagePrereqsStart("payment.vue", false);
+
+            expect(debugLog).toHaveBeenCalledWith(
+                "--- payment.vue pagePrereqs start ---",
+                null,
+                true
+            );
+        });
+
+        test("calls debugLog with forceLog false when preReqResult is true", () => {
+            pagePrereqsHelper.logPagePrereqsStart("payment.vue", true);
+
+            expect(debugLog).toHaveBeenCalledWith(
+                "--- payment.vue pagePrereqs start ---",
+                null,
+                false
+            );
+        });
+    });
+
+    describe("logPagePrereqsEnd", () => {
+        test("calls debugLog with source and forceLog when preReqResult is false", () => {
+            pagePrereqsHelper.logPagePrereqsEnd("payment-method.vue", false);
+
+            expect(debugLog).toHaveBeenCalledWith(
+                "--- payment-method.vue pagePrereqs end ---",
+                null,
+                true
+            );
+        });
+
+        test("calls debugLog with forceLog false when preReqResult is true", () => {
+            pagePrereqsHelper.logPagePrereqsEnd("payment-method.vue", true);
+
+            expect(debugLog).toHaveBeenCalledWith(
+                "--- payment-method.vue pagePrereqs end ---",
+                null,
+                false
+            );
+        });
+    });
+
+    describe("hasServiceZipInfo", () => {
+        test("returns true when zipCode and zipCodeCtu are set", () => {
+            const order = {
+                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
+            };
+
+            const result = pagePrereqsHelper.hasServiceZipInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when zipCode is missing", () => {
+            const order = {
+                serviceLocation: { zipCode: null, zipCodeCtu: "12345" },
+            };
+
+            const result = pagePrereqsHelper.hasServiceZipInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when zipCodeCtu is missing", () => {
+            const order = {
+                serviceLocation: { zipCode: "12345", zipCodeCtu: null },
+            };
+
+            const result = pagePrereqsHelper.hasServiceZipInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when both are empty strings", () => {
+            const order = {
+                serviceLocation: { zipCode: "", zipCodeCtu: "" },
+            };
+
+            const result = pagePrereqsHelper.hasServiceZipInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = {
+                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
+            };
+
+            pagePrereqsHelper.hasServiceZipInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = {
+                serviceLocation: { zipCode: "12345", zipCodeCtu: "12345" },
+            };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasServiceZipInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+
+    describe("hasServiceLocationInfo", () => {
+        const baseOrder = {
+            serviceLocation: {
+                provider: {
+                    address: {
+                        streetAddress: "123 Provider St",
+                        city: "ProviderCity",
+                        state: "OH",
+                        zipCode: "00000",
+                    },
+                },
+            },
+        };
+
+        test("returns true for mobile when address, city, state, zipCode are set", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    address: "123 Main St",
+                    city: "Anytown",
+                    state: "OH",
+                    zipCode: "12345",
+                    appointmentType: AppointmentTypeStrings.MOBILE,
+                    provider: baseOrder.serviceLocation.provider,
+                },
+            };
+
+            const result = pagePrereqsHelper.hasServiceLocationInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false for mobile when address is missing", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    address: null,
+                    city: "Anytown",
+                    state: "OH",
+                    zipCode: "12345",
+                    appointmentType: AppointmentTypeStrings.MOBILE,
+                    provider: baseOrder.serviceLocation.provider,
+                },
+            };
+
+            const result = pagePrereqsHelper.hasServiceLocationInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns true for drop-off when provider address has all fields", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    appointmentType: AppointmentTypeStrings.DROP_OFF,
+                },
+            };
+
+            const result = pagePrereqsHelper.hasServiceLocationInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false for drop-off when provider streetAddress is missing", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    appointmentType: AppointmentTypeStrings.DROP_OFF,
+                    provider: {
+                        address: {
+                            streetAddress: null,
+                            city: "ProviderCity",
+                            state: "OH",
+                            zipCode: "00000",
+                        },
+                    },
+                },
+            };
+
+            const result = pagePrereqsHelper.hasServiceLocationInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns true for in-shop when provider address has all fields", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    appointmentType: AppointmentTypeStrings.IN_SHOP,
+                },
+            };
+
+            const result = pagePrereqsHelper.hasServiceLocationInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    appointmentType: AppointmentTypeStrings.MOBILE,
+                    address: "123",
+                    city: "City",
+                    state: "OH",
+                    zipCode: "12345",
+                    provider: baseOrder.serviceLocation.provider,
+                },
+            };
+
+            pagePrereqsHelper.hasServiceLocationInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = {
+                ...baseOrder,
+                serviceLocation: {
+                    ...baseOrder.serviceLocation,
+                    appointmentType: AppointmentTypeStrings.MOBILE,
+                    address: "123",
+                    city: "City",
+                    state: "OH",
+                    zipCode: "12345",
+                    provider: baseOrder.serviceLocation.provider,
+                },
+            };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasServiceLocationInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            expect(typeof logQueue[0]).toBe("function");
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+
+    describe("hasInsuranceInfo", () => {
+        const baseOrder = {
+            payment: {
+                isInsurance: false,
+            },
+        };
+
+        beforeEach(() => {
+            store.getters = {
+                payment: {
+                    insuranceCoverage: {
+                        coverageStatus: null,
+                    },
+                },
+                policy: {
+                    currentDeductible: 100,
+                },
+            };
+        });
+
+        test("returns false when isInsurance is null", () => {
+            const order = { payment: { isInsurance: null } };
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns true when isInsurance is false and coverage is not verified", () => {
+            // Arrange
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.PENDING;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(baseOrder);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns true when isInsurance is true and coverage is verified with valid deductible", () => {
+            const order = { payment: { isInsurance: true } };
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.VERIFIED;
+            store.getters.policy.currentDeductible = 100;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns true when coverage is verified and deductible is 0", () => {
+            const order = { payment: { isInsurance: true } };
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.VERIFIED;
+            store.getters.policy.currentDeductible = 0;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when coverage is verified but deductible is null", () => {
+            const order = { payment: { isInsurance: true } };
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.VERIFIED;
+            store.getters.policy.currentDeductible = null;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when coverage is verified but deductible is undefined", () => {
+            const order = { payment: { isInsurance: true } };
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.VERIFIED;
+            store.getters.policy.currentDeductible = undefined;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when coverage is verified but deductible is negative", () => {
+            const order = { payment: { isInsurance: true } };
+            store.getters.payment.insuranceCoverage.coverageStatus = coverageStatus.VERIFIED;
+            store.getters.policy.currentDeductible = -1;
+
+            const result = pagePrereqsHelper.hasInsuranceInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = { payment: { isInsurance: null } };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasInsuranceInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+
+    describe("hasSchedulingInfo", () => {
+        const validSchedule = {
+            date: "2024-01-15",
+            startTime: "09:00",
+            endTime: "17:00",
+            jobMinMinutes: "30",
+            jobMaxMinutes: "45",
+        };
+
+        test("returns true when all schedule fields are set", () => {
+            const order = { schedule: validSchedule };
+
+            const result = pagePrereqsHelper.hasSchedulingInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when date is missing", () => {
+            const order = {
+                schedule: { ...validSchedule, date: null },
+            };
+
+            const result = pagePrereqsHelper.hasSchedulingInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when startTime is missing", () => {
+            const order = {
+                schedule: { ...validSchedule, startTime: null },
+            };
+
+            const result = pagePrereqsHelper.hasSchedulingInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when jobMinMinutes is missing", () => {
+            const order = {
+                schedule: { ...validSchedule, jobMinMinutes: null },
+            };
+
+            const result = pagePrereqsHelper.hasSchedulingInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = { schedule: validSchedule };
+
+            pagePrereqsHelper.hasSchedulingInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = { schedule: validSchedule };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasSchedulingInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+
+    describe("hasCustomerInfo", () => {
+        const validCustomer = {
+            firstName: "John",
+            lastName: "Doe",
+            phoneNumber: "555-555-5555",
+            emailAddress: "john@example.com",
+        };
+
+        test("returns true when all customer fields are set", () => {
+            const order = { customer: validCustomer };
+
+            const result = pagePrereqsHelper.hasCustomerInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when firstName is missing", () => {
+            const order = {
+                customer: { ...validCustomer, firstName: null },
+            };
+
+            const result = pagePrereqsHelper.hasCustomerInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when emailAddress is missing", () => {
+            const order = {
+                customer: { ...validCustomer, emailAddress: "" },
+            };
+
+            const result = pagePrereqsHelper.hasCustomerInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when phoneNumber is empty", () => {
+            const order = {
+                customer: { ...validCustomer, phoneNumber: "" },
+            };
+
+            const result = pagePrereqsHelper.hasCustomerInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = { customer: validCustomer };
+
+            pagePrereqsHelper.hasCustomerInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("hasGlassPartsOrRepairInfo", () => {
+        test("returns true when isRepair is true", () => {
+            const order = {
+                damage: { isRepair: true },
+                lineItems: { glassParts: [] },
+            };
+
+            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns true when glassParts has items", () => {
+            const order = {
+                damage: { isRepair: false },
+                lineItems: { glassParts: [{ id: "1" }] },
+            };
+
+            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when isRepair is false and glassParts is empty", () => {
+            const order = {
+                damage: { isRepair: false },
+                lineItems: { glassParts: [] },
+            };
+
+            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when isRepair is false and glassParts is null", () => {
+            const order = {
+                damage: { isRepair: false },
+                lineItems: { glassParts: null },
+            };
+
+            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when damage and lineItems are undefined", () => {
+            const order = {};
+
+            const result = pagePrereqsHelper.hasGlassPartsOrRepairInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = {
+                damage: { isRepair: true },
+                lineItems: { glassParts: [] },
+            };
+
+            pagePrereqsHelper.hasGlassPartsOrRepairInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = {
+                damage: { isRepair: true },
+                lineItems: { glassParts: [] },
+            };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasGlassPartsOrRepairInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+
+    describe("hasPaymentMethodInfo", () => {
+        test("returns true when isPia is true and piaType is set", () => {
+            const order = {
+                payment: { isPia: true, piaType: "Afterpay" },
+            };
+
+            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns true when isPia is false and piaType is set", () => {
+            const order = {
+                payment: { isPia: false, piaType: "PayLater" },
+            };
+
+            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);
+
+            expect(result).toBe(true);
+        });
+
+        test("returns false when isPia is null", () => {
+            const order = {
+                payment: { isPia: null, piaType: "Afterpay" },
+            };
+
+            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when isPia is false and piaType is null", () => {
+            const order = {
+                payment: { isPia: false, piaType: null },
+            };
+
+            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("returns false when isPia is false and piaType is empty string", () => {
+            const order = {
+                payment: { isPia: false, piaType: "" },
+            };
+
+            const result = pagePrereqsHelper.hasPaymentMethodInfo(order);
+
+            expect(result).toBe(false);
+        });
+
+        test("does not add to logQueue when logQueue is null", () => {
+            const order = { payment: { isPia: true, piaType: "Afterpay" } };
+
+            pagePrereqsHelper.hasPaymentMethodInfo(order, null);
+
+            expect(debugLog).not.toHaveBeenCalled();
+        });
+
+        test("adds log functions to logQueue when logQueue is provided", () => {
+            const order = { payment: { isPia: true, piaType: "Afterpay" } };
+            const logQueue = [];
+
+            pagePrereqsHelper.hasPaymentMethodInfo(order, logQueue);
+
+            expect(logQueue).toHaveLength(1);
+            logQueue[0]();
+            expect(debugLog).toHaveBeenCalled();
+        });
+    });
+});

src/layouts/payment-adyen/payment-adyen.vue

@@ -83,7 +83,15 @@ import cart from "@/fmg-components/cart/cart";
 import { coverageStatus } from "@/constants/insurance";
 import { deepClone } from "@/helpers/object-helper";
 import store from "@/store";
-import { debugLog } from "@/helpers/debug-log-helper.js";
+import {
+    logPagePrereqsStart,
+    logPagePrereqsEnd,
+    hasServiceLocationInfo,
+    hasInsuranceInfo,
+    hasSchedulingInfo,
+    hasCustomerInfo,
+    hasPaymentMethodInfo,
+} from "@/helpers/page-prerequisites-helper.js";
 
 export default {
     name: "payment-adyen",
@@ -136,110 +144,18 @@ export default {
         },
 
         arePagePrerequisitesValid() {
-            // Service Location
-            const serviceLocation = store.getters.order.serviceLocation;
-            const mobileReqs = !!(
-                serviceLocation.address &&
-                serviceLocation.city &&
-                serviceLocation.state &&
-                serviceLocation.zipCode
-            );
-
-            const providerLocation = serviceLocation.provider.address;
-            const dropOffInshopReqs = !!(
-                providerLocation.streetAddress &&
-                providerLocation.city &&
-                providerLocation.state &&
-                providerLocation.zipCode
-            );
-
-            const isMobile = serviceLocation.appointmentType === AppointmentTypeStrings.MOBILE;
-
-            const serviceLocationReqs =
-                (isMobile && mobileReqs) || (!isMobile && dropOffInshopReqs);
-
-            // Insurance
-            const isInsuranceSet = store.getters.order.payment.isInsurance !== null;
-
-            // Schedule
-            const schedule = store.getters.order.schedule;
-            const scheduleReqs = !!(
-                schedule.date &&
-                schedule.startTime &&
-                schedule.endTime &&
-                schedule.jobMaxMinutes &&
-                schedule.jobMinMinutes
-            );
-
-            // Customer
-            const customer = store.getters.order.customer;
-            const customerReqs = !!(
-                customer.firstName &&
-                customer.lastName &&
-                customer.phoneNumber &&
-                customer.emailAddress
-            );
-
-            const paymentMethodReqs =
-                store.getters.order.payment.isPia !== null &&
-                (store.getters.order.payment.isPia || !!store.getters.order.payment.piaType);
-
-            const preReqResult =
-                serviceLocationReqs &&
-                isInsuranceSet &&
-                scheduleReqs &&
-                customerReqs &&
-                paymentMethodReqs;
-
-            // prettier-ignore
-            {
-                debugLog("--- payment-adyen.vue pagePrereqs start ---", null, !preReqResult);
-                debugLog("mobileReqs:", mobileReqs, !preReqResult);
-                debugLog("serviceLocation.address:", serviceLocation.address, !preReqResult);
-                debugLog("serviceLocation.city:", serviceLocation.city, !preReqResult);
-                debugLog("serviceLocation.state:", serviceLocation.state, !preReqResult);
-                debugLog("serviceLocation.zipCode:", serviceLocation.zipCode, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("dropOffInshopReqs:", dropOffInshopReqs, !preReqResult);
-                debugLog("serviceLocationReqs:", serviceLocationReqs, !preReqResult);
-                debugLog("providerLocation.streetAddress:", providerLocation.streetAddress, !preReqResult);
-                debugLog("providerLocation.city:", providerLocation.city, !preReqResult);
-                debugLog("providerLocation.state:", providerLocation.state, !preReqResult);
-                debugLog("providerLocation.zipCode:", providerLocation.zipCode, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("isInsuranceSet:", isInsuranceSet, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("scheduleReqs:", scheduleReqs, !preReqResult);
-                debugLog("schedule.date:", schedule.date, !preReqResult);
-                debugLog("schedule.startTime:", schedule.startTime, !preReqResult);
-                debugLog("schedule.endTime:", schedule.endTime, !preReqResult);
-                debugLog("schedule.jobMaxMinutes:", schedule.jobMaxMinutes, !preReqResult);
-                debugLog("schedule.jobMinMinutes:", schedule.jobMinMinutes, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("customerReqs:", customerReqs, !preReqResult);
-                debugLog("customer.firstName:", customer.firstName, !preReqResult);
-                debugLog("customer.lastName:", customer.lastName, !preReqResult);
-                debugLog("customer.phoneNumber:", customer.phoneNumber, !preReqResult);
-                debugLog("customer.emailAddress:", customer.emailAddress, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("paymentMethodReqs:", paymentMethodReqs, !preReqResult);
-                debugLog("store.getters.order.payment.isPia:", store.getters.order?.payment?.isPia, !preReqResult);
-                debugLog("store.getters.order.payment.piaType:", store.getters.order?.payment?.piaType, !preReqResult);
-
-                debugLog("--- payment-adyen.vue pagePrereqs end ---", null, !preReqResult);
-            }
-
-            return preReqResult;
+            const order = store.getters.order;
+            const logQueue = [];
+            const result =
+                hasServiceLocationInfo(order, logQueue) &&
+                hasInsuranceInfo(order, logQueue) &&
+                hasSchedulingInfo(order, logQueue) &&
+                hasCustomerInfo(order, logQueue) &&
+                hasPaymentMethodInfo(order, logQueue);
+            logPagePrereqsStart("payment-adyen.vue", result);
+            logQueue.forEach((fn) => fn());
+            logPagePrereqsEnd("payment-adyen.vue", result);
+            return result;
         },
 
         async initializeAdyen() {

src/layouts/payment-method/payment-method.vue

@@ -178,7 +178,14 @@ import { containsRecalParts } from "@/helpers/recal-helper";
 import { getBoolFromString } from "@/helpers/boolean-helper";
 import { getAmountDue, addPricesToLineItems } from "@/helpers/pricing-helper.js";
 import { consumeQueryFromStash } from "@/router/methods/helpers/querystring-stash";
-import { debugLog } from "@/helpers/debug-log-helper";
+import {
+    logPagePrereqsStart,
+    logPagePrereqsEnd,
+    hasServiceLocationInfo,
+    hasInsuranceInfo,
+    hasSchedulingInfo,
+    hasCustomerInfo,
+} from "@/helpers/page-prerequisites-helper.js";
 import { ErrorMessage } from "vee-validate";
 import { Field } from "vee-validate";
 import experimentMixin from "../../mixins/experiment-mixin";
@@ -381,91 +388,17 @@ export default {
             this.$router.navigateWithoutSaving(scenarioName, this.pageName);
         },
         arePagePrerequisitesValid() {
-            // Service Location
-            const serviceLocation = store.getters.order.serviceLocation;
-            const mobileReqs = !!(
-                serviceLocation.address &&
-                serviceLocation.city &&
-                serviceLocation.state &&
-                serviceLocation.zipCode
-            );
-
-            const providerLocation = serviceLocation.provider.address;
-            const dropOffInshopReqs = !!(
-                providerLocation.streetAddress &&
-                providerLocation.city &&
-                providerLocation.state &&
-                providerLocation.zipCode
-            );
-
-            const isMobile = serviceLocation.appointmentType === AppointmentTypeStrings.MOBILE;
-
-            const serviceLocationReqs =
-                (isMobile && mobileReqs) || (!isMobile && dropOffInshopReqs);
-
-            // Insurance
-            const isInsurance = store.getters.order.payment.isInsurance;
-            const insuranceCoverageStatus = store.getters.payment.insuranceCoverage.coverageStatus;
-            const currentDeductible = store.getters.policy.currentDeductible;
-            const isInsuranceSet = () => {
-                if (isInsurance !== null) {
-                    if (
-                        insuranceCoverageStatus === coverageStatus.VERIFIED &&
-                        !(currentDeductible === 0 || currentDeductible > 0)
-                    ) {
-                        return false; // if coverageStatus is verified there must be a valid deductible also
-                    }
-                    return true;
-                }
-                return false;
-            };
-
-            // Schedule
-            const schedule = store.getters.order.schedule;
-            const scheduleReqs = !!(
-                schedule.date &&
-                schedule.startTime &&
-                schedule.endTime &&
-                schedule.jobMaxMinutes &&
-                schedule.jobMinMinutes
-            );
-
-            // Customer
-            const customer = store.getters.order.customer;
-            const customerReqs = !!(
-                customer.firstName &&
-                customer.lastName &&
-                customer.phoneNumber &&
-                customer.emailAddress
-            );
-
-            const preReqResult =
-                serviceLocationReqs && isInsuranceSet() && scheduleReqs && customerReqs;
-
-            // prettier-ignore
-            {
-                debugLog("--- payment-method.vue pagePrereqs start ---", null, !preReqResult);
-                debugLog("serviceLocationRequs::isMobile:", isMobile, !preReqResult);
-                debugLog("serviceLocationReqs::mobileReqs:", mobileReqs, !preReqResult);
-                debugLog("serviceLocationReqs::dropOffInshopReqs:", dropOffInshopReqs, !preReqResult);
-                debugLog("serviceLocationReqs:: result", serviceLocationReqs, !preReqResult);
-
-                debugLog("isInsuranceSet::", isInsuranceSet(), !preReqResult);
-
-                debugLog("scheduleReqs::schedule.date:", schedule.date, !preReqResult);
-                debugLog("scheduleReqs::schedule.startTime:", schedule.startTime, !preReqResult);
-                debugLog("scheduleReqs::schedule.endTime:", schedule.endTime, !preReqResult);
-                debugLog("scheduleReqs::schedule.jobMaxMinutes:", schedule.jobMaxMinutes, !preReqResult);
-                debugLog("scheduleReqs::schedule.jobMinMinutes:", schedule.jobMinMinutes, !preReqResult);
-
-                debugLog("customerReqs::customer.firstName:", customer.firstName, !preReqResult);
-                debugLog("customerReqs::customer.lastName:", customer.lastName, !preReqResult);
-                debugLog("customerReqs::customer.phoneNumber:", customer.phoneNumber, !preReqResult);
-                debugLog("customerReqs::customer.emailAddress:", customer.emailAddress, !preReqResult);
-                debugLog("--- payment-method.vue pagePrereqs end ---", null, !preReqResult);
-            }
-
-            return preReqResult;
+            const order = store.getters.order;
+            const logQueue = [];
+            const result =
+                hasServiceLocationInfo(order, logQueue) &&
+                hasInsuranceInfo(order, logQueue) &&
+                hasSchedulingInfo(order, logQueue) &&
+                hasCustomerInfo(order, logQueue);
+            logPagePrereqsStart("payment-method.vue", result);
+            logQueue.forEach((fn) => fn());
+            logPagePrereqsEnd("payment-method.vue", result);
+            return result;
         },
         getPaymentMethodFromStore() {
             const piaType = store.getters.order.payment.piaType;

src/layouts/payment/payment.vue

@@ -235,7 +235,6 @@ import { fetchCmsContentForPage } from "@/helpers/cms-content-helper";
 import { settleAllPromises } from "@/helpers/layout-helper";
 import { applicationConfig } from "@/constants/application-config";
 import { paymentMethods } from "@/constants/payment-method-constants";
-import { AppointmentTypeStrings } from "@/constants/schedule-constants";
 import baseMixin from "@/mixins/base-mixin.js";
 import { deepClone } from "@/helpers/object-helper";
 import { submitWorkOrder } from "@/helpers/heritage-integration/order-helper.js";
@@ -243,6 +242,15 @@ import iframeResize from "../../../node_modules/iframe-resizer/js/iframeResizer.
 import { coverageStatus } from "@/constants/insurance";
 import { getDisplayAmountDue, getAmountDue } from "@/helpers/pricing-helper.js";
 import { debugLog } from "@/helpers/debug-log-helper.js";
+import {
+    logPagePrereqsStart,
+    logPagePrereqsEnd,
+    hasServiceLocationInfo,
+    hasInsuranceInfo,
+    hasSchedulingInfo,
+    hasCustomerInfo,
+    hasPaymentMethodInfo,
+} from "@/helpers/page-prerequisites-helper.js";
 import buttonQuestion from "@/digital-components/button-question/button-question";
 import paymentMethodListButton from "@/layouts/payment-method/payment-method-question/payment-method-list-button/payment-method-list-button";
 
@@ -435,110 +443,18 @@ export default {
     },
     methods: {
         arePagePrerequisitesValid() {
-            // Service Location
-            const serviceLocation = store.getters.order.serviceLocation;
-            const mobileReqs = !!(
-                serviceLocation.address &&
-                serviceLocation.city &&
-                serviceLocation.state &&
-                serviceLocation.zipCode
-            );
-
-            const providerLocation = serviceLocation.provider.address;
-            const dropOffInshopReqs = !!(
-                providerLocation.streetAddress &&
-                providerLocation.city &&
-                providerLocation.state &&
-                providerLocation.zipCode
-            );
-
-            const isMobile = serviceLocation.appointmentType === AppointmentTypeStrings.MOBILE;
-
-            const serviceLocationReqs =
-                (isMobile && mobileReqs) || (!isMobile && dropOffInshopReqs);
-
-            // Insurance
-            const isInsuranceSet = store.getters.order.payment.isInsurance !== null;
-
-            // Schedule
-            const schedule = store.getters.order.schedule;
-            const scheduleReqs = !!(
-                schedule.date &&
-                schedule.startTime &&
-                schedule.endTime &&
-                schedule.jobMaxMinutes &&
-                schedule.jobMinMinutes
-            );
-
-            // Customer
-            const customer = store.getters.order.customer;
-            const customerReqs = !!(
-                customer.firstName &&
-                customer.lastName &&
-                customer.phoneNumber &&
-                customer.emailAddress
-            );
-
-            const paymentMethodReqs =
-                store.getters.order.payment.isPia !== null &&
-                (store.getters.order.payment.isPia || !!store.getters.order.payment.piaType);
-
-            const preReqResult =
-                serviceLocationReqs &&
-                isInsuranceSet &&
-                scheduleReqs &&
-                customerReqs &&
-                paymentMethodReqs;
-
-            // prettier-ignore
-            {
-                debugLog("--- payment.vue pagePrereqs start ---", null, !preReqResult);
-                debugLog("mobileReqs:", mobileReqs, !preReqResult);
-                debugLog("serviceLocation.address:", serviceLocation.address, !preReqResult);
-                debugLog("serviceLocation.city:", serviceLocation.city, !preReqResult);
-                debugLog("serviceLocation.state:", serviceLocation.state, !preReqResult);
-                debugLog("serviceLocation.zipCode:", serviceLocation.zipCode, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("dropOffInshopReqs:", dropOffInshopReqs, !preReqResult);
-                debugLog("serviceLocationReqs:", serviceLocationReqs, !preReqResult);
-                debugLog("providerLocation.streetAddress:", providerLocation.streetAddress, !preReqResult);
-                debugLog("providerLocation.city:", providerLocation.city, !preReqResult);
-                debugLog("providerLocation.state:", providerLocation.state, !preReqResult);
-                debugLog("providerLocation.zipCode:", providerLocation.zipCode, !preReqResult);
-                
-                debugLog("", null, !preReqResult);
-                
-                debugLog("isInsuranceSet:", isInsuranceSet, !preReqResult);
-
-                debugLog("", null, !preReqResult);
-
-                debugLog("scheduleReqs:", scheduleReqs, !preReqResult);
-                debugLog("schedule.date:", schedule.date, !preReqResult);
-                debugLog("schedule.startTime:", schedule.startTime, !preReqResult);
-                debugLog("schedule.endTime:", schedule.endTime, !preReqResult);
-                debugLog("schedule.jobMaxMinutes:", schedule.jobMaxMinutes, !preReqResult);
-                debugLog("schedule.jobMinMinutes:", schedule.jobMinMinutes, !preReqResult);
-                
-                debugLog("", null, !preReqResult);
-
-                debugLog("customerReqs:", customerReqs, !preReqResult);
-                debugLog("customer.firstName:", customer.firstName, !preReqResult);
-                debugLog("customer.lastName:", customer.lastName, !preReqResult);
-                debugLog("customer.phoneNumber:", customer.phoneNumber, !preReqResult);
-                debugLog("customer.emailAddress:", customer.emailAddress, !preReqResult);
-                
-                debugLog("", null, !preReqResult);
-
-                debugLog("paymentMethodReqs:", paymentMethodReqs, !preReqResult);
-                debugLog("store.getters.order.payment.isPia:", store.getters.order?.payment?.isPia, !preReqResult);
-                debugLog("store.getters.order.payment.piaType:", store.getters.order?.payment?.piaType, !preReqResult);
-
-                debugLog("--- payment.vue pagePrereqs end ---", null, !preReqResult);
-            }
-
-            return preReqResult;
+            const order = store.getters.order;
+            const logQueue = [];
+            const result =
+                hasServiceLocationInfo(order, logQueue) &&
+                hasInsuranceInfo(order, logQueue) &&
+                hasSchedulingInfo(order, logQueue) &&
+                hasCustomerInfo(order, logQueue) &&
+                hasPaymentMethodInfo(order, logQueue);
+            logPagePrereqsStart("payment.vue", result);
+            logQueue.forEach((fn) => fn());
+            logPagePrereqsEnd("payment.vue", result);
+            return result;
         },
         getAnswersNullSafe(widgetName) {
             const rawData = this.getCmsContent(widgetName, "Answers");

src/layouts/quote/quote.vue

@@ -183,6 +183,12 @@ import { routeData } from "@/router/constants/routes";
 import { consumeQueryFromStash } from "@/router/methods/helpers/querystring-stash";
 import { storeMutations } from "@/constants/store-mutations";
 import { debugLog } from "@/helpers/debug-log-helper";
+import {
+    logPagePrereqsStart,
+    logPagePrereqsEnd,
+    hasServiceZipInfo,
+    hasGlassPartsOrRepairInfo,
+} from "@/helpers/page-prerequisites-helper.js";
 import { savePageData } from "@/router/methods/helpers/save-page-data";
 import { quotePageDiscountTable } from "../../constants/quote-page-discounts";
 
@@ -728,28 +734,28 @@ export default {
             this.$refs[modalName].openModal();
         },
         arePagePrerequisitesValid() {
-            const payment = store.getters.order.payment;
+            const order = store.getters.order;
+            const logQueue = [];
+            const isVerifiedOk =
+                order.payment?.insuranceCoverage?.isVerified == null ||
+                order.payment?.insuranceCoverage?.isVerified === false;
 
             const preReqResult =
-                store.getters.order.serviceLocation.zipCode &&
-                store.getters.order.serviceLocation.zipCodeCtu &&
-                (store.getters.order.damage.isRepair ||
-                    (store.getters.order.lineItems?.glassParts != null &&
-                        store.getters.order.lineItems.glassParts.length > 0)) &&
-                (payment.insuranceCoverage?.isVerified == null ||
-                    payment.insuranceCoverage?.isVerified === false);
+                hasServiceZipInfo(order, logQueue) &&
+                hasGlassPartsOrRepairInfo(order, logQueue) &&
+                isVerifiedOk;
 
-            // prettier-ignore
-            {
-                debugLog("--- quote.vue pagePrereqs start ---", null, !preReqResult);
-                debugLog("store.getters.order.serviceLocation.zipCode:", store.getters.order.serviceLocation?.zipCode, !preReqResult);
-                debugLog("store.getters.order.serviceLocation.zipCodeCtu:", store.getters.order.serviceLocation?.zipCodeCtu, !preReqResult);
-                debugLog("store.getters.order.damage.isRepair:", store.getters.order.damage?.isRepair, !preReqResult);
-                debugLog("store.getters.order.lineItems?.glassParts:", store.getters.order.lineItems?.glassParts, !preReqResult);
-                debugLog("store.getters.order.payemt.insuranceCoverage?.isVerified:", store.getters.order.payment?.insuranceCoverage?.isVerified, !preReqResult);
-                debugLog("--- quote.vue pagePrereqs end ---", null, !preReqResult);
-            }
+            logQueue.push(() => {
+                debugLog(
+                    "payment.insuranceCoverage?.isVerified:",
+                    order.payment?.insuranceCoverage?.isVerified,
+                    !preReqResult
+                );
+            });
 
+            logPagePrereqsStart("quote.vue", preReqResult);
+            logQueue.forEach((fn) => fn());
+            logPagePrereqsEnd("quote.vue", preReqResult);
             return preReqResult;
         },
         vapsItemsSelectedAction(vapsItemsSelected) {