enigma-bbs/core/set_newscan_date.js

/* jslint node: true */
'use strict';

//	ENiGMA½
const MenuModule					= require('./menu_module.js').MenuModule;
const ViewController				= require('./view_controller.js').ViewController;
const Errors						= require('./enig_error.js').Errors;
const FileEntry						= require('./file_entry.js');
const FileBaseFilters				= require('./file_base_filter.js');
const { getAvailableFileAreaTags }	= require('./file_base_area.js');
const {
	getSortedAvailMessageConferences,
	getSortedAvailMessageAreasByConfTag,
	updateMessageAreaLastReadId,
	getMessageIdNewerThanTimestampByArea
}									= require('./message_area.js');
const stringFormat					= require('./string_format.js');

//	deps
const async					= require('async');
const moment				= require('moment');
const _						= require('lodash');

exports.moduleInfo = {
	name	: 'Set New Scan Date',
	desc	: 'Sets new scan date for applicable scans',
	author	: 'NuSkooler',
};

const MciViewIds = {
	main : {
		scanDate		: 1,
		targetSelection	: 2,
	}
};

//	:TODO: for messages, we could insert "conf - all areas" into targets, and allow such

exports.getModule = class SetNewScanDate extends MenuModule {
	constructor(options) {
		super(options);

		const config = this.menuConfig.config;

		this.target			= config.target || 'message';
		this.scanDateFormat	= config.scanDateFormat || 'YYYYMMDD';

		this.menuMethods = {
			scanDateSubmit : (formData, extraArgs, cb) => {
				let scanDate = _.get(formData, 'value.scanDate');
				if(!scanDate) {
					return cb(Errors.MissingParam('"scanDate" missing from form data'));
				}

				scanDate = moment(scanDate, this.scanDateFormat);
				if(!scanDate.isValid()) {
					return cb(Errors.Invalid(`"${_.get(formData, 'value.scanDate')}" is not a valid date`));
				}

				const targetSelection = _.get(formData, 'value.targetSelection');	//	may be undefined if N/A

				this[`setNewScanDateFor${_.capitalize(this.target)}Base`](targetSelection, scanDate, () => {
					return this.prevMenu(cb);
				});
			},
		};
	}

	setNewScanDateForMessageBase(targetSelection, scanDate, cb) {
		const target = this.targetSelections[targetSelection];
		if(!target) {
			return cb(Errors.UnexpectedState('Unable to get target in which to set new scan'));
		}

		//	selected area, or all of 'em
		let updateAreaTags;
		if('' === target.area.areaTag) {
			updateAreaTags = this.targetSelections
				.map( targetSelection => targetSelection.area.areaTag )
				.filter( areaTag => areaTag );	//	remove the blank 'all' entry
		} else {
			updateAreaTags = [ target.area.areaTag ];
		}

		async.each(updateAreaTags, (areaTag, nextAreaTag) => {
			getMessageIdNewerThanTimestampByArea(areaTag, scanDate, (err, messageId) => {
				if(err) {
					return nextAreaTag(err);
				}

				if(!messageId) {
					return nextAreaTag(null);	//	nothing to do
				}

				messageId = Math.max(messageId - 1, 0);

				return updateMessageAreaLastReadId(
					this.client.user.userId,
					areaTag,
					messageId,
					true,	//	allowOlder
					nextAreaTag
				);
			});
		}, err => {
			return cb(err);
		});
	}

	setNewScanDateForFileBase(targetSelection, scanDate, cb) {
		//
		//	ENiGMA doesn't currently have the concept of per-area
		//	scan pointers for users, so we use all areas avail
		//	to the user.
		//
		const filterCriteria = {
			areaTag				: getAvailableFileAreaTags(this.client),
			newerThanTimestamp	: scanDate,
			limit				: 1,
			orderBy				: 'upload_timestamp',
			order				: 'ascending',
		};

		FileEntry.findFiles(filterCriteria, (err, fileIds) => {
			if(err) {
				return cb(err);
			}

			if(!fileIds || 0 === fileIds.length) {
				//	nothing to do
				return cb(null);
			}

			const pointerFileId = Math.max(fileIds[0] - 1, 0);

			return FileBaseFilters.setFileBaseLastViewedFileIdForUser(
				this.client.user,
				pointerFileId,
				true,	//	allowOlder
				cb
			);
		});
	}

	loadAvailMessageBaseSelections(cb) {
		//
		//	Create an array of objects with conf/area information per entry,
		//	sorted naturally or via the 'sort' member in config
		//
		const selections = [];
		getSortedAvailMessageConferences(this.client).forEach(conf => {
			getSortedAvailMessageAreasByConfTag(conf.confTag, { client : this.client } ).forEach(area => {
				selections.push({
					conf	: {
						confTag : conf.confTag,
						name	: conf.conf.name,
						desc	: conf.conf.desc,
					},
					area	: {
						areaTag	: area.areaTag,
						name	: area.area.name,
						desc	: area.area.desc,
					}
				});
			});
		});

		selections.unshift({
			conf : {
				confTag	: '',
				name	: 'All conferences',
				desc	: 'All conferences',
			},
			area	: {
				areaTag	: '',
				name	: 'All areas',
				desc	: 'All areas',
			}
		});

		//	Find current conf/area & move it directly under "All"
		const currConfTag 	= this.client.user.properties.message_conf_tag;
		const currAreaTag	= this.client.user.properties.message_area_tag;
		if(currConfTag && currAreaTag) {
			const confAreaIndex = selections.findIndex( confArea => {
				return confArea.conf.confTag === currConfTag && confArea.area.areaTag === currAreaTag;
			});

			if(confAreaIndex > -1) {
				selections.splice(1, 0, selections.splice(confAreaIndex, 1)[0]);
			}
		}

		this.targetSelections = selections;

		return cb(null);
	}

	mciReady(mciData, cb) {
		super.mciReady(mciData, err => {
			if(err) {
				return cb(err);
			}

			const self	= this;
			const vc	= self.addViewController( 'main', new ViewController( { client : this.client } ) );

			async.series(
				[
					function validateConfig(callback) {
						if(![ 'message', 'file' ].includes(self.target)) {
							return callback(Errors.Invalid(`Invalid "target" in config: ${self.target}`));
						}
						//	:TOD0: validate scanDateFormat
						return callback(null);
					},
					function loadFromConfig(callback) {
						return vc.loadFromMenuConfig( { callingMenu : self, mciMap : mciData.menu }, callback);
					},
					function loadAvailSelections(callback) {
						switch(self.target) {
							case 'message' :
								return self.loadAvailMessageBaseSelections(callback);

							default :
								return callback(null);
						}
					},
					function populateForm(callback) {
						const today = moment();

						const scanDateView = vc.getView(MciViewIds.main.scanDate);

						//	:TODO: MaskTextEditView needs some love: If setText() with input that matches the mask, we should ignore the non-mask chars! Hack in place for now
						const scanDateFormat = self.scanDateFormat.replace(/[/\-. ]/g, '');
						scanDateView.setText(today.format(scanDateFormat));

						if('message' === self.target) {
							const messageSelectionsFormat		= self.menuConfig.config.messageSelectionsFormat || '{conf.name} - {area.name}';
							const messageSelectionFocusFormat	= self.menuConfig.config.messageSelectionFocusFormat || messageSelectionsFormat;

							const targetSelectionView = vc.getView(MciViewIds.main.targetSelection);

							targetSelectionView.setItems(self.targetSelections.map(targetSelection => stringFormat(messageSelectionFocusFormat, targetSelection)));
							targetSelectionView.setFocusItems(self.targetSelections.map(targetSelection => stringFormat(messageSelectionFocusFormat, targetSelection)));

							targetSelectionView.setFocusItemIndex(0);
						}

						self.viewControllers.main.resetInitialFocus();
						//vc.switchFocus(MciViewIds.main.scanDate);
						return callback(null);
					}
				],
				err => {
					return cb(err);
				}
			);
		});
	}
};