1065 lines
46 KiB
JavaScript
1065 lines
46 KiB
JavaScript
"use strict";
|
|
const moment = require("moment");
|
|
const httpStatus = require("http-status");
|
|
const generateControllers = require("../../core/controllers");
|
|
const QRHelper = require("../../helpers/qr.helper");
|
|
const emailHelper = require("../../helpers/mail.helper");
|
|
const notificationHelper = require("../../helpers/notification.helpers");
|
|
const path = require("path");
|
|
const messages = require("../../helpers/messages.json");
|
|
const eventService = require("./event.service");
|
|
const eventReservationService = require("./events_reservations.service");
|
|
const eventInscriptionService = require("./events_inscriptions.service");
|
|
const notificationService = require("../notification/notification.service");
|
|
|
|
const {
|
|
extractParamsFromRequest,
|
|
handleErrorResponse,
|
|
handleResultResponse,
|
|
} = require("../../helpers/controller.helper");
|
|
|
|
//PRUEBA
|
|
const SchemaValidator = require("../../middlewares/schemaValidator");
|
|
const eventValidation = require("./event.validations");
|
|
const Joi = require("joi");
|
|
const userService = require("../auth/user.service");
|
|
|
|
// Module Name
|
|
const MODULE_NAME = "[event.controller]";
|
|
const controllerOptions = { MODULE_NAME };
|
|
|
|
function generateMemberInscription(user, inscription, reservation) {
|
|
let memberInscription = null;
|
|
if (user && inscription) {
|
|
memberInscription = {
|
|
marketing_memberId: null,
|
|
email: user.email,
|
|
name: user.name,
|
|
surname: user.surname,
|
|
source: inscription.source,
|
|
event_name: inscription.event ? inscription.event.name : "N/A",
|
|
event_date: inscription.event ? inscription.event.init_date : "N/A",
|
|
reservation_code: reservation ? reservation.reservation_code : null,
|
|
date_inscription: inscription.date,
|
|
code_ticket: inscription.code_ticket,
|
|
validated: inscription.validated,
|
|
color: reservation ? reservation.color : null,
|
|
description: (reservation ? reservation.description : "Entrada").toUpperCase(),
|
|
entity: reservation ? reservation.Entity.name : user.entityId,
|
|
userId: user.id,
|
|
qrConfig: null,
|
|
qrCode: null,
|
|
};
|
|
}
|
|
|
|
return memberInscription;
|
|
}
|
|
|
|
function generateQRConfig(member) {
|
|
let qrConfig = null;
|
|
if (member) {
|
|
qrConfig = {
|
|
name: member.name,
|
|
surname: member.surname,
|
|
date: member.date_inscription,
|
|
code: member.code_ticket,
|
|
color: member.color,
|
|
};
|
|
}
|
|
|
|
return qrConfig;
|
|
}
|
|
|
|
function generateHeaderMail(member) {
|
|
let headerMail = null;
|
|
if (member) {
|
|
headerMail = {
|
|
to: member.email,
|
|
name: member.name + " " + member.surname,
|
|
subject:
|
|
(member.validated ? "Entrada" : "Lista de espera") + " para el congreso " + member.event_name + " confirmada",
|
|
};
|
|
}
|
|
|
|
return headerMail;
|
|
}
|
|
|
|
function generateBodyMail(member) {
|
|
let bodyMail = null;
|
|
if (member) {
|
|
bodyMail = {
|
|
tipoEntrada: member.validated ? "Entrada" : "Lista de espera",
|
|
descriptionEntrada: member.description,
|
|
qrCode: member.qrCode,
|
|
qrCodeUrl: member.qrCodeUrl,
|
|
color: member.qrConfig.color,
|
|
codeTicket: member.code_ticket,
|
|
eventName: member.event_name,
|
|
dateEvent: moment(member.event_date).format("D [de] MMMM [de] YYYY"),
|
|
dateInscription: moment(member.date_inscription).format("DD/MM/YY HH:mm "),
|
|
};
|
|
}
|
|
return bodyMail;
|
|
}
|
|
|
|
const extraControllers = {
|
|
checkCapacity: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
let result = {
|
|
eventId: params.params.id,
|
|
group_size: params.query.group_size ? Number(params.query.group_size) : 1,
|
|
allow: false,
|
|
error: undefined,
|
|
};
|
|
|
|
if (!result.eventId) {
|
|
return handleResultResponse(null, null, params, res, httpStatus.BAD_REQUEST);
|
|
}
|
|
|
|
if (!result.group_size) {
|
|
return handleResultResponse(null, null, params, res, httpStatus.BAD_REQUEST);
|
|
}
|
|
|
|
const Event = await eventService._getEvent(result.eventId);
|
|
try {
|
|
if (!Event) {
|
|
result = Object.assign({}, result, {
|
|
error: "El evento solicitado no existe",
|
|
});
|
|
} else {
|
|
let EventOverflow = null;
|
|
|
|
if (Event.overflow_eventId && Event.allow_overflow)
|
|
EventOverflow = await eventService._getEvent(Event.overflow_eventId);
|
|
|
|
result = Object.assign({}, result, {
|
|
allow: Event.assistants - Event.confirmed > result.group_size, // false
|
|
assistants: Event.assistants,
|
|
confirmed: Event.confirmed,
|
|
sold_out: Event.sold_out,
|
|
assistants_overflow: EventOverflow ? EventOverflow.assistants : 0,
|
|
confirmed_overflow: EventOverflow ? EventOverflow.confirmed : 0,
|
|
sold_out_overflow: EventOverflow ? EventOverflow.sold_out : 1,
|
|
allow_overflow: EventOverflow
|
|
? EventOverflow.assistants - EventOverflow.confirmed > result.group_size
|
|
: false,
|
|
});
|
|
}
|
|
|
|
return handleResultResponse(result, null, params, res, result === null ? httpStatus.NOT_FOUND : httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "allowCapacity", error, res);
|
|
}
|
|
},
|
|
|
|
checkReservationCode: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const appVersion = req && req.headers && req.headers["accept-version"] ? req.headers["accept-version"] : null;
|
|
console.log("checkReservationCode - appVersion: ", appVersion);
|
|
console.log("checkReservationCode - PARAMS ", params);
|
|
|
|
const eventId = params.params.id;
|
|
const encodedInvitationCode = params.params.encodedInvitationCode;
|
|
|
|
const registrationCode = Buffer.from(req.params.encodedInvitationCode, "base64").toString("ascii");
|
|
|
|
try {
|
|
const result = await eventReservationService._getReservaByCode(eventId, registrationCode);
|
|
if (appVersion) {
|
|
if (appVersion == "1.0.0" || appVersion == "1.0.1" || appVersion == "1.0.2")
|
|
return handleResultResponse(!!result, null, params, res, httpStatus.OK);
|
|
else return handleResultResponse(result, null, params, res, httpStatus.OK);
|
|
} else return handleResultResponse(!!result, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "checkReservationCode", error, res);
|
|
}
|
|
},
|
|
|
|
//Funcion que devuelve:
|
|
//1. Todas las inscripciones de un evento, cuando el usuario es administrador
|
|
//2. Todas las inscripciones de un usuario, cuando no nos llega ningun param con id
|
|
getInscriptions: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const eventId = params.params.id;
|
|
const userId = req.user.id;
|
|
var result = null;
|
|
|
|
console.log(params, req.user.level);
|
|
if (eventId) {
|
|
try {
|
|
if (req.user.level === 8) result = await eventInscriptionService._getInscriptionByEvent(eventId);
|
|
else result = await eventInscriptionService._getInscriptionByEventAndUser(eventId, userId);
|
|
|
|
return handleResultResponse(result, null, params, res, result === null ? httpStatus.NOT_FOUND : httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "getInscriptions", error, res);
|
|
}
|
|
} else {
|
|
try {
|
|
result = await eventInscriptionService._getInscriptionsUser(userId);
|
|
return handleResultResponse(result, null, params, res, result === null ? httpStatus.NOT_FOUND : httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "getInscriptions", error, res);
|
|
}
|
|
}
|
|
},
|
|
|
|
getInscriptionsOfNextEventsCount: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const userId = req.user.id;
|
|
|
|
try {
|
|
const result = await eventInscriptionService._getInscriptionsOfNextEventsUser(userId);
|
|
console.log("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
|
|
return handleResultResponse({ count: result }, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
console.log("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
|
|
return handleErrorResponse(MODULE_NAME, "getInscriptionsOfNextEventsCount", error, res);
|
|
}
|
|
},
|
|
|
|
getInscription: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const inscriptionId = params.params.id;
|
|
const userId = req.user.id;
|
|
|
|
try {
|
|
let inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
if (!inscription) {
|
|
return handleResultResponse("Inscripción no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
} else if (inscription.userId !== userId) {
|
|
return handleResultResponse("Inscripción no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
console.log("inscripcion encontrada>>>>>>>>>>>>>>>>>>>>>>>>>>>", inscription);
|
|
inscription = await inscription.toJSON();
|
|
var member = generateMemberInscription(inscription.user, inscription, inscription.reservation);
|
|
member.qrConfig = generateQRConfig(member);
|
|
inscription.code_ticket_qr = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
console.log(">>>>>>>voy a dar inscription");
|
|
return handleResultResponse(inscription, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleResultResponse("Error al buscar la inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
|
|
findPartners: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
try {
|
|
const result = await eventReservationService._getPartners(params.params.id);
|
|
return handleResultResponse(result, result.count, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "findPartners", error, res);
|
|
}
|
|
},
|
|
|
|
findColleges: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
try {
|
|
const result = await eventReservationService._getColleges(params.params.id);
|
|
return handleResultResponse(result, result.count, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "findPartners", error, res);
|
|
}
|
|
},
|
|
|
|
validateInscription: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const user = req.user;
|
|
const inscriptionId = params.params.id;
|
|
|
|
try {
|
|
let inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
//console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion a Validar:');
|
|
//console.log(inscription);
|
|
|
|
//Si la inscripcion no existe o ya está validada no hago nada
|
|
if (!inscription)
|
|
return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
else if (inscription.validated)
|
|
return handleResultResponse("Inscripción validada", null, params, res, httpStatus.OK);
|
|
|
|
//Si la inscripción es lista de espera de una reserva
|
|
if (inscription.reservationId) {
|
|
return handleResultResponse(
|
|
"Inscription a validar viene por reserva hay que implementarlo",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
// console.log('Tengo reservation>>>>>>>>>>>>>>>>>>', inscription.reservationId);
|
|
// NewConfirmed = await eventInscriptionService._getCountInscriptionsWithReservation(EventOrReservationChangeId)
|
|
// marketingListId = (await eventReservationService._getReservaById(EventOrReservationChangeId)).marketing_list;
|
|
// if (!await eventReservationService._updateConfirmedReservation(EventOrReservationChangeId, NewConfirmed))
|
|
// return handleResultResponse("Error al eliminar inscripción, no puedo cambiar confirmados a la reserva asociada", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
//Si la inscripcion es lista de espera del evento
|
|
else if (inscription.overflowEventId) {
|
|
const OverflowEventId = inscription.overflowEventId;
|
|
|
|
if ((await eventInscriptionService._validateInscription(inscription.id, user.id)) > 0) {
|
|
inscription.validated = true;
|
|
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion validada");
|
|
var NewConfirmedOverflow = await eventInscriptionService._getCountInscriptionsWithOverflowEventId(
|
|
OverflowEventId
|
|
);
|
|
var NewConfirmedEvent = await eventInscriptionService._getCountInscriptionsWithoutReservationAndOverflow(
|
|
inscription.eventId
|
|
);
|
|
var marketingListIdOverflow = (await eventService._getEvent(OverflowEventId)).marketing_list;
|
|
var marketingListIdEvent = (await eventService._getEvent(inscription.eventId)).marketing_list;
|
|
console.log(">>>>>>>>>>>>>>><NewConfirmedOverflow: ", NewConfirmedOverflow);
|
|
console.log(">>>>>>>>>>>>>>><NewConfirmedEvent: ", NewConfirmedEvent);
|
|
|
|
//Actualizamos aforos
|
|
if (!(await eventService._updateConfirmedEvent(OverflowEventId, NewConfirmedOverflow)))
|
|
return handleResultResponse(
|
|
"Error al validad inscripción, no puedo cambiar confirmados a la lista de espera",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
if (!(await eventService._updateConfirmedEvent(inscription.eventId, NewConfirmedEvent)))
|
|
return handleResultResponse(
|
|
"Error al validad inscripción, no puedo cambiar confirmados al evento",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
try {
|
|
//Eliminamos miembro de la lista de mailchimp a la que está asociado
|
|
await eventInscriptionService._deleteMember(marketingListIdOverflow, inscription.user.email); // inscription.marketing_memberId);
|
|
} catch (error) {
|
|
console.log("validate incription", error);
|
|
}
|
|
|
|
//Mandar correo de confirmacion de inscripcion
|
|
try {
|
|
var member = generateMemberInscription(inscription.user, inscription, inscription.reservation);
|
|
member.marketing_memberId = await eventInscriptionService._addMember(marketingListIdEvent, member);
|
|
eventInscriptionService._updateMarketingMemberOfInscription(inscription.id, member.marketing_memberId);
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
member.qrCodeUrl = QRHelper.getInscriptionQRCodeUrl(inscription.id);
|
|
console.log(
|
|
"mandar correo>>>>>>>>>>>>>await QRHelper.getInscriptionQRCode(member.qrConfig); >>>>>>>> ",
|
|
member
|
|
);
|
|
emailHelper.sendTicket(generateHeaderMail(member), generateBodyMail(member));
|
|
} catch (error) {
|
|
console.log("No se ha podido mandar email con entrada");
|
|
}
|
|
|
|
try {
|
|
let notification = notificationHelper.createNotificationValidatedInscription(inscription);
|
|
console.log(notification);
|
|
let result = notificationService.sendNotification(notification, [inscription.user.id]);
|
|
|
|
console.log(result);
|
|
} catch (error) {
|
|
console.log("No se ha podido mandar push");
|
|
}
|
|
}
|
|
|
|
return handleResultResponse("Inscripción validada", null, params, res, httpStatus.OK);
|
|
} else return handleResultResponse("No se pudo validar inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
} catch (error) {
|
|
console.log(error);
|
|
return handleResultResponse("Error al validar inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
|
|
deleteInscription: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const user = req.user;
|
|
const inscriptionId = params.params.id;
|
|
|
|
try {
|
|
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion a borrar:");
|
|
console.log(inscription);
|
|
if (!inscription || inscription.userId !== user.id)
|
|
return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
|
|
//Borramos inscripcion y descontamos asistentes
|
|
if ((await eventInscriptionService._deleteInscription(inscription.id)) > 0) {
|
|
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion borrada");
|
|
const EventOrReservationChangeId = inscription.reservationId
|
|
? inscription.reservationId
|
|
: inscription.overflowEventId
|
|
? inscription.overflowEventId
|
|
: inscription.eventId;
|
|
let NewConfirmed = 0;
|
|
let marketingListId = null;
|
|
|
|
if (inscription.reservationId != null) {
|
|
console.log("Tengo reservation>>>>>>>>>>>>>>>>>>", inscription.reservationId);
|
|
NewConfirmed = await eventInscriptionService._getCountInscriptionsWithReservation(EventOrReservationChangeId);
|
|
marketingListId = (await eventReservationService._getReservaById(EventOrReservationChangeId)).marketing_list;
|
|
} else if (inscription.overflowEventId != null) {
|
|
console.log("Tengo overflow>>>>>>>>>>>>>>>>>>", inscription.overflowEventId);
|
|
NewConfirmed = await eventInscriptionService._getCountInscriptionsWithOverflowEventId(
|
|
EventOrReservationChangeId
|
|
);
|
|
marketingListId = (await eventService._getEvent(EventOrReservationChangeId)).marketing_list;
|
|
} else if (inscription.eventId != null) {
|
|
NewConfirmed = await eventInscriptionService._getCountInscriptionsWithoutReservationAndOverflow(
|
|
EventOrReservationChangeId
|
|
);
|
|
marketingListId = (await eventService._getEvent(EventOrReservationChangeId)).marketing_list;
|
|
}
|
|
|
|
//Actualizamos aforo del evento o de la reserva
|
|
if (inscription.reservationId != null) {
|
|
console.log(">>>>>>>>>>>>>>Voy a actualizar aforo reserva", EventOrReservationChangeId);
|
|
console.log(">>>>>>>>>>>>>> ", NewConfirmed);
|
|
if (!(await eventReservationService._updateConfirmedReservation(EventOrReservationChangeId, NewConfirmed)))
|
|
return handleResultResponse(
|
|
"Error al eliminar inscripción, no puedo cambiar confirmados a la reserva asociada",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
} else {
|
|
console.log(">>>>>>>>>>>>>>Voy a actualizar aforo evento", EventOrReservationChangeId);
|
|
console.log(">>>>>>>>>>>>>> ", NewConfirmed);
|
|
if (!(await eventService._updateConfirmedEvent(EventOrReservationChangeId, NewConfirmed)))
|
|
return handleResultResponse(
|
|
"Error al eliminar inscripción, no puedo cambiar confirmados a la inscripcion",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
}
|
|
try {
|
|
//Desinscribimos de mailchimp y mandamos correo de confirmacion de desinscripcion
|
|
await eventInscriptionService._deleteMember(marketingListId, inscription.user.email); //inscription.marketing_memberId);
|
|
} catch (error) {
|
|
console.log("error mailchimp>><", error);
|
|
}
|
|
|
|
var member = generateMemberInscription(inscription.user, inscription, inscription.reservation);
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
member.qrCodeUrl = QRHelper.getInscriptionQRCodeUrl(inscription.id);
|
|
let headerMail = generateHeaderMail(member);
|
|
headerMail.subject = "Cancelación de " + headerMail.subject;
|
|
|
|
try {
|
|
emailHelper.sendCancelacion(headerMail, generateBodyMail(member));
|
|
} catch (error) {
|
|
console.log("No se ha podido mandar email con entrada");
|
|
}
|
|
|
|
console.log(">>>>>>>>>>>>>>Inscripcion eliminada con todos los pasos");
|
|
return handleResultResponse("Inscripción eliminada", null, params, res, httpStatus.DELETEOK);
|
|
} else return handleResultResponse("No se pudo eliminar inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
} catch (error) {
|
|
console.log("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeerrrrrrrrrrrrrrrrrrorrrr", error);
|
|
return handleResultResponse("Error al eliminar inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
|
|
recuperateEvent: async (req, res, next) => {
|
|
console.log(">>>>>>>>>>>>>>>>>>>> recuperateEvent");
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
let dataInscription = res.locals.dataInscription;
|
|
if (!dataInscription)
|
|
return handleResultResponse(
|
|
"Error al recuperar evento, prepareInscription requerida",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
|
|
try {
|
|
dataInscription.event = await eventService._getEvent(dataInscription.eventId);
|
|
if (dataInscription.event) {
|
|
dataInscription.event = await dataInscription.event.toJSON();
|
|
} else {
|
|
// No se ha encontrado
|
|
return handleResultResponse("Evento no encontrado", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "recuperateEvent", error, res);
|
|
}
|
|
// console.log('>>>>>>>>>>>>>>>>>>>>>>>esta es la reserva y el evento al que quiere inscribirse');
|
|
// console.log(req.dataInscription.event);
|
|
// return handleResultResponse(req.dataInscription, null, req.params, res, httpStatus.OK);
|
|
res.locals.dataInscription = dataInscription;
|
|
next();
|
|
},
|
|
|
|
//Esta función se puede llamar desde APP y desde WEB
|
|
createInscription: async (req, res, next) => {
|
|
console.log("CREATE INSCRIPTION********************************************>>>< ", req.body.type);
|
|
//Si la inscripcion en online o grupal saltamos la incripcion antigua y lo hacemos del nuevo modo
|
|
if (req.body.group_size && req.body.group_size > 1) {
|
|
next();
|
|
return;
|
|
}
|
|
if (req.body.type && req.body.type === "online") {
|
|
next();
|
|
return;
|
|
}
|
|
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
console.log("CREATE INSCRIPTION>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>< ", req.body.code);
|
|
//Iniciamos entidades relacionadas con la inscripción.
|
|
let dataUser = {
|
|
id: req.user ? req.user.id : null,
|
|
phone: req.user ? req.user.phone : null, //((req.body.phone != '+34') ? req.body.phone : null), lo quitamos de momento por la de movistar
|
|
name: req.user ? req.user.name : req.body.name,
|
|
surname: req.user ? req.user.surname : req.body.surname,
|
|
email: req.user ? req.user.email : req.body.email,
|
|
entityId: null,
|
|
userResult: req.user ? req.user : null,
|
|
};
|
|
|
|
let dataInscription = {
|
|
eventId: params.params.id,
|
|
reservationCode: req.user ? req.body.code : Buffer.from(req.body.code, "base64").toString("ascii"),
|
|
type: req.body.code ? "reservation" : "regular",
|
|
source: req.user ? "app" : "web", //En el caso de tener ya usuario viene por APP sino viene por web
|
|
validated: null, //si no esta validado la inscripción es a la lista de espera
|
|
inscriptionsWithoutReservationAndOverflowCount: null, //nº total de inscritos sin reserva y sin overflow asignada
|
|
inscriptionsWithReservationCount: null, //nº total de inscritos a la reserva asignada
|
|
event: null,
|
|
reservation: null,
|
|
inscription: null,
|
|
};
|
|
|
|
console.log("DATAUSER_INICIAL>>>>>>>>>>>>>>>>>>>>");
|
|
console.log(dataUser);
|
|
console.log("DATAINSCRIPTION_INICIAL>>>>>>>>>>>>>>>>>>");
|
|
console.log(dataInscription);
|
|
|
|
//SI VIENE CODIGO DE RESERVA, RECUPERAMOS LA RESERVA Y EL EVENTO
|
|
if (dataInscription.reservationCode) {
|
|
try {
|
|
dataInscription.reservation = await eventReservationService._getReservaByCode(
|
|
dataInscription.eventId,
|
|
dataInscription.reservationCode
|
|
);
|
|
if (dataInscription.reservation) {
|
|
dataInscription.reservation = await dataInscription.reservation.toJSON();
|
|
dataInscription.event = dataInscription.reservation.Event;
|
|
} else {
|
|
// No se ha encontrado
|
|
return handleResultResponse("Código de reserva no encontrado", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "createInscription", error, res);
|
|
}
|
|
}
|
|
//SOLO RECUPERAMOS EL EVENTO
|
|
else {
|
|
try {
|
|
dataInscription.event = await eventService._getEvent(dataInscription.eventId);
|
|
if (dataInscription.event) {
|
|
dataInscription.event = await dataInscription.event.toJSON();
|
|
} else {
|
|
// No se ha encontrado
|
|
return handleResultResponse("Evento no encontrado", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "createInscription", error, res);
|
|
}
|
|
}
|
|
|
|
console.log(">>>>>>>>>>>>>>>>>>>>>>>esta es la reserva y el evento al que quiere inscribirse");
|
|
console.log(dataInscription.reservation);
|
|
console.log(dataInscription.event);
|
|
//Asignamos a los datos del usuario a crear, el id de la entidad a la que pertenece, este caso solo es necesario cuando viene la inscripción por web ya que hay que crear un usuario nuevo
|
|
if (dataInscription.reservation) dataUser.entityId = dataInscription.reservation.entityId;
|
|
|
|
//creamos o recuperamos el usuario teniendo en cuenta que pude venir por APP o WEB
|
|
//si viene por web se tendra en cuenta el email y si viene por APP el phone para buscar
|
|
try {
|
|
//CHAPUZA PARA PODER DAR DE ALTA USUARIOS CON EL MISMO CORREO ELECTRONICO, PERO DISTINTO NOMBRE Y APELLIDO.
|
|
if (req.user)
|
|
//? 'app' : 'web', //En el caso de tener ya usuario viene por APP sino viene por web
|
|
dataUser.userResult = await userService._getOrCreateUser(dataUser);
|
|
else dataUser.userResult = await userService._getOrCreateUserWEB(dataUser);
|
|
|
|
if (!dataUser.userResult) {
|
|
// No se ha encontrado
|
|
return handleResultResponse(
|
|
"No se ha podido crear o encontrar el usuario dado",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
}
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "createInscription", error, res);
|
|
}
|
|
|
|
console.log(">>>>>>>>>>>>>>>>>>>>>>este es el usuario que quiere inscribirse");
|
|
console.log(dataUser.userResult);
|
|
|
|
try {
|
|
//Comprobamos que el usuario no tenga ya inscripcion para ese evento
|
|
dataInscription.inscription = await eventInscriptionService._getInscriptionByEventAndUser(
|
|
dataInscription.event.id,
|
|
dataUser.userResult.user.id
|
|
);
|
|
if (dataInscription.inscription) {
|
|
console.log("esta es la inscripcion que ya tengo>>>>>>>>>>>>>>>>>>>>><");
|
|
console.log(dataInscription.inscription);
|
|
//Devuelvo la reserva que ya tiene hecha el usuario
|
|
if (
|
|
!dataInscription.inscription.reservationId ||
|
|
dataInscription.inscription.reservationId == dataInscription.reservation.id
|
|
)
|
|
return handleResultResponse(dataInscription.inscription, null, params, res, httpStatus.OK);
|
|
|
|
//ACTUALIZAMOS LA RESERVA DE LA INSCRIPCION CON LA NUEVA Y CAMBIAMOS COMFIRMADOS DEVOLVIENDO LA INSCRIPCIÓN CON LA NUEVA RESERVA
|
|
let CountConfirmedOldReservation = await eventInscriptionService._getCountInscriptionsWithReservation(
|
|
dataInscription.inscription.reservationId
|
|
);
|
|
--CountConfirmedOldReservation;
|
|
console.log("actualizo confirmados de la reserva anterior");
|
|
await eventReservationService._updateConfirmedReservation(
|
|
dataInscription.inscription.reservationId,
|
|
CountConfirmedOldReservation
|
|
);
|
|
|
|
let CountConfirmedNewReservation = await eventInscriptionService._getCountInscriptionsWithReservation(
|
|
dataInscription.reservation.id
|
|
);
|
|
++CountConfirmedNewReservation;
|
|
console.log("actualizo confirmados de la nueva reserva");
|
|
await eventReservationService._updateConfirmedReservation(
|
|
dataInscription.reservation.id,
|
|
CountConfirmedNewReservation
|
|
);
|
|
await eventInscriptionService._updateReservationOfInscription(
|
|
dataInscription.inscription.id,
|
|
dataInscription.reservation.id
|
|
);
|
|
|
|
dataInscription.inscription = await eventInscriptionService._getInscriptionById(dataInscription.inscription.id);
|
|
return handleResultResponse(dataInscription.inscription, null, params, res, httpStatus.OK);
|
|
}
|
|
//TENEMOS QUE CREAR INSCRIPCIÓN
|
|
else {
|
|
//CON CODIGO DE RESERVA SE MODIFICA EL CONFIRMED DE LA RESERVA, YA QUE SE DESCONTARA DEL AFORO DE LA RESERVA
|
|
if (dataInscription.reservation) {
|
|
dataInscription.inscriptionsWithReservationCount =
|
|
await eventInscriptionService._getCountInscriptionsWithReservation(dataInscription.reservation.id);
|
|
++dataInscription.inscriptionsWithReservationCount;
|
|
|
|
console.log(
|
|
"me inscribo por reserva>>>>>>>>>>>>>>>>>>>>>>>>>>><< con asistentes: ",
|
|
dataInscription.reservation.assistants
|
|
);
|
|
console.log(dataInscription.reservation.sold_out);
|
|
console.log(dataInscription.inscriptionsWithReservationCount);
|
|
|
|
//COMPROBAMOS SI ES VALIDO O HAY QUE APUNTARLE A LA LISTA DE ESPERA DE LA RESERVA
|
|
if (
|
|
dataInscription.reservation.sold_out == 0 &&
|
|
dataInscription.reservation.assistants >= dataInscription.inscriptionsWithReservationCount
|
|
) {
|
|
dataInscription.validated = true;
|
|
|
|
//Actualizamos aforo de la lista de espera de la reserva y creamos inscripcion en la lista de espera de la reserva
|
|
if (
|
|
await eventReservationService._updateConfirmedReservation(
|
|
dataInscription.reservation.id,
|
|
dataInscription.inscriptionsWithReservationCount
|
|
)
|
|
)
|
|
dataInscription.inscription = await eventInscriptionService._createInscription(
|
|
dataInscription.event.id,
|
|
dataUser.userResult.user.id,
|
|
dataInscription.type,
|
|
dataInscription.validated,
|
|
dataInscription.source,
|
|
dataInscription.reservation.id,
|
|
null
|
|
);
|
|
else
|
|
return handleResultResponse(
|
|
"No se ha podido actualizar el aforo de la reserva",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
|
|
//Ponemos la reserva en SOLD_OUT para que no se pueda apuntar nadie más
|
|
if (dataInscription.reservation.assistants == dataInscription.inscriptionsWithReservationCount)
|
|
await eventReservationService._updateSoldOutReservation(dataInscription.reservation.id, true);
|
|
}
|
|
// APUNTARSE A LISTA DE ESPERA SI SE PUEDE
|
|
else {
|
|
if (dataInscription.reservation.allow_overflow === true) {
|
|
dataInscription.validated = false;
|
|
dataInscription.inscriptionsWithReservationCount =
|
|
await eventInscriptionService._getCountInscriptionsWithReservation(
|
|
dataInscription.reservation.overflow_reservationId
|
|
);
|
|
++dataInscription.inscriptionsWithReservationCount;
|
|
|
|
// if (dataInscription.reservation.assistants >= dataInscription.inscriptionsWithReservationCount) {
|
|
//Actualizamos aforo de la reserva y creamos inscripcion
|
|
if (
|
|
await eventReservationService._updateConfirmedReservation(
|
|
dataInscription.reservation.overflow_reservationId,
|
|
dataInscription.inscriptionsWithReservationCount
|
|
)
|
|
)
|
|
dataInscription.inscription = await eventInscriptionService._createInscription(
|
|
dataInscription.event.id,
|
|
dataUser.userResult.user.id,
|
|
dataInscription.type,
|
|
dataInscription.validated,
|
|
dataInscription.source,
|
|
dataInscription.reservation.overflow_reservationId,
|
|
null
|
|
);
|
|
else
|
|
return handleResultResponse(
|
|
"No se ha podido actualizar el aforo de la reserva",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
} else
|
|
return handleResultResponse(
|
|
"Aforo completo de la reserva y no hay lista de espera",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
}
|
|
}
|
|
//SIN CODIGO DE RESERVA SE MODIFICA EL CONFIRMED DEL EVENTO, YA QUE SE DESCONTARA DEL AFORO DEL EVENTO
|
|
else {
|
|
dataInscription.inscriptionsWithoutReservationAndOverflowCount =
|
|
await eventInscriptionService._getCountInscriptionsWithoutReservationAndOverflow(dataInscription.event.id);
|
|
++dataInscription.inscriptionsWithoutReservationAndOverflowCount;
|
|
|
|
//COMPROBAMOS SI ES VALIDO O HAY QUE APUNTARLE A LA LISTA DE ESPERA DEL EVENTO
|
|
if (
|
|
dataInscription.event.sold_out == 0 &&
|
|
dataInscription.event.assistants >= dataInscription.inscriptionsWithoutReservationAndOverflowCount
|
|
) {
|
|
dataInscription.validated = true;
|
|
//Actualizamos aforo del evento y creamos inscripcion
|
|
if (
|
|
await eventService._updateConfirmedEvent(
|
|
dataInscription.event.id,
|
|
dataInscription.inscriptionsWithoutReservationAndOverflowCount
|
|
)
|
|
)
|
|
dataInscription.inscription = await eventInscriptionService._createInscription(
|
|
dataInscription.event.id,
|
|
dataUser.userResult.user.id,
|
|
dataInscription.type,
|
|
dataInscription.validated,
|
|
dataInscription.source,
|
|
null,
|
|
null
|
|
);
|
|
else
|
|
return handleResultResponse(
|
|
"No se ha podido actualizar el aforo del evento",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
|
|
//Ponemos el evento en SOLD_OUT
|
|
if (dataInscription.event.assistants == dataInscription.inscriptionsWithoutReservationAndOverflowCount)
|
|
await eventService._updateSoldOutEvent(dataInscription.event.id, true);
|
|
}
|
|
// APUNTARSE A la lista de espera si se puede
|
|
else {
|
|
if (dataInscription.event.allow_overflow === true) {
|
|
dataInscription.validated = false;
|
|
|
|
//Actualizamos aforo de la lista de espera del evento y creamos inscripcion
|
|
console.log(
|
|
"evento de lista de espera que debo actulizar sus confirmados>>>>>>>>>>>>>>>>>>>>>",
|
|
dataInscription.event.overflow_eventId
|
|
);
|
|
//recuperamos la cantidad de apuntados al evento overflow a lista de espera
|
|
const ConfirmedWaitList = await eventInscriptionService._getCountInscriptionsWithOverflowEventId(
|
|
dataInscription.event.overflow_eventId
|
|
);
|
|
console.log(
|
|
"cantidad apuntados al evento padre>>>>>>>>>>>>>>>>>>>>>",
|
|
dataInscription.inscriptionsWithoutReservationAndOverflowCount
|
|
);
|
|
console.log(
|
|
"cantidad apuntados al evento de lista de espera asociado>>>>>>>>>>>>>>>>>>>>>",
|
|
ConfirmedWaitList
|
|
);
|
|
|
|
if (await eventService._updateConfirmedEvent(dataInscription.event.overflow_eventId, ConfirmedWaitList)) {
|
|
//console.log('voy a crearrrrrr la inscripcion');
|
|
dataInscription.inscription = await eventInscriptionService._createInscription(
|
|
dataInscription.event.id,
|
|
dataUser.userResult.user.id,
|
|
dataInscription.type,
|
|
dataInscription.validated,
|
|
dataInscription.source,
|
|
null,
|
|
dataInscription.event.overflow_eventId
|
|
);
|
|
} else {
|
|
console.log("No se ha podido actualizar el aforo del evento");
|
|
return handleResultResponse(
|
|
"No se ha podido actualizar el aforo del evento",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
}
|
|
} else
|
|
return handleResultResponse(
|
|
"Aforo completo y no hay lista de espera",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "createInscription", error, res);
|
|
}
|
|
|
|
const marketingListOfInscription = dataInscription.event.marketing_list;
|
|
/*AHORA SE ALMACENA TODO EN UNA ÚNICA LISTA DE MAILCHIMP, QUE ES LA DEL EVENTO
|
|
(si en un futuro se quiere tener listas independientes, bastaría con tratarlo aqui los campos de marketinglist de la reserva ...)
|
|
if (dataInscription.inscription.reservationId)
|
|
marketingListOfInscription = dataInscription.reservation.marketingList
|
|
else if (dataInscription.inscription.overflowEventId)
|
|
marketingListOfInscription = (await _getEvent(dataInscription.inscription.overflowEventId)).marketingList;
|
|
else
|
|
marketingListOfInscription = dataInscription.event.marketingList;
|
|
*/
|
|
//Creamos objeto member para facilitar inserción en mailchimp y envio de correo
|
|
var member = generateMemberInscription(
|
|
dataUser.userResult.user,
|
|
dataInscription.inscription,
|
|
dataInscription.reservation
|
|
);
|
|
//En este caso al ser una inscripcion recien creada hay que asignar los datos del evento desde el evento
|
|
member.event_name = dataInscription.event.name;
|
|
member.event_date = dataInscription.event.init_date;
|
|
|
|
try {
|
|
member.marketing_memberId = await eventInscriptionService._addMember(marketingListOfInscription, member);
|
|
eventInscriptionService._updateMarketingMemberOfInscription(
|
|
dataInscription.inscription.id,
|
|
member.marketing_memberId
|
|
);
|
|
} catch (error) {
|
|
console.log("No se ha podido añadir email a mailchimp");
|
|
}
|
|
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
member.qrCodeUrl = QRHelper.getInscriptionQRCodeUrl(dataInscription.inscription.id);
|
|
|
|
console.log("Mandamos mail con entrada>>>>>>>>>>>>>>>>>>>>>>>>>>>");
|
|
//console.log(headerMail, bodyMail);
|
|
|
|
try {
|
|
if (member.validated) emailHelper.sendTicket(generateHeaderMail(member), generateBodyMail(member));
|
|
else emailHelper.sendListaEspera(generateHeaderMail(member), generateBodyMail(member));
|
|
} catch (error) {
|
|
console.log("No se ha podido mandar email con entrada");
|
|
}
|
|
|
|
return handleResultResponse(await dataInscription.inscription.toJSON(), null, params, res, httpStatus.CREATED);
|
|
},
|
|
|
|
descontarAforo: async (req, res, next) => {
|
|
//_updateConfirmedEvent
|
|
console.log(">>>>>>>>>>>>>>>>>>>> descontarAforo");
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
let dataInscription = res.locals.dataInscription;
|
|
if (!dataInscription || !dataInscription.reservation || !dataInscription.event)
|
|
return handleResultResponse(
|
|
"Error createReservationToEntity, prepareInscription, recuperateEvent, ActiveReservationToEntity requerida",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
|
|
const newConfirmed = dataInscription.event.confirmed + dataInscription.reservation.assistants;
|
|
if (dataInscription.event.assistants < newConfirmed)
|
|
return handleResultResponse(
|
|
{ message: "El aforo solicitado es superior a las plazas disponibles" },
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.OK
|
|
);
|
|
|
|
//SE MODIFICA EL CONFIRMED DEL EVENTO, YA QUE SE DESCONTARA DEL AFORO DE LA RESERVA
|
|
if (!(await eventService._updateConfirmedEvent(dataInscription.event.id, newConfirmed)))
|
|
return handleResultResponse(
|
|
"No se ha podido actualizar el aforo del evento",
|
|
null,
|
|
params,
|
|
res,
|
|
httpStatus.NOT_FOUND
|
|
);
|
|
|
|
//Si se ha llenado ponemos el evento en SOLD_OUT
|
|
if (dataInscription.event.assistants == newConfirmed)
|
|
await eventService._updateSoldOutEvent(dataInscription.event.id, true);
|
|
|
|
next();
|
|
},
|
|
|
|
getQRCodeInscription: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const inscriptionId = params.params.id;
|
|
const userId = req.user.id;
|
|
|
|
try {
|
|
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
if (!inscription) {
|
|
return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
} else if (inscription.userId !== userId) {
|
|
return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
|
|
//Creamos objeto member para facilitar inserción en mailchimp y envio de correo
|
|
var member = generateMemberInscription(req.user, inscription.inscription, inscription.reservation);
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
member.qrCodeUrl = QRHelper.getInscriptionQRCodeUrl(inscription.id);
|
|
|
|
return handleResultResponse(member.qrCode, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleResultResponse("Error al buscar la inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
|
|
checkInscription: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
var eventId = params.params.id;
|
|
var email = params.params.email;
|
|
|
|
try {
|
|
const user = await userService._getUserByEmail(email);
|
|
if (user) {
|
|
const result = await eventInscriptionService._getInscriptionByEventAndUser(eventId, user.id);
|
|
if (result) return handleResultResponse(result.stateText, null, params, res, httpStatus.OK);
|
|
}
|
|
|
|
return handleResultResponse("No hay inscripción con ese email", null, params, res, httpStatus.NOT_FOUND);
|
|
} catch (error) {
|
|
return handleErrorResponse(MODULE_NAME, "checkInscription", error, res);
|
|
}
|
|
},
|
|
|
|
sendMailTicket: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const inscriptionId = params.params.id;
|
|
const user = req.user;
|
|
try {
|
|
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
if (!inscription)
|
|
return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
|
|
console.log("soy administrador?????? ", user);
|
|
// if (inscription.userId !== user.id)
|
|
// return handleResultResponse("Inscription no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
|
|
const userInscription = await userService._getUserById(inscription.userId);
|
|
|
|
//Creamos objeto member para facilitar inserción en mailchimp y envio de correo
|
|
var member = generateMemberInscription(userInscription, inscription, inscription.reservation);
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
member.qrCodeUrl = QRHelper.getInscriptionQRCodeUrl(inscription.id);
|
|
|
|
console.log("Mandamos mail con entrada>>>>>>>>>>>>>>>>>>>>>>>>>>>");
|
|
//console.log(headerMail, bodyMail);
|
|
|
|
try {
|
|
if (member.validated) emailHelper.sendTicket(generateHeaderMail(member), generateBodyMail(member));
|
|
else emailHelper.sendListaEspera(generateHeaderMail(member), generateBodyMail(member));
|
|
} catch (error) {
|
|
console.log("No se ha podido mandar email con entrada");
|
|
}
|
|
|
|
return handleResultResponse(null, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleResultResponse("Error al buscar la inscripción", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
|
|
getInscripcionsExcel: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const eventId = params.params.id;
|
|
const userId = req.user.id;
|
|
|
|
const inscriptions = await eventInscriptionService._getInscriptionsExcel(
|
|
req.user,
|
|
eventId,
|
|
function (result, status) {
|
|
if (result.messenger.code == "S99001") {
|
|
console.log(result);
|
|
res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
|
|
res.setHeader("Content-Disposition", "attachment; filename=" + result.data.name);
|
|
res.attachment(result.data.name);
|
|
res.download(path.resolve(result.data.path), result.data.name);
|
|
} else {
|
|
res.status(status).json(result);
|
|
}
|
|
}
|
|
);
|
|
},
|
|
|
|
getQRCodeImage: async (req, res, next) => {
|
|
const params = extractParamsFromRequest(req, res, {});
|
|
const inscriptionId = params.params.id;
|
|
|
|
try {
|
|
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
|
|
if (!inscription) {
|
|
return handleResultResponse("Inscripcion no encontrada", null, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
|
|
//Creamos objeto member para facilitar inserción en mailchimp y envio de correo
|
|
let member = generateMemberInscription(inscription.user, inscription, inscription.reservation);
|
|
|
|
member.qrConfig = generateQRConfig(member);
|
|
member.qrCode = await QRHelper.getInscriptionQRCode(member.qrConfig);
|
|
|
|
let buffer = new Buffer.from(member.qrCode.split(",")[1], "base64");
|
|
|
|
res.setHeader("Content-Type", "image/png");
|
|
res.setHeader("Content-Length", buffer.length);
|
|
return handleResultResponse(buffer, null, params, res, httpStatus.OK);
|
|
} catch (error) {
|
|
return handleErrorResponse("Error al buscar la inscripción", error, params, res, httpStatus.NOT_FOUND);
|
|
}
|
|
},
|
|
};
|
|
|
|
module.exports = generateControllers(eventService, extraControllers, controllerOptions);
|