(SBL-501) Feature: Results review mechanics

api/seeds/testData/lessons.js

@@ -67,6 +67,33 @@ export const russian = {
   },
 };
 
+export const ukrainian = {
+  id: 10005,
+  name: 'Ukrainian',
+  status: 'Public',
+  _blocks: {
+    _indexesOfInteractive: [0],
+    _current: [
+      {
+        id: '0b7e5d54-a78c-4340-abec-ee08713d43bc',
+        block_id: '7142e20a-0d30-47e5-aea8-546e1ec5e395',
+        _revisions: [
+          {
+            content: {
+              data: {
+                question: 'Graded question',
+              },
+            },
+            type: 'gradedQuestion',
+            answer: {},
+            revision: '06421c44-a853-4708-8f40-81c55a0e8862',
+          },
+        ],
+      },
+    ].map(assingParents),
+  },
+};
+
 export const french = {
   id: 20003,
   name: 'French',
@@ -163,13 +190,14 @@ export const lessons = [
   literature,
   french,
   russian,
+  ukrainian,
 ].map((lesson) => ({
   id: lesson.id,
   name: lesson.name,
   status: lesson.status,
 }));
 
-export const lessonBlockStructure = [math, french, russian].reduce(
+export const lessonBlockStructure = [math, french, russian, ukrainian].reduce(
   (structure, lesson) => {
     const lessonStructure = lesson._blocks._current.map((structureItem) => ({
       id: structureItem.id,
@@ -184,21 +212,24 @@ export const lessonBlockStructure = [math, french, russian].reduce(
   [],
 );
 
-export const blocks = [math, french, russian].reduce((blocksList, lesson) => {
-  const lessonBlocks = lesson._blocks._current.reduce(
-    (revisions, structureItem) => {
-      const itemBlocks = structureItem._revisions.map((block) => ({
-        ...block,
-        block_id: structureItem.block_id,
-      }));
+export const blocks = [math, french, russian, ukrainian].reduce(
+  (blocksList, lesson) => {
+    const lessonBlocks = lesson._blocks._current.reduce(
+      (revisions, structureItem) => {
+        const itemBlocks = structureItem._revisions.map((block) => ({
+          ...block,
+          block_id: structureItem.block_id,
+        }));
 
-      return [...revisions, ...itemBlocks];
-    },
-    [],
-  );
+        return [...revisions, ...itemBlocks];
+      },
+      [],
+    );
 
-  return [...blocksList, ...lessonBlocks];
-}, []);
+    return [...blocksList, ...lessonBlocks];
+  },
+  [],
+);
 
 function assingParents(structureItem, index, list) {
   const parent = list[index - 1] || null;

api/src/config/lessonService.js

@@ -6,4 +6,5 @@ export const lessonServiceErrors = {
 
 export const lessonServiceMessages = {
   LESSON_MSG_SUCCESS_ENROLL: 'messages.success_enroll',
+  LESSON_MSG_SUCCESS_REVIEW: 'messages.success_review',
 };

api/src/models/Result.js

@@ -118,6 +118,10 @@ class Result extends BaseModel {
       throw new BadRequestError(error);
     }
   }
+
+  static setCorrectness({ resultId, correctness, meta }) {
+    return this.query().findById(resultId).patch({ correctness, meta });
+  }
 }
 
 export default Result;

api/src/models/UserRole.js

@@ -103,6 +103,7 @@ class UserRole extends BaseModel {
         .modifyGraph('results', (builder) => {
           builder.where('lesson_id', resourceId);
           builder.withGraphFetched('block');
+          builder.orderBy('created_at');
         });
     }
     return query;

api/src/services/lessons-management/controllers/reviewStudentReply.js

@@ -0,0 +1,52 @@
+const options = {
+  schema: {
+    params: { $ref: 'paramsLessonId#' },
+    body: {
+      type: 'object',
+      properties: {
+        resultId: { type: 'string' },
+        correctness: { type: 'number' },
+      },
+      required: ['resultId', 'correctness'],
+    },
+    response: {
+      '4xx': { $ref: '4xx#' },
+      '5xx': { $ref: '5xx#' },
+    },
+  },
+  async onRequest(req) {
+    await this.auth({ req });
+  },
+  async preHandler({ user, params }) {
+    const { resources, roles } = this.config.globals;
+
+    await this.access({
+      userId: user.id,
+      resourceId: params.lessonId,
+      resourceType: resources.LESSON.name,
+      roleId: roles.MAINTAINER.id,
+    });
+  },
+};
+
+async function handler({ body, user }) {
+  const {
+    models: { Result },
+    config: {
+      lessonService: { lessonServiceMessages: messages },
+    },
+  } = this;
+
+  await Result.setCorrectness({
+    resultId: body.resultId,
+    correctness: body.correctness,
+    meta: {
+      reviewer: user.id,
+      reviewedAt: new Date().toISOString(),
+    },
+  });
+
+  return { message: messages.LESSON_MSG_SUCCESS_REVIEW };
+}
+
+export default { options, handler };

api/src/services/lessons-management/routes.js

@@ -11,6 +11,7 @@ import getAllStudents from './controllers/getAllStudents';
 import studentsOptions from './controllers/studentsOptions';
 import updateStatus from './controllers/updateStatus';
 import statusOptions from './controllers/statusOptions';
+import reviewStudentReply from './controllers/reviewStudentReply';
 
 export async function router(instance) {
   instance.get('/lessons', getLessons.options, getLessons.handler);
@@ -63,4 +64,10 @@ export async function router(instance) {
     studentsOptions.options,
     studentsOptions.handler,
   );
+
+  instance.post(
+    '/review/:lessonId',
+    reviewStudentReply.options,
+    reviewStudentReply.handler,
+  );
 }

api/test/integration/lessonsManagementService.spec.js

@@ -1,18 +1,22 @@
+/* eslint-disable no-underscore-dangle */
 import { v4 } from 'uuid';
 
 import build from '../../src/app';
 
 import {
-  teacherMike,
-  teacherNathan,
   defaultPassword,
   studentJohn,
+  teacherMike,
+  teacherNathan,
 } from '../../seeds/testData/users';
-import { french } from '../../seeds/testData/lessons';
+import { french, ukrainian } from '../../seeds/testData/lessons';
 
 import { authorizeUser, createLesson, prepareLessonFromSeed } from './utils';
 
-import { userServiceErrors as errors } from '../../src/config';
+import {
+  lessonServiceMessages,
+  userServiceErrors as errors,
+} from '../../src/config';
 
 describe('Maintainer flow', () => {
   const testContext = {};
@@ -532,4 +536,89 @@ describe('Maintainer flow', () => {
       expect(payload.total).toBe(0);
     });
   });
+
+  describe('Result review mechanics', () => {
+    let lessonWithGradedQuestion;
+    let gradedQuestionResult;
+    const CORRECTNESS = 0.4;
+
+    beforeAll(async () => {
+      lessonWithGradedQuestion = await createLesson({
+        app: testContext.app,
+        credentials: teacherCredentials,
+        body: prepareLessonFromSeed(ukrainian),
+      });
+
+      await testContext.studentRequest({
+        url: `lessons/${lessonWithGradedQuestion.lesson.id}/enroll`,
+      });
+
+      await testContext.studentRequest({
+        url: `learn/lessons/${lessonWithGradedQuestion.lesson.id}/reply`,
+        body: {
+          action: 'start',
+        },
+      });
+
+      await testContext.studentRequest({
+        url: `learn/lessons/${lessonWithGradedQuestion.lesson.id}/reply`,
+        body: {
+          action: 'response',
+          blockId:
+            lessonWithGradedQuestion.lesson.blocks[
+              ukrainian._blocks._indexesOfInteractive[0]
+            ].blockId,
+          revision:
+            lessonWithGradedQuestion.lesson.blocks[
+              ukrainian._blocks._indexesOfInteractive[0]
+            ].revision,
+          reply: {
+            files: [],
+            value: 'answer',
+          },
+        },
+      });
+
+      const response = await testContext.request({
+        method: 'GET',
+        url: `lessons/${lessonWithGradedQuestion.lesson.id}/students`,
+      });
+
+      const [student] = JSON.parse(response.payload).students;
+      [, gradedQuestionResult] = student.results;
+    });
+
+    it('correctness should be null after student`s response', () => {
+      expect(gradedQuestionResult.correctness).toBe(null);
+    });
+
+    it('should successfully set correctness', async () => {
+      const response = await testContext.request({
+        url: `review/${lessonWithGradedQuestion.lesson.id}`,
+        body: {
+          resultId: gradedQuestionResult.id,
+          correctness: CORRECTNESS,
+        },
+      });
+
+      const payload = JSON.parse(response.payload);
+
+      expect(response.statusCode).toBe(200);
+      expect(payload).toMatchObject({
+        message: lessonServiceMessages.LESSON_MSG_SUCCESS_REVIEW,
+      });
+    });
+
+    it('correctness should be changed successfully', async () => {
+      const response = await testContext.request({
+        method: 'GET',
+        url: `lessons/${lessonWithGradedQuestion.lesson.id}/students`,
+      });
+
+      const [student] = JSON.parse(response.payload).students;
+      const [, newResult] = student.results;
+
+      expect(newResult.correctness).toBe(CORRECTNESS);
+    });
+  });
 });

front/src/pages/Teacher/LessonStudents/LessonResults/InteractiveResults/InteractiveResults.jsx

@@ -2,6 +2,7 @@ import T from 'prop-types';
 
 import LearnContext from '@sb-ui/contexts/LearnContext';
 import ResultItem from '@sb-ui/pages/Teacher/LessonStudents/LessonResults/ResultItem';
+import { BLOCKS_TYPE_LIST_RATED } from '@sb-ui/pages/Teacher/LessonStudents/LessonResults/ResultItem/constants';
 import { useBlockIcons } from '@sb-ui/pages/Teacher/LessonStudents/LessonResults/useBlockIcons';
 import BlockElement from '@sb-ui/pages/User/LearnPage/BlockElement';
 import { LearnWrapper } from '@sb-ui/pages/User/LearnPage/LearnPage.styled';
@@ -14,37 +15,44 @@ const InteractiveResults = ({ interactiveResults }) => {
   return (
     <LearnContext.Provider value={{ handleInteractiveClick: () => {} }}>
       <S.Collapse>
-        {interactiveResults.map(({ block, correctness, time, data }) => {
-          const isResult = !!correctness || correctness === 0;
-          return (
-            <S.Panel
-              key={block.blockId}
-              $isResult={isResult}
-              header={
-                <ResultItem
-                  showCircle={isResult}
-                  icons={blockIcons}
-                  block={block}
-                  correctness={correctness}
-                  time={time}
-                />
-              }
-            >
-              {isResult && (
-                <LearnWrapper>
-                  <BlockElement
-                    element={{
-                      blockId: block.id,
-                      ...block,
-                      reply: data,
-                      isSolved: true,
-                    }}
+        {interactiveResults.map(
+          ({ block, correctness, time, data, lessonId, id }) => {
+            const isResult =
+              !!correctness ||
+              correctness === 0 ||
+              BLOCKS_TYPE_LIST_RATED.includes(block?.type);
+            return (
+              <S.Panel
+                key={block?.blockId}
+                $isResult={isResult}
+                header={
+                  <ResultItem
+                    id={id}
+                    showCircle={isResult}
+                    icons={blockIcons}
+                    block={block}
+                    correctness={correctness}
+                    time={time}
+                    lessonId={lessonId}
                   />
-                </LearnWrapper>
-              )}
-            </S.Panel>
-          );
-        })}
+                }
+              >
+                {isResult && (
+                  <LearnWrapper>
+                    <BlockElement
+                      element={{
+                        blockId: block?.blockId,
+                        ...block,
+                        reply: data,
+                        isSolved: true,
+                      }}
+                    />
+                  </LearnWrapper>
+                )}
+              </S.Panel>
+            );
+          },
+        )}
       </S.Collapse>
     </LearnContext.Provider>
   );

front/src/pages/Teacher/LessonStudents/LessonResults/InteractiveResults/InteractiveResults.styled.js

@@ -17,6 +17,9 @@ export const Panel = styled(PanelAntd).attrs({
   .ant-collapse-header {
     pointer-events: ${(props) => (props.$isResult ? 'auto' : 'none')};
   }
+  .ant-collapse-content {
+    pointer-events: all;
+  }
   pointer-events: none;
   padding: 0.5rem 1rem;
 `;