.

modules/events/event.controller.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const httpStatus = require('http-status');
 const generateControllers = require('../../core/controllers');
 const eventService = require('./event.service');
 const { extractParamsFromRequest, handleErrorResponse, handleResultResponse } = require('../../helpers/controller.helper');
@@ -45,8 +46,21 @@ const extraControllers = {
         const params = extractParamsFromRequest(req, res, {});
         console.log('crear inscripcionnnnnnnnnnnnnnnnnnnnnnnnnnnn');
 
-    }
-    //findComments: as
+        return handleResultResponse(result, result.count, params, res);
+    },
+
+
+    findOne: async (req, res, next) => {
+        const params = extractParamsFromRequest(req, res, { includeAll: false });
+
+        try {
+            const result = await eventService.fetchOne(params, { user: req.user });
+            return handleResultResponse(result, null, params, res, (result === null) ? httpStatus.NOT_FOUND : httpStatus.OK);
+        } catch (error) {
+            handleErrorResponse(MODULE_NAME, 'findOne', error, res)
+        }
+    },    
+    
 
 };
 

modules/events/event.model.js

@@ -93,25 +93,26 @@ module.exports = function (sequelize, DataTypes) {
 
     Event.associate = function (models) {
         Event.OverflowEvent = Event.belongsTo(models.Event, { 
-            as: 'EventToEvent',
+            as: 'overflowEvent',
             foreignKey: 'overflow_eventId' });
-        Event.Type = Event.belongsTo(models.EventType, { foreignKey: 'typeId' });
-        Event.UserCreate = Event.belongsTo(models.User, { foreignKey: 'userId' });
-        Event.Venue = Event.belongsTo(models.Venue, { foreignKey: 'venueId' });
+        Event.Type = Event.belongsTo(models.EventType, { foreignKey: 'typeId', as: "type" });
+        Event.UserCreate = Event.belongsTo(models.User, { foreignKey: 'userId', as: "user" });
+        Event.Venue = Event.belongsTo(models.Venue, { foreignKey: 'venueId', as: "venue" });
 
-        Event.Schedule = Event.hasMany(models.EventSchedule, { foreignKey: 'eventId' });
+        Event.Schedule = Event.hasMany(models.EventSchedule, { foreignKey: 'eventId', as: "schedule" });
 
         Event.Comments = Event.hasMany(models.Comment, {
             foreignKey: 'entityId',
+            as: "comments"
         });
 
         Event.Multimedias = Event.hasMany(models.Multimedia, { 
             foreignKey: 'entityId', 
-            as: { singular: 'Multimedia', plural: 'Multimedias' }});
+            as: { singular: 'multimedia', plural: 'multimedias' }});
 
-        Event.Reservations = Event.hasMany(models.EventReservation, { foreignKey: 'eventId' });
-        Event.Inscriptions = Event.hasMany(models.EventInscription, { foreignKey: 'eventId' });
-        Event.Questions = Event.hasMany(models.EventQuestion, { foreignKey: 'eventId' });        
+        Event.Reservations = Event.hasMany(models.EventReservation, { foreignKey: 'eventId', as: "reservations" });
+        Event.Inscriptions = Event.hasMany(models.EventInscription, { foreignKey: 'eventId', as: "inscriptions" });
+        Event.Questions = Event.hasMany(models.EventQuestion, { foreignKey: 'eventId', as: "questions" });        
     };
 
     return Event;

modules/events/event.service.js

@@ -44,13 +44,22 @@ const extraMethods = {
  
         // Incluir
         findOptions.include.push({
-            model: models.EventSchedule, include: {model: models.Speaker, attributes: ['id', 'name', 'description']}
+            model: models.EventSchedule, 
+            as: 'schedule',
+            include: { 
+                model: models.Speaker, 
+                as: 'speaker',
+                attributes: ['id', 'name', 'description']
+            }
         });
         findOptions.include.push({
-            model: models.EventType, attributes: ['name', 'tittle'],
+            model: models.EventType, 
+            as: 'type',
+            attributes: ['name', 'title'],
         });
         findOptions.include.push({
             model: models.Venue,
+            as: 'venue'
         });
 
 //        findOptions.include.push({
@@ -70,7 +79,47 @@ const extraMethods = {
         } catch(error) {
             throw error;
         }
-    }
+    },
+
+    fetchOne: async (params, context) => {
+        const findOptions = parseParamsToFindOptions(params);
+        
+        // Incluir
+        findOptions.include.push({
+            model: models.EventSchedule,
+            as: 'schedule',
+            include: {
+                model: models.Speaker,
+                as: 'speaker',
+                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'
+        });
+
+
+        findOptions.where = Object.assign({},
+            findOptions.where, {
+                state: 'publish'
+        });
+
+        return await models.Event.findOne({
+            where: findOptions.where,
+            include: findOptions.include
+        });
+    },
 };
 
 module.exports = generateService(models.Event, extraMethods);

