webhandle-calendar/handles/webhandle-calendar-admin.js

Calendar tools for node webhandle

let wh = require('webhandle')
const express = require('express')

const EventsDreck = require('./events-dreck')
const EventTypesDreck = require('./event-types-dreck')
const ProgramTypesDreck = require('./program-types-dreck')
const ProgramsDreck = require('./programs-dreck')

const CalendarService = require('../services/calendar-service')

const MonthGrid = require('../data/month-grid')
const Event = require('../data/event')


const moment = require('moment')
const url = require('url')
const path = require('path')
const sortEvents = require('../services/event-sort')


let init = (options) => {
	if(!webhandle.drecks) {
		webhandle.drecks = {}
	}
	
	if(!options.mongoDb.collections['webhandle-calendar-events']) {
		options.mongoDb.collections['webhandle-calendar-events'] = options.mongoDb.collection('webhandle-calendar-events')
	}
	if(!options.mongoDb.collections['webhandle-calendar-event-types']) {
		options.mongoDb.collections['webhandle-calendar-event-types'] = options.mongoDb.collection('webhandle-calendar-event-types')
	}
	if(!options.mongoDb.collections['webhandle-calendar-programs']) {
		options.mongoDb.collections['webhandle-calendar-programs'] = options.mongoDb.collection('webhandle-calendar-programs')
	}
	if(!options.mongoDb.collections['webhandle-calendar-program-types']) {
		options.mongoDb.collections['webhandle-calendar-program-types'] = options.mongoDb.collection('webhandle-calendar-program-types')
	}
	
	webhandle.services.calendarService = new CalendarService({
		'webhandle-calendar-events': options.mongoDb.collections['webhandle-calendar-events'],
		'webhandle-calendar-event-types': options.mongoDb.collections['webhandle-calendar-event-types'],
		'webhandle-calendar-programs': options.mongoDb.collections['webhandle-calendar-programs'],
		'webhandle-calendar-program-types': options.mongoDb.collections['webhandle-calendar-program-types']
	})
	




	let adminRouter = express.Router()
	adminRouter.get('/events/menu', (req, res, next) => {
		res.render('webhandle-calendar/events-menu')
	})
	

	// Events 
	let eventsDreck = new EventsDreck({
		mongoCollection: options.mongoDb.collection('webhandle-calendar-events'),
		eventTypesCollection: options.mongoDb.collection('webhandle-calendar-event-types'),
		programsCollection: options.mongoDb.collection('webhandle-calendar-programs'),
		locals: {
			pretemplate: options.pretemplate,
			posttemplate: options.posttemplate
		},
		templatePrefix: options.eventsTemplatePrefix
	})
	webhandle.drecks.events = eventsDreck
	
	let eventsRouter = express.Router()
	eventsDreck.addToRouter(eventsRouter)
	adminRouter.use('/events/events', eventsRouter)


	// Event Types

	let eventTypesDreck = new EventTypesDreck({
		mongoCollection: options.mongoDb.collection('webhandle-calendar-event-types'),
		locals: {
			pretemplate: options.pretemplate,
			posttemplate: options.posttemplate
		}
	})
	webhandle.drecks.eventTypes = eventTypesDreck
	
	let eventTypesRouter = express.Router()
	eventTypesDreck.addToRouter(eventTypesRouter)
	adminRouter.use('/events/types', eventTypesRouter)
	
	

	// Program Types
	let programTypesDreck = new ProgramTypesDreck({
		mongoCollection: options.mongoDb.collection('webhandle-calendar-program-types'),
		locals: {
			pretemplate: options.pretemplate,
			posttemplate: options.posttemplate
		}
	})
	
	webhandle.drecks.programTypes = programTypesDreck
	let programsTypesRouter = express.Router()
	programTypesDreck.addToRouter(programsTypesRouter)
	adminRouter.use('/event-programs/types', programsTypesRouter)



	// Events 
	let programsDreck = new ProgramsDreck({
		mongoCollection: options.mongoDb.collection('webhandle-calendar-programs'),
		programTypesCollection: options.mongoDb.collection('webhandle-calendar-program-types'),
		locals: {
			pretemplate: options.pretemplate,
			posttemplate: options.posttemplate
		}
	})
	webhandle.drecks.programs = programsDreck
	
	let programsRouter = express.Router()
	programsDreck.addToRouter(programsRouter)
	adminRouter.use('/event-programs/programs', programsRouter)
	
	
	
	
	let securedAdminRouter = require('webhandle-users/utils/allow-group')(
		['administrators'],
		adminRouter
	)
	wh.routers.primary.use(securedAdminRouter)


	
	wh.addTemplateDir(path.join(webhandle.projectRoot, 'node_modules/webhandle-calendar/views'))

	

	
	function createIdQuery(id) {
		return {
			id: Buffer.from(id, "hex"),
			_bsontype: "ObjectID"
		}
	}

	wh.services.events = {
		loadMonthAndAfterEvents: function(callback, startDate) {
			
			let monthStart = moment(startDate).startOf('month')
			options.mongoDb.collection('webhandle-calendar-events').find({
				start: { $gte: monthStart.toDate() }
			}).toArray((err, results) => {
				if(callback) {
					callback(err, results)
				}
			})
		},
		loadEventById: (eventId, callback) => {
			options.mongoDb.collection('webhandle-calendar-events').find(createIdQuery(eventId)).toArray((err, results) => {
				if(callback) {
					
					callback(err, results[0])
				}
			})
		}
	}
	
	wh.pageServer.preRun.push((req, res, next) => {
		let tag = req.query.eventTag || res.locals.page.eventTag
		if(tag) {
			webhandle.services.events.loadMonthAndAfterEvents((err, data) => {
				if(!err && data) {
					res.locals.page.events = data

					res.locals.page.events = res.locals.page.events.filter((event) => {
						return event.eventVisibility == 'draft' ? false : true
					})
					if(tag != 'all') {
						res.locals.page.events = res.locals.page.events.filter(event => {
							if(event.tags) {
								return event.tags.includes(tag)
							}
							else {
								return false
							}
						})
					}
					res.locals.page.events = res.locals.page.events.sort(sortEvents)
				}
				next()
			}, req.query.startDate)
			
			let monthStart = moment(req.query.startDate).startOf('month')
			let previousMonth = moment(monthStart).add(-1, 'month')
			let nextMonth = moment(monthStart).add(1, 'month')
			
			let curUrl = url.parse(req.originalUrl)
			let parms = new url.URLSearchParams(curUrl.query)
			parms.set('startDate', previousMonth.format('YYYY-MM-DD'))
			curUrl.search = parms.toString()
			res.locals.previousPeriodPage = curUrl.format() + '#gridded-calendar'
			
			parms.set('startDate', nextMonth.format('YYYY-MM-DD'))
			curUrl.search = parms.toString()
			res.locals.nextPeriodPage = curUrl.format() + '#gridded-calendar'
			
			
		}
		else if(req.query.eventId) {
			// webhandle.sinks.project.read('data/events.json', (err, data) => {
			// 	if(!err && data) {
			// 		res.locals.event = JSON.parse(data.toString()).filter( event => {
			// 			return event.id == req.query.eventId
			// 		})[0]
			// 	}
			// 	next()
			// })
			webhandle.services.events.loadEventById(req.query.eventId, (err, data) => {
				if(!err && data) {
					res.locals.event = data
					// res.locals.event = JSON.parse(data.toString()).filter( event => {
					// 	return event.id == req.query.eventId
					// })[0]
				}
				next()
			})
		}
		else {
			next()
		}
	})
	
	wh.pageServer.preRun.push(function(req, res, next) {
		if(res.locals.page.events) {
			let m = moment()
			if(req.query.startDate) {
				m = moment(req.query.startDate)
			}
			res.locals.page.monthGrid = new MonthGrid({
				monthNum: m.month(),
				year: m.year()
			})
			res.locals.page.events.forEach((event) => {
				let evt = new Event(event)
				evt.link = '/show-event?eventId=' + (evt.id || evt._id.toString())
				res.locals.page.monthGrid.addEvent(evt)
			})
		}
		next()
	})
	
}

module.exports = init