enigma-bbs/core/view_controller.js

869 lines
22 KiB
JavaScript

/* jslint node: true */
'use strict';
// ENiGMA½
var MCIViewFactory = require('./mci_view_factory.js').MCIViewFactory;
var menuUtil = require('./menu_util.js');
var asset = require('./asset.js');
var ansi = require('./ansi_term.js');
// deps
var events = require('events');
var util = require('util');
var assert = require('assert');
var async = require('async');
var _ = require('lodash');
var paths = require('path');
exports.ViewController = ViewController;
var MCI_REGEXP = /([A-Z]{2})([0-9]{1,2})/;
function ViewController(options) {
assert(_.isObject(options));
assert(_.isObject(options.client));
events.EventEmitter.call(this);
var self = this;
this.client = options.client;
this.views = {}; // map of ID -> view
this.formId = options.formId || 0;
this.mciViewFactory = new MCIViewFactory(this.client); // :TODO: can this not be a singleton?
this.noInput = _.isBoolean(options.noInput) ? options.noInput : false;
this.actionKeyMap = {};
//
// Small wrapper/proxy around handleAction() to ensure we do not allow
// input/additional actions queued while performing an action
//
this.handleActionWrapper = function(formData, actionBlock) {
if(self.waitActionCompletion) {
return; // ignore until this is finished!
}
self.waitActionCompletion = true;
menuUtil.handleAction(self.client, formData, actionBlock, (err) => {
if(err) {
// :TODO: What can we really do here?
if('ALREADYTHERE' === err.reasonCode) {
self.client.log.trace( err.reason );
} else {
self.client.log.warn( { err : err }, 'Error during handleAction()');
}
}
self.waitActionCompletion = false;
});
};
this.clientKeyPressHandler = function(ch, key) {
//
// Process key presses treating form submit mapped keys special.
// Everything else is forwarded on to the focused View, if any.
//
var actionForKey = key ? self.actionKeyMap[key.name] : self.actionKeyMap[ch];
if(actionForKey) {
if(_.isNumber(actionForKey.viewId)) {
//
// Key works on behalf of a view -- switch focus & submit
//
self.switchFocus(actionForKey.viewId);
self.submitForm(key);
} else if(_.isString(actionForKey.action)) {
const formData = self.getFocusedView() ? self.getFormData() : { };
self.handleActionWrapper(
Object.assign( { ch : ch, key : key }, formData ), // formData + key info
actionForKey); // actionBlock
}
} else {
if(self.focusedView && self.focusedView.acceptsInput) {
self.focusedView.onKeyPress(ch, key);
}
}
};
this.viewActionListener = function(action, key) {
switch(action) {
case 'next' :
self.emit('action', { view : this, action : action, key : key });
self.nextFocus();
break;
case 'accept' :
if(self.focusedView && self.focusedView.submit) {
// :TODO: need to do validation here!!!
var focusedView = self.focusedView;
self.validateView(focusedView, function validated(err, newFocusedViewId) {
if(err) {
var newFocusedView = self.getView(newFocusedViewId) || focusedView;
self.setViewFocusWithEvents(newFocusedView, true);
} else {
self.submitForm(key);
}
});
//self.submitForm(key);
} else {
self.nextFocus();
}
break;
}
};
this.submitForm = function(key) {
self.emit('submit', this.getFormData(key));
};
// :TODO: replace this in favor of overriding toJSON() for various things such that logging will *never* output them
this.getLogFriendlyFormData = function(formData) {
// :TODO: these fields should be part of menu.json sensitiveMembers[]
var safeFormData = _.cloneDeep(formData);
if(safeFormData.value.password) {
safeFormData.value.password = '*****';
}
if(safeFormData.value.passwordConfirm) {
safeFormData.value.passwordConfirm = '*****';
}
return safeFormData;
};
this.switchFocusEvent = function(event, view) {
if(self.emitSwitchFocus) {
return;
}
self.emitSwitchFocus = true;
self.emit(event, view);
self.emitSwitchFocus = false;
};
this.createViewsFromMCI = function(mciMap, cb) {
async.each(Object.keys(mciMap), (name, nextItem) => {
const mci = mciMap[name];
const view = self.mciViewFactory.createFromMCI(mci);
if(view) {
if(false === self.noInput) {
view.on('action', self.viewActionListener);
}
self.addView(view);
}
return nextItem(null);
},
err => {
self.setViewOrder();
return cb(err);
});
};
// :TODO: move this elsewhere
this.setViewPropertiesFromMCIConf = function(view, conf) {
var propAsset;
var propValue;
for(var propName in conf) {
propAsset = asset.getViewPropertyAsset(conf[propName]);
if(propAsset) {
switch(propAsset.type) {
case 'config' :
propValue = asset.resolveConfigAsset(conf[propName]);
break;
case 'sysStat' :
propValue = asset.resolveSystemStatAsset(conf[propName]);
break;
// :TODO: handle @art (e.g. text : @art ...)
case 'method' :
case 'systemMethod' :
if('validate' === propName) {
// :TODO: handle propAsset.location for @method script specification
if('systemMethod' === propAsset.type) {
// :TODO: implementation validation @systemMethod handling!
var methodModule = require(paths.join(__dirname, 'system_view_validate.js'));
if(_.isFunction(methodModule[propAsset.asset])) {
propValue = methodModule[propAsset.asset];
}
} else {
if(_.isFunction(self.client.currentMenuModule.menuMethods[propAsset.asset])) {
propValue = self.client.currentMenuModule.menuMethods[propAsset.asset];
}
}
} else {
if(_.isString(propAsset.location)) {
// :TODO: clean this code up!
} else {
if('systemMethod' === propAsset.type) {
// :TODO:
} else {
// local to current module
var currentModule = self.client.currentMenuModule;
if(_.isFunction(currentModule.menuMethods[propAsset.asset])) {
// :TODO: Fix formData & extraArgs... this all needs general processing
propValue = currentModule.menuMethods[propAsset.asset]({}, {});//formData, conf.extraArgs);
}
}
}
}
break;
default :
propValue = propValue = conf[propName];
break;
}
} else {
propValue = conf[propName];
}
if(!_.isUndefined(propValue)) {
view.setPropertyValue(propName, propValue);
}
}
};
this.applyViewConfig = function(config, cb) {
let highestId = 1;
let submitId;
let initialFocusId = 1;
async.each(Object.keys(config.mci || {}), function entry(mci, nextItem) {
const mciMatch = mci.match(MCI_REGEXP); // :TODO: How to handle auto-generated IDs????
if(null === mciMatch) {
self.client.log.warn( { mci : mci }, 'Unable to parse MCI code');
return;
}
const viewId = parseInt(mciMatch[2]);
assert(!isNaN(viewId), 'Cannot parse view ID: ' + mciMatch[2]); // shouldn't be possible with RegExp used
if(viewId > highestId) {
highestId = viewId;
}
const view = self.getView(viewId);
if(!view) {
self.client.log.warn( { viewId : viewId }, 'Cannot find view');
nextItem(null);
return;
}
const mciConf = config.mci[mci];
self.setViewPropertiesFromMCIConf(view, mciConf);
if(mciConf.focus) {
initialFocusId = viewId;
}
if(true === view.submit) {
submitId = viewId;
}
nextItem(null);
},
err => {
// default to highest ID if no 'submit' entry present
if(!submitId) {
var highestIdView = self.getView(highestId);
if(highestIdView) {
highestIdView.submit = true;
} else {
self.client.log.warn( { highestId : highestId }, 'View does not exist');
}
}
return cb(err, { initialFocusId : initialFocusId } );
});
};
// method for comparing submitted form data to configuration entries
this.actionBlockValueComparator = function(formValue, actionValue) {
//
// For a match to occur, one of the following must be true:
//
// * actionValue is a Object:
// a) All key/values must exactly match
// b) value is null; The key (view ID or "argName") must be present
// in formValue. This is a wildcard/any match.
// * actionValue is a Number: This represents a view ID that
// must be present in formValue.
// * actionValue is a string: This represents a view with
// "argName" set that must be present in formValue.
//
if(_.isUndefined(actionValue)) {
return false;
}
if(_.isNumber(actionValue) || _.isString(actionValue)) {
if(_.isUndefined(formValue[actionValue])) {
return false;
}
} else {
/*
:TODO: support:
value: {
someArgName: [ "key1", "key2", ... ],
someOtherArg: [ "key1, ... ]
}
*/
var actionValueKeys = Object.keys(actionValue);
for(var i = 0; i < actionValueKeys.length; ++i) {
var viewId = actionValueKeys[i];
if(!_.has(formValue, viewId)) {
return false;
}
if(null !== actionValue[viewId] && actionValue[viewId] !== formValue[viewId]) {
return false;
}
}
}
self.client.log.trace(
{
formValue : formValue,
actionValue : actionValue
},
'Action match'
);
return true;
};
if(!options.detached) {
this.attachClientEvents();
}
this.setViewFocusWithEvents = function(view, focused) {
if(!view || !view.acceptsFocus) {
return;
}
if(focused) {
self.switchFocusEvent('return', view);
self.focusedView = view;
} else {
self.switchFocusEvent('leave', view);
}
view.setFocus(focused);
};
this.validateView = function(view, cb) {
if(view && _.isFunction(view.validate)) {
view.validate(view.getData(), function validateResult(err) {
var viewValidationListener = self.client.currentMenuModule.menuMethods.viewValidationListener;
if(_.isFunction(viewValidationListener)) {
if(err) {
err.view = view; // pass along the view that failed
}
viewValidationListener(err, function validationComplete(newViewFocusId) {
cb(err, newViewFocusId);
});
} else {
cb(err);
}
});
} else {
cb(null);
}
};
}
util.inherits(ViewController, events.EventEmitter);
ViewController.prototype.attachClientEvents = function() {
if(this.attached) {
return;
}
var self = this;
this.client.on('key press', this.clientKeyPressHandler);
Object.keys(this.views).forEach(function vid(i) {
// remove, then add to ensure we only have one listener
self.views[i].removeListener('action', self.viewActionListener);
self.views[i].on('action', self.viewActionListener);
});
this.attached = true;
};
ViewController.prototype.detachClientEvents = function() {
if(!this.attached) {
return;
}
this.client.removeListener('key press', this.clientKeyPressHandler);
for(var id in this.views) {
this.views[id].removeAllListeners();
}
this.attached = false;
};
ViewController.prototype.viewExists = function(id) {
return id in this.views;
};
ViewController.prototype.addView = function(view) {
assert(!this.viewExists(view.id), 'View with ID ' + view.id + ' already exists');
this.views[view.id] = view;
};
ViewController.prototype.getView = function(id) {
return this.views[id];
};
ViewController.prototype.getViewsByMciCode = function(mciCode) {
if(!Array.isArray(mciCode)) {
mciCode = [ mciCode ];
}
const views = [];
_.each(this.views, v => {
if(mciCode.includes(v.mciCode)) {
views.push(v);
}
});
return views;
};
ViewController.prototype.getFocusedView = function() {
return this.focusedView;
};
ViewController.prototype.setFocus = function(focused) {
if(focused) {
this.attachClientEvents();
} else {
this.detachClientEvents();
}
this.setViewFocusWithEvents(this.focusedView, focused);
};
ViewController.prototype.resetInitialFocus = function() {
if(this.formInitialFocusId) {
return this.switchFocus(this.formInitialFocusId);
}
};
ViewController.prototype.switchFocus = function(id) {
//
// Perform focus switching validation now
//
var self = this;
var focusedView = self.focusedView;
self.validateView(focusedView, function validated(err, newFocusedViewId) {
if(err) {
var newFocusedView = self.getView(newFocusedViewId) || focusedView;
self.setViewFocusWithEvents(newFocusedView, true);
} else {
self.attachClientEvents();
// remove from old
self.setViewFocusWithEvents(focusedView, false);
// set to new
self.setViewFocusWithEvents(self.getView(id), true);
}
});
};
ViewController.prototype.nextFocus = function() {
let nextFocusView = this.focusedView ? this.focusedView : this.views[this.firstId];
// find the next view that accepts focus
while(nextFocusView && nextFocusView.nextId) {
nextFocusView = this.getView(nextFocusView.nextId);
if(!nextFocusView || nextFocusView.acceptsFocus) {
break;
}
}
if(nextFocusView && this.focusedView !== nextFocusView) {
this.switchFocus(nextFocusView.id);
}
};
ViewController.prototype.setViewOrder = function(order) {
var viewIdOrder = order || [];
if(0 === viewIdOrder.length) {
for(var id in this.views) {
if(this.views[id].acceptsFocus) {
viewIdOrder.push(id);
}
}
viewIdOrder.sort(function intSort(a, b) {
return a - b;
});
}
if(viewIdOrder.length > 0) {
var count = viewIdOrder.length - 1;
for(var i = 0; i < count; ++i) {
this.views[viewIdOrder[i]].nextId = viewIdOrder[i + 1];
}
this.firstId = viewIdOrder[0];
var lastId = viewIdOrder.length > 1 ? viewIdOrder[viewIdOrder.length - 1] : this.firstId;
this.views[lastId].nextId = this.firstId;
}
};
ViewController.prototype.redrawAll = function(initialFocusId) {
this.client.term.rawWrite(ansi.hideCursor());
for(var id in this.views) {
if(initialFocusId === id) {
continue; // will draw @ focus
}
this.views[id].redraw();
}
this.client.term.rawWrite(ansi.showCursor());
};
ViewController.prototype.loadFromPromptConfig = function(options, cb) {
assert(_.isObject(options));
assert(_.isObject(options.mciMap));
var self = this;
var promptConfig = _.isObject(options.config) ? options.config : self.client.currentMenuModule.menuConfig.promptConfig;
var initialFocusId = 1; // default to first
async.waterfall(
[
function createViewsFromMCI(callback) {
self.createViewsFromMCI(options.mciMap, function viewsCreated(err) {
callback(err);
});
},
function applyViewConfiguration(callback) {
if(_.isObject(promptConfig.mci)) {
self.applyViewConfig(promptConfig, function configApplied(err, info) {
initialFocusId = info.initialFocusId;
callback(err);
});
} else {
callback(null);
}
},
function prepareFormSubmission(callback) {
if(false === self.noInput) {
self.on('submit', function promptSubmit(formData) {
self.client.log.trace( { formData : self.getLogFriendlyFormData(formData) }, 'Prompt submit');
if(_.isString(self.client.currentMenuModule.menuConfig.action)) {
self.handleActionWrapper(formData, self.client.currentMenuModule.menuConfig);
} else {
//
// Menus that reference prompts can have a sepcial "submit" block without the
// hassle of by-form-id configurations, etc.
//
// "submit" : [
// { ... }
// ]
//
var menuSubmit = self.client.currentMenuModule.menuConfig.submit;
if(!_.isArray(menuSubmit)) {
self.client.log.debug('No configuration to handle submit');
return;
}
//
// Locate matching action block
//
// :TODO: this is basically the same as for menus -- DRY it up!
for(var c = 0; c < menuSubmit.length; ++c) {
var actionBlock = menuSubmit[c];
if(_.isEqualWith(formData.value, actionBlock.value, self.actionBlockValueComparator)) {
self.handleActionWrapper(formData, actionBlock);
break; // there an only be one...
}
}
}
});
}
callback(null);
},
function loadActionKeys(callback) {
if(!_.isObject(promptConfig) || !_.isArray(promptConfig.actionKeys)) {
return callback(null);
}
promptConfig.actionKeys.forEach(ak => {
//
// * 'keys' must be present and be an array of key names
// * If 'viewId' is present, key(s) will focus & submit on behalf
// of the specified view.
// * If 'action' is present, that action will be procesed when
// triggered by key(s)
//
// Ultimately, create a map of key -> { action block }
//
if(!_.isArray(ak.keys)) {
return;
}
ak.keys.forEach(kn => {
self.actionKeyMap[kn] = ak;
});
});
return callback(null);
},
function drawAllViews(callback) {
self.redrawAll(initialFocusId);
callback(null);
},
function setInitialViewFocus(callback) {
if(initialFocusId) {
self.switchFocus(initialFocusId);
}
callback(null);
}
],
function complete(err) {
cb(err);
}
);
};
ViewController.prototype.loadFromMenuConfig = function(options, cb) {
assert(_.isObject(options));
if(!_.isObject(options.mciMap)) {
cb(new Error('Missing option: mciMap'));
return;
}
var self = this;
var formIdKey = options.formId ? options.formId.toString() : '0';
this.formInitialFocusId = 1; // default to first
var formConfig;
// :TODO: honor options.withoutForm
async.waterfall(
[
function findMatchingFormConfig(callback) {
menuUtil.getFormConfigByIDAndMap(self.client.currentMenuModule.menuConfig, formIdKey, options.mciMap, function matchingConfig(err, fc) {
formConfig = fc;
if(err) {
// non-fatal
self.client.log.trace(
{ reason : err.message, mci : Object.keys(options.mciMap), formId : formIdKey },
'Unable to find matching form configuration');
}
callback(null);
});
},
function createViews(callback) {
self.createViewsFromMCI(options.mciMap, function viewsCreated(err) {
callback(err);
});
},
/*
function applyThemeCustomization(callback) {
formConfig = formConfig || {};
formConfig.mci = formConfig.mci || {};
//self.client.currentMenuModule.menuConfig.config = self.client.currentMenuModule.menuConfig.config || {};
//console.log('menu config.....');
//console.log(self.client.currentMenuModule.menuConfig)
menuUtil.applyMciThemeCustomization({
name : self.client.currentMenuModule.menuName,
type : 'menus',
client : self.client,
mci : formConfig.mci,
//config : self.client.currentMenuModule.menuConfig.config,
formId : formIdKey,
});
//console.log('after theme...')
//console.log(self.client.currentMenuModule.menuConfig.config)
callback(null);
},
*/
function applyViewConfiguration(callback) {
if(_.isObject(formConfig)) {
self.applyViewConfig(formConfig, function configApplied(err, info) {
self.formInitialFocusId = info.initialFocusId;
callback(err);
});
} else {
callback(null);
}
},
function prepareFormSubmission(callback) {
if(!_.isObject(formConfig) || !_.isObject(formConfig.submit)) {
callback(null);
return;
}
self.on('submit', function formSubmit(formData) {
self.client.log.trace( { formData : self.getLogFriendlyFormData(formData) }, 'Form submit');
//
// Locate configuration for this form ID
//
var confForFormId;
if(_.isObject(formConfig.submit[formData.submitId])) {
confForFormId = formConfig.submit[formData.submitId];
} else if(_.isObject(formConfig.submit['*'])) {
confForFormId = formConfig.submit['*'];
} else {
// no configuration for this submitId
self.client.log.debug( { formId : formData.submitId }, 'No configuration for form ID');
return;
}
//
// Locate a matching action block based on the submitted data
//
for(var c = 0; c < confForFormId.length; ++c) {
var actionBlock = confForFormId[c];
if(_.isEqualWith(formData.value, actionBlock.value, self.actionBlockValueComparator)) {
self.handleActionWrapper(formData, actionBlock);
break; // there an only be one...
}
}
});
callback(null);
},
function loadActionKeys(callback) {
if(!_.isObject(formConfig) || !_.isArray(formConfig.actionKeys)) {
callback(null);
return;
}
formConfig.actionKeys.forEach(function akEntry(ak) {
//
// * 'keys' must be present and be an array of key names
// * If 'viewId' is present, key(s) will focus & submit on behalf
// of the specified view.
// * If 'action' is present, that action will be procesed when
// triggered by key(s)
//
// Ultimately, create a map of key -> { action block }
//
if(!_.isArray(ak.keys)) {
return;
}
ak.keys.forEach(function actionKeyName(kn) {
self.actionKeyMap[kn] = ak;
});
});
callback(null);
},
function drawAllViews(callback) {
self.redrawAll(self.formInitialFocusId);
callback(null);
},
function setInitialViewFocus(callback) {
if(self.formInitialFocusId) {
self.switchFocus(self.formInitialFocusId);
}
callback(null);
}
],
function complete(err) {
if(_.isFunction(cb)) {
cb(err);
}
}
);
};
ViewController.prototype.formatMCIString = function(format) {
var self = this;
var view;
return format.replace(/{(\d+)}/g, function replacer(match, number) {
view = self.getView(number);
if(!view) {
return match;
}
return view.getData();
});
};
ViewController.prototype.getFormData = function(key) {
/*
Example form data:
{
id : 0,
submitId : 1,
value : {
"1" : "hurp",
"2" : [ 'a', 'b', ... ],
"3" 2,
"pants" : "no way"
}
}
*/
const formData = {
id : this.formId,
submitId : this.focusedView.id,
value : {},
};
if(key) {
formData.key = key;
}
let viewData;
_.each(this.views, view => {
try {
// don't fill forms with static, non user-editable data data
if(!view.acceptsInput) {
return;
}
viewData = view.getData();
if(_.isUndefined(viewData)) {
return;
}
formData.value[ view.submitArgName ? view.submitArgName : view.id ] = viewData;
} catch(e) {
this.client.log.error( { error : e.message }, 'Exception caught gathering form data' );
}
});
return formData;
};