@coorpacademy/app-review 0.1.14 → 0.1.16

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

@@ -0,0 +1,111 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 result = {
+    content: {
+        type: 'skill',
+        ref: skillRef
+    },
+    engine: {
+        ref: 'review'
+    },
+    _id: '123456123456',
+    state: {
+        allAnswers: [
+            {
+                slideRef: 'sli_NkvrWPFF2',
+                isCorrect: true,
+                answer: answer
+            }
+        ],
+        isCorrect: true,
+        nextContent: {
+            type: 'slide',
+            ref: 'sli_NJ3m5KtWh'
+        },
+        pendingSlides: [],
+        slides: ['sli_NkvrWPFF2'],
+        content: {
+            ref: 'sli_NkvrWPFF2',
+            type: 'slide'
+        },
+        step: {
+            current: 2
+        },
+        stars: 4
+    }
+};
+test.before(function () {
+    var moocApi = nock('http://localhost:3000');
+    moocApi.post("/api/v2/progressions/".concat(progressionId, "/answers")).reply(200, result);
+});
+test.after(function () {
+    nock.cleanAll();
+});
+test('should post the answers successfully', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var token, progression;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                token = process.env.API_TEST_TOKEN || '';
+                return [4 /*yield*/, postAnswer(skillRef, token, progressionId, answer)];
+            case 1:
+                progression = _a.sent();
+                t.deepEqual(result, progression);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test('should reject bad token', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var badToken, error;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                badToken = 'token is not a jwt';
+                return [4 /*yield*/, t.throwsAsync(function () { return postAnswer(skillRef, badToken, progressionId, 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')");
+                return [2 /*return*/];
+        }
+    });
+}); });

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

