aa

helpers/service.helper.js

@@ -162,6 +162,9 @@ const generateService = (model, extraMethods = {}, options = defaultOptions) =>
         },
 
         fetchOne: async (params, context) => {
+console.log('fecccccc ONE');
+console.log(params);
+console.log(context);
 
             const findOptions = parseParamsToFindOptions(params);
             const result = await model.scope(context.scopes).findOne(findOptions);

modules/auth/user.service.js

@@ -0,0 +1,49 @@
+/* global User */
+'use strict';
+
+const _ = require('lodash');
+const { generateService, parseParamsToFindOptions } = require('../../helpers/service.helper');
+const models = require('../../core/models');
+
+const extraMethods = {
+
+    _getOrCreateUser: async (params, context) => {
+        let {user} = context;
+
+console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><< USER');
+console.log(user);
+            if (user.id) {
+                return user;
+            } else {
+                try {
+                  return models.User.findOrCreate({
+                        where: {
+                            phone: user.phone
+                        },
+                        defaults: {
+                            email: user.email,
+                            name: user.name,
+                            surname: user.surname,
+                            entityId: user.entityId,
+    //                        password: crypto.createHash('sha512').update(user.phone).digest('hex'),
+                        }
+                })
+                .spread(function (resultUser, created) {
+                    user = resultUser;
+                    console.log('aaaaaaaaaaaaaaaaaaaaaNOSE QUE PASAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+                    console.log(user);
+                    return user;
+
+                });
+
+            }
+            catch (error) {
+               return error;
+            } 
+       
+        }
+    }
+
+};
+
+module.exports = generateService(models.User, extraMethods);

modules/events/event.controller.js

@@ -2,12 +2,15 @@
 
 const generateControllers = require('../../core/controllers');
 const eventService = require('./event.service');
+const eventReservationService = require('./events_reservations.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');
+const inscriptionService = require('./events_inscriptions.service');
 
 // Module Name
 const MODULE_NAME = '[event.controller]';
@@ -58,21 +61,91 @@ const extraControllers = {
         }
     },
 
-    findPass: async (req, res, next) => {
+   
-        const params = extractParamsFromRequest(req, res, {});
+        if (invitationCode) {
-        try {
+        _getLevelAndPartner()---------------------
-            const result = await eventService.fetch(params, { user: req.user, lapse: 'pass' });
+            .then(_getOrCreateUser)-------------
-            return handleResultResponse(result, result.count, params, res);
+            .then(_existsInscription)----------------
-        } catch (error) {
+            .then(_getInscriptionCount)---------
-            handleErrorResponse(MODULE_NAME, 'findNext', error, res);
+            .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);
+    }
+
+
+
 */
     createInscription: async(req, res, next) => {
         const params = extractParamsFromRequest(req, res, {});
-        console.log('crear inscripcionnnnnnnnnnnnnnnnnnnnnnnnnnnn');
+        
+        let context = {
+            eventId : params.params.id,
+            code : req.body.code,
+            event : null,
+            reservation : null,
+            inscriptionCount : null,
+            inscription : null,
+            assistants : null, // aforo
+            tickets : null, // nº de inscripciones
+            type : (req.body.code) ? 'reserva' : 'libre',
+            userId: '0939bb2a-d33d-4290-ac81-fc9faa1c015e',
+            user: {
+                phone: '+34686621059',
+                name: 'aaaaaaaaaaaa',
+                surname: 'bbbbbbb',
+                email: 'lqdvi@lqdvi.com',
 
-        return handleResultResponse(result, result.count, params, res);
+            },
+        }
+
+        //Si viene codigo invitacion _getLevelAndPartner()---------------------
+        if (context.code) {
+            context.reservation = await eventReservationService._getReserva(params, context);
+            context.reservation = context.reservation.toJSON();            
+            if (context.reservation) 
+              context.event = context.reservation.Event;
+        }
+        else {
+            context.event = await eventService._getEvent(params);
+            context.event = context.event.toJSON();            
+        } 
+
+        console.log('esta es la reserva y el evento a la que pertenece');
+        console.log(context.reservation);
+        console.log(context.event);        
+
+
+        //creamos o recuperamos el usuario .then(_getOrCreateUser)-------------
+        context.user = await userService._getOrCreateUser(params, context);
+        context.user = context.user.toJSON();
+        console.log('creamos o recuperamos el usuario');
+        console.log(context.user);
+
+
+        inscriptionService._existsInscription(params, context)
+            .then(inscriptionService._getInscriptionCount)
+            .then(function () { if (context.code) {return eventReservationService._updateReservation } else { return evenService._updateEvent }})
+            .then(inscriptionService._createInscription)
+            .catch(_handleError);
+        //_createInscription(user, congressId, invitationCode, source, callback);        
+
+//        const result = await eventService.createIncription(params, { user: req.user, lapse: 'pass' });
+//        return handleResultResponse(result, result.count, params, res);
     },
 
 /*

modules/events/event.routes.js

@@ -107,9 +107,10 @@ routes.get('/events/:id/inscriptions',
     //eventController.findComments
 );
 
+// Hacer una inscripción
 routes.post('/events/:id/inscriptions',
-    // Hacer una inscripción
+    //isLoggedUser, 
-    isLoggedUser, 
+//    SchemaValidator(eventValidation.InscriptionInputType, true), 
     eventController.createInscription
 );
 

modules/events/event.service.js

@@ -77,47 +77,43 @@ const extraMethods = {
         return eventComposer(result.toJSON(), context);
     },
 
-/*
+
-    fetchOne: async (params, context) => {
+    _getEvent: (params, context) => {
-        const findOptions = parseParamsToFindOptions(params);
+        const id = params.eventId;
-        
+
-        // Incluir
+        return new Promise(function (resolve, reject) {
-        findOptions.include.push({
+            models.Event.findOne(params,)
-            model: models.EventDetail,
+                .then(function (result) {
-            as: 'details',
+                    resolve(result);
-            include: {
+                })
-                model: models.Speaker,
+                .catch(function (error) {
-                as: 'speaker',
+                    reject(error)
-                attributes: ['id', 'name', 'description']
+                });
-            }
-        });
-        findOptions.include.push({
-            model: models.EventType,
-            as: 'type',
-            attributes: ['name', 'title'],
-        });
-        findOptions.include.push({
-            model: models.Venue,
-            as: 'venue'
         });
 
-        findOptions.include.push({
+    },
-            model: models.EventInscription,
-            as: 'inscriptions'
-        });
 
+	_updateEvent: (params, context) => {
+        const assistants = context.event.assistants; // <- aforo
+        const tickets = context.inscriptionCount + 1; // <- nº de inscritos + 1
 
-        findOptions.where = Object.assign({},
+        return new Promise(function (resolve, reject) {
-            findOptions.where, {
+            models.Event.update(
-                state: 'publish'
+                {
-        });
+                confirmed : tickets,
-
+                }, 
-        return await models.Event.findOne({
+                {
-            where: findOptions.where,
+                where : { id: context.EventId }
-            include: findOptions.include
+                })
+                .then(function (result) {
+                    resolve(result);
+                })
+                .catch(function (error) {
+                    reject(error)
+                });
         });
     },
-*/    
+
 };
 
 module.exports = generateService(models.Event, extraMethods);

modules/events/event.validations.js

@@ -1,8 +1,10 @@
 const Joi = require('joi');
-/*
+
-const EventInputType = Joi.object().keys({
+const InscriptionInputType = Joi.object().keys({
-    name: Joi.string().required(),
+    id: Joi.string().required(),
-    address: Joi.string().required(),
+    code: Joi.string().optional()
+
+/*    address: Joi.string().required(),
     city: Joi.string().required(),    
     gmt: Joi.number().min(-12).max(+12),
     description: Joi.string().optional(),
@@ -10,17 +12,17 @@ const EventInputType = Joi.object().keys({
     state: Joi.string().optional(),
     postal_code: Joi.string().optional(),
     accessibility: Joi.string().optional()
+*/    
 });