modules/events/event_schedule.model.js

@@ -32,8 +32,8 @@ module.exports = function (sequelize, DataTypes) {
         });
 
     EventSchedule.associate = function (models) {
-        EventSchedule.Event = EventSchedule.belongsTo(models.Event, { foreignKey: 'eventId' });
-        EventSchedule.Speaker = EventSchedule.belongsTo(models.Speaker, {foreignKey: 'speakerId'});
+        EventSchedule.Event = EventSchedule.belongsTo(models.Event, { foreignKey: 'eventId', as: "event" });
+        EventSchedule.Speaker = EventSchedule.belongsTo(models.Speaker, {foreignKey: 'speakerId', as: "speaker"});
     };
 
 

modules/events/event_type.model.js

@@ -10,7 +10,7 @@ module.exports = function (sequelize, DataTypes) {
         name: {
             type: DataTypes.STRING,
         },
-        tittle: {
+        title: {
             type: DataTypes.STRING,
         },
     }, {

modules/events/events_inscriptions.model.js

@@ -34,8 +34,8 @@ module.exports = function (sequelize, DataTypes) {
     });
 
     EventInscription.associate = function (models) {
-        EventInscription.Event = EventInscription.belongsTo(models.Event, { foreignKey: 'eventId' });        
-        EventInscription.User = EventInscription.belongsTo(models.User, { foreignKey: 'userId' });                
+        EventInscription.Event = EventInscription.belongsTo(models.Event, { foreignKey: 'eventId', as: 'event' });        
+        EventInscription.User = EventInscription.belongsTo(models.User, { foreignKey: 'userId', as: 'user' });                
         EventInscription.UserValidate = EventInscription.belongsTo(models.User, { foreignKey: 'validateUserId' });
     };
 

modules/events/venue.model.js

@@ -52,7 +52,7 @@ module.exports = function (sequelize, DataTypes) {
     });
 
     Venue.associate = function (models) {
-        Venue.Events = Venue.hasMany(models.Event, { foreignKey: 'venueId' });
+        Venue.Events = Venue.hasMany(models.Event, { foreignKey: 'venueId', as: 'events' });
     };
 
     return Venue;

modules/speakers/speaker.model.js

@@ -55,21 +55,28 @@ module.exports = function (sequelize, DataTypes) {
 
     Speaker.associate = function (models) {
 
-        Speaker.SpeakerType = Speaker.belongsTo(models.SpeakerType, { foreignKey: 'typeId' });
-        Speaker.UserCreate = Speaker.belongsTo(models.User, { foreignKey: 'userId' });
+        Speaker.Type = Speaker.belongsTo(models.SpeakerType, { foreignKey: 'typeId', as: "type" });
+        Speaker.UserCreate = Speaker.belongsTo(models.User, { foreignKey: 'userId', as: "user" });
         Speaker.Values = Speaker.belongsToMany(models.Value, {
             through: models.SpeakerValue,
+            as: 'values',
             foreignKey: 'speakerId'
         });
 
-        Speaker.EventSchedules = Speaker.hasMany(models.EventSchedule, { foreignKey: 'speakerId' });
-        Speaker.EventQuestions = Speaker.hasMany(models.EventQuestion, { foreignKey: 'speakerId' });
-/*
+        Speaker.Schedule = Speaker.hasMany(models.EventSchedule, { foreignKey: 'speakerId', as: "schedule" });
+        Speaker.Questions = Speaker.hasMany(models.EventQuestion, { foreignKey: 'speakerId', as: "questions" });
+
+        Speaker.Multimedias = Speaker.hasMany(models.Multimedia, {
+            foreignKey: 'entityId',
+            as: { singular: 'multimedia', plural: 'multimedias' }
+        });
+
+        /*
         Speaker.Multimedias = Speaker.belongsToMany(models.MultimediaFile, {
             through: models.MultimediaSpeaker,
             foreignKey: 'speakerId'
         });
-*/
+        */
     };
 
     return Speaker;