update reject quest route

common/locales/en/api-v3.json

@@ -74,5 +74,6 @@
   "questNotOwned": "You don't own that quest scroll.",
   "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."
+  "questAlreadyAccepted": "You already accepted the quest invitation.",
+  "questAlreadyRejected": "You already rejected the quest invitation."
 }

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

@@ -1,36 +1,37 @@
 import {
   createAndPopulateGroup,
   translate as t,
+  generateUser,
 } from '../../../../helpers/api-v3-integration.helper';
 import { v4 as generateUUID } from 'uuid';
 
-describe('POST /groups/:groupId/quests/invite/:questKey', () => {
+describe('POST /groups/:groupId/quests/reject', () => {
   let questingGroup;
-  let member;
+  let partyMembers;
-  const PET_QUEST = 'whale';
+  let user;
-  let userQuestUpdate = {
+  let leader;
-    items: {
-      quests: {},
-    },
-    'party.quest.RSVPNeeded': true,
-    'party.quest.key': PET_QUEST,
-  };
 
-  before(async () => {
+  const PET_QUEST = 'whale';
-    let { group, members } = await createAndPopulateGroup({
+
+  beforeEach(async () => {
+    let { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: { type: 'party', privacy: 'private' },
-      members: 1,
+      members: 2,
     });
 
     questingGroup = group;
-    member = members[0];
+    leader = groupLeader;
+    partyMembers = members;
 
-    userQuestUpdate.items.quests[PET_QUEST] = 1;
+    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(member.post(`/groups/${generateUUID()}/quests/reject`))
+      await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/reject`))
         .to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
@@ -38,35 +39,97 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
         });
     });
 
-    it('returns an error when group is not on a quest', async () => {
+    it('does not accept quest for a group in which user is not a member', async () => {
-      await member.update(userQuestUpdate);
+      await expect(user.post(`/groups/${questingGroup._id}/quests/accept`))
+      .to.eventually.be.rejected.and.eql({
+        code: 404,
+        error: 'NotFound',
+        message: t('groupNotFound'),
+      });
+    });
 
-      await expect(member.post(`/groups/${questingGroup._id}/quests/reject`))
+    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/reject`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('guildQuestsNotSupported'),
+      });
+    });
+
+    it('returns an error when group is not on a quest', async () => {
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
         .to.eventually.be.rejected.and.eql({
           code: 404,
           error: 'NotFound',
           message: t('questInvitationDoesNotExist'),
         });
     });
+
+    it('return an error when an user rejects an invite twice', async () => {
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
+
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
+      .to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('questAlreadyRejected'),
+      });
+    });
+
+    it('return an error when an user rejects an invite already accepted', async () => {
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
+      .to.eventually.be.rejected.and.eql({
+        code: 400,
+        error: 'BadRequest',
+        message: t('questAlreadyAccepted'),
+      });
+    });
+
+    it('does not reject invite for a quest already underway', async () => {
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
+      // quest will start after everyone has accepted
+      await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
+
+      await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
+      .to.eventually.be.rejected.and.eql({
+        code: 401,
+        error: 'NotAuthorized',
+        message: t('questAlreadyUnderway'),
+      });
+    });
   });
 
   context('successfully quest rejection', () => {
     it('rejects a quest invitation', async () => {
-      await member.update(userQuestUpdate);
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
-      await questingGroup.update({'quest.key': PET_QUEST});
 
-      let questMembers = {};
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
-      questMembers[member._id] = true;
+      await partyMembers[0].sync();
-      await questingGroup.update({'quest.members': questMembers});
+      await questingGroup.sync();
 
-      let rejectResult = await member.post(`/groups/${questingGroup._id}/quests/reject`);
+      expect(partyMembers[0].party.quest.key).to.be.null;
-      let userWithRejectInvitation = await member.get('/user');
+      expect(partyMembers[0].party.quest.RSVPNeeded).to.be.false;
-      let updatedGroup = await member.get(`/groups/${questingGroup._id}`);
+      expect(questingGroup.quest.members[partyMembers[0]._id]).to.be.false;
+      expect(questingGroup.quest.active).to.be.false;
+    });
 
-      expect(userWithRejectInvitation.party.quest.key).to.be.null;
+    it('starts the quest when the last user reject', async () => {
-      expect(userWithRejectInvitation.party.quest.RSVPNeeded).to.be.false;
+      await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
-      expect(updatedGroup.quest.members[member._id]).to.be.false;
+      await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
-      expect(updatedGroup.quest).to.deep.equal(rejectResult);
+      await partyMembers[1].post(`/groups/${questingGroup._id}/quests/reject`);
+      await questingGroup.sync();
+
+      expect(questingGroup.quest.active).to.be.true;
     });
   });
 });

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

