app2-api/modules/events/event.controller.js

'use strict';
const httpStatus = require('http-status');
const generateControllers = require('../../core/controllers');
const eventService = require('./event.service');
const eventReservationService = require('./events_reservations.service');
const eventInscriptionService = require('./events_inscriptions.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 };
const extraControllers = {
/*
    findNext: (config) => {
        config = config || {
            scopes: [],
        }

        return async function (req, res, next) {
            const params = extractParamsFromRequest(req, res, { includeAll: false });
            try {
                const result = await eventService.fetch(params, { 
                    user: req.user, 
                    scopes: config.scopes,
                    lapse: 'next' 
                });
                console.log('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
                // Joi validation options
                const _validationOptions = {
                    abortEarly: false, // abort after the last validation error
                    allowUnknown: true, // allow unknown keys that will be ignored
                    stripUnknown: true // remove unknown keys from the validated data
                };
                console.log('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa222');
                const data = Joi.validate(result.dataValues, eventValidation.EventsListOutputType, _validationOptions);
                console.log('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa333');


                console.log(data);
                return handleResultResponse(result, result.count, params, res);
            } catch (error) {
                handleErrorResponse(MODULE_NAME, 'findNext', error, res);
            }
        }
    },

    findCurrent: async (req, res, next) => {
        const params = extractParamsFromRequest(req, res, {});
        try {
            const result = await eventService.fetch(params, { user: req.user, lapse: 'current' });
            return handleResultResponse(result, result.count, params, res);
        } catch (error) {
            handleErrorResponse(MODULE_NAME, 'findNext', error, res);
        }
    },

   
        if (invitationCode) {
        _getLevelAndPartner()---------------------
            .then(_getOrCreateUser)-------------
            .then(_existsInscription)----------------
            .then(_getInscriptionCount)---------
            .then(_updateLevel)--------------
            .then(_createInscription)--
            .then(_addMember)
            .then(_updateInscription)
            .then(_getConference)
            .then(_sendConfirmMail)
            .then(_handleResponse)
            .catch(_handleError);
    } else {
        _existsInscription()-------------
            .then(_getInscriptionCount)-----------
            .then(_getConference)------
            .then(_updateConference)----
            .then(_createInscription)--
            .then(_addMember)
            .then(_updateInscription)
            .then(_handleResponse)
            .catch(_handleError);
    }



*/
    checkReservationCode: async (req, res, next) => {
        const params = extractParamsFromRequest(req, res, {});
        
        const eventId = params.params.id;
        const encodedInvitationCode = params.params.encodedInvitationCode;
        
        const registrationCode = encodedInvitationCode; //Buffer.from(req.params.encodedInvitationCode, 'base64').toString('ascii');

        try {
            const result = await eventReservationService._getReservaByCode(eventId, registrationCode);
            handleResultResponse(!!result, null, params, res, (result === null) ? httpStatus.NOT_FOUND : httpStatus.OK);
        } catch(error) {
            handleErrorResponse(MODULE_NAME, 'checkReservationCode', error, res)
        }
    }, 


    createInscription: async(req, res, next) => {
        const params = extractParamsFromRequest(req, res, {});

        let dataUser = {
            id: null,            
            phone: '+34686621049',
            name: 'aaaaaaaasdasdaaaaaa',
            surname: 'bbbbbbb',
            email: 'lqdvi2@lqdvi.com',
            userResult: null,
        }
        
        let dataInscription = {
            eventId: params.params.id,
            encodedReservationCode: req.body.code,
            reservationCode: req.body.code, //Buffer.from(req.body.code, 'base64').toString('ascii');
            event : null,
            reservation : null,
            inscription: null,
            ticket : null, //nº total de inscritos (libres + con reserva) - Para ticket - entrada
            inscriptionsWithoutReservationCount: null, //nº total de inscritos sin reserva asignada
            inscriptionsWithReservationCount: null, //nº total de inscritos a la reserva asignada
            type : (req.body.code) ? 'reserva' : 'libre',
        }

        //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 a la que pertenece');
        console.log(dataInscription.reservation);
        console.log(dataInscription.event);        

        //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 {
            dataUser.userResult = await userService._getOrCreateUser(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._getInscription(dataInscription.event.id, dataUser.userResult.user.id);
            if (dataInscription.inscription) {
                console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>inscription existe, revisar si es con codigo vip y cambiarlo');
                console.log(dataInscription.inscription);
                return handleResultResponse(result, null, params, res, (result === null) ? httpStatus.NOT_FOUND : httpStatus.OK);
            }
            //TENEMOS QUE CREAR INSCRIPCIÓN
            else {
                const source = (dataUser.userResult.isCreated) ? 'web' : 'app';
                dataInscription.ticket = await eventInscriptionService._getCountInscriptionsEvent(dataInscription.event.id);      
                ++dataInscription.ticket;

                //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;  
//??????????????????????????????????????????????                    
                    //En la reserva lo tengo pero me fio mas del count reservation.confirmed++ ??????????????????????????????
                
                    //Actualizamos aforo y creamos inscripcion
                    if (await eventReservationService._updateReservationEvent(dataInscription.reservation.id, dataInscription.inscriptionsWithReservationCount))
                        dataInscription.inscription = await eventInscriptionService._createInscription(dataInscription.event.id, dataUser.userResult.user.id, dataInscription.ticket, dataInscription.type, true, source, null)
                    else
                        return handleResultResponse("No se ha podido actualizar el aforo de la reserva", 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.inscriptionsWithoutReservationCount = await eventInscriptionService._getCountInscriptionsWithoutReservation(dataInscription.event.id);
                    ++dataInscription.inscriptionsWithoutReservationCount;
                
                    //Actualizamos aforo y creamos inscripcion
                    if (await eventService._updateConfirmedEvent(dataInscription.event.id, dataInscription.inscriptionsWithoutReservationCount))
                        dataInscription.inscription = await eventInscriptionService._createInscription(dataInscription.event.id, dataUser.userResult.user.id, dataInscription.ticket, dataInscription.type, true, source, null)
                    else
                        return handleResultResponse("No se ha podido actualizar el aforo del evento", null, params, res, httpStatus.NOT_FOUND);                    
                }    
            }

        } catch (error) {
            return handleErrorResponse(MODULE_NAME, 'createInscription', error, res);
        }


        return handleResultResponse(await dataInscription.inscription.toJSON(), null, params, res, httpStatus.CREATED)     
    },
   

};

module.exports = generateControllers(eventService, extraControllers, controllerOptions);