Modelado completo final

modules/auth/user.model.js

@@ -50,7 +50,7 @@ module.exports = function (sequelize, DataTypes) {
             defaultValue: null,
         },
     }, {
-        tableName: 'user',
+        tableName: 'users',
         freezeTableName: true,
         timestamps: true,
     });
@@ -62,8 +62,10 @@ module.exports = function (sequelize, DataTypes) {
         });
         User.Entity = User.belongsTo(models.Entity, { foreignKey: 'entityId' });
         User.Devices = User.hasMany(models.UserDevice, { foreignKey: 'userId' });
-
+        User.Comments = User.hasMany(models.Comment, { foreignKey: 'userId' });
-        //User.Comments = User.hasMany(models.UserComment, { foreignKey: 'UserId' });
+        User.EventsReservations = User.hasMany(models.EventReservation, { foreignKey: 'userId' });        
+        User.EventsInscriptions = User.hasMany(models.EventInscription, { foreignKey: 'userId' });                
+//        User.InscriptionsValidate = User.hasMany(models.EventIncription, { foreignkey: 'validateUserId'})
         //User.Reactions = User.hasMany(models.UserReaction, { foreignKey: 'UserId' });      
     };
 

modules/blog/post.model.js

@@ -35,7 +35,7 @@ module.exports = function (sequelize, DataTypes) {
             through: models.PostCategory,
             foreignKey: 'postId'
         });
-        Post.Comments = Post.hasMany(models.Comment, { foreignKey: 'postId' });
+        //Post.Comments = Post.hasMany(models.Comment, { foreignKey: 'postId' });
         //Post.Reactions = Post.hasMany(models.PostReaction, { foreignKey: 'postId' });
         //Post.User = Post.belongsTo(models.User, { foreignKey: 'userId' });
 /*

modules/comments/comment.model.js

@@ -5,42 +5,62 @@ module.exports = function (sequelize, DataTypes) {
             defaultValue: DataTypes.UUIDV4,
             primaryKey: true
         },
-        entityType: {
+        entityId: {
-            field: 'type',
+            type: DataTypes.UUID,
-            type: DataTypes.STRING,
+            allowNull: false,
-            allowNull: false
         },
-        entity: {
+        entityName: {
-            type: DataTypes.VIRTUAL(DataTypes.UUID, ['conferenceId', 'speakerId', 'postId']),
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        type: {
+            type: DataTypes.STRING,
+            allowNull: false,
         },
         content: {
             type: DataTypes.STRING,
             allowNull: false
         },
-        user: {
+        entity: {
-            type: DataTypes.VIRTUAL(DataTypes.UUID, ['userId']),
+            type: DataTypes.VIRTUAL,
-        },
+            get: function () {
-        /*conference: {
+                const name = this.get('entityName');
-            type: DataTypes.VIRTUAL(DataTypes.UUID, ['conferenceId']),
+                const id = this.get('entityId');
-        },*/
+                let modelName = '';
-        post: {
+                switch (name) {
-            type: DataTypes.VIRTUAL(DataTypes.UUID, ['postId']),
+                    case 'post':
-        },
+                        modelName = 'Post';
-        /*speaker: {
+                        break;
-            type: DataTypes.VIRTUAL(DataTypes.UUID, ['speakerId']),
+                    case 'speaker':
-        },*/
+                        modelName = 'Speaker'
-        
+                        break;
+
+                    case 'event':
+                        modelName = 'Event';
+                        break;
+
+                    default:
+                        break;
+                }
+
+                return sequelize.models[modelName].findOne(id);
+            }
+        }
     }, {
+            indexes: [{
+                unique: false,
+                fields: ['entityId']
+            }],
             tableName: 'comments',
             freezeTableName: true,
             timestamps: true,
-
         });
 
+
     Comment.associate = function (models) {
         Comment.User = Comment.belongsTo(models.User, { foreignKey: 'userId', constraints: false });
         //Comment.Conference = Comment.belongsTo(models.Conference, { foreignKey: 'conferenceId', constraints: false });
-        Comment.Post = Comment.belongsTo(models.Post, { foreignKey: 'postId', constraints: false });
+        //Comment.Post = Comment.belongsTo(models.Post, { foreignKey: 'postId', constraints: false });
         //Comment.Speaker = Comment.belongsTo(models.Speaker, { foreignKey: 'speakerId', constraints: false });
     };
 

