310 lines
9.6 KiB
JavaScript
310 lines
9.6 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 = 33;
|
|
let page = 1;
|
|
|
|
let totalRows = 0;
|
|
let totalPages = -1;
|
|
|
|
do {
|
|
let offset = (page - 1) * limit;
|
|
let result = await userService._getActiveUserIds(offset, limit, notification.recipients.country);
|
|
|
|
if (totalPages == -1) {
|
|
totalPages = Math.ceil(result.count / limit);
|
|
}
|
|
|
|
page = page + 1;
|
|
|
|
let ids = result.rows.map(function (item) {
|
|
return item.id;
|
|
});
|
|
notificationService.sendNotificationToUsers(notification, ids);
|
|
} while (page <= totalPages);
|
|
|
|
return "OK";
|
|
}
|
|
|
|
async function _sendNotificationAllActiveDevices(notification) {
|
|
let limit = 33;
|
|
let page = 1;
|
|
|
|
let totalRows = 0;
|
|
let totalPages = -1;
|
|
|
|
do {
|
|
let offset = (page - 1) * limit;
|
|
let result = await userDeviceService._getActiveDeviceIds(offset, limit, notification.recipients.country);
|
|
|
|
console.log(result);
|
|
|
|
if (totalPages == -1) {
|
|
totalPages = Math.ceil(result.count / limit);
|
|
}
|
|
|
|
page = page + 1;
|
|
|
|
notificationService.sendNotificationToDevices(notification, result.rows);
|
|
} 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 = {
|
|
* "title": "título de la notificación",
|
|
* "body": "cuerpo de la notificación",
|
|
* "recipients": {
|
|
* OPCION 1- Unos usuarios determinados
|
|
* "userIds": ["*" | "f428a317-6d1f-4eda-aa3e-22baff3f48d7", ...]
|
|
* "segment": "ALL" | "LAST_YEAR" | "LAST_MONTH"
|
|
* "country": "*" | "ES" | "MX"
|
|
*
|
|
* 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"
|
|
* OPCION 3 - A todos los dispositivos activos de un país
|
|
* "deviceIds": ["*" | "ExponentPushToken[YbOS1AIZjQbchZbxNaVRqC]", ...]
|
|
* "country": "*" | "ES" | "MX"
|
|
* },
|
|
* "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 deviceIds = undefined;
|
|
let eventId = undefined;
|
|
let segment = undefined;
|
|
let country = 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;
|
|
country = body.recipients.country;
|
|
} else if (body.recipients.deviceIds) {
|
|
deviceIds = body.recipients.deviceIds;
|
|
country = body.recipients.country;
|
|
} else {
|
|
return handleErrorResponse(
|
|
controllerOptions.MODULE_NAME,
|
|
"sendNotification",
|
|
new Error("Missing user Ids or event Ids or devices Ids"),
|
|
res
|
|
);
|
|
}
|
|
|
|
try {
|
|
let notification = notificationHelper.createNotification({
|
|
...body,
|
|
userId: context.user.id,
|
|
});
|
|
|
|
if (userIds && userIds.length == 1 && userIds[0] == "*") {
|
|
receipt = _sendNotificationAllActiveUsers(notification);
|
|
} else if (deviceIds && deviceIds.length == 1 && deviceIds[0] == "*") {
|
|
receipt = _sendNotificationAllActiveDevices(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.sendNotificationToUsers(notification, _userIds);
|
|
}
|
|
}
|
|
|
|
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,
|
|
country: req.body.country,
|
|
userId,
|
|
};
|
|
|
|
let params = extractParamsFromRequest(req, res, {
|
|
includeAll: false,
|
|
paginate: { limit: 1, page: 1 },
|
|
params: {
|
|
token: data.token,
|
|
},
|
|
});
|
|
|
|
console.log(req.body, data, params);
|
|
|
|
// 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);
|