@coorpacademy/app-review 0.1.19 → 0.1.20

package/es/actions/api/post-answer.js

@@ -5,21 +5,22 @@ export const POST_ANSWER_REQUEST = '@@answer/POST_REQUEST';
 export const POST_ANSWER_SUCCESS = '@@answer/POST_SUCCESS';
 export const POST_ANSWER_FAILURE = '@@answer/POST_FAILURE';
 export const postAnswer = async (dispatch, getState, { services }) => {
+    const state = getState();
+    const token = get('data.token', state);
+    const answer = get('ui.answers', state);
+    const progression = state.data.progression;
+    if (!progression)
+        throw new Error('cannot answer question of inexisting progression');
     const action = buildTask({
         types: [POST_ANSWER_REQUEST, POST_ANSWER_SUCCESS, POST_ANSWER_FAILURE],
         task: () => {
-            const state = getState();
-            const token = get('data.token', state);
-            const answer = get('ui.answers', state);
-            const progressionId = get('data.progression._id', state);
-            const skillRef = get('data.progression.content.ref', state);
-            return services.postAnswer(skillRef, token, progressionId, answer);
+            return services.postAnswer(progression, token, answer);
         }
     });
     const response = await dispatch(action);
     if (response.type === POST_ANSWER_SUCCESS) {
-        const progression = response.payload;
-        const slideRef = progression.state.nextContent.ref;
+        const updatedProgression = response.payload;
+        const slideRef = updatedProgression.state.nextContent.ref;
         await dispatch(fetchSlide(slideRef));
     }
 };

package/es/actions/api/test/post-answer.test.js

@@ -1,6 +1,6 @@
 import test from 'ava';
 import { createTestStore } from '../../test/create-test-store';
-import { postAnswerResponse, services } from '../../../test/util/services.mock';
+import { postAnswerResponses, services } from '../../../test/util/services.mock';
 import { postAnswer, POST_ANSWER_FAILURE, POST_ANSWER_REQUEST, POST_ANSWER_SUCCESS } from '../post-answer';
 import { SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS } from '../fetch-slide';
 import { qcmGraphicSlide } from '../../../views/slides/test/fixtures/qcm-graphic';
