webhandle-calendar/services/calendar-service.js

Calendar tools for node webhandle

const addCallbackToPromise = require('dreck/add-callback-to-promise')
const filog = require('filter-log')

const sortEvents = require('./event-sort')

/**
 * options: {
 * 	products: a mongo collection object which stores the information
 * }
 * 
 */


 
function createFetch(collectionName) {
	return function(query, callback) {
		query = query || {}
		let p = new Promise((resolve, reject) => {
			this[collectionName].find(query).toArray((err, result) => {
				if(err) {
					this.log.error(err)
					return reject(err)
				}
				if(result && this.postFetchesProcessor) {
					this.postFetchesProcessor(result, collectionName).then((processed) => {
						resolve(processed)
					})
				}
				else {
					resolve(result)
				}
			})
		})
		return addCallbackToPromise(p, callback)
	}
	
}

function createIdFetch(fetchFunction) {
	return function(id, callback) {
		return fetchFunction.apply(this, [this.createIdQuery(id), callback])
	}
}

function createSave(collectionName) {
	return function(focus, callback) {
		let p = new Promise((resolve, reject) => {
			this[collectionName].save(focus, (err, result) => {
				if(!err) {
					return resolve(result)
				}
				this.log.error(err)
				return reject(err)
			})
		})		
		return addCallbackToPromise(p, callback)
	}
}



class CalendarService {
	
	constructor(options) {
		Object.assign(this, {
			log: filog('CalendarData:')
		}, options)
		
		
		this.fetchEvents = createFetch('webhandle-calendar-events')
		this.fetchEventsById = createIdFetch(this.fetchEvents)
		this.saveEvent = createSave('webhandle-calendar-events')
		
		this.fetchEventTypes = createFetch('webhandle-calendar-event-types')
		this.fetchOrderById = createIdFetch(this.fetchEventTypes)
		this.saveEventType = createSave('webhandle-calendar-event-types')
		
		
		this.fetchPrograms = createFetch('webhandle-calendar-programs')
		this.fetchProgramById = createIdFetch(this.fetchPrograms)
		this.saveProgaram = createSave('webhandle-calendar-programs')

		this.fetchProgramTypes = createFetch('webhandle-calendar-program-types')
		this.fetchProgramTypeById = createIdFetch(this.fetchProgramTypes)
		this.saveProgaramType = createSave('webhandle-calendar-program-types')

	}

	createIdQuery(id) {
		if(Array.isArray(id)) {
			let ids = id.map(item => {
				return {
					id: Buffer.from(item, "hex"),
					_bsontype: "ObjectID"
				}
			})
			return {_id: {$in: ids}}
		}
		else {
			return {
				id: Buffer.from(id, "hex"),
				_bsontype: "ObjectID"
			}
		}
	}
	
	postFetchesProcessor(result, collectionName) {
		return new Promise((resolve, reject) => {
			resolve(result)
		})
	}

	sortPrograms(programs) {
		programs = programs.sort((one, two) => {
			try {
				let o1 = parseInt(one.sortOrder) || 0
				let o2 = parseInt(two.sortOrder) || 0
				if(o1 < o2) {
					return -1
				}
				if(o1 > o2) {
					return 1
				}
				return 0
			}
			catch(e) {
				return 0
			}
		})
		return programs
	}

	materializeProgramsTree(callback) {
		let p = new Promise((resolve, reject) => {
			let promises = []
			promises.push(this.fetchProgramTypes())
			promises.push(this.fetchPrograms())
			promises.push(this.fetchEvents())
			Promise.all(promises).then(results => {
				let types = results[0]
				let programs = results[1]
				let events = results[2]
				let typesById = {}
				let eventsByProgram = events.reduce((acc, event) => {
					if(event.programType) {
						let el = acc[event.programType]
						if(!el) {
							el = []
							acc[event.programType] = el
						}
						el.push(event)
					}
					return acc
				}, {})
				types.forEach(type => {
					type.programs = []
					typesById[type._id] = type
				})
				programs.forEach(program => {
					if(program.programType && typesById[program.programType]) {
						typesById[program.programType].programs.push(program)
					}
					let el = eventsByProgram[program._id]
					if(el) {
						program.events = el
					}
				})
				types.forEach(type => {
					type.programs = this.sortPrograms(type.programs)
					for(let p of type.programs) {
//						p.events.sort(sortEvents)
					}
				})
				resolve(types)
			})
		})
		return addCallbackToPromise(p, callback)
	}

}

module.exports = CalendarService