.Repsaso de activar una reserva automática de cole

helpers/mail.helper.js

@@ -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,
 };

modules/events/event.controller.js

@@ -153,12 +153,13 @@ const extraControllers = {
 
 
     try {
-      if (req.user.level === 8) result = await eventInscriptionService._getInscriptionByEvent(eventId);
+      if (req.user.level === 8) result = await eventInscriptionService._getInscriptionOnlineByEvent(eventId);
-      else result = await eventInscriptionService._getInscriptionByEventAndUser(eventId, userId);
+      //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);
     }
 
 

modules/events/events_inscriptions.service.js

@@ -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: {

modules/events/events_inscriptions_online.model.js

@@ -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;
+};

modules/events/events_reservations.controller.js

@@ -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);
+  const eventToDiscountAssistants = reservation.overflow_reservationId
-  //La reserva puede estar asociada a la lista de espera es de donde se quitará aforo, si no al evento
+    ? await eventService._getEvent(reservation.overflow_reservationId)
-  const eventToDiscountAssistants = reservation.overflowEventId
+    : reservation.Event;
-    ? await eventService._getEvent(reservation.overflowEventId)
-    : reservation.event;
 
-  console.log(eventToDiscountAssistants);
+  //En el caso de ya estar publicada no hacemos nada se devuelve tal cual
-  return true;
+  if (reservation.state === 'publish')
-}
+    return reservation;
-
-async function activeReservationById(id) {
-  //Buscar reserva con evento y entidad
-  let reservation = await eventReservationService._getReservaByIdWithEntityAndEvent(id);
-  return activeReservation(reservation);
 
   const plazasDisponibles = eventToDiscountAssistants.assistants - eventToDiscountAssistants.confirmed;
-  if (plazasDisponibles < dataInscription.reservation.assistants)
+  if (plazasDisponibles < reservation.assistants) {
-    return handleResultResponse("Aforo lleno no es posible efectuar la reserva", null, params, res, httpStatus.NOT_FOUND)
+    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)))
+  if (!(await eventService._updateAssistantsEvent(eventToDiscountAssistants.id, newAforo))) {
-    return handleResultResponse(
+    console.log("No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas");
-      "No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas",
+    return null;
-      null,
+  }
-      params,
-      res,
-      httpStatus.NOT_FOUND
-    );
 
   //Si se ha llenado ponemos el evento en SOLD_OUT
   if (eventToDiscountAssistants.confirmed >= newAforo)
     await eventService._updateSoldOutEvent(eventToDiscountAssistants.id, true);
 
-
+  //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))) {
-  if (await _addConfirmedToEvent(reservation.assistants, reservation.Event))
-    if (!(await eventReservationService._updatePublishReservation(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 reservationPublicada = await activeReservation(dataInscription.reservation);
-      const eventToDiscountAssistants = dataInscription.reservation.overflowEventId
+      if (reservationPublicada === null)
-        ? 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)))
         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();
   },
 

modules/events/mail.service.js

@@ -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,