Add getProgressArray && update theme sorting

Author: BarryPiccinni

questionnaire/questionnaire-service.js

@@ -13,6 +13,7 @@ const questionnaireResource = require('./resources/questionnaire-resource');
 const createQuestionnaireHelper = require('./questionnaire/questionnaire');
 const isQuestionnaireCompatible = require('./utils/isQuestionnaireVersionCompatible');
 const createTaskListService = require('./task-list/task-list-service');
+const getProgress = require('./utils/getProgressArray');
 
 const defaults = {};
 defaults.createQuestionnaireDAL = require('./questionnaire-dal');
@@ -192,16 +193,6 @@ function createQuestionnaireService({
         return answerResource;
     }
 
-    function getProgress(questionnaire) {
-        const progress = [];
-        Object.keys(questionnaire.routes.states).forEach(task => {
-            progress.push(...questionnaire.routes.states[task].progress);
-        });
-
-        // Filter out unwanted states, e.g. "completed", "notApplicable", etc
-        return progress.filter(sectionId => sectionId.startsWith('p-'));
-    }
-
     async function getAnswers(questionnaireId) {
         const questionnaire = await getQuestionnaire(questionnaireId);
         const progress = getProgress(questionnaire);

questionnaire/questionnaire/questionnaire.js

@@ -13,6 +13,7 @@ defaults.deepClone = require('./utils/deepCloneJsonDerivedObject');
 defaults.getJsonExpressionEvaluator = require('./utils/getJsonExpressionEvaluator');
 defaults.qExpression = require('q-expressions');
 defaults.sortThemedAnswers = require('./utils/sortThemedAnswers');
+defaults.getProgressArray = require('../utils/getProgressArray');
 
 function createQuestionnaire({
     questionnaireDefinition,
@@ -25,41 +26,17 @@ function createQuestionnaire({
     deepClone = defaults.deepClone,
     getJsonExpressionEvaluator = defaults.getJsonExpressionEvaluator,
     qExpression = defaults.qExpression,
-    sortThemedAnswers = defaults.sortThemedAnswers
+    sortThemedAnswers = defaults.sortThemedAnswers,
+    getProgressArray = defaults.getProgressArray
 }) {
     function getId() {
         return questionnaireDefinition.id;
     }
 
     function getProgress() {
-        if (
-            questionnaireDefinition.routes?.type &&
-            questionnaireDefinition.routes.type === 'parallel'
-        ) {
-            const progress = [];
-            Object.keys(questionnaireDefinition.routes.states).forEach(task => {
-                progress.push(...questionnaireDefinition.routes.states[task].progress);
-            });
-
-            // Filter out unwanted states, e.g. "completed", "notApplicable", etc
-            return progress.filter(sectionId => sectionId.startsWith('p-'));
-        }
-
-        return questionnaireDefinition.progress;
+        return getProgressArray(questionnaireDefinition);
     }
 
-    /* function getProgressUntil(sectionId) {
-        const allProgress = getProgress();
-        const endIndex = allProgress.indexOf(sectionId);
-
-        if (endIndex > -1) {
-            const progressSubset = allProgress.slice(0, endIndex);
-            return progressSubset;
-        }
-
-        return allProgress;
-    } */
-
     function getRoles() {
         return questionnaireDefinition?.attributes?.q__roles || {};
     }
@@ -69,7 +46,7 @@ function createQuestionnaire({
     }
 
     function getOrderedAnswers() {
-        const progress = getProgress();
+        const progress = getProgress(questionnaireDefinition);
         const answers = getAnswers();
         const orderedAnswers = {};
 
@@ -169,7 +146,7 @@ function createQuestionnaire({
         if (fnName === 'summary') {
             // TODO: handle multiple summary pages e.g. summarise between last summary and this one
             // const progressSubset = getProgressUntil(sectionId);
-            const progressSubset = getProgress();
+            const progressSubset = getProgress(questionnaireDefinition);
             const summaryOptions = value[1];
 
             // eslint-disable-next-line no-use-before-define
@@ -315,7 +292,7 @@ function createQuestionnaire({
     }
 
     function getDataAttributes({
-        progress = getProgress(),
+        progress = getProgress(questionnaireDefinition),
         dataAttributeTransformer,
         includeMetadata = true
     } = {}) {

questionnaire/questionnaire/utils/sortThemedAnswers/index.js

@@ -42,13 +42,9 @@ function sortThemes(themeContent, sortingInstructions) {
         return themesWithAnswers;
     }
     const orderMap = new Map();
-    let orderIndex = 0;
 
-    sortingInstructions.sections.forEach(obj => {
-        // eslint-disable-next-line no-unused-vars
-        const [key, ids] = Object.entries(obj)[0];
-        // eslint-disable-next-line no-plusplus
-        ids.forEach(id => orderMap.set(id, orderIndex++));
+    sortingInstructions.sections.forEach((id, index) => {
+        orderMap.set(id, index);
     });
 
     return themesWithAnswers.sort((a, b) => {

questionnaire/questionnaire/utils/sortThemedAnswers/index.test.js

@@ -275,10 +275,7 @@ describe('sort-themed-answers', () => {
                     'q-applicant-what-other-names-have-you-used'
                 ]
             },
-            sections: [
-                {'s-about-application': ['contact-details']},
-                {s_applicant_details: ['default', 'applicant-details']}
-            ]
+            sections: ['contact-details', 'default', 'applicant-details']
         };
         const themedAnswers = [
             {

questionnaire/submissions/submissions-service.js

@@ -11,7 +11,7 @@ const {
 } = require('../questionnaire/utils/taskRunner/tasks/generateCaseReference');
 const {sendSubmissionMessageToSQS} = require('../questionnaire/utils/taskRunner/tasks/postToSQS');
 const sendNotifyMessageToSQS = require('../questionnaire/utils/taskRunner/tasks/postToNotify');
-
+const getProgress = require('../utils/getProgressArray');
 const {createAppError} = require('../../middleware/error-handler/createAppError');
 
 function createSubmissionService({
@@ -34,16 +34,6 @@ function createSubmissionService({
         ownerId
     });
 
-    function getProgress(questionnaireDefinition) {
-        const progress = [];
-        Object.keys(questionnaireDefinition.routes.states).forEach(task => {
-            progress.push(...questionnaireDefinition.routes.states[task].progress);
-        });
-
-        // Filter out unwanted states, e.g. "completed", "notApplicable", etc
-        return progress.filter(sectionId => sectionId.startsWith('p-'));
-    }
-
     function hasSummaryIdInProgressEntries(questionnaireDefinition) {
         // are we currently, or have we been on this questionnaire's summary page?
         // we infer a questionnaire is complete if the user has visited the summary page.

questionnaire/utils/getProgressArray/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function getProgress(questionnaireDefinition) {
+    if (
+        questionnaireDefinition.routes?.type &&
+        questionnaireDefinition.routes.type === 'parallel'
+    ) {
+        const progress = [];
+        Object.keys(questionnaireDefinition.routes.states).forEach(task => {
+            progress.push(...questionnaireDefinition.routes.states[task].progress);
+        });
+
+        // Filter out unwanted states, e.g. "completed", "notApplicable", etc
+        return progress.filter(sectionId => sectionId.startsWith('p-'));
+    }
+
+    return questionnaireDefinition.progress;
+}
+
+module.exports = getProgress;

questionnaire/utils/getProgressArray/index.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const getProgress = require('./index');
+
+const singleTaskTemplate = {
+    type: 'apply-for-compensation',
+    version: 'foobar',
+    sections: {},
+    routes: {
+        initial: 'old-routes',
+        referrer: '',
+        summary: ['old-routes'],
+        confirmation: 'old-routes',
+        states: {}
+    },
+    answers: {},
+    onSubmit: {},
+    progress: ['old-routes'],
+    taxonomies: {},
+    meta: {},
+    attributes: {}
+};
+const multiTaskTemplate = {
+    id: 'foobar',
+    meta: {},
+    type: 'apply-for-compensation',
+    routes: {
+        id: 'foobar',
+        type: 'parallel',
+        states: {
+            A: {
+                id: 'A',
+                states: {
+                    'p-page-one': {}
+                },
+                initial: 'p-page-one',
+                progress: ['p-page-one'],
+                currentSectionId: 'p-page-one'
+            },
+            B: {
+                id: 'B',
+                states: {
+                    'p-page-two': {}
+                },
+                initial: 'p-page-two',
+                progress: ['p-page-two'],
+                currentSectionId: 'p-page-two'
+            },
+            C: {
+                id: 'C',
+                states: {
+                    'p-page-three': {}
+                },
+                initial: 'p-page-three',
+                progress: ['p-page-three'],
+                currentSectionId: 'p-page-three'
+            }
+        },
+        summary: ['foobar'],
+        referrer: 'foobar',
+        confirmation: 'foobar'
+    },
+    answers: {},
+    version: 'foobar',
+    sections: {},
+    attributes: {},
+    taxonomies: {},
+    currentSectionId: 'foobar'
+};
+
+describe('getProgress', () => {
+    it('should return a progress array when passed a single-task template', () => {
+        expect(getProgress(singleTaskTemplate)).toEqual(['old-routes']);
+    });
+
+    it('should return a progress array when passed a multi-task template', () => {
+        expect(getProgress(multiTaskTemplate)).toEqual([
+            'p-page-one',
+            'p-page-two',
+            'p-page-three'
+        ]);
+    });
+
+    it('should filter states that are not valid page Ids', () => {
+        multiTaskTemplate.routes.states.C.progress[0] = 'complete';
+        expect(getProgress(multiTaskTemplate)).toEqual(['p-page-one', 'p-page-two']);
+    });
+});