@@ -21,7 +21,7 @@ const initialState = {
                 allAnswers: [],
                 isCorrect: true,
                 nextContent: {
-                    ref: 'sli_VJYjJnJhg',
+                    ref: freeTextSlide.id,
                     type: 'slide'
                 },
                 pendingSlides: [],
@@ -39,7 +39,7 @@ const initialState = {
         token: '1234'
     },
     ui: {
-        currentSlideRef: 'sli_VJYjJnJhg',
+        currentSlideRef: freeTextSlide.id,
         navigation: ['skills', 'slides'],
         answers: answer,
         slide: {
@@ -52,12 +52,12 @@ test('should dispatch POST_ANSWER_REQUEST, then POST_ANSWER_SUCCESS when the upd
         { type: POST_ANSWER_REQUEST },
         {
             type: POST_ANSWER_SUCCESS,
-            payload: postAnswerResponse
+            payload: postAnswerResponses[freeTextSlide.id]
         },
-        { type: SLIDE_FETCH_REQUEST, meta: { slideRef: 'sli_VkSQroQnx' } },
+        { type: SLIDE_FETCH_REQUEST, meta: { slideRef: qcmGraphicSlide.id } },
         {
             type: SLIDE_FETCH_SUCCESS,
-            meta: { slideRef: 'sli_VkSQroQnx' },
+            meta: { slideRef: qcmGraphicSlide.id },
             payload: qcmGraphicSlide
         },
         { type: SET_CURRENT_SLIDE, payload: qcmGraphicSlide }

package/es/reducers/data/test/progression.test.js

@@ -2,7 +2,8 @@ import test from 'ava';
 import reducer from '../progression';
 import { POST_PROGRESSION_SUCCESS } from '../../../actions/api/post-progression';
 import { POST_ANSWER_SUCCESS } from '../../../actions/api/post-answer';
-import { postAnswerResponse, postProgressionResponse } from '../../../test/util/services.mock';
+import { postAnswerResponses, postProgressionResponse } from '../../../test/util/services.mock';
+import { freeTextSlide } from '../../../views/slides/test/fixtures/free-text';
 test('should have initial value', t => {
     const state = reducer(undefined, {});
     t.is(state, null);
@@ -17,7 +18,7 @@ test('should set the value of POST_PROGRESSION_SUCCESS action', t => {
 test('should set the value of POST_ANSWER_SUCCESS action', t => {
     const state = reducer(null, {
         type: POST_ANSWER_SUCCESS,
-        payload: postAnswerResponse
+        payload: postAnswerResponses[freeTextSlide.universalRef]
     });
-    t.deepEqual(state, postAnswerResponse);
+    t.deepEqual(state, postAnswerResponses[freeTextSlide.universalRef]);
 });

package/es/services/post-answer.d.ts

@@ -1,2 +1,2 @@
 import { ProgressionFromAPI } from '../types/common';
-export declare const postAnswer: (skillRef: string, token: string, progressionId: string, answer: string[]) => Promise<ProgressionFromAPI>;
+export declare const postAnswer: (progression: ProgressionFromAPI, token: string, answer: string[]) => Promise<ProgressionFromAPI>;

package/es/services/post-answer.js

@@ -1,7 +1,9 @@
 import crossFetch from 'cross-fetch';
 import decode from 'jwt-decode';
 import { toJSON } from './tools/fetch-responses';
-export const postAnswer = async (skillRef, token, progressionId, answer) => {
+export const postAnswer = async (progression, token, answer) => {
+    const progressionId = progression._id;
+    const skillRef = progression.content.ref;
     const { host } = decode(token);
     const response = await crossFetch(`${host}/api/v2/progressions/${progressionId}/answers`, {
         method: 'post',

package/es/services/test/post-answer.test.js

@@ -1,9 +1,32 @@
 import test from 'ava';
 import nock from 'nock';
 import { postAnswer } from '../post-answer';
-const progressionId = '123456789123';
 const skillRef = '_skill-ref';
 const answer = ['Lister vos tâches pour vous libérer l’esprit', 'Vous isoler dans un lieu calme'];
+const initProgression = {
+    content: {
+        type: 'skill',
+        ref: skillRef
+    },
+    engine: {
+        ref: 'review'
+    },
+    _id: '123456123456',
+    state: {
+        allAnswers: [],
+        isCorrect: true,
+        nextContent: {
+            type: 'slide',
+            ref: 'sli_NkvrWPFF2'
+        },
+        pendingSlides: [],
+        slides: [],
+        step: {
+            current: 1
+        },
+        stars: 0
+    }
+};
 const result = {
     content: {
         type: 'skill',
@@ -40,18 +63,18 @@ const result = {
 };
 test.before(() => {
     const moocApi = nock('http://localhost:3000');
-    moocApi.post(`/api/v2/progressions/${progressionId}/answers`).reply(200, result);
+    moocApi.post('/api/v2/progressions/123456123456/answers').reply(200, result);
 });
 test.after(() => {
     nock.cleanAll();
 });
 test('should post the answers successfully', async (t) => {
     const token = process.env.API_TEST_TOKEN || '';
-    const progression = await postAnswer(skillRef, token, progressionId, answer);
+    const progression = await postAnswer(initProgression, token, answer);
     t.deepEqual(result, progression);
 });
 test('should reject bad token', async (t) => {
     const badToken = 'token is not a jwt';
-    const error = await t.throwsAsync(() => postAnswer(skillRef, badToken, progressionId, answer));
+    const error = await t.throwsAsync(() => postAnswer(initProgression, badToken, answer));
     t.is(error?.message, "Invalid token specified: Cannot read properties of undefined (reading 'replace')");
 });

package/es/test/util/services.mock.d.ts

@@ -1,4 +1,5 @@
 import { ProgressionFromAPI, Services } from '../../types/common';
 export declare const postProgressionResponse: ProgressionFromAPI;
-export declare const postAnswerResponse: ProgressionFromAPI;
+export declare const postAnswerResponses: Record<string, ProgressionFromAPI>;
+export declare const progressionSlideWithPendingSlide: ProgressionFromAPI;
 export declare const services: Services;

package/es/test/util/services.mock.js

@@ -1,8 +1,16 @@
+import get from 'lodash/fp/get';
 import { qcmSlide } from '../../views/slides/test/fixtures/qcm';
 import { qcmGraphicSlide } from '../../views/slides/test/fixtures/qcm-graphic';
 import { freeTextSlide } from '../../views/slides/test/fixtures/free-text';
 import { sliderSlide } from '../../views/slides/test/fixtures/slider';
 import { templateSlide } from '../../views/slides/test/fixtures/template';
+const content = {
+    ref: '_skill-ref',
+    type: 'skill'
+};
+const engine = {
+    ref: 'review'
+};
 const getSlideFixture = (ref) => {
     switch (ref) {
         case qcmSlide.universalRef:
@@ -33,18 +41,13 @@ const fetchSkillsResponse = [
 ];
 export const postProgressionResponse = {
     _id: '62b1d1087aa12f00253f40ee',
-    content: {
-        ref: '_skill-ref',
-        type: 'skill'
-    },
-    engine: {
-        ref: 'review'
-    },
+    content,
+    engine,
     state: {
         allAnswers: [],
         isCorrect: true,
         nextContent: {
-            ref: 'sli_VJYjJnJhg',
+            ref: freeTextSlide.universalRef,
             type: 'slide'
         },
         pendingSlides: [],
@@ -55,43 +58,281 @@ export const postProgressionResponse = {
         stars: 0
     }
 };
-export const postAnswerResponse = {
-    _id: '62b1d1087aa12f00253f40ee',
-    content: {
-        ref: '_skill-ref',
-        type: 'skill'
+export const postAnswerResponses = {
+    [freeTextSlide.universalRef]: {
+        _id: '62b1d1087aa12f00253f40ee',
+        content,
+        engine,
+        state: {
+            allAnswers: [
+                {
+                    slideRef: freeTextSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Benchmark']
+                }
+            ],
+            isCorrect: true,
+            nextContent: {
+                ref: qcmGraphicSlide.universalRef,
+                type: 'slide'
+            },
+            content: {
+                ref: freeTextSlide.universalRef,
+                type: 'slide'
+            },
+            pendingSlides: [],
+            slides: [freeTextSlide.universalRef],
+            step: {
+                current: 2
+            },
+            stars: 8
+        }
+    },
+    [qcmGraphicSlide.universalRef]: {
+        _id: '62b1d1087aa12f00253f40ee',
+        content,
+        engine,
+        state: {
+            allAnswers: [
+                {
+                    slideRef: freeTextSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Benchmark']
+                },
+                {
+                    slideRef: qcmGraphicSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Faux']
+                }
+            ],
+            isCorrect: true,
+            nextContent: {
+                ref: qcmSlide.universalRef,
+                type: 'slide'
+            },
+            content: {
+                ref: qcmGraphicSlide.universalRef,
+                type: 'slide'
+            },
+            pendingSlides: [],
+            slides: [freeTextSlide.universalRef, qcmGraphicSlide.universalRef],
+            step: {
+                current: 3
+            },
+            stars: 16
+        }
     },
-    engine: {
-        ref: 'review'
+    [qcmSlide.universalRef]: {
+        _id: '62b1d1087aa12f00253f40ee',
+        content,
+        engine,
+        state: {
+            allAnswers: [
+                {
+                    slideRef: freeTextSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Benchmark']
+                },
+                {
+                    slideRef: qcmGraphicSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Faux']
+                },
+                {
+                    slideRef: qcmSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Le créateur peut fixer un pourcentage pour chaque transaction future']
+                }
+            ],
+            isCorrect: true,
+            nextContent: {
+                ref: sliderSlide.universalRef,
+                type: 'slide'
+            },
+            content: {
+                ref: qcmSlide.universalRef,
+                type: 'slide'
+            },
+            pendingSlides: [],
+            slides: [freeTextSlide.universalRef, qcmGraphicSlide.universalRef, qcmSlide.universalRef],
+            step: {
+                current: 4
+            },
+            stars: 24
+        }
     },
+    [sliderSlide.universalRef]: {
+        _id: '62b1d1087aa12f00253f40ee',
+        content,
+        engine,
+        state: {
+            allAnswers: [
+                {
+                    slideRef: freeTextSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Benchmark']
+                },
+                {
+                    slideRef: qcmGraphicSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Faux']
+                },
+                {
+                    slideRef: qcmSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Le créateur peut fixer un pourcentage pour chaque transaction future']
+                },
+                {
+                    slideRef: sliderSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['7']
+                }
+            ],
+            isCorrect: true,
+            nextContent: {
+                ref: templateSlide.universalRef,
+                type: 'slide'
+            },
+            content: {
+                ref: sliderSlide.universalRef,
+                type: 'slide'
+            },
+            pendingSlides: [],
+            slides: [
+                freeTextSlide.universalRef,
+                qcmGraphicSlide.universalRef,
+                qcmSlide.universalRef,
+                sliderSlide.universalRef
+            ],
+            step: {
+                current: 5
+            },
+            stars: 32
+        }
+    },
+    [templateSlide.universalRef]: {
+        _id: '62b1d1087aa12f00253f40ee',
+        content,
+        engine,
+        state: {
+            allAnswers: [
+                {
+                    slideRef: freeTextSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Benchmark']
+                },
+                {
+                    slideRef: qcmGraphicSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Faux']
+                },
+                {
+                    slideRef: qcmSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Le créateur peut fixer un pourcentage pour chaque transaction future']
+                },
+                {
+                    slideRef: sliderSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['7']
+                },
+                {
+                    slideRef: templateSlide.universalRef,
+                    isCorrect: true,
+                    answer: ['Leaderboard', 'utilisateurs', 'étoiles']
+                }
+            ],
+            isCorrect: true,
+            nextContent: {
+                ref: 'successExitNode',
+                type: 'success'
+            },
+            content: {
+                ref: templateSlide.universalRef,
+                type: 'slide'
+            },
+            pendingSlides: [],
+            slides: [
+                freeTextSlide.universalRef,
+                qcmGraphicSlide.universalRef,
+                qcmSlide.universalRef,
+                sliderSlide.universalRef,
+                templateSlide.universalRef
+            ],
+            step: {
+                current: 6
+            },
+            stars: 40
+        }
+    }
+};
+export const progressionSlideWithPendingSlide = {
+    _id: '62b1d1087aa12f00253f40ee',
+    content,
+    engine,
     state: {
         allAnswers: [
             {
-                slideRef: 'sli_VJYjJnJhg',
+                slideRef: freeTextSlide.universalRef,
+                isCorrect: false,
+                answer: ['Wrong']
+            },
+            {
+                slideRef: qcmGraphicSlide.universalRef,
+                isCorrect: true,
+                answer: ['Faux']
+            },
+            {
+                slideRef: qcmSlide.universalRef,
+                isCorrect: false,
+                answer: ['Wrong']
+            },
+            {
+                slideRef: sliderSlide.universalRef,
+                isCorrect: true,
+                answer: ['7']
+            },
+            {
+                slideRef: templateSlide.universalRef,
+                isCorrect: true,
+                answer: ['Leaderboard', 'utilisateurs', 'étoiles']
+            },
+            {
+                slideRef: freeTextSlide.universalRef,
                 isCorrect: true,
                 answer: ['Benchmark']
             }
         ],
         isCorrect: true,
         nextContent: {
-            ref: 'sli_VkSQroQnx',
+            ref: qcmSlide.universalRef,
             type: 'slide'
         },
         content: {
-            ref: 'sli_VJYjJnJhg',
+            ref: freeTextSlide.universalRef,
             type: 'slide'
         },
-        pendingSlides: [],
-        slides: ['sli_VJYjJnJhg'],
+        pendingSlides: [qcmSlide.universalRef],
+        slides: [
+            freeTextSlide.universalRef,
+            qcmGraphicSlide.universalRef,
+            qcmSlide.universalRef,
+            sliderSlide.universalRef,
+            templateSlide.universalRef,
+            freeTextSlide.universalRef
+        ],
         step: {
-            current: 2
+            current: 7
         },
-        stars: 4
+        stars: 32
     }
 };
 export const services = {
     fetchSkills: () => Promise.resolve(fetchSkillsResponse),
     fetchSlide: ref => Promise.resolve({ ...getSlideFixture(ref), universalRef: ref, id: ref }),
     postProgression: () => Promise.resolve(postProgressionResponse),
-    postAnswer: () => Promise.resolve(postAnswerResponse)
+    postAnswer: progression => {
+        const currentSlide = progression.state.nextContent.ref;
+        return Promise.resolve(get(currentSlide, postAnswerResponses));
+    }
 };

package/es/types/common.d.ts

@@ -74,7 +74,7 @@ export declare type SlideFromAPI = {
         type: 'chapter' | 'course';
     };
 };
-declare type ProgressionAnswerItem = {
+export declare type ProgressionAnswerItem = {
     isCorrect: boolean;
     slideRef: string;
     answer: string[];
@@ -97,15 +97,17 @@ export declare type ProgressionState = {
     };
     stars: number;
 };
+export declare type ReviewContent = {
+    type: 'skill';
+    ref: string;
+};
+export declare type ReviewEngine = {
+    ref: 'review';
+};
 export declare type ProgressionFromAPI = {
     _id: string;
-    content: {
-        type: 'skill';
-        ref: string;
-    };
-    engine: {
-        ref: 'review';
-    };
+    content: ReviewContent;
+    engine: ReviewEngine;
     state: ProgressionState;
 };
 export declare type Skill = {
@@ -118,7 +120,7 @@ export declare type Services = {
     fetchSkills(token: string): Promise<Skill[]>;
     fetchSlide(slideRef: string, token: string): Promise<SlideFromAPI | void>;
     postProgression(skillRef: string, token: string): Promise<ProgressionFromAPI>;
-    postAnswer(skillRef: string, token: string, progressionId: string, answer: string[]): Promise<ProgressionFromAPI>;
+    postAnswer(progression: ProgressionFromAPI, token: string, answer: string[]): Promise<ProgressionFromAPI>;
 };
 export declare type Options = {
     services: Services;

package/es/views/slides/index.d.ts

@@ -86,5 +86,6 @@ export declare type SlidesViewProps = {
     };
 };
 export declare const initialState: SlidesStack;
+export declare const buildStepItems: (state: StoreState) => StepItem[];
 export declare const mapStateToSlidesProps: (state: StoreState, dispatch: Dispatch) => SlidesViewProps;
 export {};

package/es/views/slides/index.js

@@ -1,7 +1,8 @@
 import concat from 'lodash/fp/concat';
+import findLast from 'lodash/fp/findLast';
 import get from 'lodash/fp/get';
 import getOr from 'lodash/fp/getOr';
-import isEmpty from 'lodash/fp/isEmpty';
+import last from 'lodash/fp/last';
 import pipe from 'lodash/fp/pipe';
 import reduce from 'lodash/fp/reduce';
 import set from 'lodash/fp/set';
@@ -73,7 +74,14 @@ const buildStackSlides = (state, dispatch) => {
     }, initialState, initialState);
     return stack;
 };
-const buildStepItems = (state) => {
+const getIconForCurrentStep = (slideRef, lastGivenAnswerForSlide, currentSlideRef, lastGivenAsnswer) => {
+    if (slideRef !== currentSlideRef)
+        return lastGivenAnswerForSlide.isCorrect ? 'right' : 'wrong';
+    if (lastGivenAsnswer.slideRef !== slideRef)
+        return 'no-answer';
+    return lastGivenAnswerForSlide.isCorrect ? 'right' : 'wrong';
+};
+export const buildStepItems = (state) => {
     const { progression } = state.data;
     const { currentSlideRef } = state.ui;
     if (!progression)
@@ -105,22 +113,30 @@ const buildStepItems = (state) => {
             value: '5'
         }
     ];
+    const slideRefs = getProgressionSlidesRefs(progression);
     const allAnswers = progression.state.allAnswers;
     const step = progression.state.step;
-    if (isEmpty(allAnswers))
+    const nextContentRef = progression.state.nextContent.ref;
+    const lastGivenAnswer = last(allAnswers);
+    if (!lastGivenAnswer)
         return defaultProps;
     const steps = defaultProps.map((stepItem, index) => {
-        const givenAnswer = allAnswers[index];
-        if (!givenAnswer) {
+        const slideRef = slideRefs[index];
+        if (!slideRef)
+            return stepItem; // non fecthed slide pour given index
+        const lastGivenAnswerForSlide = findLast(answer => answer.slideRef === slideRef, allAnswers);
+        // never answered slide
+        if (!lastGivenAnswerForSlide) {
             return {
                 ...stepItem,
-                current: step.current === index + 1
+                current: nextContentRef === currentSlideRef && step.current === index + 1
             };
         }
+        // already answered slide, we computed based on the lastGivenAnswer
         return {
             ...stepItem,
-            icon: givenAnswer.isCorrect ? 'right' : 'wrong',
-            current: givenAnswer.slideRef === currentSlideRef
+            icon: getIconForCurrentStep(slideRef, lastGivenAnswerForSlide, currentSlideRef, lastGivenAnswer),
+            current: lastGivenAnswerForSlide.slideRef === currentSlideRef
         };
     });
     return steps;