-*/
+/*
-
 const EventsListOutputType = Joi.object().keys({
     id: Joi.string().required(),
     name: Joi.string().required(),
     description: Joi.string().required(),
 });
-
+*/
 
 module.exports = {
 //    VenueInputType,
-    EventsListOutputType
+    InscriptionInputType
 };

modules/events/events_inscripcions.service.js

@@ -1,14 +0,0 @@
-/* global Venue */
-'use strict';
-
-const _ = require('lodash');
-const { generateService, parseParamsToFindOptions } = require('../../helpers/service.helper');
-const models = require('../../core/models');
-
-const extraMethods = {
-
-
-    
-};
-
-module.exports = generateService(models.EventInscription, extraMethods);

modules/events/events_inscriptions.model.js

@@ -27,6 +27,10 @@ module.exports = function (sequelize, DataTypes) {
         validated: {
             type: DataTypes.DATE,
         },
+        reservationId:{
+            type: DataTypes.UUID,
+            foreignKey: true,
+        }
     }, {
         tableName: 'events_inscriptions',
         freezeTableName: true,
@@ -35,6 +39,7 @@ module.exports = function (sequelize, DataTypes) {
 
     EventInscription.associate = function (models) {
         EventInscription.Event = EventInscription.belongsTo(models.Event, { foreignKey: 'eventId', as: 'event' });        
+        EventInscription.Reservation = EventInscription.belongsTo(models.EventReservation, { foreignKey: 'reservationId', as: 'reservation' });                
         EventInscription.User = EventInscription.belongsTo(models.User, { foreignKey: 'userId', as: 'user' });                
         EventInscription.UserValidate = EventInscription.belongsTo(models.User, { foreignKey: 'validateUserId' });
     };

modules/events/events_inscriptions.service.js

@@ -0,0 +1,71 @@
+/* global Venue */
+'use strict';
+
+const _ = require('lodash');
+const { generateService, parseParamsToFindOptions } = require('../../helpers/service.helper');
+const models = require('../../core/models');
+
+const extraMethods = {
+
+    _existsInscription: (params, context) => {
+
+        return new Promise (function (resolve, reject) {
+             models.EventInscription.count({
+                where: params,
+             
+            }).then(function (count) {
+                    if (count > 0) {
+                        reject({ message: 'Ya existe una inscripción para ese email' })
+                    } else {
+                        resolve(true);
+                    }
+            }).catch(function (error) {
+                 reject(error)
+            });
+        })
+    },
+
+    _getInscriptionCount: (params, context) => {
+
+        return new Promise(function (resolve, reject) {
+            models.Inscription.count({
+                where: {
+                    eventId: context.eventId,
+                    reservationId: (context.code) ? context.reservation.id : null,
+                },
+            })
+            .then(function (count) {
+                context.inscriptionCount = count;
+                resolve(count);
+            }).catch(function (error) {
+                reject(error)
+            });
+        })
+    },
+    
+    _createInscription: (params, context) => {
+
+        return new Promise(function (resolve, reject) {
+            database.models.Inscription.create({
+                eventId: context.eventId,
+                type: context.type,
+                source: 'web',
+                userId: context.user.id,
+                //valid: !(tickets > assistants),
+                reservationId: (context.code) ? context.reservation.id : null
+            })
+                .then(function (result) {
+                    inscription = result.dataValues;
+                    inscription.user = context.user;
+                    resolve(inscription);
+                })
+                .catch(function (error) {
+                    reject(error)
+                });
+        });
+    },
+
+    
+};
+
+module.exports = generateService(models.EventInscription, extraMethods);

modules/events/events_reservations.model.js

@@ -41,7 +41,7 @@ module.exports = function (sequelize, DataTypes) {
         description: {
             type: DataTypes.STRING,
         },
-        code: {
+        reservation_code: {
             type: DataTypes.STRING,
             allowNull: false,
         },

modules/events/events_reservations.service.js

@@ -0,0 +1,45 @@
+/* global Events Reservations */
+'use strict';
+
+const _ = require('lodash');
+const { generateService, parseParamsToFindOptions } = require('../../helpers/service.helper');
+const models = require('../../core/models');
+
+const extraMethods = {
+
+    _getReserva: (params, context) => {
+        const wheraaaae = { reservation_code: context.code, eventId: context.eventId};
+
+        return new Promise (function (resolve, reject) {
+            models.EventReservation.findOne({
+                where: wheraaaae,
+                include: [{
+                    model: models.Event,
+                }],
+            }).then(function (result) {
+                resolve(result);
+            }).catch(function (error) {
+                reject(error)
+            });
+        })
+    },
+
+    _updateReservation: (params, context) => {
+        
+        const tickets = inscriptionCount + 1; // <- nº de inscritos + 1
+
+        return new Promise (function (resolve, reject) {
+            models.EventReservation.update({
+                confirmed: tickets
+                }, {
+                    where: {
+                        id: eventReservationid
+                    }
+            })
+
+        })
+    }
+
+};
+
+module.exports = generateService(models.EventReservation, extraMethods);

script-carga-bd-anterior.sql

@@ -105,7 +105,7 @@ Crear campo entityname (varchar(255)) en tabla events_reservations
 insert into lqdvi_v2.events_reservations
 (id, init_available_date, end_available_date, gmt, state, 
 assistants, confirmed, allow_multiple, multiple_limit, 
-description, lqdvi_v2.events_reservations.code, color,
+description, reservation_code, color,
 allow_overflow, overflow_event_reservationID, marketing_list,
 createdAt, updatedAt, userID, 
 entityId, eventid, entityname)
@@ -137,6 +137,10 @@ update lqdvi_v2.entities
 set state = 'publish'
 where state = 'ff';
 
+//OJO ASIGNAMOS EVENTO SEVILLA PARA PRUEBA, ESTE DEBE SER LUEGO LA CORUÑA
+update lqdvi_v2.events_reservations
+set eventID = '5f772798-5616-4663-a661-b6484dd11bd7';
+
 
 //ENLAZAMOS CON LAS RESERVAS