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

const routes = require('express').Router();

const { isAdministratorUser, isLoggedUser } = require('../../middlewares/accessValidator');
const SchemaValidator = require('../../middlewares/schemaValidator');

const { cacheSuccesses } = require('../../middlewares/cache');
const PaginateMiddleware = require('../../middlewares/paginate');
const FieldMiddleware = require('../../middlewares/fields');
const SortMiddleware = require('../../middlewares/sort');

//const entityValidation = require('./entity.validations');
const eventController = require('./event.controller');
const eventInscriptionController = require('./events_inscriptions.controller');
const eventReservationController = require('./events_reservations.controller');
const eventValidation = require('./event.validations');

const generalInvalidFields = [
    'userId', 'createdAt', 'updatedAt',
    'assistants', 'confirmed', 'allow_multiple', 'overflow_eventId',
    'state', 'confirmed', 
    'multiple_limit', 'allow_overflow', 'marketing_list',
];

routes.get('/events', 
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    (req, res, next) => {
        if (!req.body.city)
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails'],
            })(req, res, next)
        else
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails', { method: ['onlyOfCity', req.body.city] }]
            })(req, res, next);
    } 
);

routes.get('/events/cities',
    isLoggedUser,
    SortMiddleware.middleware({ default: "city" }),
    eventController.find({
        scopes: ['CitiesOfEvents']
    })
);


routes.get('/events/next',
    isLoggedUser, 
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "init_available_date" }), 
    (req, res, next) => {
        return eventController.find({
            scopes: ['defaultScope', 'next', 'includeVenue', 'includeMultimedias', { method: ['includeInscription', req.user.id] }],
        })(req, res, next)
    } 

);

routes.get('/events/past', cacheSuccesses('24 hours'),
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    eventController.find({
        scopes: ['defaultScope', 'past', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/events/today',
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'today', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/events/current', 
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    eventController.find({
        scopes: ['defaultScope', 'current', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/events/:id', 
    isLoggedUser, 
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    (req, res, next) => {
        return eventController.findOne({
            scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails', { method: ['includeInscription', req.user.id] }]
        })(req, res, next)
    } 
);

// Comentarios

routes.get('/events/:id/comments',
    isLoggedUser, 
    (req, res, next) => {
        req.params.association = 'Comments';
        next();
    },
    eventController.find,

);

// Multimedias
routes.get('/events/:id/multimedias',
    isLoggedUser, 
    (req, res, next) => {
        req.params.association = 'Multimedias';
        next();
    },
    eventController.find,
);

// Inscripciones
// Esto da las inscripciones de un usuario
routes.get('/events/:id/inscriptions',
    isLoggedUser,
    eventController.getInscriptions,
);


// Esto da todas las inscripciones de un usuario
routes.get('/me/inscriptions/count',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscriptionsOfNextEventsCount,
);

// Esto da todas las inscripciones de un usuario
routes.get('/me/inscriptions',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscriptions,
);

// Esto da la inscripción de un usuario
routes.get('/me/inscriptions/:id',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscription,
);

// Inscription QR Code
routes.get('/me/inscriptions/:id/qr', isLoggedUser,
    //cacheSuccesses('1 hour'),
    eventController.getQRCodeInscription,
);

/*router.get('/:conferenceId/inscription/:userId/qrimage', function (req, res) {
    conference.getInscriptionQRCode(req.params.conferenceId, req.params.userId, function (result, status) {
        if (result && result.data) {
            var buffer = new Buffer(result.data.split(",")[1], 'base64');

            res.writeHead(status, {
                'Content-Type': 'image/png',
                'Content-Length': buffer.length
            });

            res.end(buffer);
        } else {
            res.status(200).end('')
        }
    });
});*/

// Hacer una inscripción
routes.post('/events/:id/inscriptions',
    isLoggedUser, 
    SchemaValidator(eventValidation.InscriptionInputType, true), 
    eventController.createInscription
);

// Borrar una inscripción
routes.delete('/inscriptions/:id',
    isLoggedUser, 
    //SchemaValidator(eventValidation.InscriptionInputType, true),     
    eventController.deleteInscription
);


routes.get('/events/:id/reservations/:encodedInvitationCode',
    isLoggedUser, 
    //eventController.findComments
    eventController.checkReservationCode
);


//WEB

//Eventos con inscripciones abiertas para la web
routes.get('/web/events',
    //    isLoggedUser,
    FieldMiddleware.middleware({
        validFields: ['id', 'name']
    }),
    //    PaginateMiddleware.middleware(),
    //    SortMiddleware.middleware({ default: "init_available_date" }),
    eventController.find({
        scopes: ['defaultScope', 'withOpenInscriptions']
    }),
);

// Hacer una inscripción por la web
routes.post('/web/events/:id/inscriptions',
    SchemaValidator(eventValidation.webInscriptionInputType, true),
    eventController.createInscription
);


/*
routes.get('/tickets/:id/',
    isLoggedUser,
    eventController.findComments
);
*/

//routes.get('/venues', isLoggedUser, SortMiddleware.middleware({ default: "name" }), venueController.find);
//routes.get('/venues/:id', isLoggedUser, venueController.findOne);

//routes.post('/entity/', SchemaValidator(VenueValidation.VenueInputType, true), venueController.create);
//routes.put('/venues/:id', isAdministratorUser, venueController.update);
//routes.delete('/venues/:id', isAdministratorUser, venueController.delete);



/********************************************************************************************************
 *  ADMINISTRACIÓN   
 ********************************************************************************************************* 
 */
// Inscripciones
// Esto da las inscripciones de un evento
routes.get('/admin/events/:id/inscriptions',
    isAdministratorUser,
    eventController.getInscriptions,
);

// Todos los ponentes
routes.get('/admin/events',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    (req, res, next) => {
        if (!req.body.city)
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails'],
            })(req, res, next)
        else
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails', { method: ['onlyOfCity', req.body.city] }]
            })(req, res, next);
    }
);

routes.get('/admin/events/next',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "init_available_date" }),
    eventController.find({
        scopes: ['defaultScope', 'next', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/past',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'past', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/current',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'current', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/:id',
    isAdministratorUser,
    (req, res, next) => {
        return eventController.findOne({
            scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeOverflowEvent', 'includeDetails']
        })(req, res, next)
    }
);

routes.get('/admin/events/:id/partners',
    isAdministratorUser,
    eventController.findPartners,    
);

routes.get('/admin/events/:id/colleges',
    isAdministratorUser,
    eventController.findColleges,
);

routes.get('/admin/events/:id/reservations/excel',
    isAdministratorUser,
    eventController.getReservationsExcel,
);

routes.get('/admin/events/:id/inscriptions/excel',
    isAdministratorUser,
    eventController.getInscripcionsExcel,
);

routes.get('/admin/events/:eventId/partners/:entityId/reservations',
    isAdministratorUser,
    eventReservationController.find(),
);


routes.post('/admin/reservations',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    eventReservationController.create(),

    );

routes.get('/admin/reservations/:id',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    (req, res, next) => {
        return eventReservationController.findOne({
            scopes: ['includeEvent', 'includeInscriptions']
        })(req, res, next)
    },

);

routes.put('/admin/reservations/:id',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    eventReservationController.update(),
);

// Borrar reserva
routes.delete('/admin/reservations/:id',
    isAdministratorUser,
    eventReservationController.delete()
);

module.exports = routes;