499 lines
24 KiB
Vue
499 lines
24 KiB
Vue
<template>
|
|
<Form
|
|
@submit="onSubmit"
|
|
@invalid-submit="onInvalidSubmit"
|
|
ref="theForm"
|
|
v-slot="{ meta }"
|
|
>
|
|
<div class="page-container-grouped-styles part-questions">
|
|
<loadingModal ref="loadingModal"/>
|
|
<funnelHeader cmsWidgetName="FunnelHeaderWidget" />
|
|
<vehicleBanner cmsWidgetName="VehicleBannerWidget" :displayGenericVehicleImage=false />
|
|
<funnelSubHeader cmsWidgetName="FunnelSubHeaderWidget" />
|
|
<div class="fade-on-route-transition sub-container make-tall">
|
|
<alert
|
|
ref="alertFewMoreQuestions"
|
|
cmsWidgetName="AlertFewMoreQuestionsWidget"
|
|
class="my-5"
|
|
alertClass="alert-warning"
|
|
:manualHeadline="AlertFewMoreQuestionsHeader"
|
|
:manualCopy="AlertFewMoreQuestionsCopy"
|
|
v-bind:isDismissible="false"
|
|
/>
|
|
<div v-for="(glass, i) in partsQuestionsData" :key="glass.key">
|
|
<questionChain
|
|
ref="questionChain"
|
|
v-model="selectedAnswers[glass.glassLocation + '-' + glass.glassName]"
|
|
:questionData="glass.questions"
|
|
:glassIndex="i"
|
|
v-if="showThisQuestionChain(glass, i)"
|
|
validationRules="questions-required"
|
|
/>
|
|
</div>
|
|
<funnel-footer
|
|
ref="funnelFooter"
|
|
cmsWidgetName="FunnelFooterWidget"
|
|
:isForwardActionDisabled="!meta.valid"
|
|
@back-clicked="backButtonAction"
|
|
@ForwardClicked="forwardButtonAction"
|
|
/>
|
|
</div>
|
|
</div>
|
|
</Form>
|
|
</template>
|
|
|
|
<script>
|
|
// Components
|
|
import funnelHeader from "@/common-components/funnel-header/funnel-header";
|
|
import vehicleBanner from "@/common-components/vehicle-banner/vehicle-banner";
|
|
import alert from "@/ux-components/alert/alert";
|
|
import questionChain from "@/common-components/question-chain/question-chain";
|
|
import funnelSubHeader from "@/common-components/funnel-sub-header/funnel-sub-header";
|
|
import funnelFooter from "@/common-components/funnel-footer/funnel-footer";
|
|
import loadingModal from '@/common-components/loading-modal/loading-modal.vue';
|
|
|
|
// Supporting Files
|
|
import { fetchCmsContentForPage } from "@/helpers/cms-content-helper";
|
|
import { settleAllPromises } from "@/helpers/layout-helper";
|
|
import store from "@/store";
|
|
import { storeActions } from "@/constants/store-actions";
|
|
import { storeMutations } from "@/constants/store-mutations";
|
|
import { fmgPageValues } from "@/router/router-constants/fmgPage-values";
|
|
import { Form, defineRule } from "vee-validate";
|
|
import { required } from "@/helpers/validation-rules";
|
|
import { errorMessages } from "@/constants/error-messages";
|
|
import vehicleQuestionsMixin from "@/mixins/vehicle-questions-mixin";
|
|
|
|
// DEFINE VALIDATION RULES
|
|
defineRule("questions-required", required(errorMessages.OPTION_REQUIRED));
|
|
|
|
export default {
|
|
name: "part-questions",
|
|
async beforeRouteEnter(to, from, next) {
|
|
// Call APIs
|
|
const cmsContentPromise = fetchCmsContentForPage(to.query.fmgPage);
|
|
|
|
// Settle promises and get results
|
|
const promiseResultMap = [
|
|
{
|
|
resultKey: "cmsContent",
|
|
promise: cmsContentPromise,
|
|
},
|
|
];
|
|
|
|
const resultMap = await settleAllPromises(promiseResultMap);
|
|
|
|
// Call the "next" function to complete the transition to this page.
|
|
next((vm) => {
|
|
vm.setCmsContent(resultMap.cmsContent);
|
|
});
|
|
},
|
|
data() {
|
|
return {
|
|
partsQuestionsData: store.getters.pageData(fmgPageValues.PART_QUESTIONS).partsOrQuestions,
|
|
selectedAnswers: {},
|
|
currentGlassIndex: 0,
|
|
foundDuplicateQuestions: [],
|
|
};
|
|
},
|
|
computed: {
|
|
AlertFewMoreQuestionsHeader() {
|
|
return this.getCmsContent("AlertPartsQuestions", "HeadlineText");
|
|
},
|
|
AlertFewMoreQuestionsCopy() {
|
|
return this.getCmsContent("AlertPartsQuestions", "BodyText");
|
|
},
|
|
pageData() {
|
|
return this.$store.getters.pageData(fmgPageValues.PART_QUESTIONS);
|
|
}
|
|
},
|
|
mixins: [vehicleQuestionsMixin],
|
|
mounted() {
|
|
this.LoadInitialData();
|
|
},
|
|
methods: {
|
|
arePagePrerequisitesValid() {
|
|
const partQuestionsFromPageData = store.getters.pageData(fmgPageValues.PART_QUESTIONS);
|
|
return partQuestionsFromPageData && Object.keys(partQuestionsFromPageData).length > 0;
|
|
},
|
|
showThisQuestionChain(glass, i) {
|
|
if (!glass.questions || glass.questions?.length < 1 || glass.isSuppressedPart) { return false; } // return false if no questions or if suppressed
|
|
return this.currentGlassIndex === i || glass.answerData?.answerResult?.length > 0;
|
|
},
|
|
async forwardButtonAction() {
|
|
const questionAnswersArray = this.partsQuestionsData.map((glass) => {
|
|
return {
|
|
glassLocation: glass.glassLocation,
|
|
glassName: glass.glassName,
|
|
result: glass.answerData.answerResult,
|
|
answeredQuestions: glass.answerData.answeredQuestions,
|
|
isSuppressedPart: glass.isSuppressedPart,
|
|
};
|
|
});
|
|
|
|
// clear out answerData for future page loads; must occur prior to store save
|
|
this.partsQuestionsData.forEach((glass) => {
|
|
glass.answerData = {};
|
|
});
|
|
|
|
// save to vuex store as order.damage.partQuestionAnswers (array)
|
|
await this.dispatchStoreAction(this.storeActions.SAVE_PART_QUESTION_ANSWERS, questionAnswersArray, false);
|
|
|
|
// call API parts method
|
|
const partsLookup = await this.dispatchStoreAction(storeActions.GET_PARTS)
|
|
.catch(() => {
|
|
return this.$refs.funnelFooter.removeLoader();
|
|
});
|
|
|
|
const glassNameAndPartsForStore = partsLookup.data.glassNameAndParts;
|
|
|
|
this.navigateForward(glassNameAndPartsForStore);
|
|
},
|
|
handleAnswerUpdates(key, answer) {
|
|
// only runs when all questions in a question-chain have been answered
|
|
// when selectedAnswers updates, user has completed this part's question chain and has a final answer
|
|
// (does not get run for each invididual question's answer, only when
|
|
// all relevent questions for the current part have been answered)
|
|
|
|
/*
|
|
answer example format:
|
|
{
|
|
"answerResult": "DD11132",
|
|
"answeredQuestions": [
|
|
{
|
|
"questionText": "Is your Grand Cherokee the Laredo model?",
|
|
"selectedAnswerText": "Yes",
|
|
"questionNum": 1,
|
|
}
|
|
],
|
|
"glassIndex": 0
|
|
}
|
|
*/
|
|
|
|
// collect a list of the answered questions' numbers, needed later below
|
|
const answeredQuestionIndexes = [];
|
|
|
|
// if user has answered a question differently than anything that was preloaded,
|
|
// we need to clear out any preloaded answers
|
|
this.selectedAnswers = {};
|
|
|
|
// loop through every answered question on the currently answered glass part
|
|
answer.answeredQuestions?.forEach((aq) => {
|
|
|
|
// keep track of this question number
|
|
answeredQuestionIndexes.push(aq.questionNum);
|
|
|
|
const answeredQuestionText = aq.questionText.toUpperCase();
|
|
const answeredQuestionAnswer = aq.selectedAnswerText.toUpperCase();
|
|
|
|
// HANDLE DUPLICATE QUESTIONS
|
|
|
|
// loop through all glass parts data
|
|
this.partsQuestionsData.forEach((glass, gpIndex) => {
|
|
|
|
// only look for duplicates forward... to parts that follow after the currently being answered part
|
|
if (gpIndex > answer.glassIndex) {
|
|
|
|
let suppressUntil;
|
|
// reset this glass part, in case user is changing their previous answers
|
|
glass.answerData = null;
|
|
glass.isSuppressedPart = null;
|
|
|
|
// loop through this glass part's questions, looking for a questionText match
|
|
glass.questions.forEach((pq, pqIndex) => {
|
|
|
|
// clear out any previously set answers
|
|
pq.answerSelected = null;
|
|
|
|
// clear or set suppressQuestion property for each question
|
|
if (suppressUntil) {
|
|
// if suppressUntil has been set, then suppress this question if before it
|
|
if (pqIndex + 1 < suppressUntil) {
|
|
pq.suppressQuestion = true;
|
|
} else {
|
|
pq.suppressQuestion = null;
|
|
}
|
|
} else {
|
|
pq.suppressQuestion = null;
|
|
}
|
|
|
|
// if these match then we have a duplicate question
|
|
if (pq.questionText.toUpperCase() === answeredQuestionText) {
|
|
|
|
const thisAnsweredQuestion = glass.questions[pqIndex];
|
|
let matchedAnswer;
|
|
let rejectedAnswers = []; // set as an array, in case we ever have questions with more than 2 answers...
|
|
|
|
// which one of this questions' answers matches our answer?
|
|
pq.answers.forEach((ans) => {
|
|
if (ans.answerText.toUpperCase() === answeredQuestionAnswer) {
|
|
matchedAnswer = ans;
|
|
ans.selected = true;
|
|
} else {
|
|
rejectedAnswers.push(ans);
|
|
ans.selected = null;
|
|
}
|
|
});
|
|
|
|
// Update the key to re-render this part's question-chain component
|
|
this.partsQuestionsData[gpIndex].key = this.partsQuestionsData[gpIndex].glassLocation + this.partsQuestionsData[gpIndex].glassName + Date.now().toString();
|
|
|
|
// handle suppressing downstream in this question chain
|
|
|
|
if (matchedAnswer.nextQuestionSequence) {
|
|
// ensure that the question that the accepted answer has set to be next is NOT suppressed
|
|
glass.questions[matchedAnswer.nextQuestionSequence - 1].suppressQuestion = null;
|
|
// if the duplicate is the 1ST question, then set suppressUntil var to lowest nextQuestion number
|
|
if (pqIndex === 0) {
|
|
if (!suppressUntil) { suppressUntil = matchedAnswer.nextQuestionSequence }
|
|
if (matchedAnswer.nextQuestionSequence < suppressUntil) { suppressUntil = matchedAnswer.nextQuestionSequence}
|
|
}
|
|
}
|
|
|
|
// handle suppressing upstream in this question chain
|
|
glass.questions.forEach((q) => {
|
|
q.answers.forEach((thisAns) => {
|
|
// restore any of the answers that formerly led to the duplicated question
|
|
if (thisAns.originalNextQuestionSequence === pq.questionSequence) {
|
|
// restore original nextQuestionSequence
|
|
thisAns.nextQuestionSequence = thisAns.originalNextQuestionSequence;
|
|
this.originalNextQuestionSequence = null;
|
|
// restore original answerResult
|
|
if (thisAns.originalAnswerResult) {
|
|
thisAns.answerResult = thisAns.originalAnswerResult;
|
|
thisAns.originalAnswerResult = null;
|
|
}
|
|
}
|
|
// search for any answers that lead to the duplicated question
|
|
if (thisAns.nextQuestionSequence === pq.questionSequence) {
|
|
// update either the nextQuestionSequence or the answerResult
|
|
if (matchedAnswer.nextQuestionSequence) {
|
|
thisAns.originalNextQuestionSequence = thisAns.nextQuestionSequence;
|
|
thisAns.nextQuestionSequence = matchedAnswer.nextQuestionSequence;
|
|
} else {
|
|
thisAns.originalNextQuestionSequence = thisAns.nextQuestionSequence;
|
|
thisAns.nextQuestionSequence = null;
|
|
thisAns.originalAnswerResult = thisAns.originalAnswerResult || thisAns.answerResult;
|
|
thisAns.answerResult = matchedAnswer.answerResult;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// suppress current question
|
|
thisAnsweredQuestion.suppressQuestion = true;
|
|
|
|
const thisGlassPart = "glass" + gpIndex;
|
|
if (this.foundDuplicateQuestions[thisGlassPart]) {
|
|
if (!this.foundDuplicateQuestions[thisGlassPart].includes(thisAnsweredQuestion.questionSequence)) {
|
|
this.foundDuplicateQuestions[thisGlassPart].push(thisAnsweredQuestion.questionSequence);
|
|
}
|
|
} else {
|
|
this.foundDuplicateQuestions[thisGlassPart] = [thisAnsweredQuestion.questionSequence];
|
|
}
|
|
|
|
// are there any questions left that are not suppressed?
|
|
const remainingQuestions = glass.questions.filter((q) => {
|
|
return !q.suppressQuestion;
|
|
});
|
|
|
|
if (remainingQuestions.length < 1) {
|
|
// this is the final answer for this glass part
|
|
|
|
// mark this part as completely answered by adding answerData
|
|
const answeredQuestionObj = {
|
|
questionText: pq.questionText,
|
|
selectedAnswerText: matchedAnswer.answerText,
|
|
questionNum: pq.questionSequence,
|
|
suppressQuestion: pq.suppressQuestion,
|
|
};
|
|
// set the answerData as 'already answered'
|
|
glass.answerData = {
|
|
answerResult: matchedAnswer.nextQuestionSequence ? matchedAnswer.nextQuestionSequence : matchedAnswer.answerResult,
|
|
answeredQuestions: [answeredQuestionObj],
|
|
};
|
|
|
|
// suppress this glass because it has an answer
|
|
glass.isSuppressedPart = true;
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// Update the key to re-render this part's question-chain component
|
|
this.partsQuestionsData[gpIndex].key = this.partsQuestionsData[gpIndex].glassLocation + this.partsQuestionsData[gpIndex].glassName + Date.now().toString();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
// DETERMINE ANSWERED QUESTIONS LIST FOR THIS GLASS PART
|
|
|
|
// look through all (this part's) part questions for any duplicates that were suppressed;
|
|
// add them to the list of answered questions if found
|
|
|
|
// EX answeredQuestionIndexes: [1,5,11,13]
|
|
|
|
// EX this.foundDuplicateQuestions = {
|
|
// "glassPart1": [1],
|
|
// "glassPart2": [7, 10]
|
|
// };
|
|
|
|
const thisPartsDupes = this.foundDuplicateQuestions["glass" + answer.glassIndex];
|
|
const completeAnsweredQuestions = answer.answeredQuestions ? [...answer.answeredQuestions] : [];
|
|
const glassPartAnswered = this.partsQuestionsData[answer.glassIndex];
|
|
|
|
thisPartsDupes?.forEach((dupe) => {
|
|
// dupe is a single integer
|
|
const dupeQuestion = glassPartAnswered.questions[dupe - 1];
|
|
const dupeQuestionAnswer = dupeQuestion.answers.find((q) => q.selected === true);
|
|
|
|
glassPartAnswered.questions.forEach((q) => {
|
|
let includeThisDupeInAnsweredQuestions = false;
|
|
|
|
// did one of the answers of this question point to the duplicated question?
|
|
q.answers.forEach((a) => {
|
|
if ((dupe === a.originalNextQuestionSequence) &&
|
|
(answeredQuestionIndexes.includes(q.questionSequence)) &&
|
|
(a.answerText.toUpperCase() === dupeQuestionAnswer.answerText.toUpperCase())) {
|
|
includeThisDupeInAnsweredQuestions = true;
|
|
}
|
|
});
|
|
|
|
// is this q.questionSequence listed as the duplicated question's nextQuestionSequence?
|
|
if ((q.questionSequence === dupeQuestionAnswer.nextQuestionSequence) && (answeredQuestionIndexes.includes(q.questionSequence))) {
|
|
includeThisDupeInAnsweredQuestions = true;
|
|
}
|
|
|
|
if (includeThisDupeInAnsweredQuestions) {
|
|
completeAnsweredQuestions.push({
|
|
questionNum: dupeQuestion.questionSequence,
|
|
questionText: dupeQuestion.questionText,
|
|
selectedAnswerText: dupeQuestionAnswer.answerText,
|
|
suppressQuestion: dupeQuestion.suppressQuestion,
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
// make sure there are no duplicated dupes in the list...
|
|
const foundInCompleteAnsweredQuestions = new Set();
|
|
let filteredCompleteAnsweredQuestions = completeAnsweredQuestions.filter(el => {
|
|
const duplicate = foundInCompleteAnsweredQuestions.has(el.questionText);
|
|
foundInCompleteAnsweredQuestions.add(el.questionText);
|
|
return !duplicate;
|
|
});
|
|
filteredCompleteAnsweredQuestions = filteredCompleteAnsweredQuestions.sort((a,b) => a.questionNum - b.questionNum);
|
|
|
|
// set final answer data for the current answered glass part
|
|
glassPartAnswered.answerData = {
|
|
answerResult: answer.answerResult,
|
|
answeredQuestions: filteredCompleteAnsweredQuestions,
|
|
}
|
|
|
|
// this part has been fully answered, so advance to next part's question chain
|
|
for (let i = answer.glassIndex + 1; i < this.partsQuestionsData.length; i++) {
|
|
// if this part has not yet been fully answered, then make it the current part
|
|
if (!this.partsQuestionsData[i].answerData?.answerResult) {
|
|
this.currentGlassIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
},
|
|
LoadInitialData() {
|
|
|
|
// are there alreadyAnsweredQuestions?
|
|
const alreadyAnsweredQuestions = store.getters.damage.partQuestionAnswers;
|
|
|
|
this.partsQuestionsData = this.pageData.partsOrQuestions.filter(x => x.partQuestions).map((glass, i) => {
|
|
glass.key = glass.glassLocation + "-" + glass.glassName;
|
|
// NOTE: property "questions" can differ between layouts
|
|
glass.questions = glass.partQuestions;
|
|
|
|
this.selectedAnswers[glass.key] = [];
|
|
if (!alreadyAnsweredQuestions) {
|
|
glass.answerData = null;
|
|
}
|
|
|
|
alreadyAnsweredQuestions?.forEach((savedPart) => {
|
|
|
|
if (!savedPart.glassLocation || !savedPart.glassName || !savedPart.answeredQuestions || !savedPart.result) {
|
|
return;
|
|
}
|
|
if (glass.glassLocation === savedPart.glassLocation && glass.glassName === savedPart.glassName) {
|
|
let answerString = "";
|
|
|
|
// matches; loop through answeredQuestions for matches
|
|
savedPart.answeredQuestions.forEach((aq) => {
|
|
if (!aq.questionNum || !aq.selectedAnswerText) {
|
|
return;
|
|
}
|
|
// determine which answer was previously chosen
|
|
const theAns = glass.questions[aq.questionNum-1].answers.find((a) => {
|
|
return a.answerText.toUpperCase() === aq.selectedAnswerText.toUpperCase();
|
|
});
|
|
if (theAns.nextQuestionSequence) {
|
|
answerString = `${aq.questionNum}|nextQuestion|${theAns.nextQuestionSequence}|${theAns.answerText}`
|
|
} else {
|
|
answerString = `${aq.questionNum}|answer|${theAns.answerResult}|${theAns.answerText}`
|
|
}
|
|
|
|
// mark this question as answered (question-chain will read this)
|
|
glass.questions[aq.questionNum-1].answerSelected = answerString;
|
|
// mark this question as duplicate if it is (question-chain will read this)
|
|
if (aq.suppressQuestion) {
|
|
glass.questions[aq.questionNum-1].suppressQuestion = true;
|
|
}
|
|
});
|
|
|
|
// advance the currentGlassIndex
|
|
this.currentGlassIndex = i;
|
|
|
|
// add answerData to current glass
|
|
glass.answerData = {
|
|
answerResult: savedPart.result,
|
|
answeredQuestions: savedPart.answeredQuestions
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
// Set up watch for each set of glass questions, which gets updated when all questions for a glass have been answered
|
|
this.$watch("selectedAnswers." + glass.key, (newValue) => {
|
|
if (newValue) {
|
|
this.handleAnswerUpdates(glass.key, newValue);
|
|
}
|
|
}, {deep: true})
|
|
|
|
return glass;
|
|
});
|
|
|
|
},
|
|
},
|
|
components: {
|
|
funnelHeader,
|
|
vehicleBanner,
|
|
alert,
|
|
questionChain,
|
|
funnelSubHeader,
|
|
funnelFooter,
|
|
loadingModal,
|
|
Form,
|
|
},
|
|
};
|
|
</script>
|
|
|
|
<style lang="scss">
|
|
.part-questions {
|
|
.question-text {
|
|
margin-bottom: .5rem;
|
|
span {
|
|
text-align: left;
|
|
}
|
|
}
|
|
}
|
|
</style>
|