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

'use strict';
const moment = require('moment');
const Sequelize = require('sequelize');

const getStateText = (conference) => {

    var currentDate = moment().utc(),
        initDate = moment.utc(conference.ini_date),
        endDate = moment.utc(conference.end_date),
        init_availableDate = moment.utc(conference.init_available_date),
        end_availableDate = moment.utc(conference.end_available_date),
        isFull = (conference.confirmed > conference.assistans);

    if (moment(currentDate).isBetween(initDate, endDate)) {
        return 'Congreso en curso';
    } else {
        if (moment(endDate).isBefore(currentDate)) {
            return 'Congreso finalizado';
        } else {
            if (moment(currentDate).isBetween(init_availableDate, end_availableDate)) {
                return isFull ? 'Inscripciones abiertas a lista de espera' : 'Inscripciones abiertas';
            } else {
                return 'Inscripciones a partir del ' + moment(init_availableDate).format('ll');
            }
        }
    };
};


module.exports = function (sequelize, DataTypes) {

    const Event = sequelize.define('Event', {
        id: {
            type: DataTypes.UUID,
            defaultValue: DataTypes.UUIDV4,
            primaryKey: true,
        },
        name: {
            type: DataTypes.STRING,
            allowNull: false,
        },
        description: {
            type: DataTypes.STRING,
        },
        campaign_text: {
            type: DataTypes.TEXT,
            allowNull: true
        },
        init_date: {
            type: DataTypes.DATE,
            allowNull: false,
        }, 
        end_date: { 
            type: DataTypes.DATE,
        },       
        init_available_date: {
            type: DataTypes.DATE,
        },
        end_available_date: {
            type: DataTypes.DATE,
        },
        gmt: {
            type: DataTypes.INTEGER,
            defaultValue: 1,
        },
        assistants: {
            type: DataTypes.INTEGER,
        },
        confirmed: {
            type: DataTypes.INTEGER,
        },
        allow_multiple: {
            type: DataTypes.BOOLEAN,
            allowNull: false,
            defaultValue: false,            
        },
        multiple_limit: {
            type: DataTypes.INTEGER,
        },
        allow_overflow: {
            type: DataTypes.BOOLEAN,
            allowNull: false,
            defaultValue: false,
        },
        overflow_eventId: {
            type: DataTypes.UUID,
            foreignKey: true,
            require: false,
        },
        state: {
            type: DataTypes.STRING,
            allowNull: false,
            defaultValue: 'draft'
        },
        stateText: {
            type: Sequelize.VIRTUAL(Sequelize.STRING, ['init_date', 'end_date', 'init_available_date', 'end_available_date', 'assistants', 'confirmed']),
            get: function () {
                return getStateText(this);
            },
        },
        typeId: {
            type: DataTypes.UUID,
            foreignKey: true,
        },
        venueId: {
            type: DataTypes.UUID,
            foreignKey: true,
        },
        url_streaming: {
            type: DataTypes.STRING,
        },
        url_poll: {
            type: DataTypes.STRING,
        },
        url_registration: {
            type: DataTypes.STRING,
        },
        marketing_list: {
            type: DataTypes.STRING,
        },
        userId: {
            type: DataTypes.UUID,
            foreignKey: true,
        },

    }, {
        tableName: 'events',
        freezeTableName: true,
        timestamps: true,

        defaultScope: {
            where: {
                state: 'publish'
            },
            include: [{
                model: sequelize.models.EventType,
                as: 'type',
                attributes: ['name', 'title'],
            }]

        },
    });
       
    Event.associate = function (models) {
//        Event.OverflowEvent = Event.belongsTo(models.Event, { 
//            as: 'overflowEvent',
//            foreignKey: 'overflow_eventId',
//            required: false });
        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.Details = Event.hasMany(models.EventDetail, { foreignKey: 'eventId', as: "details" });

//OJOJOJOJOJOJOJJOJ
// OJO GENERA UN FOREIGN KEY Con eventos y habrá ID de otras entidades que no exitan en la tabla eventos, porque son post o speakers
//        Event.Comments = Event.hasMany(models.Comment, {
//            foreignKey: 'entityId',
//            scope: {
//                entityName: 'event'
//            },
//            as: "comments"
//        });

//        Event.Multimedias = Event.hasMany(models.Multimedia, { 
//            foreignKey: 'entityId', 
//            scope: {
//                entityName: 'event'
//            },
//            as: { singular: 'multimedia', plural: 'multimedias' }});

        Event.Multimedias = Event.hasMany(models.Multimedia, {
            foreignKey: 'entityId',
            as: { singular: 'multimedia', plural: 'multimedias' }
        });

        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" });        
    };
    
    Event.addScope('includeVenue', () => {
        return {
            include: [
                { model: sequelize.models.Venue, as: 'venue' }
            ]
        }
    });

    Event.addScope('includeDetails', () => {
        return {
            include: [
                { model: sequelize.models.EventDetail, as: 'details' }
            ]
        }
    });

    Event.addScope('includeMultimedias', () => {
        return {
            include: [{ 
                model: sequelize.models.Multimedia, 
                as: 'multimedias',
                required: false,
                include : [{
                    model: sequelize.models.MultimediaFile,
                }]
            },
            ]
        }
    });

    Event.addScope('includeInscription', (userId) => {
        return {
            include: [
                { model: sequelize.models.EventInscription, as: 'inscriptions', where: {userId: userId} }
            ]
        }
    });


    Event.addScope('includeSpeakers', () => {
        return {
            include: [{ 
                model: sequelize.models.EventDetail, 
                as: 'details', 
                where: { 
                    type: 'speaker'
                },
                required: false,
                include: [{ 
                    model: sequelize.models.Speaker, 
                    as: 'speaker',
                    required: false,
                    include : [{
                        model: sequelize.models.Multimedia,
                        as: 'multimedias',
                        required: false,
                        include: [{
                            model: sequelize.models.MultimediaFile, 
                        }]
                    }]
                }]
            }]
        }
    });

    Event.addScope('next', {
        where: {
            init_date: {
                [Sequelize.Op.gte]: moment().add(1, 'days').startOf('day').utc()
            }
        },
    });

    Event.addScope('current', {
        where: {
            init_date: {
                [Sequelize.Op.gte]: moment().startOf('day').utc(),
                [Sequelize.Op.lt]: moment().add(1, 'days').startOf('day').utc(),
            }
        }
    });

    Event.addScope('past', {
        where: {
            init_date: {
                [Sequelize.Op.lt]: moment().startOf('day').utc()
            }
        }
    });

    return Event;
};