webhandle-calendar/handles/events-dreck.js

Calendar tools for node webhandle

const Dreck = require('dreck')
let wh = global.webhandle
const moment = require('moment')

const addCallbackToPromise = require('dreck/add-callback-to-promise')
const priceTypes = require('../data/price-types')

class EventsDreck extends Dreck {
	constructor(options) {
		super(options)
		
		options.timeZone = options.timeZone || '-06:00'
		
		this.templatePrefix = options.templatePrefix || 'webhandle-calendar/events/'
		this.bannedInjectMembers.push("startDate")
		this.bannedInjectMembers.push("startTime")
		this.bannedInjectMembers.push("durationHours")
		this.bannedInjectMembers.push("durationMinutes")
		
		let self = this
		
		this.eventTypesCollection = options.eventTypesCollection
		this.programsCollection = options.programsCollection

		this.injectors.unshift((req, focus, next) => {
			delete focus.ticketedEvent
			next()
		})
		
		this.injectors.push((req, focus, next) => {
			
				let day 
				if(req.body.startDate && req.body.startTime) {
					day = moment(req.body.startDate + ' ' + req.body.startTime)
				}
				else if(req.body.startDate) {
					day = moment(req.body.startDate + ' 00:00:00')
				}
				else {
					day = moment(new Date())
				}
				
				focus.start = day.toDate()
				let end = moment(day)
				end.add(req.body.durationHours, 'H')
				end.add(req.body.durationMinutes, 'm')
				focus.end = end.toDate()
				this.deleteTemporary(focus)

				
				if(!req.body.tag) {
					focus.tags = []
				}
				else {
					focus.tags = [req.body.tag]
				}
				
				if(!req.body.allDayEvent) {
					delete focus.allDayEvent
				}
				
				if(focus.ticketedEvent) {
					for(let priceType of priceTypes) {
						if(!focus[priceType + 'Price']) {
							focus[priceType + 'Price'] = "0"
						}
					}
				}

				next()
			}
		)

	}
	
	deleteTemporary(focus) {
		delete focus.startDate
		delete focus.startTime
		delete focus.durationHours
		delete focus.durationMinutes
		delete focus.tag
		
	}
	save(focus, callback) {
		this.deleteTemporary(focus)
		
		let p = new Promise((resolve, reject) => {
			this.mongoCollection.save(focus, (err, result) => {
				if(!err) {
					if(wh.events && wh.events.global) {
						let obj = result.ops ? result.ops[0] : focus
						wh.events.global.emit('object-change', obj, null, 'event')
					}
					return resolve(result)
				}
				this.log.error(err)
				return reject(err)
			})
		})		
		return addCallbackToPromise(p, callback)
	}	
	
	synchronousPostProcessor(obj) {
		try {
			if(obj.start) {
				let m = moment(obj.start)
				// obj.startDate = m.format('YYYY-MM-DD')
				// obj.startTime = m.format('HH:mm')
				obj.startDate = obj.start
				obj.startTime = obj.start
				let diff = moment(obj.end).diff(obj.start)
				obj.durationHours = parseInt(diff / (1000 * 60 * 60))
				obj.durationMinutes = parseInt(diff / (1000 * 60)) - (obj.durationHours * 60)
			}
			if(obj.tags && obj.tags.length > 0) {
				obj.tag = obj.tags[0]
			}
		}
		catch(e) {
			
		}
		return obj
	}
	
	loadReferencedData(res, callback) {
		let promises = []

		if(this.eventTypesCollection) {
			promises.push(new Promise((resolve, reject) => {
				this.eventTypesCollection.find({}).toArray((err, types) => {
					res.locals.eventTypes = types
					if(err) {
						reject(err)
					}
					resolve()
				})
			}))
		}
		if(this.programsCollection) {
			promises.push(new Promise((resolve, reject) => {
					this.programsCollection.find({}).toArray((err, types) => {
					res.locals.programs = types
					if(err) {
						reject(err)
					}
					resolve()
				})
			}))
		}

		if(promises.length > 0) {
			Promise.all(promises).then(() => {
				callback()
			})
		}
		else {
			callback()
		}

	}

	newGET(req, res, next) {
		this.loadReferencedData(res, () => {
			return super.newGET(req, res, next)
		})
	}
	
	editGET(req, res, next) {
		this.loadReferencedData(res, () => {
			return super.editGET(req, res, next)
		})
	}
	
	createTitle(focus) {
		return 'Create Event'
	}
	
	editTitle(focus) {
		return 'Edit Event'
	}
	
	listTitle(items) {
		return 'List Events'
	}
	
	showTitle(items) {
		return 'View Event'
	}
	
	sort(req, res, focus, callback) {
		let p = new Promise((resolve, reject) => {
			if(focus && Array.isArray(focus)) {
				focus = focus.sort((one, two) => {
					try {
						if(!one.start || !two.start) {
							return 0
						}
						if (one.start > two.start) {
							return -1
						}
						if (one.start < two.start) {
							return 1
						}
					}
					catch(e) {}
					return 0
				})
			}
			resolve(focus)
		})
		
		let returnPromise = addCallbackToPromise(p, callback)
		return returnPromise
	}
}


module.exports = EventsDreck