feat(datatrakWeb): RN-1391: Generate system comments for tasks

packages/central-server/src/apiV2/tasks/CreateTask.js

@@ -21,13 +21,19 @@ export class CreateTask extends CreateHandler {
   }
 
   async createRecord() {
-    const { comment, ...data } = this.newRecordData;
-
-    return this.models.wrapInTransaction(async transactingModels => {
-      const task = await transactingModels.task.create(data);
+    const { comment, ...newRecordData } = this.newRecordData;
+    await this.models.wrapInTransaction(async transactingModels => {
+      const task = await transactingModels.task.create(newRecordData);
+      // Add the user comment first, since the transaction will mean that all comments have the same created_at time, but we want the user comment to be the 'most recent'
       if (comment) {
-        await task.addComment(comment, this.req.user.id);
+        await task.addComment(comment, this.req.user.id, transactingModels.taskComment.types.User);
       }
+      await task.addComment(
+        'Created this task',
+        this.req.user.id,
+        transactingModels.taskComment.types.System,
+      );
+
       return {
         id: task.id,
       };

packages/central-server/src/apiV2/tasks/EditTask.js

@@ -26,6 +26,7 @@ export class EditTask extends EditHandler {
       if (comment) {
         await originalTask.addComment(comment, this.req.user.id);
       }
+      await originalTask.addSystemCommentsOnUpdate(this.updatedFields, this.req.user.id);
       return task;
     });
   }

packages/central-server/src/tests/apiV2/tasks/EditTask.test.js

@@ -129,83 +129,267 @@ describe('Permissions checker for EditTask', async () => {
   });
 
   describe('PUT /tasks/:id', async () => {
-    it('Sufficient permissions: allows a user to edit a task if they have BES Admin permission', async () => {
-      await app.grantAccess(BES_ADMIN_POLICY);
-      await app.put(`tasks/${tasks[1].id}`, {
-        body: {
-          entity_id: facilities[0].id,
-          survey_id: surveys[0].survey.id,
-        },
+    describe('Permissions', async () => {
+      it('Sufficient permissions: allows a user to edit a task if they have BES Admin permission', async () => {
+        await app.grantAccess(BES_ADMIN_POLICY);
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            entity_id: facilities[0].id,
+            survey_id: surveys[0].survey.id,
+          },
+        });
+        const result = await models.task.find({
+          id: tasks[1].id,
+        });
+        expect(result[0].entity_id).to.equal(facilities[0].id);
+        expect(result[0].survey_id).to.equal(surveys[0].survey.id);
       });
-      const result = await models.task.find({
-        id: tasks[1].id,
+
+      it('Sufficient permissions: allows a user to edit a task if they have access to the task, and entity and survey are not being updated', async () => {
+        await app.grantAccess(DEFAULT_POLICY);
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            status: 'completed',
+          },
+        });
+        const result = await models.task.find({
+          id: tasks[1].id,
+        });
+        expect(result[0].status).to.equal('completed');
+      });
+
+      it('Sufficient permissions: allows a user to edit a task if they have access to the task, and the entity and survey that are being linked to the task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            survey_id: surveys[1].survey.id,
+            entity_id: facilities[1].id,
+          },
+        });
+        const result = await models.task.find({
+          id: tasks[1].id,
+        });
+        expect(result[0].entity_id).to.equal(facilities[1].id);
+        expect(result[0].survey_id).to.equal(surveys[1].survey.id);
+      });
+
+      it('Insufficient permissions: throws an error if the user does not have access to the task being edited', async () => {
+        await app.grantAccess(DEFAULT_POLICY);
+        const { body: result } = await app.put(`tasks/${tasks[0].id}`, {
+          body: {
+            status: 'completed',
+          },
+        });
+        expect(result).to.have.keys('error');
+        expect(result.error).to.include('Need to have access to the country of the task');
+      });
+
+      it('Insufficient permissions: throws an error if the user does not have access to the survey being linked to the task', async () => {
+        await app.grantAccess(DEFAULT_POLICY);
+        const { body: result } = await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            survey_id: surveys[0].survey.id,
+          },
+        });
+        expect(result).to.have.keys('error');
+        expect(result.error).to.include('Need to have access to the new survey of the task');
+      });
+
+      it('Insufficient permissions: throws an error if the user does not have access to the entity being linked to the task', async () => {
+        await app.grantAccess(DEFAULT_POLICY);
+        const { body: result } = await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            entity_id: facilities[0].id,
+          },
+        });
+        expect(result).to.have.keys('error');
+        expect(result.error).to.include('Need to have access to the new entity of the task');
       });
