@coorpacademy/app-review 0.1.14 → 0.1.16

package/src/reducers/ui/test/navigation.test.ts

@@ -0,0 +1,19 @@
+import test from 'ava';
+import reducer from '../navigation';
+import {NavigateTo, NAVIGATE_TO, NAVIGATE_BACK} from '../../../actions/ui/navigation';
+
+test('should have inital value', t => {
+  const state = reducer(undefined, {} as NavigateTo);
+  t.deepEqual(state, []);
+});
+
+test('should set the value of NAVIGATE_TO and NAVIGATE_BACK action', t => {
+  const state = reducer([], {type: NAVIGATE_TO, payload: 'loader'});
+  t.deepEqual(state, ['loader']);
+
+  const updatedState = reducer(state, {type: NAVIGATE_TO, payload: 'skills'});
+  t.deepEqual(updatedState, ['loader', 'skills']);
+
+  const _updatedState = reducer(updatedState, {type: NAVIGATE_BACK});
+  t.deepEqual(_updatedState, ['loader']);
+});

package/src/services/fetch-slide.ts

@@ -6,7 +6,7 @@ import {toJSON} from './tools/fetch-responses';
 
 export const fetchSlide = async (slideRef: string, token: string): Promise<SlideFromAPI | void> => {
   const {host}: JWT = decode(token);
-  const response = await crossFetch(`${host}/api/v2/slide/${slideRef}`, {
+  const response = await crossFetch(`${host}/api/v2/slide/${slideRef}/parentContentTitle`, {
     headers: {authorization: token}
   });
 

package/src/services/index.ts

@@ -2,9 +2,11 @@ import {Services} from '../types/common';
 import {fetchSkills} from './fetch-skills';
 import {postProgression} from './post-progression';
 import {fetchSlide} from './fetch-slide';
+import {postAnswer} from './post-answer';
 
 export const getServices = (): Services => ({
   fetchSkills,
   fetchSlide,
-  postProgression
+  postProgression,
+  postAnswer
 });

package/src/services/post-answer.ts

@@ -0,0 +1,27 @@
+import crossFetch from 'cross-fetch';
+import decode from 'jwt-decode';
+
+import {JWT, ProgressionFromAPI} from '../types/common';
+import {toJSON} from './tools/fetch-responses';
+
+export const postAnswer = async (
+  skillRef: string,
+  token: string,
+  progressionId: string,
+  answer: string[]
+): Promise<ProgressionFromAPI> => {
+  const {host}: JWT = decode(token);
+  const response = await crossFetch(`${host}/api/v2/progressions/${progressionId}/answers`, {
+    method: 'post',
+    headers: {authorization: token},
+    body: JSON.stringify({
+      content: {
+        ref: skillRef,
+        type: 'slide'
+      },
+      answer
+    })
+  });
+
+  return toJSON<ProgressionFromAPI>(response);
+};

package/src/services/test/fetch-slide.test.ts

@@ -0,0 +1,30 @@
+import test from 'ava';
+import nock from 'nock';
+import {qcmDragSlide} from '../../views/slides/test/fixtures/qcm-drag';
+import {fetchSlide} from '../fetch-slide';
+
+test.before(() => {
+  nock('http://localhost:3000')
+    .get('/api/v2/slide/sli_123546/parentContentTitle')
+    .reply(200, qcmDragSlide);
+});
+
+test.after(() => {
+  nock.cleanAll();
+});
+
+test('should fetch a slide with the parentTitleContent info successfully', async t => {
+  const token = process.env.API_TEST_TOKEN || '';
+  const slide = await fetchSlide('sli_123546', token);
+  t.deepEqual(qcmDragSlide, slide);
+});
+
+test('should reject if a bad token is passed', async t => {
+  const badToken = 'token is not a jwt';
+  const error = await t.throwsAsync(() => fetchSlide('sli_123546', badToken));
+
+  t.is(
+    error?.message,
+    "Invalid token specified: Cannot read properties of undefined (reading 'replace')"
+  );
+});

package/src/services/test/post-answer.test.ts

@@ -0,0 +1,68 @@
+import test from 'ava';
+import nock from 'nock';
+import type {ProgressionFromAPI} from '../../types/common';
+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 result: ProgressionFromAPI = {
+  content: {
+    type: 'skill',
+    ref: skillRef
+  },
+  engine: {
+    ref: 'review'
+  },
+  _id: '123456123456',
+  state: {
+    allAnswers: [
+      {
+        slideRef: 'sli_NkvrWPFF2',
+        isCorrect: true,
+        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(() => {
+  const moocApi = nock('http://localhost:3000');
+  moocApi.post(`/api/v2/progressions/${progressionId}/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);
+  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));
+
+  t.is(
+    error?.message,
+    "Invalid token specified: Cannot read properties of undefined (reading 'replace')"
+  );
+});

package/src/services/test/post-progression.test.ts

@@ -6,16 +6,26 @@ import {postProgression} from '../post-progression';
 const skillRef = '_skill-ref';
 const result: ProgressionFromAPI = {
   _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
   }
 };
 

package/src/test/util/services.mock.ts

@@ -1,4 +1,4 @@
-import {qcmSlide} from '../../helpers/test/fixtures/qcm';
+import {freeTextSlide} from '../../views/slides/test/fixtures/free-text';
 import {Services} from '../../types/common';
 
 export const services: Services = {
@@ -19,21 +19,63 @@ export const services: Services = {
     ]);
   },
   fetchSlide: ref => {
-    return Promise.resolve({...qcmSlide, universalRef: ref, id: ref});
+    return Promise.resolve({...freeTextSlide, universalRef: ref, id: ref});
   },
   postProgression: () => {
     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: () => {
+    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/src/types/common.ts

@@ -1,4 +1,5 @@
-import {UISlide} from './slides';
+import {SlideIndexes} from '../common';
+import {AnswerUI} from './slides';
 
 // TODO use type from components
 type TemplateContextValues = {
@@ -24,25 +25,25 @@ type BaseContent = {
   choices: ChoiceFromAPI[];
 };
 
-type Question = {
+type BaseQuestion = {
   header?: string;
   content: BaseContent;
   explanation?: string;
 };
 
-export type QcmQuestion = Question & {
+export type QcmQuestion = BaseQuestion & {
   type: 'qcm';
 };
 
-export type QcmGraphicQuestion = Question & {
+export type QcmGraphicQuestion = BaseQuestion & {
   type: 'qcmGraphic';
 };
 
-export type QcmDragQuestion = Question & {
+export type QcmDragQuestion = BaseQuestion & {
   type: 'qcmDrag';
 };
 
-export type BasicQuestion = Omit<Question, 'content'> & {
+export type BasicQuestion = Omit<BaseQuestion, 'content'> & {
   type: 'basic';
   content: {
     media?: unknown;
@@ -52,7 +53,7 @@ export type BasicQuestion = Omit<Question, 'content'> & {
   };
 };
 
-export type SliderQuestion = Omit<Question, 'content'> & {
+export type SliderQuestion = Omit<BaseQuestion, 'content'> & {
   content: {
     media?: unknown;
     unitLabel: string;
@@ -63,42 +64,70 @@ export type SliderQuestion = Omit<Question, 'content'> & {
   type: 'slider';
 };
 
-export type TemplateQuestion = Omit<Question, 'content'> & {
+export type TemplateQuestion = Omit<BaseQuestion, 'content'> & {
   content: BaseContent & {
     template: string;
   };
   type: 'template';
 };
 
+export type Question =
+  | QcmQuestion
+  | QcmGraphicQuestion
+  | QcmDragQuestion
+  | BasicQuestion
+  | SliderQuestion
+  | TemplateQuestion;
+
 export 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';
+  };
+};
+
+type ProgressionAnswerItem = {
+  isCorrect: boolean;
+  slideRef: string;
+  answer: string[];
+};
+
+export 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 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 type Skill = {
@@ -112,6 +141,12 @@ export 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 type Options = {
@@ -137,31 +172,33 @@ export type JWT = {
   host: string;
 };
 
-// -----------------------------------------------------------------------------
 type SlideUIAnimations = 'unstack' | 'restack';
-export type Slide = UISlide & {
+
+export 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'>;
 };
 
-const ICON_VALUES = {
-  right: 'right',
-  wrong: 'wrong',
-  'no-answer': 'no-answer'
-} as const;
+export type UISlide = {
+  questionText?: string;
+  answerUI?: AnswerUI;
+  hidden?: boolean;
+  position: number;
+  animationType?: SlideUIAnimations;
+  isCorrect?: boolean;
+  endReview?: boolean;
+  nextContent?: NextUISlide;
+};
 
-export type IconValue = keyof typeof ICON_VALUES;
 export type FinishedSlides = {
-  slideNumbers: number[];
-  [key: number]: true;
+  [key in SlideIndexes]?: true;
 };
 
-// -----------------------------------------------------------------------------
-
 export type WithRequired<T, K extends keyof T> = T & {
   // the "-" is a Mapping Modifier, removes optionality from a prop
   [P in K]-?: T[P];

package/src/types/slides.ts

@@ -94,8 +94,3 @@ export type AnswerUI = {
 };
 
 export type SlideUIAnimations = 'unstack' | 'restack';
-
-export type UISlide = {
-  questionText?: string;
-  answerUI?: AnswerUI;
-};

package/src/views/skills/index.ts

@@ -0,0 +1,56 @@
+import {StoreState} from '../../reducers';
+
+type SkillCard = {
+  'aria-label': string;
+  skillTitle: string;
+  skillAriaLabel: string;
+  buttonLabel: string;
+  buttonAriaLabel: string;
+  reviseLabel: string;
+  reviseAriaLabel: string;
+  isCustom: boolean;
+  onClick: Function;
+};
+
+type NoSkillsProps = {
+  titleNoSkills: string;
+  textNoSkills: string;
+  iconSkillAriaLabel: string;
+};
+
+type SkillsProps = NoSkillsProps & {
+  'aria-label'?: string;
+  title: string;
+  isLoading?: boolean;
+  isLoadingAriaLabel: string;
+  listSkills: SkillCard[];
+};
+
+export {SkillsProps};
+
+export const mapStateToSkillsProps = (state: StoreState): SkillsProps | null => {
+  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(skill => ({
+      '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: () => console.log('@todo plug dispatcher select skill')
+    }))
+  };
+};