modules/entities/entity.model.js

@@ -20,9 +20,8 @@ module.exports = function (sequelize, DataTypes) {
             through: models.EntityEntitiesTypes,
             foreignKey: 'entityId'
         });
-        Entity.Users = Entity.hasMany(models.User, {
+        Entity.Users = Entity.hasMany(models.User, { foreignKey: 'entityId' });
-            foreignKey: 'entityId'
+        Entity.EventsReservations = Entity.hasMany(models.EventReservation, { foreignKey: 'entityId' });
-        });
     };
     return Entity;
 };

modules/events/event.model.js

@@ -64,9 +64,6 @@ module.exports = function (sequelize, DataTypes) {
             type: DataTypes.UUID,
             foreignKey: true,
         },
-        schedule: {
-            type: DataTypes.TEXT,
-        },
         venueId: {
             type: DataTypes.UUID,
             foreignKey: true,
@@ -80,9 +77,8 @@ module.exports = function (sequelize, DataTypes) {
         url_registration: {
             type: DataTypes.STRING,
         },
-        user_id: {
+        marketingList: {
-            type: DataTypes.UUID,
+            type: DataTypes.STRING,
-            foreignKey: true,
         },
     }, {
         tableName: 'events',
@@ -96,16 +92,12 @@ module.exports = function (sequelize, DataTypes) {
         Event.UserCreate = Event.belongsTo(models.User, { foreignKey: 'userId' });
         Event.Venue = Event.belongsTo(models.Venue, { foreignKey: 'venueId' });
 
-        Event.Speakers = Event.belongsToMany(models.Speaker, {
+        Event.Schedule = Event.hasMany(models.EventSchedule, { foreignKey: 'eventId' });
-            through: models.EventSpeaker,
+        Event.EventReservations = Event.hasMany(models.EventReservation, { foreignKey: 'eventId' });
-            foreignKey: 'eventId'
+        Event.EventInscriptions = Event.hasMany(models.EventInscription, { foreignKey: 'eventId' });
-        });
+        Event.EventQuestions = Event.hasMany(models.EventQuestion, { foreignKey: 'eventId' });        
-
+        //No puede haber clave foranea con entityId ya que podría repetirse ID con el caso de speakerId, un multimedia de un speaker
-        Event.Multimedias = Event.belongsToMany(models.MultimediaFile, {
+        //Event.Multimedias = Event.hasMany(models.Multimedia, { foreignKey: 'eventId' });
-            through: models.MultimediaEvent,
-            foreignKey: 'eventId',
-            otherKey: 'type'
-        });
 
     };
 

modules/events/event_questions.model.js

@@ -0,0 +1,41 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const EventQuestion = sequelize.define('EventQuestion', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        description: {
+            type: DataTypes.STRING,
+        },
+        anonimous: {
+            type: DataTypes.INTEGER,
+            allowNull: true
+        },
+        answered: {
+            type: DataTypes.INTEGER,
+            allowNull: true
+        },
+        discared: {
+            type: DataTypes.INTEGER,
+            allowNull: true
+        },
+        answer: {
+            type: DataTypes.TEXT,
+        },
+    }, {
+        tableName: 'events_questions',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    EventQuestion.associate = function (models) {
+        EventQuestion.Event = EventQuestion.belongsTo(models.Event, { foreignKey: 'eventId' });
+        EventQuestion.Speaker = EventQuestion.belongsTo(models.Speaker, { foreignKey: 'speakerId' });
+        EventQuestion.UserCreate = EventQuestion.belongsTo(models.User, { foreignKey: 'userId' });
+    };
+
+    return EventQuestion;
+};

modules/events/event_schedule.model.js

@@ -0,0 +1,40 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const EventSchedule = sequelize.define('EventSchedule', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true
+        },
+        eventId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
+        speakerId: {
+            type: DataTypes.UUID,
+        },
+        order: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+        },
+        description: {
+            type: DataTypes.STRING,
+        },        
+    }, {
+            indexes: [{
+                unique: false,
+                fields: ['speakerId']
+            }],
+            tableName: 'events_schedules',
+            freezeTableName: true,
+            timestamps: true,
+        });
+
+    EventSchedule.associate = function (models) {
+        EventSchedule.Event = EventSchedule.belongsTo(models.Event, { foreignKey: 'eventId' });
+    };
+
+
+    return EventSchedule;
+};