@@ -19,13 +19,11 @@ import {
   sendTxn as sendTxnEmail,
 } from '../../libs/api-v3/email';
 import { quests as questScrolls } from '../../../../common/script/content';
-import { track } from '../../libs/api-v3/analyticsService';
-import Q from 'q';
 
 function canStartQuestAutomatically (group)  {
   // If all members are either true (accepted) or false (rejected) return true
   // If any member is null/undefined (undecided) return false
-  return _.every(group.quest.members, Boolean);
+  return _.every(group.quest.members, _.isBoolean);
 }
 
 let api = {};
@@ -191,9 +189,8 @@ api.acceptQuest = {
  * @apiGroup Group
  *
  * @apiParam {string} groupId The group _id (or 'party')
- * @apiParam {string} questKey The quest _id
  *
- * @apiSuccess {Object} Quest Object
+ * @apiSuccess {Object} quest Quest Object
  */
 api.rejectQuest = {
   method: 'POST',
@@ -209,32 +206,37 @@ api.rejectQuest = {
 
     let group = await Group.getGroup({user, groupId: req.params.groupId, fields: 'type quest'});
     if (!group) throw new NotFound(res.t('groupNotFound'));
+    if (group.type !== 'party') throw new NotAuthorized(res.t('guildQuestsNotSupported'));
     if (!group.quest.key) throw new NotFound(res.t('questInvitationDoesNotExist'));
-
+    if (group.quest.active) throw new NotAuthorized(res.t('questAlreadyUnderway'));
-    let analyticsData = {
+    if (group.quest.members[user._id]) throw new BadRequest(res.t('questAlreadyAccepted'));
-      category: 'behavior',
+    if (group.quest.members[user._id] === false) throw new BadRequest(res.t('questAlreadyRejected'));
-      owner: false,
-      response: 'reject',
-      gaLabel: 'reject',
-      questName: group.quest.key,
-      uuid: user._id,
-    };
-    track('quest', analyticsData);
 
     group.quest.members[user._id] = false;
     group.markModified('quest.members');
 
-    user.party.quest.RSVPNeeded = false;
+    user.party.quest = Group.cleanQuestProgress();
-    user.party.quest.key = null;
+    user.markModified('party.quest');
+
+    if (canStartQuestAutomatically(group)) {
+      await group.startQuest(user);
+    }
 
     let [savedGroup] = await Q.all([
       group.save(),
       user.save(),
     ]);
 
-    // questStart(req,res,next);
-
     res.respond(200, savedGroup.quest);
+
+    analytics.track('quest', {
+      category: 'behavior',
+      owner: false,
+      response: 'reject',
+      gaLabel: 'reject',
+      questName: group.quest.key,
+      uuid: user._id,
+    });
   },
 };
 

website/src/models/group.js

@@ -301,7 +301,6 @@ schema.methods.startQuest = async function startQuest (user) {
 };
 
 function _cleanQuestProgress (merge) {
-  // TODO clone? (also in sendChat message)
   let clean = {
     key: null,
     progress: {