@coorpacademy/app-review 0.1.19 → 0.1.20

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

@@ -43,27 +43,28 @@ export var POST_ANSWER_FAILURE = '@@answer/POST_FAILURE';
 export var postAnswer = function (dispatch, getState, _a) {
     var services = _a.services;
     return __awaiter(void 0, void 0, void 0, function () {
-        var action, response, progression, slideRef;
+        var state, token, answer, progression, action, response, updatedProgression, slideRef;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    state = getState();
+                    token = get('data.token', state);
+                    answer = get('ui.answers', state);
+                    progression = state.data.progression;
+                    if (!progression)
+                        throw new Error('cannot answer question of inexisting progression');
                     action = buildTask({
                         types: [POST_ANSWER_REQUEST, POST_ANSWER_SUCCESS, POST_ANSWER_FAILURE],
                         task: function () {
-                            var state = getState();
-                            var token = get('data.token', state);
-                            var answer = get('ui.answers', state);
-                            var progressionId = get('data.progression._id', state);
-                            var skillRef = get('data.progression.content.ref', state);
-                            return services.postAnswer(skillRef, token, progressionId, answer);
+                            return services.postAnswer(progression, token, answer);
                         }
                     });
                     return [4 /*yield*/, dispatch(action)];
                 case 1:
                     response = _b.sent();
                     if (!(response.type === POST_ANSWER_SUCCESS)) return [3 /*break*/, 3];
-                    progression = response.payload;
-                    slideRef = progression.state.nextContent.ref;
+                    updatedProgression = response.payload;
+                    slideRef = updatedProgression.state.nextContent.ref;
                     return [4 /*yield*/, dispatch(fetchSlide(slideRef))];
                 case 2:
                     _b.sent();

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

@@ -48,7 +48,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var _a;
 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';
@@ -69,7 +69,7 @@ var initialState = {
                 allAnswers: [],
                 isCorrect: true,
                 nextContent: {
-                    ref: 'sli_VJYjJnJhg',
+                    ref: freeTextSlide.id,
                     type: 'slide'
                 },
                 pendingSlides: [],
@@ -87,7 +87,7 @@ var initialState = {
         token: '1234'
     },
     ui: {
-        currentSlideRef: 'sli_VJYjJnJhg',
+        currentSlideRef: freeTextSlide.id,
         navigation: ['skills', 'slides'],
         answers: answer,
         slide: {
@@ -104,12 +104,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/lib/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', function (t) {
     var state = reducer(undefined, {});
     t.is(state, null);
@@ -17,7 +18,7 @@ test('should set the value of POST_PROGRESSION_SUCCESS action', function (t) {
 test('should set the value of POST_ANSWER_SUCCESS action', function (t) {
     var state = reducer(null, {
         type: POST_ANSWER_SUCCESS,
-        payload: postAnswerResponse
+        payload: postAnswerResponses[freeTextSlide.universalRef]
     });
-    t.deepEqual(state, postAnswerResponse);
+    t.deepEqual(state, postAnswerResponses[freeTextSlide.universalRef]);
 });

package/lib/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/lib/services/post-answer.js

@@ -37,11 +37,13 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import crossFetch from 'cross-fetch';
 import decode from 'jwt-decode';
 import { toJSON } from './tools/fetch-responses';
-export var postAnswer = function (skillRef, token, progressionId, answer) { return __awaiter(void 0, void 0, void 0, function () {
-    var host, response;
+export var postAnswer = function (progression, token, answer) { return __awaiter(void 0, void 0, void 0, function () {
+    var progressionId, skillRef, host, response;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
+                progressionId = progression._id;
+                skillRef = progression.content.ref;
                 host = decode(token).host;
                 return [4 /*yield*/, crossFetch("".concat(host, "/api/v2/progressions/").concat(progressionId, "/answers"), {
                         method: 'post',

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

@@ -37,9 +37,32 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import test from 'ava';
 import nock from 'nock';
 import { postAnswer } from '../post-answer';
-var progressionId = '123456789123';
 var skillRef = '_skill-ref';
 var answer = ['Lister vos tâches pour vous libérer l’esprit', 'Vous isoler dans un lieu calme'];
+var 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
+    }
+};
 var result = {
     content: {
         type: 'skill',
@@ -76,7 +99,7 @@ var result = {
 };
 test.before(function () {
     var moocApi = nock('http://localhost:3000');
-    moocApi.post("/api/v2/progressions/".concat(progressionId, "/answers")).reply(200, result);
+    moocApi.post('/api/v2/progressions/123456123456/answers').reply(200, result);
 });
 test.after(function () {
     nock.cleanAll();
@@ -87,7 +110,7 @@ test('should post the answers successfully', function (t) { return __awaiter(voi
         switch (_a.label) {
             case 0:
                 token = process.env.API_TEST_TOKEN || '';
-                return [4 /*yield*/, postAnswer(skillRef, token, progressionId, answer)];
+                return [4 /*yield*/, postAnswer(initProgression, token, answer)];
             case 1:
                 progression = _a.sent();
                 t.deepEqual(result, progression);
@@ -101,7 +124,7 @@ test('should reject bad token', function (t) { return __awaiter(void 0, void 0,
         switch (_a.label) {
             case 0:
                 badToken = 'token is not a jwt';
-                return [4 /*yield*/, t.throwsAsync(function () { return postAnswer(skillRef, badToken, progressionId, answer); })];
+                return [4 /*yield*/, t.throwsAsync(function () { return postAnswer(initProgression, badToken, answer); })];
             case 1:
                 error = _a.sent();
                 t.is(error === null || error === void 0 ? void 0 : error.message, "Invalid token specified: Cannot read properties of undefined (reading 'replace')");

package/lib/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/lib/test/util/services.mock.js

@@ -9,11 +9,20 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var _a;
+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';
+var content = {
+    ref: '_skill-ref',
+    type: 'skill'
+};
+var engine = {
+    ref: 'review'
+};
 var getSlideFixture = function (ref) {
     switch (ref) {
         case qcmSlide.universalRef:
@@ -44,18 +53,13 @@ var fetchSkillsResponse = [
 ];
 export var postProgressionResponse = {
     _id: '62b1d1087aa12f00253f40ee',
-    content: {
-        ref: '_skill-ref',
-        type: 'skill'
-    },
-    engine: {
-        ref: 'review'
-    },
+    content: content,
+    engine: engine,
     state: {
         allAnswers: [],
         isCorrect: true,
         nextContent: {
-            ref: 'sli_VJYjJnJhg',
+            ref: freeTextSlide.universalRef,
             type: 'slide'
         },
         pendingSlides: [],
@@ -66,43 +70,281 @@ export var postProgressionResponse = {
         stars: 0
     }
 };
-export var postAnswerResponse = {
-    _id: '62b1d1087aa12f00253f40ee',
-    content: {
-        ref: '_skill-ref',
-        type: 'skill'
+export var postAnswerResponses = (_a = {},
+    _a[freeTextSlide.universalRef] = {
+        _id: '62b1d1087aa12f00253f40ee',
+        content: content,
+        engine: 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
+        }
     },
-    engine: {
-        ref: 'review'
+    _a[qcmGraphicSlide.universalRef] = {
+        _id: '62b1d1087aa12f00253f40ee',
+        content: content,
+        engine: 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
+        }
+    },
+    _a[qcmSlide.universalRef] = {
+        _id: '62b1d1087aa12f00253f40ee',
+        content: content,
+        engine: 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
+        }
+    },
+    _a[sliderSlide.universalRef] = {
+        _id: '62b1d1087aa12f00253f40ee',
+        content: content,
+        engine: 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
+        }
+    },
+    _a[templateSlide.universalRef] = {
+        _id: '62b1d1087aa12f00253f40ee',
+        content: content,
+        engine: 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
+        }
     },
+    _a);
+export var progressionSlideWithPendingSlide = {
+    _id: '62b1d1087aa12f00253f40ee',
+    content: content,
+    engine: 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 var services = {
     fetchSkills: function () { return Promise.resolve(fetchSkillsResponse); },
     fetchSlide: function (ref) { return Promise.resolve(__assign(__assign({}, getSlideFixture(ref)), { universalRef: ref, id: ref })); },
     postProgression: function () { return Promise.resolve(postProgressionResponse); },
-    postAnswer: function () { return Promise.resolve(postAnswerResponse); }
+    postAnswer: function (progression) {
+        var currentSlide = progression.state.nextContent.ref;
+        return Promise.resolve(get(currentSlide, postAnswerResponses));
+    }
 };

package/lib/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/lib/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/lib/views/slides/index.js

@@ -10,9 +10,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 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';
@@ -84,7 +85,14 @@ var buildStackSlides = function (state, dispatch) {
     }, initialState, initialState);
     return stack;
 };
-var buildStepItems = function (state) {
+var getIconForCurrentStep = function (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 var buildStepItems = function (state) {
     var progression = state.data.progression;
     var currentSlideRef = state.ui.currentSlideRef;
     if (!progression)
@@ -116,16 +124,24 @@ var buildStepItems = function (state) {
             value: '5'
         }
     ];
+    var slideRefs = getProgressionSlidesRefs(progression);
     var allAnswers = progression.state.allAnswers;
     var step = progression.state.step;
-    if (isEmpty(allAnswers))
+    var nextContentRef = progression.state.nextContent.ref;
+    var lastGivenAnswer = last(allAnswers);
+    if (!lastGivenAnswer)
         return defaultProps;
     var steps = defaultProps.map(function (stepItem, index) {
-        var givenAnswer = allAnswers[index];
-        if (!givenAnswer) {
-            return __assign(__assign({}, stepItem), { current: step.current === index + 1 });
+        var slideRef = slideRefs[index];
+        if (!slideRef)
+            return stepItem; // non fecthed slide pour given index
+        var lastGivenAnswerForSlide = findLast(function (answer) { return answer.slideRef === slideRef; }, allAnswers);
+        // never answered slide
+        if (!lastGivenAnswerForSlide) {
+            return __assign(__assign({}, stepItem), { current: nextContentRef === currentSlideRef && step.current === index + 1 });
         }
-        return __assign(__assign({}, stepItem), { icon: givenAnswer.isCorrect ? 'right' : 'wrong', current: givenAnswer.slideRef === currentSlideRef });
+        // already answered slide, we computed based on the lastGivenAnswer
+        return __assign(__assign({}, stepItem), { icon: getIconForCurrentStep(slideRef, lastGivenAnswerForSlide, currentSlideRef, lastGivenAnswer), current: lastGivenAnswerForSlide.slideRef === currentSlideRef });
     });
     return steps;
 };