mirror of
https://github.com/HabitRPG/habitica.git
synced 2025-12-14 21:27:23 +01:00
583 lines
18 KiB
JavaScript
583 lines
18 KiB
JavaScript
import each from 'lodash/each';
|
|
import every from 'lodash/every';
|
|
import isBoolean from 'lodash/isBoolean';
|
|
import { authWithHeaders } from '../../middlewares/auth';
|
|
import { getAnalyticsServiceByEnvironment } from '../../libs/analyticsService';
|
|
import {
|
|
model as Group,
|
|
basicFields as basicGroupFields,
|
|
} from '../../models/group';
|
|
import { model as User } from '../../models/user';
|
|
import {
|
|
NotFound,
|
|
NotAuthorized,
|
|
BadRequest,
|
|
} from '../../libs/errors';
|
|
import {
|
|
getUserInfo,
|
|
sendTxn as sendTxnEmail,
|
|
} from '../../libs/email';
|
|
import common from '../../../common';
|
|
import { sendNotification as sendPushNotification } from '../../libs/pushNotifications';
|
|
import { apiError } from '../../libs/apiError';
|
|
import { questActivityWebhook } from '../../libs/webhook';
|
|
import { model as UserHistory } from '../../models/userHistory';
|
|
|
|
const analytics = getAnalyticsServiceByEnvironment();
|
|
|
|
const questScrolls = common.content.quests;
|
|
|
|
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, isBoolean);
|
|
}
|
|
|
|
/**
|
|
* @apiDefine QuestNotFound
|
|
* @apiError (404) {NotFound} QuestNotFound The specified quest could not be found.
|
|
*/
|
|
|
|
/**
|
|
* @apiDefine QuestLeader Quest Leader
|
|
* The quest leader can use this route.
|
|
*/
|
|
|
|
const api = {};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/invite/:questKey Invite users to a quest
|
|
* @apiName InviteToQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
* @apiParam (Path) {String} questKey
|
|
*
|
|
* @apiSuccess {Object} data Quest object
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.inviteToQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/invite/:questKey',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
const { user } = res.locals;
|
|
const { questKey } = req.params;
|
|
const quest = questScrolls[questKey];
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId: req.params.groupId, fields: basicGroupFields.concat(' quest chat') });
|
|
|
|
if (!group) throw new NotFound(res.t('groupNotFound'));
|
|
if (group.type !== 'party') throw new NotAuthorized(res.t('guildQuestsNotSupported'));
|
|
if (!quest) throw new NotFound(apiError('questNotFound', { key: questKey }));
|
|
if (!user.items.quests[questKey]) throw new NotAuthorized(res.t('questNotOwned'));
|
|
if (group.quest.key) throw new NotAuthorized(res.t('questAlreadyUnderway'));
|
|
|
|
const members = await User.find({
|
|
'party._id': group._id,
|
|
_id: { $ne: user._id },
|
|
})
|
|
.select('auth preferences.emailNotifications preferences.pushNotifications preferences.language profile.name pushDevices webhooks')
|
|
.exec();
|
|
|
|
group.markModified('quest');
|
|
group.quest.key = questKey;
|
|
group.quest.leader = user._id;
|
|
group.quest.members = {};
|
|
group.quest.members[user._id] = true;
|
|
|
|
user.party.quest.RSVPNeeded = false;
|
|
user.party.quest.key = questKey;
|
|
|
|
await User.updateMany({
|
|
'party._id': group._id,
|
|
_id: { $ne: user._id },
|
|
}, {
|
|
$set: {
|
|
'party.quest.RSVPNeeded': true,
|
|
'party.quest.key': questKey,
|
|
},
|
|
}).exec();
|
|
|
|
each(members, member => {
|
|
group.quest.members[member._id] = null;
|
|
});
|
|
|
|
if (canStartQuestAutomatically(group)) {
|
|
await group.startQuest(user);
|
|
}
|
|
|
|
const [savedGroup] = await Promise.all([
|
|
group.save(),
|
|
user.save(),
|
|
]);
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
// send out invites
|
|
const inviterVars = getUserInfo(user, ['name', 'email']);
|
|
const membersToEmail = [];
|
|
|
|
for (const member of members) {
|
|
// send push notifications while filtering members before sending emails
|
|
if (member.preferences.pushNotifications.invitedQuest !== false) {
|
|
// eslint-disable-next-line no-await-in-loop
|
|
await sendPushNotification(
|
|
member,
|
|
{
|
|
title: quest.text(member.preferences.language),
|
|
message: res.t('questInvitationNotificationInfo', member.preferences.language),
|
|
identifier: 'questInvitation',
|
|
category: 'questInvitation',
|
|
},
|
|
);
|
|
}
|
|
|
|
// Send webhooks
|
|
questActivityWebhook.send(member, {
|
|
type: 'questInvited',
|
|
group,
|
|
quest,
|
|
});
|
|
|
|
if (member.preferences.emailNotifications.invitedQuest !== false) {
|
|
membersToEmail.push(member);
|
|
}
|
|
}
|
|
|
|
sendTxnEmail(membersToEmail, `invite-${quest.boss ? 'boss' : 'collection'}-quest`, [
|
|
{ name: 'QUEST_NAME', content: quest.text() },
|
|
{ name: 'INVITER', content: inviterVars.name },
|
|
{ name: 'PARTY_URL', content: '/party' },
|
|
]);
|
|
|
|
// Send webhook to the inviter too
|
|
questActivityWebhook.send(user, {
|
|
type: 'questInvited',
|
|
group,
|
|
quest,
|
|
});
|
|
|
|
// track that the inviting user has accepted the quest
|
|
analytics.track('quest', {
|
|
user,
|
|
uuid: user._id,
|
|
category: 'behavior',
|
|
headers: req.headers,
|
|
owner: true,
|
|
questName: questKey,
|
|
response: 'accept',
|
|
});
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(group.quest.key, 'invite')
|
|
.commit();
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/accept Accept a pending quest
|
|
* @apiName AcceptQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.acceptQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/accept',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
const { user } = res.locals;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId: req.params.groupId, fields: basicGroupFields.concat(' quest chat') });
|
|
|
|
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('questInviteNotFound'));
|
|
if (group.quest.active) throw new NotAuthorized(res.t('questAlreadyStartedFriendly'));
|
|
if (group.quest.members[user._id]) throw new BadRequest(res.t('questAlreadyAccepted'));
|
|
|
|
const acceptedSuccessfully = await group.handleQuestInvitation(user, true);
|
|
if (!acceptedSuccessfully) {
|
|
throw new NotAuthorized(res.t('questAlreadyAccepted'));
|
|
}
|
|
|
|
user.party.quest.RSVPNeeded = false;
|
|
await user.save();
|
|
|
|
if (canStartQuestAutomatically(group)) {
|
|
await group.startQuest(user);
|
|
}
|
|
|
|
const savedGroup = await group.save();
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
// track that a user has accepted the quest
|
|
analytics.track('quest', {
|
|
user,
|
|
category: 'behavior',
|
|
owner: false,
|
|
response: 'accept',
|
|
questName: group.quest.key,
|
|
uuid: user._id,
|
|
headers: req.headers,
|
|
});
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(group.quest.key, 'accept')
|
|
.commit();
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/reject Reject a quest
|
|
* @apiName RejectQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.rejectQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/reject',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
const { user } = res.locals;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId: req.params.groupId, fields: basicGroupFields.concat(' quest chat') });
|
|
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('questAlreadyStartedFriendly'));
|
|
if (group.quest.members[user._id]) throw new BadRequest(res.t('questAlreadyAccepted'));
|
|
if (group.quest.members[user._id] === false) throw new BadRequest(res.t('questAlreadyRejected'));
|
|
|
|
const rejectedSuccessfully = await group.handleQuestInvitation(user, false);
|
|
if (!rejectedSuccessfully) {
|
|
throw new NotAuthorized(res.t('questAlreadyRejected'));
|
|
}
|
|
|
|
user.party.quest = Group.cleanQuestUser(user.party.quest.progress);
|
|
user.markModified('party.quest');
|
|
await user.save();
|
|
|
|
if (canStartQuestAutomatically(group)) {
|
|
await group.startQuest(user);
|
|
}
|
|
|
|
const savedGroup = await group.save();
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
analytics.track('quest', {
|
|
user,
|
|
category: 'behavior',
|
|
owner: false,
|
|
response: 'reject',
|
|
questName: group.quest.key,
|
|
uuid: user._id,
|
|
headers: req.headers,
|
|
});
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(group.quest.key, 'reject')
|
|
.commit();
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/force-start Force-start a pending quest
|
|
* @apiName ForceQuestStart
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiPermission QuestLeader
|
|
* @apiPermission GroupLeader
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.forceStart = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/force-start',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
const { user } = res.locals;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId: req.params.groupId, fields: basicGroupFields.concat(' quest chat') });
|
|
|
|
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('questNotPending'));
|
|
if (group.quest.active) throw new NotAuthorized(res.t('questAlreadyStarted'));
|
|
if (!(user._id === group.quest.leader || user._id === group.leader)) {
|
|
throw new NotAuthorized(res.t('questOrGroupLeaderOnlyStartQuest'));
|
|
}
|
|
|
|
group.markModified('quest');
|
|
|
|
await group.startQuest(user);
|
|
|
|
const [savedGroup] = await Promise.all([
|
|
group.save(),
|
|
user.save(),
|
|
]);
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
analytics.track('quest', {
|
|
user,
|
|
category: 'behavior',
|
|
owner: user._id === group.quest.leader,
|
|
response: 'force-start',
|
|
questName: group.quest.key,
|
|
uuid: user._id,
|
|
headers: req.headers,
|
|
});
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/cancel Cancel a quest that is not active
|
|
* @apiName CancelQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiPermission QuestLeader
|
|
* @apiPermission GroupLeader
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.cancelQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/cancel',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
// Cancel a quest BEFORE it has begun (i.e., in the invitation stage)
|
|
// Quest scroll has not yet left quest owner's inventory so no need to return it.
|
|
// Do not wipe quest progress for members because they'll
|
|
// want it to be applied to the next quest that's started.
|
|
const { user } = res.locals;
|
|
const { groupId } = req.params;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId, fields: basicGroupFields.concat(' 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 (user._id !== group.leader && group.quest.leader !== user._id) {
|
|
throw new NotAuthorized(res.t('onlyLeaderCancelQuest'));
|
|
}
|
|
if (group.quest.active) throw new NotAuthorized(res.t('cantCancelActiveQuest'));
|
|
|
|
const questKey = group.quest.key;
|
|
const questName = questScrolls[questKey].text('en');
|
|
const newChatMessage = await group.sendChat({
|
|
message: `\`${user.profile.name} cancelled the party quest ${questName}.\``,
|
|
info: {
|
|
type: 'quest_cancel',
|
|
user: user.profile.name,
|
|
quest: questKey,
|
|
},
|
|
});
|
|
|
|
group.quest = Group.cleanGroupQuest();
|
|
group.markModified('quest');
|
|
|
|
const [savedGroup] = await Promise.all([
|
|
group.save(),
|
|
newChatMessage.save(),
|
|
User.updateMany(
|
|
{ 'party._id': groupId },
|
|
Group.cleanQuestParty(),
|
|
).exec(),
|
|
]);
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(questKey, 'cancel')
|
|
.commit();
|
|
if (group.quest.leader !== user._id) {
|
|
await UserHistory.beginUserHistoryUpdate(group.quest.leader, req.headers)
|
|
.withQuestInviteResponse(questKey, 'cancelByLeader')
|
|
.commit();
|
|
}
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/abort Abort the current quest
|
|
* @apiName AbortQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiPermission QuestLeader
|
|
* @apiPermission GroupLeader
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.abortQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/abort',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
// Abort a quest AFTER it has begun
|
|
const { user } = res.locals;
|
|
const { groupId } = req.params;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId, fields: basicGroupFields.concat(' quest chat') });
|
|
|
|
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'));
|
|
|
|
const questKey = group.quest.key;
|
|
const questName = questScrolls[questKey].text('en');
|
|
const newChatMessage = await group.sendChat({
|
|
message: `\`${common.i18n.t('chatQuestAborted', { username: user.profile.name, questName }, 'en')}\``,
|
|
info: {
|
|
type: 'quest_abort',
|
|
user: user.profile.name,
|
|
quest: questKey,
|
|
},
|
|
});
|
|
await newChatMessage.save();
|
|
|
|
const memberUpdates = User.updateMany({
|
|
'party._id': groupId,
|
|
}, Group.cleanQuestParty()).exec();
|
|
|
|
const questLeaderUpdate = User.updateOne({
|
|
_id: group.quest.leader,
|
|
}, {
|
|
$inc: {
|
|
[`items.quests.${questKey}`]: 1, // give back the quest to the quest leader
|
|
},
|
|
}).exec();
|
|
|
|
group.quest = Group.cleanGroupQuest();
|
|
group.markModified('quest');
|
|
|
|
const [groupSaved] = await Promise.all([group.save(), memberUpdates, questLeaderUpdate]);
|
|
|
|
res.respond(200, groupSaved.quest);
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(questKey, 'abort')
|
|
.commit();
|
|
if (group.quest.leader !== user._id) {
|
|
await UserHistory.beginUserHistoryUpdate(group.quest.leader, req.headers)
|
|
.withQuestInviteResponse(questKey, 'abortByLeader')
|
|
.commit();
|
|
}
|
|
},
|
|
};
|
|
|
|
/**
|
|
* @api {post} /api/v3/groups/:groupId/quests/leave Leave the active quest
|
|
* @apiName LeaveQuest
|
|
* @apiGroup Quest
|
|
*
|
|
* @apiParam (Path) {String} groupId The group _id (or 'party')
|
|
*
|
|
* @apiSuccess {Object} data Quest Object
|
|
*
|
|
* @apiUse GroupNotFound
|
|
* @apiUse QuestNotFound
|
|
*/
|
|
api.leaveQuest = {
|
|
method: 'POST',
|
|
url: '/groups/:groupId/quests/leave',
|
|
middlewares: [authWithHeaders()],
|
|
async handler (req, res) {
|
|
const { user } = res.locals;
|
|
const { groupId } = req.params;
|
|
|
|
req.checkParams('groupId', apiError('groupIdRequired')).notEmpty();
|
|
|
|
const validationErrors = req.validationErrors();
|
|
if (validationErrors) throw validationErrors;
|
|
|
|
const group = await Group.getGroup({ user, groupId, fields: basicGroupFields.concat(' quest') });
|
|
|
|
if (!group) throw new NotFound(res.t('groupNotFound'));
|
|
if (group.type !== 'party') throw new NotAuthorized(res.t('guildQuestsNotSupported'));
|
|
if (group.quest.leader === user._id) throw new NotAuthorized(res.t('questLeaderCannotLeaveQuest'));
|
|
if (!group.quest.members[user._id]) throw new NotAuthorized(res.t('notPartOfQuest'));
|
|
|
|
group.quest.members[user._id] = false;
|
|
group.markModified('quest.members');
|
|
|
|
user.party.quest = Group.cleanQuestUser(user.party.quest.progress);
|
|
user.markModified('party.quest');
|
|
|
|
const [savedGroup] = await Promise.all([
|
|
group.save(),
|
|
user.save(),
|
|
]);
|
|
|
|
res.respond(200, savedGroup.quest);
|
|
|
|
await UserHistory.beginUserHistoryUpdate(user._id, req.headers)
|
|
.withQuestInviteResponse(group.quest.key, 'leave')
|
|
.commit();
|
|
},
|
|
};
|
|
|
|
export default api;
|