Merge branch 'TheHollidayInn-api-v3-quests-abort' into sabrecat/quest-accept

common/locales/en/api-v3.json

@@ -75,6 +75,8 @@
   "questLevelTooHigh": "You must be Level <%= level %> to begin this quest.",
   "questAlreadyUnderway": "Your party is already on a quest. Try again when the current quest has ended.",
   "questAlreadyAccepted": "You already accepted the quest invitation.",
+  "noActiveQuestToAbort": "There is no active quest to abort.",
+  "onlyLeaderAbortQuest": "Only the group or quest leader can abort a quest.",
   "questAlreadyRejected": "You already rejected the quest invitation.",
   "cantCancelActiveQuest": "You can not cancel an active quest, use the abort functionality.",
   "onlyLeaderCancelQuest": "Only the group or quest leader can cancel the quest.",

test/api/v3/integration/quests/POST-groups_groupid_quests_abort.test.js

@@ -0,0 +1,126 @@
+import {
+  createAndPopulateGroup,
+  translate as t,
+  generateUser,
+} from '../../../../helpers/api-v3-integration.helper';
+import { v4 as generateUUID } from 'uuid';
+
+describe('POST /groups/:groupId/quests/leave', () => {
+  let questingGroup;
+  let partyMembers;
+  let user;
+  let leader;
+
+  const PET_QUEST = 'whale';
+
+  beforeEach(async () => {
+    let { group, groupLeader, members } = await createAndPopulateGroup({
+      groupDetails: { type: 'party', privacy: 'private' },
+      members: 2,
+    });
+
+    questingGroup = group;
+    leader = groupLeader;
+    partyMembers = members;
+
+    await leader.update({
+      [`items.quests.${PET_QUEST}`]: 1,
+    });
+    user = await generateUser();
+  });
+
+  context('failure conditions', () => {
+    it('returns an error when group is not found', async () => {
+      await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/abort`))
+        .to.eventually.be.rejected.and.eql({
+          code: 404,
+          error: 'NotFound',
+          message: t('groupNotFound'),
+        });
+    });
+
+    it('returns an error for a group in which user is not a member', async () => {
+      await expect(user.post(`/groups/${questingGroup._id}/quests/abort`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+    });
+
+    it('returns an error when group is a guild', async () => {
+      let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
+        groupDetails: { type: 'guild', privacy: 'private' },
+      });
+
+      await expect(guildLeader.post(`/groups/${guild._id}/quests/abort`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('guildQuestsNotSupported'),
+      });
+    });
+
+    it('returns an error when quest is not active', async () => {
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/abort`))
+        .to.eventually.be.rejected.and.eql({
+          code: 404,
+          error: 'NotFound',
+          message: t('noActiveQuestToAbort'),
+        });
+    });
+
+    it('returns an error when non quest leader attempts to abort', async () => {
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+      await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
+
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/abort`))
+        .to.eventually.be.rejected.and.eql({
+          code: 401,
+          error: 'NotAuthorized',
+          message: t('onlyLeaderAbortQuest'),
+        });
+    });
+  });
+
+  it('aborts a quest', async () => {
+    await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+    await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+    await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
+
+    let res = await leader.post(`/groups/${questingGroup._id}/quests/abort`);
+    Promise.all([
+      leader.sync(),
+      questingGroup.sync(),
+      partyMembers[0].sync(),
+      partyMembers[1].sync(),
+    ]);
+
+    let cleanUserQuestObj = {
+      key: null,
+      progress: {
+        up: 0,
+        down: 0,
+        collect: {},
+      },
+      completed: null,
+      RSVPNeeded: false,
+    };
+
+    expect(leader.party.quest).to.eql(cleanUserQuestObj);
+    expect(partyMembers[0].party.quest).to.eql(cleanUserQuestObj);
+    expect(partyMembers[1].party.quest).to.eql(cleanUserQuestObj);
+    expect(leader.items.quests[PET_QUEST]).to.equal(1);
+    expect(questingGroup.quest).to.deep.equal(res);
+    expect(questingGroup.quest).to.eql({
+      key: null,
+      active: false,
+      leader: null,
+      progress: {
+        collect: {},
+      },
+      members: {},
+    });
+  });
+});

website/src/controllers/api-v3/quests.js

@@ -6,9 +6,7 @@ import analytics from '../../libs/api-v3/analyticsService';
 import {
   model as Group,
 } from '../../models/group';
-import {
-  model as User,
-} from '../../models/user';
+import { model as User } from '../../models/user';
 import {
   NotFound,
   NotAuthorized,
@@ -275,15 +273,71 @@ api.cancelQuest = {
 
     group.quest = Group.cleanGroupQuest();
     group.markModified('quest');
-    await group.save();
 
-    await User.update(
-      {'party._id': groupId},
-      {$set: {'party.quest': Group.cleanQuestProgress()}},
-      {multi: true}
-    );
+    let [savedGroup] = await Promise.all([
+      group.save(),
+      User.update(
+        {'party._id': groupId},
+        {$set: {'party.quest': Group.cleanQuestProgress()}},
+        {multi: true}
+      ),
+    ]);
 
-    res.respond(200, group.quest);
+    res.respond(200, savedGroup.quest);
+  },
+};
+
+/**
+ * @api {post} /groups/:groupId/quests/abort Abort the current quest
+ * @apiVersion 3.0.0
+ * @apiName AbortQuest
+ * @apiGroup Group
+ *
+ * @apiParam {string} groupId The group _id (or 'party')
+ *
+ * @apiSuccess {Object} quest Quest Object
+ */
+api.abortQuest = {
+  method: 'POST',
+  url: '/groups/:groupId/quests/abort',
+  middlewares: [authWithHeaders(), cron],
+  async handler (req, res) {
+    // Abort a quest AFTER it has begun (see questCancel for BEFORE)
+    let user = res.locals.user;
+    let groupId = req.params.groupId;
+
+    req.checkParams('groupId', res.t('groupIdRequired')).notEmpty();
+
+    let validationErrors = req.validationErrors();
+    if (validationErrors) throw validationErrors;
+
+    let group = await Group.getGroup({user, groupId, fields: 'type quest leader'});
+    if (!group) throw new NotFound(res.t('groupNotFound'));
+    if (group.type !== 'party') throw new NotAuthorized(res.t('guildQuestsNotSupported'));
+    if (!group.quest.active) throw new NotFound(res.t('noActiveQuestToAbort'));
+    if (user._id !== group.leader && user._id !== group.quest.leader) throw new NotAuthorized(res.t('onlyLeaderAbortQuest'));
+
+    let memberUpdates = User.update({
+      'party._id': groupId,
+    }, {
+      $set: {'party.quest': Group.cleanQuestProgress()},
+      $inc: {_v: 1}, // TODO update middleware
+    }, {multi: true}).exec();
+
+    let questLeaderUpdate = User.update({
+      _id: group.quest.leader,
+    }, {
+      $inc: {
+        [`items.quests.${group.quest.key}`]: 1, // give back the quest to the quest leader
+      },
+    }).exec();
+
+    group.quest = Group.cleanGroupQuest();
+    group.markModified('quest');
+
+    let [groupSaved] = await Q.all([group.save(), memberUpdates, questLeaderUpdate]);
+
+    res.respond(200, groupSaved.quest);
   },
 };