[WIP] Shared completion for Group Dailies

website/client/components/tasks/column.vue

@@ -609,8 +609,8 @@ export default {
       if (!taskList) return [];
       return taskList.filter(task => {
         if (filter === 'complete2') return task.completed;
-        if (filter === 'due') return task.isDue;
-        if (filter === 'notDue') return !task.isDue;
+        if (filter === 'due') return !task.completed && task.isDue;
+        if (filter === 'notDue') return task.completed || !task.isDue;
         return !task.completed;
       });
     },

website/client/components/tasks/taskModal.vue

@@ -159,7 +159,7 @@
                 | {{ $t(frequency) }}
 
         .option.group-options(v-if='groupId')
-          .form-group(v-if="task.type === 'todo'")
+          .form-group(v-if="task.type === 'todo' || task.type === 'daily'")
             label(v-once) {{ $t('sharedCompletion') }}
             b-dropdown.inline-dropdown(:text="$t(sharedCompletion)")
               b-dropdown-item(

website/server/libs/groupTasks.js

@@ -1,24 +1,68 @@
 import * as Tasks from '../models/task';
+import {model as Groups} from '../models/group';
+import {model as Users} from '../models/user/index';
 
 const SHARED_COMPLETION = {
   default: 'recurringCompletion',
   single: 'singleCompletion',
   every: 'allAssignedCompletion',
 };
 
-async function _completeMasterTask (masterTask) {
-  masterTask.completed = true;
+async function _completeOrUncompleteMasterTask (masterTask, completed) {
+  masterTask.completed = completed;
   await masterTask.save();
 }
 
-async function _deleteUnfinishedTasks (groupMemberTask) {
-  await Tasks.Task.deleteMany({
-    'group.taskId': groupMemberTask.group.taskId,
-    $and: [
-      {userId: {$exists: true}},
-      {userId: {$ne: groupMemberTask.userId}},
-    ],
-  }).exec();
+async function _updateAssignedUsersTasks (masterTask, groupMemberTask) {
+  if (groupMemberTask.type == 'todo') {
+    if (groupMemberTask.completed) {
+      // The task was done by one person and is removed from others' lists
+      await Tasks.Task.deleteMany({
+        'group.taskId': groupMemberTask.group.taskId,
+        $and: [
+          {userId: {$exists: true}},
+          {userId: {$ne: groupMemberTask.userId}},
+        ],
+      }).exec();
+    } else {
+      // The task was uncompleted by the group member and should be recreated for assignedUsers
+      let group = await Groups.findById(masterTask.group.id).exec();
+      let userList = [];
+      masterTask.group.assignedUsers.forEach(userId => {
+        let query = {_id: userId};
+        userList.push(query);
+      });
+      await Users.find({
+        $or: userList
+      }).then(async assignedUsers => {
+        for (const assignedUser of assignedUsers) {
+          let promises = [];
+          promises.push(group.syncTask(masterTask, assignedUser));
+          promises.push(group.save());
+          await Promise.all(promises);
+        }
+      });
+    }
+  } else {
+    // Complete or uncomplete the task on other users' lists
+    await Tasks.Task.find({
+      'group.taskId': groupMemberTask.group.taskId,
+      $and: [
+        {userId: {$exists: true}},
+        {userId: {$ne: groupMemberTask.userId}}
+      ]}).then(tasks => {
+        tasks.forEach (task => {
+          // Ajdust the task's completion to match the groupMemberTask
+          // @REVIEW Completed or notDue tasks have no effect at cron
+          // This maintain's the user's streak without scoring the task if someone else completed the task
+          // If no assignedUser completes the due daily, all users lose their streaks at their cron
+          // An alternative is to set the other assignedUsers' tasks to a later startDate
+          // Should we break their streaks to encourage competition for the daily?
+          task.completed = groupMemberTask.completed;
+          task.save();
+        });
+      });
+  }
 }
 
 async function _evaluateAllAssignedCompletion (masterTask) {
@@ -35,21 +79,19 @@ async function _evaluateAllAssignedCompletion (masterTask) {
       completed: true,
     }).exec();
   }
-  if (completions >= masterTask.group.assignedUsers.length) {
-    await _completeMasterTask(masterTask);
-  }
+  await _completeOrUncompleteMasterTask(masterTask, (completions >= masterTask.group.assignedUsers.length));
 }
 
 async function handleSharedCompletion (groupMemberTask) {
   let masterTask = await Tasks.Task.findOne({
     _id: groupMemberTask.group.taskId,
   }).exec();
 
-  if (!masterTask || !masterTask.group || masterTask.type !== 'todo') return;
+  if (!masterTask || !masterTask.group || masterTask.type == 'habit') return;
 
   if (masterTask.group.sharedCompletion === SHARED_COMPLETION.single) {
-    await _deleteUnfinishedTasks(groupMemberTask);
-    await _completeMasterTask(masterTask);
+    await _updateAssignedUsersTasks(masterTask, groupMemberTask);
+    await _completeOrUncompleteMasterTask(masterTask, groupMemberTask.completed);
   } else if (masterTask.group.sharedCompletion === SHARED_COMPLETION.every) {
     await _evaluateAllAssignedCompletion(masterTask);
   }