modules/events/event_speaker.model.js

@@ -1,25 +0,0 @@
-'use strict';
-
-module.exports = function (sequelize, DataTypes) {
-    const EventSpeaker = sequelize.define('EventSpeaker', {
-        eventId: {
-            type: DataTypes.UUID,
-            primaryKey: true,
-            allowNull: false,
-        },
-        speakerId: {
-            type: DataTypes.UUID,
-            primaryKey: true,
-            allowNull: false,
-        },
-        order: {
-            type: DataTypes.INTEGER,
-        },
-    }, {
-            tableName: 'events_speakers',
-            freezeTableName: true,
-            timestamps: true,
-        });
-
-    return EventSpeaker;
-};

modules/events/events_inscriptions.model.js

@@ -0,0 +1,43 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const EventInscription = sequelize.define('EventInscription', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        date: {
+            type: DataTypes.DATE,
+        },
+        code_ticket: {
+            type: DataTypes.INTEGER,
+        },
+        type: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: 'regular'   //grupal, invitacion-regular, invitation-grupal
+        },
+        source: {
+            type: DataTypes.STRING,   //app, web
+        },
+        marketing_memberId: {
+            type: DataTypes.STRING,
+        },
+        validated: {
+            type: DataTypes.DATE,
+        },
+    }, {
+        tableName: 'events_inscriptions',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    EventInscription.associate = function (models) {
+        EventInscription.Event = EventInscription.belongsTo(models.Event, { foreignKey: 'eventId' });        
+        EventInscription.User = EventInscription.belongsTo(models.User, { foreignKey: 'userId' });                
+        EventInscription.UserValidate = EventInscription.belongsTo(models.User, { foreignKey: 'validateUserId' });
+    };
+
+    return EventInscription;
+};

modules/events/events_reservations.model.js

@@ -0,0 +1,76 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const EventReservation = sequelize.define('EventReservation', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        init_avalible_date: {
+            type: DataTypes.DATE,
+        },
+        end_avalible_date: {
+            type: DataTypes.DATE,
+        },
+        gmt: {
+            type: DataTypes.INTEGER,
+            defaultValue: 1,
+        },
+        state: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: 'borrador'
+        },
+        assistants: {
+            type: DataTypes.INTEGER,
+        },
+        confirmed: {
+            type: DataTypes.INTEGER,
+        },
+        allow_multiple: {
+            type: DataTypes.BOOLEAN,
+            allowNull: false,
+            defaultValue: false,
+        },
+        multiple_limit: {
+            type: DataTypes.INTEGER,
+        },
+        description: {
+            type: DataTypes.STRING,
+        },
+        code: {
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        color: {
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        allow_overflow: {
+            type: DataTypes.BOOLEAN,
+            allowNull: false,
+            defaultValue: false,
+        },
+        overflow_event_reservationId: {
+            type: DataTypes.UUID,
+            foreignKey: true,
+        },
+        marketingList: {
+            type: DataTypes.STRING,
+        },
+    }, {
+        tableName: 'events_reservations',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    EventReservation.associate = function (models) {
+        EventReservation.OverflowEventReservation = EventReservation.belongsTo(models.EventReservation, { foreignKey: 'overflow_event_reservationId' });        
+        EventReservation.Entity = EventReservation.belongsTo(models.Entity, { foreignKey: 'entityId' });
+        EventReservation.Event = EventReservation.belongsTo(models.Event, { foreignKey: 'eventId' });
+        EventReservation.UserCreate = EventReservation.belongsTo(models.User, { foreignKey: 'userId' });
+    };
+
+    return EventReservation;
+};

modules/multimedia/multimedia_events.model.js

@@ -1,26 +0,0 @@
-'use strict';
-
-module.exports = function (sequelize, DataTypes) {
-    const MultimediaEvent = sequelize.define('MultimediaEvent', {
-        multimediafileId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        eventId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        type: {
-            type: DataTypes.STRING,
-            primaryKey: true,
-        },
-    }, {
-        tableName: 'multimedia_events',
-        freezeTableName: true,
-        timestamps: true,
-    });
-
-    return MultimediaEvent;
-};

modules/multimedia/multimedia_file.model.js

@@ -40,12 +40,7 @@ module.exports = function (sequelize, DataTypes) {
         MultimediaFile.MultimediaType = MultimediaFile.belongsTo(models.MultimediaType, { foreignKey: 'typeId' });
         MultimediaFile.UserCreate = MultimediaFile.belongsTo(models.User, { foreignKey: 'userId' }); 
 
-        MultimediaFile.Events = MultimediaFile.belongsToMany(models.Event, {
+        MultimediaFile.Multimedias = MultimediaFile.hasMany(models.Multimedia, { foreignKey: 'multimediafileId' });        
-            through: models.MultimediaEvent,
-            foreignKey: 'multimediafileId',
-            otherKey: 'type'
-        });        
-
     };
 
     return MultimediaFile;

modules/multimedia/multimedia_posts.js

@@ -1,26 +0,0 @@
-'use strict';
-
-module.exports = function (sequelize, DataTypes) {
-    const MultimediaPost = sequelize.define('MultimediaPost', {
-        multimediafileId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        postId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        type: {
-            type: DataTypes.STRING,
-            primaryKey: true,            
-        },
-    }, {
-        tableName: 'multimedia_posts',
-        freezeTableName: true,
-        timestamps: true,
-    });
-
-    return MultimediaPost;
-};

modules/multimedia/multimedia_speakers.model.js

@@ -1,26 +0,0 @@
-'use strict';
-
-module.exports = function (sequelize, DataTypes) {
-    const MultimediaSpeaker = sequelize.define('MultimediaSpeaker', {
-        multimediafileId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        speakerId: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-            primaryKey: true,
-        },
-        type: {
-            type: DataTypes.STRING,
-            primaryKey: true,
-        },
-    }, {
-        tableName: 'multimedia-speakers',
-        freezeTableName: true,
-        timestamps: true,
-    });
-
-    return MultimediaSpeaker;
-};

