289 lines
11 KiB
JavaScript
289 lines
11 KiB
JavaScript
'use strict';
|
|
const httpStatus = require('http-status');
|
|
const moment = require('moment');
|
|
const generateControllers = require('../../core/controllers');
|
|
const { buildContext } = require('../../core/controllers');
|
|
const notificationService = require('./notification.service');
|
|
const notificationDetailService = require('./notification_detail.service');
|
|
const userService = require('../auth/user.service');
|
|
const userDeviceService = require('./user_device.service');
|
|
const eventInscriptionService = require('../events/events_inscriptions.service');
|
|
const { usersIdsComposer } = require('../../helpers/composes.helper');
|
|
const pushHelper = require('../../helpers/push.helper');
|
|
const notificationHelper = require('../../helpers/notification.helpers')
|
|
|
|
const { extractParamsFromRequest, handleErrorResponse, handleResultResponse } = require('../../helpers/controller.helper');
|
|
const { get } = require('lodash');
|
|
|
|
// Module Name
|
|
const MODULE_NAME = '[notification.controller]';
|
|
const controllerOptions = { MODULE_NAME };
|
|
|
|
|
|
async function _sendNotificationAllActiveUsers(notification) {
|
|
let limit = 4;
|
|
let page = 1;
|
|
|
|
let totalRows = 0;
|
|
let totalPages = -1;
|
|
|
|
do {
|
|
let offset = (page - 1) * limit;
|
|
let result = await userService._getActiveUserIds(offset, limit);
|
|
|
|
if (totalPages == -1) {
|
|
totalPages = Math.ceil(result.count / limit);
|
|
}
|
|
|
|
page = page + 1;
|
|
|
|
let ids = result.rows.map(function (item) { return item.id });
|
|
notificationService.sendNotification(notification, ids);
|
|
|
|
|
|
} while (page <= totalPages);
|
|
|
|
return 'OK';
|
|
}
|
|
|
|
async function _getUserIdsForEventId(eventId, segment) {
|
|
let userIds = [];
|
|
|
|
switch (segment) {
|
|
//Todos los inscritos tanto invitados como libres
|
|
case 'ALL_VALIDATED':
|
|
userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, true);
|
|
break;
|
|
//Todos los de lista de espera tanto invitados como libres (Actualmente en invitados no hay lista de espera)
|
|
case 'ALL_NOT_VALIDATED':
|
|
userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, false);
|
|
break;
|
|
|
|
//Solo invitados como actualmente no se usa codigo de reserva para los coles, vale con filtrar por aquellos que tengan codigo de reserva
|
|
case 'PARTNERS_ALL':
|
|
userIds = await eventInscriptionService._getInscriptionByEventFromPartner(eventId);
|
|
break;
|
|
|
|
//Todos los inscritos al evento, tanto validados como en lista de espera
|
|
default: //ALL
|
|
userIds = await eventInscriptionService._getInscriptionByEvent(eventId);
|
|
break;
|
|
}
|
|
|
|
return usersIdsComposer(userIds);
|
|
}
|
|
|
|
|
|
const extraControllers = {
|
|
|
|
sendNotification: (config) => {
|
|
|
|
/**
|
|
* notificationSample = {
|
|
* "tittle": "título de la notificación",
|
|
* "message": "cuerpo de la notificación",
|
|
* "recipients": {
|
|
* OPCION 1- Unos usuarios determinados
|
|
* "userIds": ["*" | "f428a317-6d1f-4eda-aa3e-22baff3f48d7", ...]
|
|
* "segment": "ALL" | "LAST_YEAR" | "LAST_MONTH"
|
|
*
|
|
* OPCION 2 - A todos los usuarios inscritos a un evento, se puede segmentar
|
|
* "eventId": "xxx-xxx-xxx-xxx",
|
|
* "segment": "ALL" | "ALL_VALIDATED" | "ALL_NOT_VALIDATED" |
|
|
* "PARTNERS_ALL" | "PARTNERS_VALIDATED" | "PARTNERS_NOT_VALIDATED" |
|
|
* "COLLEGE_ALL" | "COLLEGE_VALIDATED" | "COLLEGE_NOT_VALIDATED"
|
|
* },
|
|
* "data": {
|
|
* "type": "message",
|
|
* "title": "Título del mensaje",
|
|
* "message": "Cuerpo del mensaje",
|
|
* "button": {
|
|
* "caption": "Etiqueta del boton",
|
|
* "url": "https://www.site.es",
|
|
* "screen": "<RouterName>",
|
|
* "paramId": "23",
|
|
* }
|
|
* }
|
|
*}
|
|
*/
|
|
|
|
return async (req, res, next) => {
|
|
config = config || {
|
|
scopes: [],
|
|
};
|
|
|
|
const context = buildContext(req, config);
|
|
let params = extractParamsFromRequest(req, res);
|
|
|
|
let receipt = undefined;
|
|
let userIds = undefined;
|
|
let eventId = undefined;
|
|
let segment = undefined;
|
|
const { body } = req;
|
|
|
|
if (!body.title) {
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing message title'), res)
|
|
}
|
|
|
|
if (!body.body) {
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing body content'), res)
|
|
}
|
|
|
|
// Evento?
|
|
if (body.recipients.eventId) {
|
|
eventId = body.recipients.eventId;
|
|
segment = body.recipients.segment;
|
|
} else if (body.recipients.userIds) {
|
|
userIds = body.recipients.userIds;
|
|
segment = body.recipients.segment;
|
|
} else {
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing user Ids or event Ids'), res)
|
|
}
|
|
|
|
|
|
try {
|
|
|
|
let notification = notificationHelper.createNotification({
|
|
...body,
|
|
userId: context.user.id
|
|
});
|
|
|
|
if ((userIds) && (userIds.length == 1) && (userIds[0] == "*")) {
|
|
receipt = _sendNotificationAllActiveUsers(notification);
|
|
} else {
|
|
|
|
let _userIds = null;
|
|
|
|
if (userIds) {
|
|
_userIds = userIds;
|
|
} else {
|
|
if (eventId) {
|
|
_userIds = await _getUserIdsForEventId(eventId, segment);
|
|
} else {
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing event and segment'), res)
|
|
}
|
|
}
|
|
|
|
if (_userIds) {
|
|
receipt = notificationService.sendNotification(notification, _userIds);
|
|
}
|
|
}
|
|
|
|
|
|
/*let getUserIds = async () => {
|
|
if (userIds) {
|
|
return new Promise(function(resolve) { resolve(userIds) } );
|
|
} else if (eventId) {
|
|
switch (segment) {
|
|
//Todos los inscritos tanto invitados como libres
|
|
case 'ALL_VALIDATED':
|
|
userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, true);
|
|
break;
|
|
//Todos los de lista de espera tanto invitados como libres (Actualmente en invitados no hay lista de espera)
|
|
case 'ALL_NOT_VALIDATED':
|
|
userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, false);
|
|
break;
|
|
|
|
//Solo invitados como actualmente no se usa codigo de reserva para los coles, vale con filtrar por aquellos que tengan codigo de reserva
|
|
case 'PARTNERS_ALL':
|
|
userIds = await eventInscriptionService._getInscriptionByEventFromPartner(eventId);
|
|
break;
|
|
|
|
//Todos los inscritos al evento, tanto validados como en lista de espera
|
|
default: //ALL
|
|
userIds = await eventInscriptionService._getInscriptionByEvent(eventId);
|
|
break;
|
|
}
|
|
|
|
return new Promise(function (resolve) { resolve(usersIdsComposer(userIds)); });
|
|
|
|
} else {
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing event and segment'), res)
|
|
}
|
|
} */
|
|
|
|
//receipt = notificationService.sendNotification(notification, await getUserIds());
|
|
|
|
return handleResultResponse(receipt, null, null, res, httpStatus.OK);
|
|
} catch (error) {
|
|
console.error(error);
|
|
return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', error, res)
|
|
}
|
|
}
|
|
},
|
|
|
|
updateNotificationsWithReceipts: (config) => {
|
|
return async (req, res, next) => {
|
|
/*config = config || {
|
|
scopes: [],
|
|
};
|
|
|
|
const context = buildContext(req, config);
|
|
let params = extractParamsFromRequest(req, res);
|
|
|
|
let getNotificationsWithoutReceipt = async () => {
|
|
let params = {
|
|
where: {}
|
|
};
|
|
return await notificationDetailService.fetchAll(params, context);
|
|
}
|
|
|
|
let receipt = await Promise.all(getUserDevicesList).then(
|
|
function (userDeviceList) {
|
|
return Promise.all(userDeviceList.map(buildMessagePromise))
|
|
})
|
|
.then(sendNotificationsPromise)
|
|
*/
|
|
}
|
|
},
|
|
|
|
registerDevice: (config) => {
|
|
return async (req, res, next) => {
|
|
config = config || {
|
|
scopes: [],
|
|
};
|
|
|
|
|
|
try {
|
|
const context = buildContext(req, config);
|
|
const userId = context.user && context.user.id ? context.user.id : null;
|
|
|
|
|
|
let data = {
|
|
token: req.body.token,
|
|
valid: 1,
|
|
userId
|
|
};
|
|
|
|
|
|
let params = extractParamsFromRequest(req, res, {
|
|
includeAll: false,
|
|
paginate: { limit: 1, page: 1 },
|
|
params: {
|
|
token: data.token,
|
|
}
|
|
});
|
|
|
|
// Buscamos el token y el usuario
|
|
console.log('>> Busco el token', params.params);
|
|
let result = await userDeviceService.fetchOne(params, context);
|
|
|
|
if (result) {
|
|
// Borramos el registro donde aparece el token
|
|
console.log('>> Borro el registro del token', params.params, data, context);
|
|
result = await userDeviceService.delete(params, context);
|
|
}
|
|
|
|
// Dar de alta el token
|
|
console.log('>> Dar de alta el token', data);
|
|
result = await userDeviceService.create(data, context);
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
// En todo caso devolver OK al cliente
|
|
return handleResultResponse('OK', null, null, res, httpStatus.OK);
|
|
}
|
|
},
|
|
};
|
|
|
|
module.exports = generateControllers(notificationService, extraControllers, controllerOptions); |