543 lines
17 KiB
JavaScript
543 lines
17 KiB
JavaScript
import { createStore } from "vuex";
|
|
import { endpoints } from "@/constants/endpoints.js";
|
|
import { storeMutations } from "@/constants/store-mutations";
|
|
import { getDateForSavedSessionTimeout } from "@/helpers/heritage-integration/session-helper";
|
|
import createPersistedState from "vuex-persistedstate";
|
|
import globalMethods from "@/global-methods";
|
|
|
|
// Export State
|
|
const getDefaultState = () => {
|
|
return {
|
|
order: {
|
|
vehicle: {
|
|
year: null,
|
|
make: null,
|
|
model: null,
|
|
style: null,
|
|
carId: null,
|
|
category: null,
|
|
vin: null,
|
|
imageUrl: null,
|
|
imageVifNumber: null,
|
|
imageColor: null,
|
|
registration: {
|
|
licensePlate: null,
|
|
address: null,
|
|
city: null,
|
|
state: null,
|
|
zipCode: null,
|
|
firstName: null,
|
|
lastName: null,
|
|
},
|
|
},
|
|
serviceLocation: {
|
|
zip: null,
|
|
},
|
|
customer: {
|
|
emailAddress: null,
|
|
},
|
|
damage: {
|
|
isRepair: null,
|
|
numberOfChips: null,
|
|
glassToReplace: null,
|
|
},
|
|
lineItems: {
|
|
glassParts: null,
|
|
otherParts: null
|
|
},
|
|
payment:{
|
|
isInsurance: null,
|
|
insuranceCoverage: {
|
|
isVerified: null
|
|
}
|
|
},
|
|
referralNumber: null,
|
|
referralDate: null,
|
|
referralCorrelationId: null,
|
|
accountNumber: 0,
|
|
},
|
|
applicationUser: {
|
|
eventBus: [],
|
|
pageData: {},
|
|
savedSessionTimeout: getDateForSavedSessionTimeout()
|
|
},
|
|
}
|
|
};
|
|
|
|
export const state = getDefaultState();
|
|
|
|
// Export Mutations
|
|
export const mutations = {
|
|
// VEHICLE MUTATIONS
|
|
updateYear(state, year) {
|
|
state.order.vehicle.year = year;
|
|
},
|
|
updateMake(state, make) {
|
|
state.order.vehicle.make = make;
|
|
},
|
|
updateModel(state, model) {
|
|
state.order.vehicle.model = model;
|
|
},
|
|
updateStyle(state, style) {
|
|
state.order.vehicle.style = style;
|
|
},
|
|
updateCarId(state, carId) {
|
|
state.order.vehicle.carId = carId;
|
|
},
|
|
updateVehicleCategory(state, category) {
|
|
state.order.vehicle.category = category;
|
|
},
|
|
updateVehicleImageUrl(state, imageUrl) {
|
|
state.order.vehicle.imageUrl = imageUrl;
|
|
},
|
|
updateVehicleImageVifNumber(state, imageVifNumber) {
|
|
state.order.vehicle.imageVifNumber = imageVifNumber;
|
|
},
|
|
updateVehicleImageColor(state, imageColor) {
|
|
state.order.vehicle.imageColor = imageColor;
|
|
},
|
|
updateVehicleVin(state, vin) {
|
|
state.order.vehicle.vin = vin;
|
|
},
|
|
updateIsRepair(state, isRepair) {
|
|
state.order.damage.isRepair = isRepair;
|
|
},
|
|
updateNumberOfChips(state, numberOfChips) {
|
|
state.order.damage.numberOfChips = numberOfChips;
|
|
},
|
|
updateGlassToReplace(state, glassToReplace) {
|
|
state.order.damage.glassToReplace = glassToReplace;
|
|
},
|
|
updateParts(state, partsData) {
|
|
state.order.lineItems.glassParts = partsData;
|
|
},
|
|
updatePageData(state, pageData) {
|
|
state.applicationUser.pageData[pageData.page] = pageData.data;
|
|
},
|
|
updateReferralCorrelationId(state, referralCorrelationId) {
|
|
state.order.referralCorrelationId = referralCorrelationId;
|
|
},
|
|
updateReferralNumber(state, referralNumber) {
|
|
state.order.referralNumber = referralNumber;
|
|
},
|
|
updateReferralDate(state, referralDate) {
|
|
state.order.referralDate = referralDate;
|
|
},
|
|
updateParentAcctNumber(state, parentAcctNumber) {
|
|
state.order.accountNumber = parentAcctNumber;
|
|
},
|
|
updateIsInsurance(state, isInsurance) {
|
|
state.order.payment.isInsurance = isInsurance;
|
|
},
|
|
updateInsuranceVerifiedStatus(state, isVerified) {
|
|
state.order.payment.insuranceCoverage.isVerified = isVerified;
|
|
},
|
|
updateRegistrationLicensePlate(state, licensePlate){
|
|
state.order.vehicle.registration.licensePlate = licensePlate;
|
|
},
|
|
updateRegistrationState(state, registrationState){
|
|
state.order.vehicle.registration.state = registrationState;
|
|
},
|
|
updateRegistrationZipCode(state, registrationZipCode){
|
|
state.order.vehicle.registration.zipCode = registrationZipCode;
|
|
},
|
|
updateRegistrationAddress(state, registrationAddress){
|
|
state.order.vehicle.registration.address = registrationAddress;
|
|
},
|
|
updateServiceLocationZip(state, serviceLocationZip){
|
|
state.order.vehicle.registration.zip = serviceLocationZip;
|
|
},
|
|
updateRegistrationCity(state, serviceCity){
|
|
state.order.vehicle.registration.city = serviceCity;
|
|
},
|
|
updateRegistrationFirstName(state, firstName){
|
|
state.order.vehicle.registration.firstName = firstName;
|
|
},
|
|
updateRegistrationLastName(state, lastName){
|
|
state.order.vehicle.registration.lastName = lastName;
|
|
},
|
|
updateCustomerEmailAddress(state, customerEmailAddress){
|
|
state.order.customer.emailAddress = customerEmailAddress;
|
|
},
|
|
|
|
|
|
// EVENT BUS MUTATIONS
|
|
addEventToBus(state, event) {
|
|
state.applicationUser.eventBus.push(event);
|
|
},
|
|
removeEventFromBus(state, eventData) {
|
|
const matchedEvent = state.applicationUser.eventBus.find(
|
|
({ category, subCategory }) =>
|
|
category === eventData.category &&
|
|
subCategory === eventData.subCategory
|
|
);
|
|
const itemIndex = state.applicationUser.eventBus.indexOf(matchedEvent);
|
|
|
|
// If the item exists, remove it.
|
|
if (itemIndex > -1) {
|
|
state.applicationUser.eventBus.splice(itemIndex, 1);
|
|
}
|
|
},
|
|
|
|
// DEPENDENCY MUTATIONS
|
|
resetVehicleState(state) {
|
|
state.order.vehicle.year = null;
|
|
state.order.vehicle.make = null;
|
|
state.order.vehicle.model = null;
|
|
state.order.vehicle.style = null;
|
|
state.order.vehicle.carId = null;
|
|
state.order.vehicle.category = null;
|
|
},
|
|
resetDamageState(state) {
|
|
state.order.damage.isRepair = null;
|
|
state.order.damage.numberOfChips = null;
|
|
state.order.damage.glassToReplace = null;
|
|
},
|
|
resetRegistrationState(state) {
|
|
state.order.vehicle.registration.licensePlate = null;
|
|
state.order.vehicle.registration.address = null;
|
|
state.order.vehicle.registration.city = null;
|
|
state.order.vehicle.registration.state = null;
|
|
state.order.vehicle.registration.zipCode = null;
|
|
state.order.vehicle.registration.firstName = null;
|
|
state.order.vehicle.registration.lastName = null;
|
|
},
|
|
resetPartsState(state) {
|
|
state.order.lineItems.glassParts = null;
|
|
state.order.lineItems.otherParts = null;
|
|
},
|
|
resetState(state) {
|
|
Object.assign(state, getDefaultState());
|
|
},
|
|
|
|
// Misc Mutations
|
|
updateStateWithOrderInformation(state, orderInformation) {
|
|
state.order.referralNumber = orderInformation.referralNumber;
|
|
state.order.referralDate = orderInformation.referralDate;
|
|
state.order.referralCorrelationId = orderInformation.referralCorrelationId;
|
|
|
|
state.order.vehicle = Object.assign(state.order.vehicle, {
|
|
year: orderInformation.vehicle?.year,
|
|
make: orderInformation.vehicle?.make,
|
|
model: orderInformation.vehicle?.model,
|
|
style: orderInformation.vehicle?.style,
|
|
vin: orderInformation.vehicle?.vin,
|
|
carId: orderInformation.vehicle?.carId,
|
|
category: orderInformation.vehicle?.category,
|
|
imageUrl: orderInformation.vehicle?.imageUrl,
|
|
imageVifNumber: orderInformation.vehicle?.imageVifNumber,
|
|
imageColor: orderInformation.vehicle?.imageVifColor,
|
|
});
|
|
|
|
state.order.damage.glassToReplace = orderInformation.glassToReplace;
|
|
state.order.damage.isRepair = orderInformation.isRepair;
|
|
state.order.damage.numberOfChips = orderInformation.numberOfChips;
|
|
|
|
state.order.lineItems.glassParts = orderInformation.parts;
|
|
state.order.accountNumber = orderInformation.accountNumber;
|
|
state.order.serviceLocation.zipCode = orderInformation.zipCode;
|
|
|
|
state.order.payment.isInsurance = orderInformation.IsInsuranceOrder;
|
|
state.order.payment.insuranceCoverage.isVerified = orderInformation?.insuranceInfo.coverageVerified;
|
|
}
|
|
}
|
|
|
|
// Export Getters
|
|
export const getters = {
|
|
vehicle: (state) => state.order.vehicle,
|
|
eventBusItem: (state) => (eventCategory, eventSubCategory) => {
|
|
const matchedEvent = state.applicationUser.eventBus.find(
|
|
({ category, subCategory }) =>
|
|
category === eventCategory && subCategory === eventSubCategory
|
|
);
|
|
|
|
return matchedEvent !== undefined ? matchedEvent.eventValue : undefined;
|
|
},
|
|
eventBus: (state) => state.applicationUser.eventBus,
|
|
damage: (state) => state.order.damage,
|
|
lineItems: (state) => state.order.lineItems,
|
|
pageData: (state) => (page) => { return state.applicationUser.pageData[page]; },
|
|
applicationUser: (state) => state.applicationUser,
|
|
order: (state) => state.order,
|
|
payment: (state) => state.order.payment,
|
|
}
|
|
|
|
// Export Actions
|
|
export const actions = {
|
|
// Vehicle API Actions
|
|
getVehicleYears(context) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetVehicleYears.method,
|
|
endpoint: endpoints.GetVehicleYears.url,
|
|
payload: {},
|
|
});
|
|
},
|
|
lookupVehicleByYmms(context, { year, make, model, style }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LookupVehicleByYmms.method,
|
|
endpoint: `${endpoints.LookupVehicleByYmms.url}/${year}/${make}/${model}/${style}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
lookupVehicleByVin(context, { vin }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LookupVehicleByVin.method,
|
|
endpoint: endpoints.LookupVehicleByVin.url,
|
|
payload: {
|
|
vin: vin, // EX "1J4GW58S4XC541166"
|
|
},
|
|
});
|
|
},
|
|
lookupVinByPlate(context, { licensePlate, licenseState }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LookupVinByPlate.method,
|
|
endpoint: endpoints.LookupVinByPlate.url,
|
|
payload: {
|
|
licensePlate: licensePlate,
|
|
licenseState: licenseState
|
|
},
|
|
});
|
|
},
|
|
lookupVinByAddress(context, { licenseLastName, licenseStreetAddress, licenseZip, licenseState }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LookupVinByAddress.method,
|
|
endpoint: endpoints.LookupVinByAddress.url,
|
|
payload: {
|
|
licenseLastName: licenseLastName,
|
|
licenseStreetAddress: licenseStreetAddress,
|
|
licenseZip: licenseZip,
|
|
licenseState: licenseState
|
|
},
|
|
});
|
|
},
|
|
getVehicleMakes(context, { year }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetVehicleMakes.method,
|
|
endpoint: `${endpoints.GetVehicleMakes.url}/${year}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
getVehicleModels(context, { year, make }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetVehicleModels.method,
|
|
endpoint: `${endpoints.GetVehicleModels.url}/${year}/${make}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
getVehicleStyles(context, { year, make, model }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetVehicleStyles.method,
|
|
endpoint: `${endpoints.GetVehicleStyles.url}/${year}/${make}/${model}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
setVehicle(context, { year, make, model, style }) {
|
|
return globalMethods
|
|
.callHttpClient({
|
|
methods: endpoints.GetVehicle.method,
|
|
endpoint: `${endpoints.GetVehicle.url}/${year}/${make}/${model}/${style}`,
|
|
payload: {},
|
|
})
|
|
.then((response) => {
|
|
context.commit(storeMutations.UPDATE_CAR_ID, response.data.carId);
|
|
context.commit(storeMutations.UPDATE_VEHICLE_CATEGORY, response.data.category);
|
|
context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_URL, response.data.imageUrl);
|
|
context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_VIF_NUMBER, response.data.imageVifNumber);
|
|
context.commit(storeMutations.UPDATE_VEHICLE_IMAGE_COLOR, response.data.imageVifColor);
|
|
return response;
|
|
});
|
|
},
|
|
getDamageOptions(context, { carId }) {
|
|
return globalMethods.callHttpClient({
|
|
methods: endpoints.GetDamageOptions.method,
|
|
endpoint: `${endpoints.GetDamageOptions.url}/${carId}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
validateZip(context, { zip }) {
|
|
return globalMethods.callHttpClient({
|
|
methods: endpoints.ValidateZip.method,
|
|
endpoint: `${endpoints.ValidateZip.url}/${zip}`
|
|
})
|
|
},
|
|
|
|
// DEPENDENCY ACTIONS
|
|
resetVehicleAndDependencies(context) {
|
|
context.commit(storeMutations.RESET_VEHICLE_STATE);
|
|
context.commit(storeMutations.RESET_DAMAGE_STATE);
|
|
context.commit(storeMutations.RESET_REGISTRATION_STATE);
|
|
},
|
|
resetDamageAndDependencies(context) {
|
|
context.commit(storeMutations.RESET_DAMAGE_STATE);
|
|
context.commit(storeMutations.RESET_PARTS_STATE);
|
|
},
|
|
resetRegistrationAndDependencies(context) {
|
|
context.commit(storeMutations.RESET_REGISTRATION_STATE);
|
|
context.commit(storeMutations.RESET_PARTS_STATE)
|
|
},
|
|
resetPartsAndDependencies(context) {
|
|
context.commit(storeMutations.RESET_PARTS_STATE);
|
|
},
|
|
resetState(context) {
|
|
context.commit(storeMutations.RESET_STATE);
|
|
},
|
|
|
|
// Content API Actions
|
|
getRouteInfo(context, { pageName }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetRouteInfo.method,
|
|
endpoint: endpoints.GetRouteInfo.url,
|
|
payload: {
|
|
pageName: pageName,
|
|
},
|
|
});
|
|
},
|
|
getHomepageName(context) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetHomepageInfo.method,
|
|
endpoint: endpoints.GetHomepageInfo.url,
|
|
});
|
|
},
|
|
getPageData(context, { pageName }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetPageData.method,
|
|
endpoint: `${endpoints.GetPageData.url}/${pageName}`,
|
|
payload: {},
|
|
});
|
|
},
|
|
getEvoxImage(context, { relativeUrl }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetPageData.method,
|
|
endpoint: relativeUrl,
|
|
payload: {},
|
|
});
|
|
},
|
|
|
|
// Misc Actions
|
|
setReferralInformation(context, { referralNumber, referralDate, referralCorrelationId }) {
|
|
context.commit(storeMutations.UPDATE_REFERRAL_NUMBER, referralNumber);
|
|
context.commit(storeMutations.UPDATE_REFERRAL_DATE, referralDate);
|
|
context.commit(storeMutations.UPDATE_REFERRAL_CORRELATION_ID, referralCorrelationId);
|
|
},
|
|
|
|
logExperimentExposure(context, { userId, sessionKey, pageName, universeName }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LogExperimentExposureIfAssigned.method,
|
|
endpoint: endpoints.LogExperimentExposureIfAssigned.url,
|
|
payload: {
|
|
userId: userId,
|
|
sessionKey: sessionKey,
|
|
pageName: pageName,
|
|
universeName: universeName
|
|
}
|
|
});
|
|
},
|
|
|
|
logActivity(context, { userId, sessionKey, pageName, sessionId, pageEvent, customEvent, shouldUseSessionId }) {
|
|
var payload = {
|
|
userId: userId,
|
|
sessionKey: sessionKey,
|
|
sessionId: sessionId,
|
|
pageName: pageName,
|
|
applicationName: 'SafeliteDotCom',
|
|
shouldUseSessionId: shouldUseSessionId
|
|
};
|
|
|
|
if (typeof pageEvent !== 'undefined') {
|
|
payload.pageEvent = { action: pageEvent.action, event: pageEvent.event};
|
|
}
|
|
|
|
if (typeof customEvent !== 'undefined') {
|
|
payload.customEvents = [{category: customEvent.category, action: customEvent.action, label: customEvent.label, value: customEvent.value}];
|
|
}
|
|
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LogActivity.method,
|
|
endpoint: endpoints.LogActivity.url,
|
|
payload: payload,
|
|
logApiCall: false
|
|
});
|
|
},
|
|
|
|
getExperimentsByUserForGa(context, { userId }){
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetExperimentsByUserForGa.method,
|
|
endpoint: `${endpoints.GetExperimentsByUserForGa.url}/${userId}`,
|
|
payload: {}
|
|
});
|
|
},
|
|
|
|
|
|
// Parts API Actions
|
|
getPartsOrQuestions(context, { carId, glassArray, zipCode, vin = '' }) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.GetPartsOrQuestions.method,
|
|
endpoint: endpoints.GetPartsOrQuestions.url,
|
|
payload: {
|
|
carId: carId,
|
|
glass: glassArray,
|
|
zip: zipCode,
|
|
vin: vin
|
|
},
|
|
});
|
|
},
|
|
|
|
// Order API Actions
|
|
saveOrder(context) {
|
|
const vehicle = context.getters.vehicle;
|
|
const damage = context.getters.damage;
|
|
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.SaveOrder.method,
|
|
endpoint: endpoints.SaveOrder.url,
|
|
payload: {
|
|
vehicle: {
|
|
carId: vehicle.carId,
|
|
year: vehicle.year,
|
|
make: vehicle.make,
|
|
model: vehicle.model,
|
|
style: vehicle.style,
|
|
vin: vehicle.vin
|
|
},
|
|
numberOfChips: damage.numberOfChips,
|
|
zipCode: 43215, // TODO CSR-416, should not be hardcoded (state.order.serviceLocation.zipCode)
|
|
glassToReplace: damage.glassToReplace,
|
|
referralNumber: context.state.order.referralNumber,
|
|
referralDate: context.state.order.referralDate,
|
|
accountNumber: context.state.order.accountNumber
|
|
},
|
|
});
|
|
},
|
|
|
|
loadOrder(context, { referralNumber, referralDate, referralCorrelationId, accountNumber}) {
|
|
return globalMethods.callHttpClient({
|
|
method: endpoints.LoadOrder.method,
|
|
endpoint: endpoints.LoadOrder.url,
|
|
payload: {
|
|
referralNumber: referralNumber,
|
|
referralDate: referralDate,
|
|
referralCorrelationId: referralCorrelationId,
|
|
accountNumber: accountNumber
|
|
},
|
|
}).then((response) => {
|
|
context.commit(storeMutations.RESET_STATE);
|
|
context.commit(storeMutations.UPDATE_STATE_WITH_ORDER_INFORMATION, response.data);
|
|
return response;
|
|
});
|
|
}
|
|
}
|
|
|
|
export default createStore({
|
|
plugins: [createPersistedState()],
|
|
|
|
// IMPORTANT: Be VERY careful when modifying these fields for at least a few reasons:
|
|
// * The CMS can reference the fields by name
|
|
// * Return users may have a previous "version" of the model, and we don't want
|
|
// them to have a breaking experience, because the model might have changed.
|
|
state,
|
|
mutations,
|
|
getters,
|
|
actions,
|
|
});
|
|
|
|
// Private Functions
|