modules/multimedia/multimedias.model.js

@@ -1,12 +1,16 @@
 'use strict';
 
 module.exports = function (sequelize, DataTypes) {
-    const Multimedias = sequelize.define('Multimedias', {
+    const Multimedia = sequelize.define('Multimedia', {
         id: {
             type: DataTypes.UUID,
             defaultValue: DataTypes.UUIDV4,
             primaryKey: true,
         },
+        multimediafileId: {
+            type: DataTypes.UUID,
+            allowNull: false,
+        },
         entityId: {
             type: DataTypes.UUID,
             allowNull: false,
@@ -54,7 +58,9 @@ module.exports = function (sequelize, DataTypes) {
         timestamps: true,
     });
 
+    Multimedia.associate = function (models) {
+        Multimedia.MultimediaFile = Multimedia.belongsTo(models.MultimediaFile, { foreignKey: 'multimediafileId' });
+    };
 
-
+    return Multimedia;
-    return Multimedias;
 };

modules/speakers/speaker.model.js

@@ -12,7 +12,7 @@ module.exports = function (sequelize, DataTypes) {
             allowNull: false,
         },
         description: {
-            type: DataTypes.STRING,
+            type: DataTypes.TEXT,
         },
         short_description: {
             type: DataTypes.STRING,
@@ -29,7 +29,7 @@ module.exports = function (sequelize, DataTypes) {
         youtube: {
             type: DataTypes.STRING,
         },
-        linkedlin: {
+        linkedin: {
             type: DataTypes.STRING,
         },
         instagram: {
@@ -47,10 +47,6 @@ module.exports = function (sequelize, DataTypes) {
             type: DataTypes.UUID,
             foreignKey: true,
         },
-        user_id: {
-            type: DataTypes.UUID,
-            foreignKey: true,
-        },
     }, {
         tableName: 'speakers',
         freezeTableName: true,
@@ -66,11 +62,8 @@ module.exports = function (sequelize, DataTypes) {
             foreignKey: 'speakerId'
         });
 
-        Speaker.Events = Speaker.belongsToMany(models.Event, {
+        Speaker.EventSchedules = Speaker.hasMany(models.EventSchedule, { foreignKey: 'speakerId' });
-            through: models.EventSpeaker,
+        Speaker.EventQuestions = Speaker.hasMany(models.EventQuestion, { foreignKey: 'speakerId' });
-            foreignKey: 'speakerId'
-        });
-
 /*
         Speaker.Multimedias = Speaker.belongsToMany(models.MultimediaFile, {
             through: models.MultimediaSpeaker,