cambio multimedia

core/controllers/index.js

@@ -59,6 +59,7 @@ const generateControllers = (service, extraControllers = {}, options = {}) => {
 
         create: async (req, res, next) => {
             try {
+                console.log(req.body);
                 const result = await service.create(req.body, buildContext(req, res));                
                 return handleResultResponse(result, null, null, res, httpStatus.CREATED)
             } catch (error) {

helpers/service.helper.js

@@ -142,7 +142,7 @@ const generateService = (model, extraMethods = {}, options = defaultOptions) =>
         },
 
         create: async (values, context) => {
-            return await model.create(data);
+            return await model.create(values);
         },
 
         update: async (params, values, context) => {

modules/blog/post.model.js

@@ -38,6 +38,12 @@ module.exports = function (sequelize, DataTypes) {
         Post.Comments = Post.hasMany(models.Comment, { foreignKey: 'postId' });
         //Post.Reactions = Post.hasMany(models.PostReaction, { foreignKey: 'postId' });
         //Post.User = Post.belongsTo(models.User, { foreignKey: 'userId' });
+/*
+        Post.Multimedias = Post.belongsToMany(models.MultimediaFile, {
+            through: models.MultimediaPost,
+            foreignKey: 'postId'
+        });        
+*/        
     };
     return Post;
 };

modules/events/event.model.js

@@ -14,6 +14,10 @@ module.exports = function (sequelize, DataTypes) {
         description: {
             type: DataTypes.STRING,
         },
+        campaign_text: {
+            type: DataTypes.TEXT,
+            allowNull: true
+        },
         date: {
             type: DataTypes.DATE,
             allowNull: false,
@@ -92,11 +96,17 @@ module.exports = function (sequelize, DataTypes) {
         Event.UserCreate = Event.belongsTo(models.User, { foreignKey: 'userId' });
         Event.Venue = Event.belongsTo(models.Venue, { foreignKey: 'venueId' });
 
-        Event.Multimedias = Event.belongsToMany(models.Multimedia, {
+        Event.Speakers = Event.belongsToMany(models.Speaker, {
-            through: models.MultimediaEvent,
+            through: models.EventSpeaker,
             foreignKey: 'eventId'
         });
 
+        Event.Multimedias = Event.belongsToMany(models.MultimediaFile, {
+            through: models.MultimediaEvent,
+            foreignKey: 'eventId',
+            otherKey: 'type'
+        });
+
     };
 
     return Event;

modules/events/event_speaker.model.js

@@ -0,0 +1,25 @@
+'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/venue.controller.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const generateControllers = require('../../core/controllers');
+const venueService = require('./venue.service');
+
+
+// Module Name
+const MODULE_NAME = '[venue.controller]';
+
+const controllerOptions = { MODULE_NAME };
+const extraControllers = {};
+
+module.exports = generateControllers(venueService, extraControllers, controllerOptions);
+

modules/events/venue.model.js

@@ -9,15 +9,18 @@ module.exports = function (sequelize, DataTypes) {
         },
         name: {
             type: DataTypes.STRING,
+            allowNull: false,
         },
         description: {
             type: DataTypes.STRING,
         },
         address: {
             type: DataTypes.STRING,
+            allowNull: false,
         },     
         city: {
             type: DataTypes.STRING,
+            allowNull: false,
         },  
         country: {
             type: DataTypes.STRING,
@@ -33,6 +36,7 @@ module.exports = function (sequelize, DataTypes) {
         },           
         gmt: {
             type: DataTypes.INTEGER,
+            allowNull: false,
             defaultValue: 1,
         },                          
     }, {

modules/events/venue.routes.js

@@ -0,0 +1,21 @@
+const routes = require('express').Router();
+
+const { isAdministratorUser, isLoggedUser } = require('../../middlewares/accessValidator');
+const SchemaValidator = require('../../middlewares/schemaValidator');
+
+/*const PaginateMiddleware = require('../../middlewares/paginate');
+const FieldMiddleware = require('../../middlewares/fields');*/
+//const SortMiddleware = require('../../middlewares/sort');
+
+const VenueValidation = require('./venue.validations');
+const venueController = require('./venue.controller');
+
+//routes.get('/venues', true, SortMiddleware.middleware({ default: "name" }), venueController.find);
+//routes.get('/venues', isLoggedUser, SortMiddleware.middleware({ default: "name" }), venueController.find);
+//routes.get('/venues/:id', isLoggedUser, venueController.findOne);
+
+routes.post('/venues/', SchemaValidator(VenueValidation.VenueInputType, true), venueController.create);
+//routes.put('/venues/:id', isAdministratorUser, venueController.update);
+//routes.delete('/venues/:id', isAdministratorUser, venueController.delete);
+
+module.exports = routes;

modules/events/venue.service.js

@@ -0,0 +1,10 @@
+/* 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.Venue, extraMethods);

modules/events/venue.validations.js

@@ -0,0 +1,24 @@
+const Joi = require('joi');
+
+const VenueInputType = Joi.object().keys({
+    name: Joi.string().required(),
+    address: Joi.string().required(),
+    city: Joi.string().required(),    
+    gmt: Joi.number().min(-12).max(+12),
+    description: Joi.string().optional(),
+    country: Joi.string().optional(), 
+    state: Joi.string().optional(),
+    postal_core: Joi.string().optional(),
+    accessibility: Joi.string().optional()
+});
+/*
+const VenueOutputType = Joi.object().keys({
+    name: Joi.string().required(),
+    address: Joi.string().required(),
+});
+*/
+
+module.exports = {
+    VenueInputType,
+//    VenueOutputType
+};

modules/multimedia/multimedia_events.model.js

@@ -2,18 +2,19 @@
 
 module.exports = function (sequelize, DataTypes) {
     const MultimediaEvent = sequelize.define('MultimediaEvent', {
-        multimediaId: {
+        multimediafileId: {
             type: DataTypes.UUID,
+            foreignKey: true,
             primaryKey: true,
-            allowNull: false,
         },
         eventId: {
             type: DataTypes.UUID,
+            foreignKey: true,
             primaryKey: true,
-            allowNull: false,
         },
         type: {
             type: DataTypes.STRING,
+            primaryKey: true,
         },
     }, {
         tableName: 'multimedia_events',

modules/multimedia/multimedia_file.model.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = function (sequelize, DataTypes) {
-    const Multimedia = sequelize.define('Multimedia', {
+    const MultimediaFile = sequelize.define('MultimediaFile', {
         id: {
             type: DataTypes.UUID,
             defaultValue: DataTypes.UUIDV4,
@@ -31,20 +31,22 @@ module.exports = function (sequelize, DataTypes) {
             foreignKey: true,
         },   
     }, {
-        tableName: 'multimedias',
+        tableName: 'multimedia_files',
         freezeTableName: true,
         timestamps: true,
     });
 
-    Multimedia.associate = function (models) {
+    MultimediaFile.associate = function (models) {
-        Multimedia.MultimediaType = Multimedia.belongsTo(models.MultimediaType, { foreignKey: 'typeId' });
+        MultimediaFile.MultimediaType = MultimediaFile.belongsTo(models.MultimediaType, { foreignKey: 'typeId' });
-        Multimedia.UserCreate = Multimedia.belongsTo(models.User, { foreignKey: 'userId' }); 
+        MultimediaFile.UserCreate = MultimediaFile.belongsTo(models.User, { foreignKey: 'userId' }); 
 
-        Multimedia.Events = Multimedia.belongsToMany(models.Event, {
+        MultimediaFile.Events = MultimediaFile.belongsToMany(models.Event, {
             through: models.MultimediaEvent,
-            foreignKey: 'multimediaId'
+            foreignKey: 'multimediafileId',
+            otherKey: 'type'
         });        
+
     };
 
-    return Multimedia;
+    return MultimediaFile;
 };

modules/multimedia/multimedia_posts.js

@@ -0,0 +1,26 @@
+'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

@@ -0,0 +1,26 @@
+'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/multimedia_types.controller.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const generateControllers = require('../../core/controllers');
+const multimediaTypeService = require('./multimedia_types.service');
+
+
+// Module Name
+const MODULE_NAME = '[multimedia_types.controller]';
+
+const controllerOptions = { MODULE_NAME };
+const extraControllers = {};
+
+module.exports = generateControllers(multimediaTypeService, extraControllers, controllerOptions);
+

modules/multimedia/multimedia_types.model.js

@@ -19,9 +19,9 @@ module.exports = function (sequelize, DataTypes) {
         timestamps: true,
     });
 
-//    EventType.associate = function (models) {
+    MultimediaType.associate = function (models) {
-//        EventType.Events = EventType.hasMany(models.Event, { foreignKey: 'typeId' });
+        MultimediaType.MultimediasFiles = MultimediaType.hasMany(models.MultimediaFile, { foreignKey: 'typeId' });
-//    };
+    };
 
     return MultimediaType;
 };

modules/multimedia/multimedia_types.routes.js

@@ -0,0 +1,21 @@
+const routes = require('express').Router();
+
+const { isAdministratorUser, isLoggedUser } = require('../../middlewares/accessValidator');
+const SchemaValidator = require('../../middlewares/schemaValidator');
+
+/*const PaginateMiddleware = require('../../middlewares/paginate');
+const FieldMiddleware = require('../../middlewares/fields');*/
+//const SortMiddleware = require('../../middlewares/sort');
+
+const MultimediaTypesValidation = require('./multimedia_types.validations');
+const MultimediaTypesController = require('./multimedia_types.controller');
+
+//routes.get('/venues', true, SortMiddleware.middleware({ default: "name" }), venueController.find);
+//routes.get('/venues', isLoggedUser, SortMiddleware.middleware({ default: "name" }), venueController.find);
+//routes.get('/venues/:id', isLoggedUser, venueController.findOne);
+
+routes.post('/multimediaTypes/', SchemaValidator(MultimediaTypesValidation.MultimediaTypesInputType, true), MultimediaTypesController.create);
+//routes.put('/venues/:id', isAdministratorUser, venueController.update);
+//routes.delete('/venues/:id', isAdministratorUser, venueController.delete);
+
+module.exports = routes;

modules/multimedia/multimedia_types.service.js

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

modules/multimedia/multimedia_types.validations.js

@@ -0,0 +1,17 @@
+const Joi = require('joi');
+
+const MultimediaTypesInputType = Joi.object().keys({
+    name: Joi.string().required(),
+    description: Joi.string().optional(),
+});
+/*
+const MultimediaTypesOutputType = Joi.object().keys({
+    name: Joi.string().required(),
+    description: Joi.string().optional(),
+});
+*/
+
+module.exports = {
+    MultimediaTypesInputType,
+//    MultimediaTypesOutputType
+};

modules/speakers/speaker.model.js

@@ -0,0 +1,83 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const Speaker = sequelize.define('Speaker', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        name: {
+            type: DataTypes.STRING,
+            allowNull: false,
+        },
+        description: {
+            type: DataTypes.STRING,
+        },
+        short_description: {
+            type: DataTypes.STRING,
+        },
+        slogan: {
+            type: DataTypes.STRING,
+        },        
+        twitter: {
+            type: DataTypes.STRING,
+        },
+        facebook: {
+            type: DataTypes.STRING,
+        },
+        youtube: {
+            type: DataTypes.STRING,
+        },
+        linkedlin: {
+            type: DataTypes.STRING,
+        },
+        instagram: {
+            type: DataTypes.STRING,
+        },
+        web: {
+            type: DataTypes.STRING,
+        },
+        state: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: 'borrador'
+        },
+        typeId: {
+            type: DataTypes.UUID,
+            foreignKey: true,
+        },
+        user_id: {
+            type: DataTypes.UUID,
+            foreignKey: true,
+        },
+    }, {
+        tableName: 'speakers',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    Speaker.associate = function (models) {
+
+        Speaker.SpeakerType = Speaker.belongsTo(models.SpeakerType, { foreignKey: 'typeId' });
+        Speaker.UserCreate = Speaker.belongsTo(models.User, { foreignKey: 'userId' });
+        Speaker.Values = Speaker.belongsToMany(models.Value, {
+            through: models.SpeakerValue,
+            foreignKey: 'speakerId'
+        });
+
+        Speaker.Events = Speaker.belongsToMany(models.Event, {
+            through: models.EventSpeaker,
+            foreignKey: 'speakerId'
+        });
+
+/*
+        Speaker.Multimedias = Speaker.belongsToMany(models.MultimediaFile, {
+            through: models.MultimediaSpeaker,
+            foreignKey: 'speakerId'
+        });
+*/
+    };
+
+    return Speaker;
+};

modules/speakers/speaker_type.model.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const SpeakerType = sequelize.define('SpeakerType', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        name: {
+            type: DataTypes.STRING,
+        },
+    }, {
+        tableName: 'speaker_types',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    SpeakerType.associate = function (models) {
+        SpeakerType.Speakers = SpeakerType.hasMany(models.Speaker, { foreignKey: 'typeId' });
+    };
+
+    return SpeakerType;
+};

modules/speakers/speaker_values.model.js

@@ -0,0 +1,22 @@
+'use strict';
+
+module.exports = function (sequelize, DataTypes) {
+    const SpeakerValue = sequelize.define('SpeakerValue', {
+        speakerId: {
+            type: DataTypes.UUID,
+            primaryKey: true,
+            allowNull: false,
+        },
+        valueId: {
+            type: DataTypes.UUID,
+            primaryKey: true,
+            allowNull: false,
+        },
+    }, {
+        tableName: 'speakers_values',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    return SpeakerValue;
+};

modules/values/values.model.js

@@ -0,0 +1,27 @@
+module.exports = function (sequelize, DataTypes) {
+    const Value = sequelize.define('Value', {
+        id: {
+            type: DataTypes.UUID,
+            defaultValue: DataTypes.UUIDV4,
+            primaryKey: true,
+        },
+        name: {
+            type: DataTypes.STRING,
+            allowNull: false
+        },
+    }, {
+        tableName: 'values',
+        freezeTableName: true,
+        timestamps: true,
+    });
+
+    Value.associate = function (models) {
+       
+        Value.Speakers = Value.belongsToMany(models.Speaker, {
+            through: models.SpeakerValue,
+            foreignKey: 'valueId'
+        });
+    };
+
+    return Value;
+};