@@ -40,16 +40,26 @@ import { postProgression } from '../post-progression';
 var skillRef = '_skill-ref';
 var result = {
     _id: '123456123456',
+    content: {
+        ref: '_skill-ref',
+        type: 'skill'
+    },
+    engine: {
+        ref: 'review'
+    },
     state: {
+        allAnswers: [],
         isCorrect: true,
-        step: {
-            current: 1
-        },
         nextContent: {
             type: 'slide',
             ref: 'sli_NJ3m5KtWh'
         },
-        pendingSlides: []
+        pendingSlides: [],
+        slides: [],
+        step: {
+            current: 1
+        },
+        stars: 0
     }
 };
 test.before(function () {

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

@@ -9,7 +9,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { qcmSlide } from '../../helpers/test/fixtures/qcm';
+import { freeTextSlide } from '../../views/slides/test/fixtures/free-text';
 export var services = {
     fetchSkills: function () {
         return Promise.resolve([
@@ -28,21 +28,63 @@ export var services = {
         ]);
     },
     fetchSlide: function (ref) {
-        return Promise.resolve(__assign(__assign({}, qcmSlide), { universalRef: ref, id: ref }));
+        return Promise.resolve(__assign(__assign({}, freeTextSlide), { universalRef: ref, id: ref }));
     },
     postProgression: function () {
         return Promise.resolve({
             _id: '62b1d1087aa12f00253f40ee',
+            content: {
+                ref: '_skill-ref',
+                type: 'skill'
+            },
+            engine: {
+                ref: 'review'
+            },
             state: {
+                allAnswers: [],
+                isCorrect: true,
+                nextContent: {
+                    ref: 'sli_N1XACJobn',
+                    type: 'slide'
+                },
                 pendingSlides: [],
+                slides: [],
                 step: {
                     current: 1
                 },
+                stars: 0
+            }
+        });
+    },
+    postAnswer: function () {
+        return Promise.resolve({
+            _id: '62b1d1087aa12f00253f40ee',
+            content: {
+                ref: '_skill-ref',
+                type: 'skill'
+            },
+            engine: {
+                ref: 'review'
+            },
+            state: {
+                allAnswers: [
+                    {
+                        slideRef: 'sli_N1XACJobn',
+                        isCorrect: true,
+                        answer: ['Le créateur peut fixer un pourcentage pour chaque transaction future']
+                    }
+                ],
                 isCorrect: true,
                 nextContent: {
-                    ref: 'sli_N1XACJobn',
+                    ref: 'sli_VkSQroQnx',
                     type: 'slide'
-                }
+                },
+                pendingSlides: [],
+                slides: ['sli_N1XACJobn'],
+                step: {
+                    current: 2
+                },
+                stars: 4
             }
         });
     }

package/lib/types/common.d.ts

@@ -1,4 +1,5 @@
-import { UISlide } from './slides';
+import { SlideIndexes } from '../common';
+import { AnswerUI } from './slides';
 declare type TemplateContextValues = {
     brandTheme?: unknown;
     theme?: unknown;
@@ -22,21 +23,21 @@ declare type BaseContent = {
     media?: unknown;
     choices: ChoiceFromAPI[];
 };
-declare type Question = {
+declare type BaseQuestion = {
     header?: string;
     content: BaseContent;
     explanation?: string;
 };
-export declare type QcmQuestion = Question & {
+export declare type QcmQuestion = BaseQuestion & {
     type: 'qcm';
 };
-export declare type QcmGraphicQuestion = Question & {
+export declare type QcmGraphicQuestion = BaseQuestion & {
     type: 'qcmGraphic';
 };
-export declare type QcmDragQuestion = Question & {
+export declare type QcmDragQuestion = BaseQuestion & {
     type: 'qcmDrag';
 };
-export declare type BasicQuestion = Omit<Question, 'content'> & {
+export declare type BasicQuestion = Omit<BaseQuestion, 'content'> & {
     type: 'basic';
     content: {
         media?: unknown;
@@ -45,7 +46,7 @@ export declare type BasicQuestion = Omit<Question, 'content'> & {
         id: string;
     };
 };
-export declare type SliderQuestion = Omit<Question, 'content'> & {
+export declare type SliderQuestion = Omit<BaseQuestion, 'content'> & {
     content: {
         media?: unknown;
         unitLabel: string;
@@ -55,34 +56,59 @@ export declare type SliderQuestion = Omit<Question, 'content'> & {
     };
     type: 'slider';
 };
-export declare type TemplateQuestion = Omit<Question, 'content'> & {
+export declare type TemplateQuestion = Omit<BaseQuestion, 'content'> & {
     content: BaseContent & {
         template: string;
     };
     type: 'template';
 };
+export declare type Question = QcmQuestion | QcmGraphicQuestion | QcmDragQuestion | BasicQuestion | SliderQuestion | TemplateQuestion;
 export declare type SlideFromAPI = {
-    question: QcmQuestion | QcmGraphicQuestion | QcmDragQuestion | BasicQuestion | SliderQuestion | TemplateQuestion;
+    question: Question;
     klf: string;
     universalRef: string;
     tips?: string;
     clue?: string;
     hasClue?: boolean;
-    id?: string;
+    id: string;
+    parentContentTitle: {
+        title: string;
+        type: 'chapter' | 'course';
+    };
+};
+declare type ProgressionAnswerItem = {
+    isCorrect: boolean;
+    slideRef: string;
+    answer: string[];
+};
+export declare type ProgressionState = {
+    allAnswers: ProgressionAnswerItem[];
+    content?: {
+        ref: string;
+        type: string;
+    };
+    isCorrect: boolean;
+    nextContent: {
+        type: 'success' | 'slide';
+        ref: 'successExitNode' | string;
+    };
+    pendingSlides: string[];
+    slides: string[];
+    step: {
+        current: number;
+    };
+    stars: number;
 };
 export declare type ProgressionFromAPI = {
     _id: string;
-    state: {
-        isCorrect: boolean;
-        step: {
-            current: number;
-        };
-        nextContent: {
-            type: 'success' | 'slide';
-            ref: 'successExitNode' | string;
-        };
-        pendingSlides: [];
+    content: {
+        type: 'skill';
+        ref: string;
     };
+    engine: {
+        ref: 'review';
+    };
+    state: ProgressionState;
 };
 export declare type Skill = {
     skillRef: string;
@@ -94,6 +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>;
 };
 export declare type Options = {
     services: Services;
@@ -116,23 +143,27 @@ export declare type JWT = {
     host: string;
 };
 declare type SlideUIAnimations = 'unstack' | 'restack';
-export declare type Slide = UISlide & {
+export declare type NextUISlide = {
+    questionText?: string;
+    answerUI?: AnswerUI;
     hidden?: boolean;
-    position: number;
+    position?: number;
     animationType?: SlideUIAnimations;
     isCorrect?: boolean;
     endReview?: boolean;
-    nextContent?: Omit<Slide, 'endReview' | 'hidden' | 'position' | 'nextContent'>;
 };
-declare const ICON_VALUES: {
-    readonly right: "right";
-    readonly wrong: "wrong";
-    readonly 'no-answer': "no-answer";
+export declare type UISlide = {
+    questionText?: string;
+    answerUI?: AnswerUI;
+    hidden?: boolean;
+    position: number;
+    animationType?: SlideUIAnimations;
+    isCorrect?: boolean;
+    endReview?: boolean;
+    nextContent?: NextUISlide;
 };
-export declare type IconValue = keyof typeof ICON_VALUES;
 export declare type FinishedSlides = {
-    slideNumbers: number[];
-    [key: number]: true;
+    [key in SlideIndexes]?: true;
 };
 export declare type WithRequired<T, K extends keyof T> = T & {
     [P in K]-?: T[P];

package/lib/types/common.js

@@ -1,6 +1 @@
-var ICON_VALUES = {
-    right: 'right',
-    wrong: 'wrong',
-    'no-answer': 'no-answer'
-};
 export {};

package/lib/types/slides.d.ts

@@ -74,7 +74,3 @@ export declare type AnswerUI = {
     help: string;
 };
 export declare type SlideUIAnimations = 'unstack' | 'restack';
-export declare type UISlide = {
-    questionText?: string;
-    answerUI?: AnswerUI;
-};

package/{es/types/views/skills.d.ts → lib/views/skills/index.d.ts}

@@ -1,3 +1,4 @@
+import { StoreState } from '../../reducers';
 declare type SkillCard = {
     'aria-label': string;
     skillTitle: string;
@@ -22,3 +23,4 @@ declare type SkillsProps = NoSkillsProps & {
     listSkills: SkillCard[];
 };
 export { SkillsProps };
+export declare const mapStateToSkillsProps: (state: StoreState) => SkillsProps | null;

package/lib/views/skills/index.js

@@ -0,0 +1,25 @@
+export var mapStateToSkillsProps = function (state) {
+    if (!state.data.skills) {
+        return null;
+    }
+    return {
+        title: '@todo title',
+        titleNoSkills: '@todo titleNoSkills',
+        textNoSkills: '@todo textNoSkills',
+        iconSkillAriaLabel: '@todo iconSkillAriaLabel',
+        isLoading: false,
+        isLoadingAriaLabel: '@todo loading',
+        listSkills: state.data.skills.map(function (skill) { return ({
+            'aria-label': '',
+            isCustom: skill.custom,
+            skillTitle: skill.name,
+            skillAriaLabel: '@todo skill aria label',
+            buttonLabel: '@todo button',
+            buttonAriaLabel: '@todo button aria label',
+            reviseLabel: '@todo revise',
+            reviseAriaLabel: '@todo revise aria label',
+            // eslint-disable-next-line no-console
+            onClick: function () { return console.log('@todo plug dispatcher select skill'); }
+        }); })
+    };
+};

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

@@ -0,0 +1,79 @@
+import { Dispatch } from 'redux';
+import { UISlide } from '../../types/common';
+import { SlideIndexes } from '../../common';
+import { StoreState } from '../../reducers';
+declare const ICON_VALUES: {
+    readonly right: "right";
+    readonly wrong: "wrong";
+    readonly 'no-answer': "no-answer";
+};
+declare type IconValue = keyof typeof ICON_VALUES;
+declare type StepItem = {
+    current: boolean;
+    icon: IconValue;
+    value: string;
+};
+declare type SlidesStack = {
+    [key in SlideIndexes]: UISlide;
+};
+export declare type CorrectionPopinProps = {
+    klf: {
+        label: string;
+        onClick: Function;
+        tooltip: string;
+    };
+    information: {
+        label: string;
+        message: string;
+    };
+    next: {
+        label: string;
+        ariaLabel: string;
+    };
+    successLabel: string;
+    failureLabel: string;
+};
+export declare type SlidesViewProps = {
+    header: {
+        mode: string;
+        skillName: string;
+        onQuitClick: Function;
+        'aria-label'?: string;
+        closeButtonAriaLabel: string;
+        steps: StepItem[];
+    };
+    stack: {
+        slides: SlidesStack;
+        validateButton: {
+            label: string;
+            disabled: boolean;
+            onClick: Function;
+        };
+        correctionPopinProps?: CorrectionPopinProps;
+        endReview: boolean;
+    };
+    reviewBackgroundAriaLabel?: string;
+    congratsProps?: {
+        'aria-label'?: string;
+        'data-name'?: string;
+        animationLottie: unknown;
+        title: string;
+        cardCongratsStar: unknown;
+        cardCongratsRank: unknown;
+        buttonRevising: {
+            'aria-label'?: string;
+            label: string;
+            onClick: Function;
+            type: string;
+        };
+        buttonRevisingSkill: {
+            'aria-label'?: string;
+            label: string;
+            onClick: Function;
+            type: string;
+        };
+    };
+};
+export declare const initialState: SlidesStack;
+export declare const mapStateToSlidesProps: (state: StoreState, dispatch: Dispatch) => SlidesViewProps | null;
+export {};

package/lib/views/slides/index.js

@@ -0,0 +1,155 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import concat from 'lodash/fp/concat';
+import get from 'lodash/fp/get';
+import getOr from 'lodash/fp/getOr';
+import isEmpty from 'lodash/fp/isEmpty';
+import pipe from 'lodash/fp/pipe';
+import reduce from 'lodash/fp/reduce';
+import set from 'lodash/fp/set';
+import slice from 'lodash/fp/slice';
+import toInteger from 'lodash/fp/toInteger';
+import { mapApiSlideToUi } from './map-api-slide-to-ui';
+var ICON_VALUES = {
+    right: 'right',
+    wrong: 'wrong',
+    'no-answer': 'no-answer'
+};
+export var initialState = {
+    '0': {
+        hidden: false,
+        position: 0
+    },
+    '1': {
+        hidden: false,
+        position: 1
+    },
+    '2': {
+        hidden: false,
+        position: 2
+    },
+    '3': {
+        hidden: false,
+        position: 3
+    },
+    '4': {
+        hidden: false,
+        position: 4
+    }
+};
+var getProgressionSlidesRef = function (progression) {
+    if (progression.state.step.current < 5) {
+        var slideRef = progression.state.nextContent.ref;
+        return concat([slideRef], progression.state.slides);
+    }
+    return slice(0, 5, progression.state.slides);
+};
+var buildStackSlides = function (state, dispatch) {
+    var currentSlideRef = state.ui.currentSlideRef;
+    var progression = state.data.progression;
+    if (!currentSlideRef || !progression)
+        return initialState;
+    var slideRefs = getProgressionSlidesRef(progression);
+    // @ts-expect-error typescript does not support capped versions of lodash functions
+    var stack = reduce.convert({ cap: false })(function (acc, uiSlide, index) {
+        var slideRef = slideRefs[toInteger(index)];
+        if (!slideRef)
+            return set(index, uiSlide, acc);
+        var slideFromAPI = get(slideRef, state.data.slides);
+        var answers = state.ui.answers;
+        var _a = mapApiSlideToUi(dispatch)(slideFromAPI, answers), questionText = _a.questionText, answerUI = _a.answerUI;
+        var parentContentTitle = getOr('', 'parentContentTitle.title', slideFromAPI);
+        var parentContentType = getOr('', 'parentContentTitle.type', slideFromAPI);
+        var updatedUiSlide = pipe(set(['questionText'], questionText), set(['answerUI'], answerUI), set(['parentContentTitle'], "From \"".concat(parentContentTitle, "\" ").concat(parentContentType)) // TODO translate: -From- .... -Course/chapter-
+        // TODO: Set position according to currentSlideRef et slideRefs (or maybe a value on the state ui.slidePositions !!)
+        )(uiSlide);
+        return set(index, updatedUiSlide, acc);
+    }, initialState, initialState);
+    return stack;
+};
+var buildStepItems = function (state) {
+    var progression = state.data.progression;
+    var currentSlideRef = state.ui.currentSlideRef;
+    if (!progression)
+        return [];
+    var defaultProps = [
+        {
+            icon: 'no-answer',
+            current: true,
+            value: '1'
+        },
+        {
+            icon: 'no-answer',
+            current: false,
+            value: '2'
+        },
+        {
+            icon: 'no-answer',
+            current: false,
+            value: '3'
+        },
+        {
+            icon: 'no-answer',
+            current: false,
+            value: '4'
+        },
+        {
+            icon: 'no-answer',
+            current: false,
+            value: '5'
+        }
+    ];
+    var allAnswers = progression.state.allAnswers;
+    var step = progression.state.step;
+    if (isEmpty(allAnswers))
+        return defaultProps;
+    var steps = defaultProps.map(function (stepItem, index) {
+        var givenAnswer = allAnswers[index];
+        if (!givenAnswer) {
+            return __assign(__assign({}, stepItem), { current: step.current === index + 1 });
+        }
+        return __assign(__assign({}, stepItem), { icon: givenAnswer.isCorrect ? 'right' : 'wrong', current: givenAnswer.slideRef === currentSlideRef });
+    });
+    return steps;
+};
+export var mapStateToSlidesProps = function (state, dispatch) {
+    if (!state.data.slides) {
+        return null;
+    }
+    return {
+        header: {
+            mode: '__revision_mode',
+            skillName: '__agility',
+            onQuitClick: function () {
+                // eslint-disable-next-line no-console
+                console.log('onQuitClick');
+            },
+            'aria-label': 'aria-header-wrapper',
+            closeButtonAriaLabel: 'aria-close-button',
+            steps: buildStepItems(state)
+        },
+        stack: {
+            slides: buildStackSlides(state, dispatch),
+            validateButton: {
+                label: '__validate',
+                disabled: true,
+                onClick: function () {
+                    // eslint-disable-next-line no-console
+                    console.log('TODO: validate question');
+                }
+            },
+            correctionPopinProps: undefined,
+            endReview: false
+        },
+        congratsProps: undefined
+    };
+};

package/lib/views/slides/map-api-slide-to-ui.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch } from 'redux';
+import { AnswerUI } from '../../types/slides';
+import { Question, SlideFromAPI } from '../../types/common';
+export declare const getQuestionType: (question: Question) => Question['type'];
+export declare const mapApiSlideToUi: (dispatch: Dispatch) => (slide: SlideFromAPI, answers: string[]) => {
+    questionText: string;
+    answerUI: AnswerUI;
+};