-      expect(result[0].entity_id).to.equal(facilities[0].id);
-      expect(result[0].survey_id).to.equal(surveys[0].survey.id);
     });
 
-    it('Sufficient permissions: allows a user to edit a task if they have access to the task, and entity and survey are not being updated', async () => {
-      await app.grantAccess(DEFAULT_POLICY);
-      await app.put(`tasks/${tasks[1].id}`, {
-        body: {
-          status: 'completed',
-        },
+    describe('User generated comments', async () => {
+      it('Handles adding a comment when editing a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            survey_id: surveys[1].survey.id,
+            entity_id: facilities[1].id,
+            comment: 'This is a test comment',
+          },
+        });
+        const result = await models.task.find({
+          id: tasks[1].id,
+        });
+        expect(result[0].entity_id).to.equal(facilities[1].id);
+        expect(result[0].survey_id).to.equal(surveys[1].survey.id);
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          message: 'This is a test comment',
+        });
+        expect(comment).not.to.be.null;
       });
-      const result = await models.task.find({
-        id: tasks[1].id,
+
+      it('Handles adding a comment when no other edits are made', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            comment: 'This is a test comment',
+          },
+        });
+        const result = await models.task.find({
+          id: tasks[1].id,
+        });
+        expect(result[0].entity_id).to.equal(tasks[1].entity_id);
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          message: 'This is a test comment',
+        });
+        expect(comment).not.to.be.null;
       });
-      expect(result[0].status).to.equal('completed');
     });
 
-    it('Sufficient permissions: allows a user to edit a task if they have access to the task, and the entity and survey that are being linked to the task', async () => {
-      await app.grantAccess({
-        DL: ['Donor'],
-        TO: ['Donor'],
+    describe('System generated comments', () => {
+      it('Adds a comment when the due date changes on a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            due_date: new Date('2021-11-30').toISOString(),
+          },
+        });
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: 'Changed due date from 31 December 21 to 30 November 21',
+        });
+        expect(comment).not.to.be.null;
       });
-      await app.put(`tasks/${tasks[1].id}`, {
-        body: {
-          survey_id: surveys[1].survey.id,
-          entity_id: facilities[1].id,
-        },
+
+      it('Adds a comment when the repeat schedule changes from not repeating to repeating on a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            // this is currently null when setting a task to repeat
+            due_date: null,
+            repeat_schedule: {
+              frequency: 'daily',
+            },
+          },
+        });
+
+        const repeatComment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: "Changed recurring task from Doesn't repeat to Daily",
+        });
+
+        const dueDateComment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: 'Changed due date from 31 December 21 to null',
+        });
+        expect(repeatComment).not.to.be.null;
+        // should not add a comment about the due date changing in this case
+        expect(dueDateComment).to.be.null;
       });
-      const result = await models.task.find({
-        id: tasks[1].id,
+
+      it('Adds a comment when the repeat schedule changes from repeating to not repeating on a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            repeat_schedule: {
+              frequency: 'daily',
+            },
+          },
+        });
+
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            repeat_schedule: null,
+          },
+        });
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: "Changed recurring task from Daily to Doesn't repeat",
+        });
+        expect(comment).not.to.be.null;
       });
-      expect(result[0].entity_id).to.equal(facilities[1].id);
-      expect(result[0].survey_id).to.equal(surveys[1].survey.id);
-    });
 
