Feature/travel grants

backend/common/errors/errorHandler.js

@@ -40,7 +40,7 @@ const errorHandler = (error, request, response, next) => {
             }
         }
     }
-    console.log('FOOBAR', error.message);
+    console.log('UNHANDLED ERROR', error.message);
 
     return response.status(500).json({
         message: 'Unexpected error',

backend/common/services/sendgrid.js

@@ -64,6 +64,70 @@ const SendgridService = {
 
         return SendgridService.send(msg);
     },
+
+    sendTravelGrantAcceptedEmail: (event, user, params) => {
+        const msg = SendgridService.buildTemplateMessage(user.email, global.gConfig.SENDGRID_GENERIC_TEMPLATE, {
+            header_image: event.coverImage.url,
+            subject: `Your travel grant for ${event.name} has been confirmed`,
+            subtitle: `You have been granted a travel grant of up to ${params.amount}€`,
+            body: `This means that we will assist you with your travel costs to Junction 2019, up to the amount above. Please note that the following conditions apply:
+                <ul>
+                    <li>
+                        The travel grant is valid for travel from ${params.countryOfTravel} to ${event.name}. If you are travelling from somewhere else, 
+                        Junction reserves the right to change your travel grant class and/or amount.
+                    </li>
+                    <li>
+                        Travel grants are only available to participants who have checked in at the venue. 
+                    </li>
+                    <li>    
+                        You will need to supply receipt(s) of your travel to ${event.name}, which clearly shows the total cost of your trip, per traveller. You may provide additional details in the travel receipt file.
+                    </li>
+                    <li>
+                        You have to submit the travel receipt file and additional required information before 24th November 23:59 Finnish Time.
+                    </li>
+                </ul>
+
+                You will be able to submit your receipts and other information required for receiving the travel grant via the registration platform once you have checked in to the event. See you soon!
+
+                Psst, please note that the transaction will be made in Euros, so please make sure you have a bank account able to receive Euro payments available.
+            `,
+            cta_text: 'Event dashboard',
+            cta_link: `${global.gConfig.FRONTEND_URL}/dashboard/${event.slug}`
+        });
+
+        return SendgridService.send(msg);
+    },
+    sendTravelGrantRejectedEmail: (event, user) => {
+        const msg = SendgridService.buildTemplateMessage(user.email, global.gConfig.SENDGRID_GENERIC_TEMPLATE, {
+            header_image: event.coverImage.url,
+            subject: `Your travel grant status for ${event.name}`,
+            subtitle: `Unfortunately we we're unable to give you a travel grant this time...`,
+            body: `
+                We would have loved to give everyone a travel grant, but unfortunately we have a limited budget and you 
+                didn't quite make the cut this time.
+                <br/>
+                <br/>
+                Don't worry, it's nothing personal – we want to give out travel 
+                grants as evenly as possible to our participants, and thus we divided the travel grant applicants to 
+                geographical areas by the country of travel – these are called travel grant classes. We then gave out 
+                the travel grants for confirmed participants in order of registration time within that travel grant class. 
+                This time there were more people applying for travel grants in your travel grant class than we had budget 
+                for and the travel grants were given to those who applied to ${event.name} before you. 
+                <br/>
+                <br/>
+                Hopefully you can still make it to ${event.name} despite this - it's going to be awesome!
+                <br/>
+                <br/>
+                If you won't be able to travel to the event due to not receiving a travel grant, or won't be able to make 
+                it for some other reason, please be so kind and cancel your registration via the Event Dashboard so we can 
+                accept someone from the waitlist.
+            `,
+            cta_text: 'Event dashboard',
+            cta_link: `${global.gConfig.FRONTEND_URL}/dashboard/${event.slug}`
+        });
+
+        return SendgridService.send(msg);
+    },
     sendGenericEmail: (to, params) => {
         const msg = SendgridService.buildTemplateMessage(to, global.gConfig.SENDGRID_GENERIC_TEMPLATE, {
             subject: params.subject,

backend/modules/email-task/controller.js

@@ -3,6 +3,7 @@ const SendgridService = require('../../common/services/sendgrid');
 const EmailTypes = require('./types');
 const EventController = require('../event/controller');
 const UserController = require('../user-profile/controller');
+const RegistrationController = require('../registration/controller');
 const shortid = require('shortid');
 const Promise = require('bluebird');
 const controller = {};
@@ -55,6 +56,25 @@ controller.createRegisteredTask = async (userId, eventId, deliverNow = false) =>
     return task;
 };
 
+controller.createTravelGrantAcceptedTask = async (registration, deliverNow = false) => {
+    const task = await controller.createTask(registration.user, registration.event, EmailTypes.travelGrantAccepted, {
+        amount: registration.travelGrant,
+        countryOfTravel: registration.answers.countryOfTravel
+    });
+    if (task && deliverNow) {
+        return controller.deliverEmailTask(task);
+    }
+    return task;
+};
+
+controller.createTravelGrantRejectedTask = async (registration, deliverNow = false) => {
+    const task = await controller.createTask(registration.user, registration.event, EmailTypes.travelGrantRejected);
+    if (task && deliverNow) {
+        return controller.deliverEmailTask(task);
+    }
+    return task;
+};
+
 controller.createGenericTask = async (userId, eventId, uniqueId, msgParams, deliverNow = false) => {
     if (!uniqueId) {
         uniqueId = shortid.generate();
@@ -84,6 +104,14 @@ controller.deliverEmailTask = async task => {
             await SendgridService.sendRegisteredEmail(event, user);
             break;
         }
+        case EmailTypes.travelGrantAccepted: {
+            await SendgridService.sendTravelGrantAcceptedEmail(event, user, task.params);
+            break;
+        }
+        case EmailTypes.travelGrantRejected: {
+            await SendgridService.sendTravelGrantRejectedEmail(event, user, task.params);
+            break;
+        }
         default: {
             await SendgridService.sendGenericEmail(user.email, task.params);
             break;

backend/modules/email-task/types.js

@@ -1,7 +1,9 @@
 const EmailTypes = {
     registrationAccepted: 'registration-accepted',
     registrationRejected: 'registration-rejected',
-    registrationReceived: 'registration-received'
+    registrationReceived: 'registration-received',
+    travelGrantRejected: 'travelgrant-rejected',
+    travelGrantAccepted: 'travelgrant-accepted'
 };
 
 module.exports = EmailTypes;

backend/modules/filter-group/controller.js

@@ -0,0 +1,35 @@
+const FilterGroup = require('./model');
+
+const controller = {};
+const { NotFoundError } = require('../../common/errors/errors');
+
+controller.createFilterGroup = (label, description, createdBy, eventId, filters) => {
+    const filterGroup = new FilterGroup({
+        label,
+        description,
+        createdBy,
+        filters,
+        event: eventId
+    });
+
+    return filterGroup.save();
+};
+
+controller.editFilterGroup = (label, description, sub, eventId, filters) => {
+    return FilterGroup.findOne({ label, event: eventId }).then(filterGroup => {
+        if (!filterGroup) throw new NotFoundError(`Filter group with label ${label} does not exist`);
+        filterGroup.description = description;
+        filterGroup.filters = filters;
+        return filterGroup.save();
+    });
+};
+
+controller.deleteFilterGroup = (label, eventId) => {
+    return FilterGroup.findOneAndRemove({ label, event: eventId });
+};
+
+controller.getFilterGroupsForEvent = eventId => {
+    return FilterGroup.find({ event: eventId });
+};
+
+module.exports = controller;

backend/modules/filter-group/model.js

@@ -0,0 +1,47 @@
+const mongoose = require('mongoose');
+const {FilterTypes} = require('@hackjunction/shared');
+
+const FilterGroupSchema = new mongoose.Schema({
+    label: {
+        type: String,
+        required: true
+    },
+    description: {
+        type: String
+    },
+    event: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Event',
+        required: true
+    },
+    createdBy: {
+        type: String,
+        required: true
+    },
+    filters: [
+        {
+            label: {
+                type: String
+            },
+            path: {
+                type: String,
+                required: true
+            },
+            type: {
+                type: String,
+                enum: Object.keys(FilterTypes.filterTypes),
+                required: true
+            },
+            value: {
+                type: mongoose.Mixed
+            }
+        }
+    ]
+});
+
+FilterGroupSchema.set('timestamps', true);
+FilterGroupSchema.index({ event: 1, label: 1 }, { unique: true });
+
+const FilterGroup = mongoose.model('FilterGroup', FilterGroupSchema);
+
+module.exports = FilterGroup;

backend/modules/filter-group/routes.js

@@ -0,0 +1,60 @@
+const express = require('express');
+const router = express.Router();
+const asyncHandler = require('express-async-handler');
+
+const { Auth } = require('@hackjunction/shared');
+
+const FilterGroupController = require('./controller');
+
+const { hasToken } = require('../../common/middleware/token');
+const { hasPermission } = require('../../common/middleware/permissions');
+const { isEventOrganiser } = require('../../common/middleware/events');
+
+const createFilterGroup = asyncHandler(async (req, res) => {
+    console.log('CREATING FILTER GROUP');
+
+    const { label, description, filters } = req.body;
+    const { sub } = req.user;
+    const { _id } = req.event;
+    console.log('CREATING FILTER GROUP');
+
+    const filterGroup = await FilterGroupController.createFilterGroup(label, description, sub, _id.toString(), filters);
+    console.log('CREATING FILTER GROUP');
+
+    return res.status(200).json(filterGroup);
+});
+
+const editFilterGroup = asyncHandler(async (req, res) => {
+    const { label, description, filters } = req.body;
+    const { sub } = req.user;
+    const { _id } = req.event;
+
+    const filterGroup = await FilterGroupController.editFilterGroup(label, description, sub, _id.toString(), filters);
+    return res.status(200).json(filterGroup);
+});
+
+const deleteFilterGroup = asyncHandler(async (req, res) => {
+    const { label } = req.body;
+    const { _id } = req.event;
+
+    const filterGroup = await FilterGroupController.deleteFilterGroup(label, _id.toString());
+
+    return res.status(200).json(filterGroup);
+});
+
+const getFilterGroupsForEvent = asyncHandler(async (req, res) => {
+    const { _id } = req.event;
+
+    const filterGroups = await FilterGroupController.getFilterGroupsForEvent(_id.toString());
+
+    return res.status(200).json(filterGroups);
+});
+
+router
+    .route('/:slug')
+    .get(hasToken, hasPermission(Auth.Permissions.MANAGE_EVENT), isEventOrganiser, getFilterGroupsForEvent)
+    .post(hasToken, hasPermission(Auth.Permissions.MANAGE_EVENT), isEventOrganiser, createFilterGroup)
+    .patch(hasToken, hasPermission(Auth.Permissions.MANAGE_EVENT), isEventOrganiser, editFilterGroup)
+    .delete(hasToken, hasPermission(Auth.Permissions.MANAGE_EVENT), isEventOrganiser, deleteFilterGroup);
+
+module.exports = router;

backend/modules/registration/controller.js

@@ -1,6 +1,6 @@
 const _ = require('lodash');
 const Promise = require('bluebird');
-const { RegistrationStatuses } = require('@hackjunction/shared');
+const { RegistrationStatuses, RegistrationFields, FieldTypes } = require('@hackjunction/shared');
 const Registration = require('./model');
 const { NotFoundError, ForbiddenError } = require('../../common/errors/errors');
 const UserProfileController = require('../user-profile/controller');
@@ -74,19 +74,26 @@ controller.getRegistrationsForEvent = eventId => {
     }).then(registrations => {
         /** Do some minor optimisation here to cut down on size */
         return registrations.map(reg => {
-            reg.answers = _.mapValues(reg.answers, answer => {
-                if (typeof answer === 'string' && answer.length > 50) {
-                    return answer.slice(0, 10) + '...';
-                }
-                if (typeof answer === 'object' && Object.keys(answer).length > 0) {
-                    return _.mapValues(answer, subAnswer => {
-                        if (typeof subAnswer === 'string' && subAnswer.length > 50) {
-                            return subAnswer.slice(0, 10);
+            reg.answers = _.mapValues(reg.answers, (answer, field) => {
+                const fieldType = RegistrationFields.getFieldType(field);
+                switch (fieldType) {
+                    case FieldTypes.LONG_TEXT.id:
+                        if (answer && answer.length > 10) {
+                            return answer.slice(0, 10) + '...';
+                        }
+                        return answer;
+                    default: {
+                        if (typeof answer === 'object' && !Array.isArray(answer) && Object.keys(answer).length > 0) {
+                            return _.mapValues(answer, subAnswer => {
+                                if (typeof subAnswer === 'string' && subAnswer.length > 50) {
+                                    return subAnswer.slice(0, 10);
+                                }
+                                return subAnswer;
+                            });
                         }
-                        return subAnswer;
-                    });
+                        return answer;
+                    }
                 }
-                return answer;
             });
             return reg;
         });
@@ -126,7 +133,7 @@ controller.assignRegistrationForEvent = data => {
 };
 
 controller.bulkEditRegistrations = (eventId, registrationIds, edits) => {
-    const cleanedEdits = _.pick(edits, ['status', 'tags', 'rating', 'assignedTo']);
+    const cleanedEdits = _.pick(edits, ['status', 'tags', 'rating', 'assignedTo', 'travelGrant']);
     return Registration.updateMany(
         {
             event: eventId,
@@ -138,6 +145,37 @@ controller.bulkEditRegistrations = (eventId, registrationIds, edits) => {
     );
 };
 
+controller.bulkAssignTravelGrants = (eventId, grants) => {
+    const updates = grants.map(({ _id, amount }) => {
+        return Registration.findById(_id).then(reg => {
+            reg.travelGrant = amount;
+            return reg.save();
+        });
+    });
+
+    return Promise.all(updates);
+};
+
+controller.rejectPendingTravelGrants = eventId => {
+    return Registration.find({
+        event: eventId,
+        status: {
+            $in: ['confirmed', 'checkedIn']
+        },
+        travelGrant: {
+            $exists: false
+        },
+        'answers.needsTravelGrant': true
+    }).then(registrations => {
+        const promises = registrations.map(registration => {
+            registration.travelGrant = 0;
+            return registration.save();
+        });
+
+        return Promise.all(promises);
+    });
+};
+
 controller.getFullRegistration = (eventId, registrationId) => {
     return Registration.findById(registrationId).then(registration => {
         if (!registration || registration.event.toString() !== eventId) {
@@ -155,6 +193,7 @@ controller.editRegistration = (registrationId, event, data, user) => {
         registration.ratedBy = user.sub;
         registration.tags = data.tags;
         registration.assignedTo = data.assignedTo;
+        registration.travelGrant = data.travelGrant;
         return registration.save();
     });
 };