Groups assign tasks (#7887)

* Added initial code for creating and reading group tasks * Separated group task routes. Separated shared task functions * Added taskOrder to group * Minor style fixes * Fixed lint issues * Added unit tests for task manager * Updated task helper functions * Fixed history test * Fixed group task query * Removed extra var * Updated with new file structure * Updated noset values * Removed unecessary undefineds, fixed comments, Added apiignore * Separated group task routes. Separated shared task functions * Added unit tests for task manager * Added initial groups assign route and tests * Added sync assigned task to user * Added unassign route and unlink method * Added remove and unlink group task * Updated linking and unlinking. Add test for updating task info * Added delete group task and tests * Added sync on task update and tests * Added multiple users assignment * Updated unassign for multiple users * Added test for delete task with multiple assigend users * Added update task for multiple assigned users * Fixed issue with get tasks * Abstracted syncable attributes and add tests * Fixed merge conflicts * Fixed style issues, limited group query fields, and added await * Fixed group fields needed. Removed api v2 code * Fixed style issues * Moved group field under group sub document. Updated tests. Fixed other broken tests * Renamed linkedTaskId and fixed broken alias tests * Added debug middleware to new routes * Fixed debug middleware import * Added additional user id check for original group tasks * Updated challenge task check to look for challenge id * Added checklist sync fix
2016-09-03 03:54:55 -05:00
parent 173b3f3f84
commit 836cee2531
17 changed files with 1488 additions and 162 deletions
@@ -0,0 +1,72 @@
+import {
+  translate as t,
+  createAndPopulateGroup,
+} from '../../../../../helpers/api-integration/v3';
+import { find } from 'lodash';
+
+describe('DELETE /tasks/:id', () => {
+  let user, guild, member, member2, task;
+
+  function findAssignedTask (memberTask) {
+    return memberTask.group.id === guild._id;
+  }
+
+  beforeEach(async () => {
+    let {group, members, groupLeader} = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Test Guild',
+        type: 'guild',
+      },
+      members: 2,
+    });
+
+    guild = group;
+    user = groupLeader;
+    member = members[0];
+    member2 = members[1];
+
+    task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+  });
+
+  it('deletes a group task', async () => {
+    await user.del(`/tasks/${task._id}`);
+
+    await expect(user.get(`/tasks/${task._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('taskNotFound'),
+      });
+  });
+
+  it('unlinks assigned user', async () => {
+    await user.del(`/tasks/${task._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    expect(syncedTask.group.broken).to.equal('TASK_DELETED');
+  });
+
+  it('unlinks all assigned users', async () => {
+    await user.del(`/tasks/${task._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    let member2Tasks = await member2.get('/tasks/user');
+    let member2SyncedTask = find(member2Tasks, findAssignedTask);
+
+    expect(syncedTask.group.broken).to.equal('TASK_DELETED');
+    expect(member2SyncedTask.group.broken).to.equal('TASK_DELETED');
+  });
+});
@@ -0,0 +1,80 @@
+import {
+  generateUser,
+  generateGroup,
+  translate as t,
+} from '../../../../../helpers/api-integration/v3';
+import { v4 as generateUUID } from 'uuid';
+import { each } from 'lodash';
+
+describe('GET /tasks/group/:groupId', () => {
+  let user, group, task, groupWithTask;
+  let tasks = [];
+  let tasksToTest = {
+    habit: {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+    },
+    todo: {
+      text: 'test todo',
+      type: 'todo',
+    },
+    daily: {
+      text: 'test daily',
+      type: 'daily',
+      frequency: 'daily',
+      everyX: 5,
+      startDate: new Date(),
+    },
+    reward: {
+      text: 'test reward',
+      type: 'reward',
+    },
+  };
+
+  before(async () => {
+    user = await generateUser();
+    group = await generateGroup(user);
+  });
+
+  it('returns error when group is not found', async () => {
+    let dummyId = generateUUID();
+
+    await expect(user.get(`/tasks/group/${dummyId}`)).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('groupNotFound'),
+    });
+  });
+
+  each(tasksToTest, (taskValue, taskType) => {
+    context(`${taskType}`, () => {
+      before(async () => {
+        task = await user.post(`/tasks/group/${group._id}`, taskValue);
+        tasks.push(task);
+        groupWithTask = await user.get(`/groups/${group._id}`);
+      });
+
+      it('gets group tasks', async () => {
+        let getTask = await user.get(`/tasks/group/${groupWithTask._id}`);
+        expect(getTask).to.eql(tasks);
+      });
+
+      it('gets group tasks filtered by type', async () => {
+        let groupTasks = await user.get(`/tasks/group/${groupWithTask._id}?type=${task.type}s`);
+        expect(groupTasks).to.eql([task]);
+      });
+
+      it('cannot get a task owned by someone else', async () => {
+        let anotherUser = await generateUser();
+
+        await expect(anotherUser.get(`/tasks/group/${groupWithTask._id}`)).to.eventually.be.rejected.and.eql({
+          code: 404,
+          error: 'NotFound',
+          message: t('groupNotFound'),
+        });
+      });
+    });
+  });
+});
@@ -0,0 +1,119 @@
+import {
+  generateUser,
+  generateGroup,
+  translate as t,
+} from '../../../../../helpers/api-v3-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /tasks/group/:groupid', () => {
+  let user, guild;
+
+  beforeEach(async () => {
+    user = await generateUser({balance: 1});
+    guild = await generateGroup(user, {type: 'guild'});
+  });
+
+  it('returns error when group is not found', async () => {
+    await expect(user.post(`/tasks/group/${generateUUID()}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('groupNotFound'),
+    });
+  });
+
+  it('returns error when user is not a member of the group', async () => {
+    let userWithoutChallenge = await generateUser();
+
+    await expect(userWithoutChallenge.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    })).to.eventually.be.rejected.and.eql({
+      code: 404,
+      error: 'NotFound',
+      message: t('groupNotFound'),
+    });
+  });
+
+  it('returns error when non leader tries to create a task', async () => {
+    let userThatIsNotLeaderOfGroup = await generateUser({
+      guilds: [guild._id],
+    });
+
+    await expect(userThatIsNotLeaderOfGroup.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    })).to.eventually.be.rejected.and.eql({
+      code: 401,
+      error: 'NotAuthorized',
+      message: t('onlyGroupLeaderCanEditTasks'),
+    });
+  });
+
+  it('creates a habit', async () => {
+    let task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    expect(groupTask[0].group.id).to.equal(guild._id);
+    expect(task.text).to.eql('test habit');
+    expect(task.notes).to.eql('1976');
+    expect(task.type).to.eql('habit');
+    expect(task.up).to.eql(false);
+    expect(task.down).to.eql(true);
+  });
+
+  it('creates a todo', async () => {
+    let task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test todo',
+      type: 'todo',
+      notes: 1976,
+    });
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    expect(groupTask[0].group.id).to.equal(guild._id);
+    expect(task.text).to.eql('test todo');
+    expect(task.notes).to.eql('1976');
+    expect(task.type).to.eql('todo');
+  });
+
+  it('creates a daily', async () => {
+    let now = new Date();
+    let task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test daily',
+      type: 'daily',
+      notes: 1976,
+      frequency: 'daily',
+      everyX: 5,
+      startDate: now,
+    });
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    expect(groupTask[0].group.id).to.equal(guild._id);
+    expect(task.text).to.eql('test daily');
+    expect(task.notes).to.eql('1976');
+    expect(task.type).to.eql('daily');
+    expect(task.frequency).to.eql('daily');
+    expect(task.everyX).to.eql(5);
+    expect(new Date(task.startDate)).to.eql(now);
+  });
+});
@@ -0,0 +1,113 @@
+import {
+  generateUser,
+  createAndPopulateGroup,
+  translate as t,
+} from '../../../../../helpers/api-v3-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+import { find } from 'lodash';
+
+describe('POST /tasks/:taskId', () => {
+  let user, guild, member, member2, task;
+
+  function findAssignedTask (memberTask) {
+    return memberTask.group.id === guild._id;
+  }
+
+  beforeEach(async () => {
+    let {group, members, groupLeader} = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Test Guild',
+        type: 'guild',
+      },
+      members: 2,
+    });
+
+    guild = group;
+    user = groupLeader;
+    member = members[0];
+    member2 = members[1];
+
+    task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+  });
+
+  it('returns error when task is not found', async () => {
+    await expect(user.post(`/tasks/${generateUUID()}/assign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('taskNotFound'),
+      });
+  });
+
+  it('returns error when task is not a group task', async () => {
+    let nonGroupTask = await user.post('/tasks/user', {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    await expect(user.post(`/tasks/${nonGroupTask._id}/assign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('onlyGroupTasksCanBeAssigned'),
+      });
+  });
+
+  it('returns error when user is not a member of the group', async () => {
+    let nonUser = await generateUser();
+
+    await expect(nonUser.post(`/tasks/${task._id}/assign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+  });
+
+  it('returns error when non leader tries to create a task', async () => {
+    await expect(member.post(`/tasks/${task._id}/assign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('onlyGroupLeaderCanEditTasks'),
+      });
+  });
+
+  it('assigns a task to a user', async () => {
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    expect(groupTask[0].group.assignedUsers).to.contain(member._id);
+    expect(syncedTask).to.exist;
+  });
+
+  it('assigns a task to multiple users', async () => {
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let member1SyncedTask = find(memberTasks, findAssignedTask);
+
+    let member2Tasks = await member2.get('/tasks/user');
+    let member2SyncedTask = find(member2Tasks, findAssignedTask);
+
+    expect(groupTask[0].group.assignedUsers).to.contain(member._id);
+    expect(groupTask[0].group.assignedUsers).to.contain(member2._id);
+    expect(member1SyncedTask).to.exist;
+    expect(member2SyncedTask).to.exist;
+  });
+});
@@ -0,0 +1,117 @@
+import {
+  generateUser,
+  createAndPopulateGroup,
+  translate as t,
+} from '../../../../../helpers/api-v3-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+import { find } from 'lodash';
+
+describe('POST /tasks/:taskId/unassign/:memberId', () => {
+  let user, guild, member, member2, task;
+
+  function findAssignedTask (memberTask) {
+    return memberTask.group.id === guild._id;
+  }
+
+  beforeEach(async () => {
+    let {group, members, groupLeader} = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Test Guild',
+        type: 'guild',
+      },
+      members: 2,
+    });
+
+    guild = group;
+    user = groupLeader;
+    member = members[0];
+    member2 = members[1];
+
+    task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+  });
+
+  it('returns error when task is not found', async () => {
+    await expect(user.post(`/tasks/${generateUUID()}/unassign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('taskNotFound'),
+      });
+  });
+
+  it('returns error when task is not a group task', async () => {
+    let nonGroupTask = await user.post('/tasks/user', {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    await expect(user.post(`/tasks/${nonGroupTask._id}/unassign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('onlyGroupTasksCanBeAssigned'),
+      });
+  });
+
+  it('returns error when user is not a member of the group', async () => {
+    let nonUser = await generateUser();
+
+    await expect(nonUser.post(`/tasks/${task._id}/unassign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+  });
+
+  it('returns error when non leader tries to create a task', async () => {
+    await expect(member.post(`/tasks/${task._id}/unassign/${member._id}`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('onlyGroupLeaderCanEditTasks'),
+      });
+  });
+
+  it('unassigns a user from a task', async () => {
+    await user.post(`/tasks/${task._id}/unassign/${member._id}`);
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    expect(groupTask[0].group.assignedUsers).to.not.contain(member._id);
+    expect(syncedTask).to.not.exist;
+  });
+
+  it('unassigns a user and only that user from a task', async () => {
+    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+
+    await user.post(`/tasks/${task._id}/unassign/${member._id}`);
+
+    let groupTask = await user.get(`/tasks/group/${guild._id}`);
+
+    let memberTasks = await member.get('/tasks/user');
+    let member1SyncedTask = find(memberTasks, findAssignedTask);
+
+    let member2Tasks = await member2.get('/tasks/user');
+    let member2SyncedTask = find(member2Tasks, findAssignedTask);
+
+    expect(groupTask[0].group.assignedUsers).to.not.contain(member._id);
+    expect(member1SyncedTask).to.not.exist;
+
+    expect(groupTask[0].group.assignedUsers).to.contain(member2._id);
+    expect(member2SyncedTask).to.exist;
+  });
+});
@@ -0,0 +1,92 @@
+import {
+  createAndPopulateGroup,
+} from '../../../../../helpers/api-integration/v3';
+import { find } from 'lodash';
+
+describe('PUT /tasks/:id', () => {
+  let user, guild, member, member2, task;
+
+  function findAssignedTask (memberTask) {
+    return memberTask.group.id === guild._id;
+  }
+
+  beforeEach(async () => {
+    let {group, members, groupLeader} = await createAndPopulateGroup({
+      groupDetails: {
+        name: 'Test Guild',
+        type: 'guild',
+      },
+      members: 2,
+    });
+
+    guild = group;
+    user = groupLeader;
+    member = members[0];
+    member2 = members[1];
+
+    task = await user.post(`/tasks/group/${guild._id}`, {
+      text: 'test habit',
+      type: 'habit',
+      up: false,
+      down: true,
+      notes: 1976,
+    });
+
+    await user.post(`/tasks/${task._id}/assign/${member._id}`);
+    await user.post(`/tasks/${task._id}/assign/${member2._id}`);
+  });
+
+  it('updates a group task', async () => {
+    let savedHabit = await user.put(`/tasks/${task._id}`, {
+      text: 'some new text',
+      up: false,
+      down: false,
+      notes: 'some new notes',
+    });
+
+    expect(savedHabit.text).to.eql('some new text');
+    expect(savedHabit.notes).to.eql('some new notes');
+    expect(savedHabit.up).to.eql(false);
+    expect(savedHabit.down).to.eql(false);
+  });
+
+  it('updates the linked tasks', async () => {
+    await user.put(`/tasks/${task._id}`, {
+      text: 'some new text',
+      up: false,
+      down: false,
+      notes: 'some new notes',
+    });
+
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    expect(syncedTask.text).to.eql('some new text');
+    expect(syncedTask.up).to.eql(false);
+    expect(syncedTask.down).to.eql(false);
+  });
+
+  it('updates the linked tasks for all assigned users', async () => {
+    await user.put(`/tasks/${task._id}`, {
+      text: 'some new text',
+      up: false,
+      down: false,
+      notes: 'some new notes',
+    });
+
+    let memberTasks = await member.get('/tasks/user');
+    let syncedTask = find(memberTasks, findAssignedTask);
+
+    let member2Tasks = await member2.get('/tasks/user');
+    let member2SyncedTask = find(member2Tasks, findAssignedTask);
+
+    expect(syncedTask.text).to.eql('some new text');
+    expect(syncedTask.up).to.eql(false);
+    expect(syncedTask.down).to.eql(false);
+
+    expect(member2SyncedTask.text).to.eql('some new text');
+    expect(member2SyncedTask.up).to.eql(false);
+    expect(member2SyncedTask.down).to.eql(false);
+  });
+});