-    it('Insufficient permissions: throws an error if the user does not have access to the task being edited', async () => {
-      await app.grantAccess(DEFAULT_POLICY);
-      const { body: result } = await app.put(`tasks/${tasks[0].id}`, {
-        body: {
-          status: 'completed',
-        },
+      it('Adds a comment when the status changes on a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            status: 'completed',
+          },
+        });
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: 'Changed status from To do to Completed',
+        });
+        expect(comment).not.to.be.null;
       });
-      expect(result).to.have.keys('error');
-      expect(result.error).to.include('Need to have access to the country of the task');
-    });
 
-    it('Insufficient permissions: throws an error if the user does not have access to the survey being linked to the task', async () => {
-      await app.grantAccess(DEFAULT_POLICY);
-      const { body: result } = await app.put(`tasks/${tasks[1].id}`, {
-        body: {
-          survey_id: surveys[0].survey.id,
-        },
+      it('Adds a comment when the assignee changes to Unassigned on a task', async () => {
+        await app.grantAccess({
+          DL: ['Donor'],
+          TO: ['Donor'],
+        });
+        await app.put(`tasks/${tasks[1].id}`, {
+          body: {
+            assignee_id: null,
+          },
+        });
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[1].id,
+          type: models.taskComment.types.System,
+          message: 'Changed assignee from Peter Pan to Unassigned',
+        });
+        expect(comment).not.to.be.null;
       });
-      expect(result).to.have.keys('error');
-      expect(result.error).to.include('Need to have access to the new survey of the task');
-    });
 
-    it('Insufficient permissions: throws an error if the user does not have access to the entity being linked to the task', async () => {
-      await app.grantAccess(DEFAULT_POLICY);
-      const { body: result } = await app.put(`tasks/${tasks[1].id}`, {
-        body: {
-          entity_id: facilities[0].id,
-        },
+      it('Adds a comment when the assignee changes from unassigned to assigned on a task', async () => {
+        await app.grantAccess(BES_ADMIN_POLICY);
+        await app.put(`tasks/${tasks[0].id}`, {
+          body: {
+            assignee_id: assignee.id,
+          },
+        });
+
+        const comment = await models.taskComment.findOne({
+          task_id: tasks[0].id,
+          type: models.taskComment.types.System,
+          message: 'Changed assignee from Unassigned to Peter Pan',
+        });
+        expect(comment).not.to.be.null;
       });
-      expect(result).to.have.keys('error');
-      expect(result.error).to.include('Need to have access to the new entity of the task');
     });
 
     it('Handles adding a comment when editing a task', async () => {

packages/database/src/__tests__/changeHandlers/TaskCompletionHandler.test.js

@@ -95,6 +95,12 @@ describe('TaskCompletionHandler', () => {
         { entity_id: tonga.id, date: '2024-07-21' },
       ]);
       await assertTaskStatus(task.id, 'completed', responseIds[0]);
+      const comments = await models.taskComment.find({ task_id: task.id });
+      expect(comments[0]).toMatchObject({
+        message: 'Completed this task',
+        user_id: userId,
+        type: models.taskComment.types.System,
+      });
     });
 
     it('created response marks associated tasks as completed if created_time === data_time', async () => {
@@ -106,6 +112,18 @@ describe('TaskCompletionHandler', () => {
       await createResponses([{ entity_id: tonga.id, date: '2021-07-08' }]);
       await assertTaskStatus(task.id, 'to_do', null);
     });
+
+    it('created response does not mark associated tasks as completed if status is null, but should still create a comment', async () => {
+      await models.task.update({ id: task.id }, { status: null });
+      await createResponses([{ entity_id: tonga.id, date: '2021-07-08' }]);
+      await assertTaskStatus(task.id, null, null);
+      const comments = await models.taskComment.find({ task_id: task.id });
+      expect(comments[0]).toMatchObject({
+        message: 'Completed this task',
+        user_id: userId,
+        type: 'system',
+      });
+    });
   });
 
   describe('updating a survey response', () => {