lqdvi/app2-api
2
0
Fork 0
Code Issues 24 Pull Requests Actions Packages Projects Releases Wiki Activity

.Repsaso de activar una reserva automática de cole

Browse Source
This commit is contained in:
David Arranz 2022-06-07 10:33:00 +02:00
parent 2d91689f95
commit 7923896dab
6 changed files with 244 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
helpers/mail.helper.js
View File

@ -201,6 +201,27 @@ console.log('sendReservationCode >>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<', header, bod
return send(header, body);
}
function sendReservationCodeCollege(header, values) {
const body = {
TemplateID: 3985837,
TemplateLanguage: true,
TemplateErrorDeliver: true,
TemplateErrorReporting: {
Email: "info@rodax-software.com",
Name: "Air traffic control",
},
Variables: {
entityName: values.entityName,
eventName: values.eventName,
dateEvent: values.dateEvent,
reservationCode: values.reservationCode,
reservationDescription: values.reservationDescription ? values.reservationDescription : "-",
},
};
console.log('sendReservationCodeCollege >>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<', header, body)
return send(header, body);
}
function sendCancelacion(header, values) {
const body = {
TemplateID: 978886,
@ -250,5 +271,6 @@ module.exports = {
sendListaEspera,
sendCancelacion,
sendReservationCode,
sendReservationCodeCollege,
sendTicketOnline,
};

7
modules/events/event.controller.js
View File

@ -153,12 +153,13 @@ const extraControllers = {
try {
if (req.user.level === 8) result = await eventInscriptionService._getInscriptionByEvent(eventId);
else result = await eventInscriptionService._getInscriptionByEventAndUser(eventId, userId);
if (req.user.level === 8) result = await eventInscriptionService._getInscriptionOnlineByEvent(eventId);
//No se le llamará nunca desde la app, la app trata todas las incripciopnes como normales
// 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);
return handleErrorResponse(MODULE_NAME, "getInscriptionsOnline", error, res);
}

18
modules/events/events_inscriptions.service.js
View File

@ -223,6 +223,24 @@ const extraMethods = {
);
},
//Validamos la inscripcion del tutor que hizo la reserva
_validateInscriptionTutorOfReservation: (reservationId, userId) => {
return models.EventInscription.update(
{
validated: true,
overflowEventId: null,
validateUserId: userId,
},
{
where: {
reservationId: reservationId,
userId: userId,
},
}
);
},
_getInscriptionsWithoutMemberId: (eventId) => {
return models.EventInscription.scope(["includeEventAndVenue", "includeReservation", "defaultScope"]).findAll({
where: {

72
modules/events/events_inscriptions_online.model.js Normal file
View File

@ -0,0 +1,72 @@
"use strict";
const Sequelize = require("sequelize");
/*const getStateText = (inscription) => {
if (inscription.type !== "online" && inscription !== "online group") {
if (inscription.validated == true) {
return "Inscripción confirmada";
} else if (inscription.overflowEventId) {
return "Inscripción confirmada a lista de espera";
} else if (inscription.reservationId) {
return "Inscripción confirmada a lista de espera de tu reserva";
} else return "N/A";
} else {
// online
return "Inscripción online confirmada";
}
};
*/
module.exports = function (sequelize, DataTypes) {
const EventInscriptionOnline = sequelize.define(
"EventInscriptionOnline",
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
eventId: {
type: DataTypes.UUID,
// foreignKey: true,
},
userId: {
type: DataTypes.UUID,
// foreignKey: true,
},
date: {
type: DataTypes.DATE,
},
email: {
type: DataTypes.STRING,
allowNull: false,
// defaultValue: "regular", //grupal, invitacion-regular, invitation-grupal, online, online group, onsite, onsite group
},
assistants: {
type: DataTypes.INTEGER,
},
},
{
tableName: "v_events_inscriptions_online",
freezeTableName: true,
timestamps: true,
defaultScope: {
order: [["date", "DESC"]],
include: [
{
model: sequelize.models.User,
as: "user",
include: [{ model: sequelize.models.Entity, attributes: ["id", "name"], required: false }],
},
],
},
}
);
EventInscriptionOnline.associate = function (models) {
EventInscriptionOnline.Event = EventInscriptionOnline.belongsTo(models.Event, { foreignKey: "eventId", as: "event" });
EventInscriptionOnline.User = EventInscriptionOnline.belongsTo(models.User, { foreignKey: "userId", as: "user" });
};
return EventInscriptionOnline;
};

139
modules/events/events_reservations.controller.js
View File

@ -6,6 +6,7 @@ const eventService = require("./event.service");
const eventReservationService = require("./events_reservations.service");
const eventInscriptionService = require("./events_inscriptions.service");
const mailService = require("./mail.service");
const userService = require("../auth/user.service");
const marketingListService = require("./marketing_list.service");
const {
@ -23,7 +24,7 @@ const MODULE_NAME = "[eventReservation.controller]";
const controllerOptions = { MODULE_NAME };
/*BORRAR TRAS COMPROBAR TODO
async function _addConfirmedToEvent(confirmed, event) {
const newConfirmed = event.confirmed + confirmed;
if (event.assistants < newConfirmed) {
@ -41,52 +42,75 @@ async function _addConfirmedToEvent(confirmed, event) {
return true;
}
*/
/**** Activa una reserva que está en borrador (Draft), descontando asistentes del aforo total del evento
* Devuelve la reserva pasada por parametro publicada (publish) o null en el caso de error
*/
async function activeReservation(reservation) {
if (!reservation)
throw new Error("activeReservation: reservation should be an object");
console.log('>>>>>>> ', reservation);
//La reserva puede estar asociada a la lista de espera es de donde se quitará aforo, si no al evento
const eventToDiscountAssistants = reservation.overflowEventId
? await eventService._getEvent(reservation.overflowEventId)
: reservation.event;
const eventToDiscountAssistants = reservation.overflow_reservationId
? await eventService._getEvent(reservation.overflow_reservationId)
: reservation.Event;
console.log(eventToDiscountAssistants);
return true;
}
async function activeReservationById(id) {
//Buscar reserva con evento y entidad
let reservation = await eventReservationService._getReservaByIdWithEntityAndEvent(id);
return activeReservation(reservation);
//En el caso de ya estar publicada no hacemos nada se devuelve tal cual
if (reservation.state === 'publish')
return reservation;
const plazasDisponibles = eventToDiscountAssistants.assistants - eventToDiscountAssistants.confirmed;
if (plazasDisponibles < dataInscription.reservation.assistants)
return handleResultResponse("Aforo lleno no es posible efectuar la reserva", null, params, res, httpStatus.NOT_FOUND)
if (plazasDisponibles < reservation.assistants) {
console.log("Aforo lleno no es posible efectuar la reserva");
return null;
}
const newAforo = eventToDiscountAssistants.assistants - reservation.assistants;
//Modificamos los asistentes de evento (AFORO) para quitar los de la reserva
if (!(await eventService._updateAssistantsEvent(reservation.eventId, newAforo)))
return handleResultResponse(
"No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas",
null,
params,
res,
httpStatus.NOT_FOUND
);
if (!(await eventService._updateAssistantsEvent(eventToDiscountAssistants.id, newAforo))) {
console.log("No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas");
return null;
}
//Si se ha llenado ponemos el evento en SOLD_OUT
if (eventToDiscountAssistants.confirmed >= newAforo)
await eventService._updateSoldOutEvent(eventToDiscountAssistants.id, true);
if (await _addConfirmedToEvent(reservation.assistants, reservation.Event))
if (!(await eventReservationService._updatePublishReservation(id))) {
//REvisar confirmados en lista de espera
//Finalmente publicamos la reserva solo si no está asociada a la lista de espera
if (!reservation.overflow_reservationId) {
if (!(await eventReservationService._updatePublishReservation(reservation.id))) {
console.log("No se ha podido publicar la reserva del evento");
return null;
}
reservation.state = "publish";
//Finalmente hay que validar la inscripción del tutor
if ((await eventInscriptionService._validateInscriptionTutorOfReservation(reservation.id, reservation.userId)) <= 0) {
console.log("No se ha podido validar la inscripción del tutor");
return null;
}
//Mandamos el código de reserva para que registra a sus alumnos
const user = await userService._getUserById(reservation.userId);
reservation.contact_email = user.email;
reservation.contact_name = user.name;
reservation.event = reservation.Event;
try {
mailService.sendReservationCollegeEmail(reservation);
} catch (error) {
console.log(error);
};
return reservation;
}
}
async function activeReservationById(id) {
//Buscar reserva con evento y entidad
let reservation = await eventReservationService._getReservaByIdWithEntityAndEvent(id);
if (await activeReservation(reservation) === null) {
console.log("Error activeReservationById")
return false;
}
return true;
@ -360,58 +384,19 @@ const extraControllers = {
return;
};
//Si es centro aliado
if (dataUser.entityLevel === "aliado") {
//La reserva puede estar asociada a la lista de espera es de donde se quitará aforo, si no al evento
const eventToDiscountAssistants = dataInscription.reservation.overflowEventId
? await eventService._getEvent(dataInscription.reservation.overflowEventId)
: dataInscription.event;
const plazasDisponibles = eventToDiscountAssistants.assistants - eventToDiscountAssistants.confirmed;
if (plazasDisponibles < dataInscription.reservation.assistants)
return handleResultResponse("Aforo lleno no es posible efectuar la reserva", null, params, res, httpStatus.NOT_FOUND)
const newAforo = eventToDiscountAssistants.assistants - dataInscription.reservation.assistants;
//Modificamos los asistentes de evento (AFORO) para quitar los de la reserva
if (!(await eventService._updateAssistantsEvent(eventToDiscountAssistants.id, newAforo)))
const reservationPublicada = await activeReservation(dataInscription.reservation);
if (reservationPublicada === null)
return handleResultResponse(
"No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas",
"Error activeReservationToEntity requerida",
null,
params,
res,
httpStatus.NOT_FOUND
);
httpStatus.NOT_FOUND);
else dataInscription.reservation = reservationPublicada;
};
//Si se ha llenado ponemos el evento en SOLD_OUT
if (eventToDiscountAssistants.confirmed >= newAforo)
await eventService._updateSoldOutEvent(eventToDiscountAssistants.id, true);
//Finalmente publicamos la reserva solo si no está asociada a la lista de espera
if (!dataInscription.reservation.overflowEventId) {
if (!(await eventReservationService._updatePublishReservation(dataInscription.reservation.id)))
return handleResultResponse(
"No se ha podido publicar la reserva del evento",
null,
params,
res,
httpStatus.NOT_FOUND
);
dataInscription.reservation.state = "publish";
//Mandamos el código de reserva para que registra a sus alumnos
dataInscription.reservation.contact_email = dataUser.email;
dataInscription.reservation.contact_name = dataUser.name;
dataInscription.reservation.event = dataInscription.event;
console.log('MANDAMOS CODIO RESERVA>>>>>>', dataInscription.reservation);
try {
mailService.sendReservationEmail(dataInscription.reservation);
} catch (error) {
console.log(error);
}
}
}
next();
},

9
modules/events/mail.service.js
View File

@ -199,11 +199,20 @@ async function sendReservationEmail(reservation) {
}
}
async function sendReservationCollegeEmail(reservation) {
try {
emailHelper.sendReservationCodeCollege(generateHeaderMailReservation(reservation), generateBodyMailReservation(reservation));
} catch (error) {
console.log("No se ha podido mandar email _sendReservationCodeCollege", error);
}
}
module.exports = {
sendEmailConfirm,
sendEmailCancelate,
sendReservationEmail,
sendReservationCollegeEmail,
generateHeaderMail,
generateHeaderMailReservation,
generateBodyMail,