nakedobjects.spa
Version:
Single Page Application client for a Naked Objects application.
365 lines • 17.8 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
import forEach from 'lodash/forEach';
import fromPairs from 'lodash/fromPairs';
import keys from 'lodash/keys';
import last from 'lodash/last';
import map from 'lodash/map';
import mapKeys from 'lodash/mapKeys';
import mapValues from 'lodash/mapValues';
import reduce from 'lodash/reduce';
import { Command } from './Command';
import * as Commandresult from './command-result';
import * as Constants from '../constants';
import * as Models from '../models';
import * as Usermessages from '../user-messages';
import * as Validate from '../validate';
var Enter = (function (_super) {
__extends(Enter, _super);
function Enter() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.shortCommand = "en";
_this.fullCommand = Usermessages.enterCommand;
_this.helpText = Usermessages.enterHelp;
_this.minArguments = 2;
_this.maxArguments = 2;
return _this;
}
Enter.prototype.isAvailableInCurrentContext = function () {
return this.isDialog() || this.isEdit() || this.isTransient() || this.isForm();
};
Enter.prototype.doExecute = function (args, chained) {
var fieldName = this.argumentAsString(args, 0);
var fieldEntry = this.argumentAsString(args, 1, false, false);
if (fieldName === undefined) {
return this.returnResult("", Usermessages.doesNotMatchDialog(fieldName));
}
if (fieldEntry === undefined) {
return this.returnResult("", Usermessages.tooFewArguments);
}
if (this.isDialog()) {
return this.fieldEntryForDialog(fieldName, fieldEntry);
}
else {
return this.fieldEntryForEdit(fieldName, fieldEntry);
}
};
;
Enter.prototype.fieldEntryForEdit = function (fieldName, fieldEntry) {
var _this = this;
return this.getObject().then(function (obj) {
var fields = _this.matchingProperties(obj, fieldName);
switch (fields.length) {
case 0:
var s = Usermessages.doesNotMatchProperties(fieldName);
return _this.returnResult("", s);
case 1:
var field = fields[0];
if (fieldEntry === "?") {
//TODO: does this work in edit mode i.e. show entered value
var s_1 = _this.renderFieldDetails(field, field.value());
return _this.returnResult("", s_1);
}
else {
_this.findAndClearAnyDependentFields(field.id(), obj.propertyMembers());
return _this.setField(field, fieldEntry);
}
default:
var ss = reduce(fields, function (s, prop) { return s + prop.extensions().friendlyName() + "\n"; }, fieldName + " " + Usermessages.matchesMultiple);
return _this.returnResult("", ss);
}
});
};
Enter.prototype.isDependentField = function (fieldName, possibleDependent) {
var promptLink = possibleDependent.promptLink();
if (promptLink) {
var pArgs = promptLink.arguments();
var argNames = keys(pArgs);
return (argNames.indexOf(fieldName.toLowerCase()) >= 0);
}
return false;
};
Enter.prototype.findAndClearAnyDependentFields = function (changingField, allFields) {
var _this = this;
forEach(allFields, function (field) {
if (_this.isDependentField(changingField, field)) {
if (!_this.isMultiChoiceField(field)) {
_this.clearField(field);
}
}
});
};
Enter.prototype.fieldEntryForDialog = function (fieldName, fieldEntry) {
var _this = this;
return this.getActionForCurrentDialog().then(function (action) {
//TODO: error - need to get invokable action to get the params.
var params = map(action.parameters(), function (param) { return param; });
params = _this.matchFriendlyNameAndOrMenuPath(params, fieldName);
switch (params.length) {
case 0:
return _this.returnResult("", Usermessages.doesNotMatchDialog(fieldName));
case 1:
if (fieldEntry === "?") {
var p = params[0];
var value = Commandresult.getParametersAndCurrentValue(p.parent, _this.context)[p.id()];
var s = _this.renderFieldDetails(p, value);
return _this.returnResult("", s);
}
else {
_this.findAndClearAnyDependentFields(fieldName, action.parameters());
return _this.setField(params[0], fieldEntry);
}
default:
return _this.returnResult("", Usermessages.multipleFieldMatches + " " + fieldName); //TODO: list them
}
});
};
Enter.prototype.clearField = function (field) {
this.context.cacheFieldValue(this.routeData().dialogId, field.id(), new Models.Value(null));
if (field instanceof Models.Parameter) {
this.context.cacheFieldValue(this.routeData().dialogId, field.id(), new Models.Value(null));
}
else if (field instanceof Models.PropertyMember) {
var parent_1 = field.parent;
this.context.cachePropertyValue(parent_1, field, new Models.Value(null));
}
};
Enter.prototype.setField = function (field, fieldEntry) {
if (field instanceof Models.PropertyMember && field.disabledReason()) {
return this.returnResult("", field.extensions().friendlyName() + " " + Usermessages.isNotModifiable);
}
var entryType = field.entryType();
switch (entryType) {
case Models.EntryType.FreeForm:
return this.handleFreeForm(field, fieldEntry);
case Models.EntryType.AutoComplete:
return this.handleAutoComplete(field, fieldEntry);
case Models.EntryType.Choices:
return this.handleChoices(field, fieldEntry);
case Models.EntryType.MultipleChoices:
return this.handleChoices(field, fieldEntry);
case Models.EntryType.ConditionalChoices:
return this.handleConditionalChoices(field, false, fieldEntry);
case Models.EntryType.MultipleConditionalChoices:
return this.handleConditionalChoices(field, false, fieldEntry);
default:
return this.returnResult("", Usermessages.invalidCase);
}
};
Enter.prototype.handleFreeForm = function (field, fieldEntry) {
var _this = this;
if (field.isScalar()) {
var mandatoryError = Validate.validateMandatory(field, fieldEntry);
if (mandatoryError) {
return this.returnResult("", this.validationMessage(mandatoryError, new Models.Value(""), field.extensions().friendlyName()));
}
var value = new Models.Value(fieldEntry);
if (Models.isDateOrDateTime(field)) {
var dt = Validate.validateDate(fieldEntry, Constants.supportedDateFormats);
if (dt) {
value = new Models.Value(Models.toDateString(dt.toDate()));
}
}
// if optional but empty always valid
if (fieldEntry != null && fieldEntry !== "") {
var remoteMask = field.extensions().mask();
var localFilter = this.mask.toLocalFilter(remoteMask, field.extensions().format());
var validateError = Validate.validateMandatoryAgainstType(field, fieldEntry, localFilter);
if (validateError) {
return this.returnResult("", this.validationMessage(validateError, value, field.extensions().friendlyName()));
}
}
this.setFieldValue(field, value);
return this.returnResult("", "", function () { return _this.urlManager.triggerPageReloadByFlippingReloadFlagInUrl(); });
}
else {
return this.handleReferenceField(field, fieldEntry);
}
};
Enter.prototype.setFieldValue = function (field, value) {
var urlVal = this.valueForUrl(value, field);
if (urlVal != null) {
if (field instanceof Models.Parameter) {
this.setFieldValueInContext(field, urlVal);
}
else if (field instanceof Models.PropertyMember) {
var parent_2 = field.parent;
if (parent_2 instanceof Models.DomainObjectRepresentation) {
this.setPropertyValueinContext(parent_2, field, urlVal);
}
}
}
};
Enter.prototype.handleReferenceField = function (field, fieldEntry) {
if (this.isPaste(fieldEntry)) {
return this.handleClipboard(field);
}
else {
return this.returnResult("", Usermessages.invalidRefEntry);
}
};
Enter.prototype.isPaste = function (fieldEntry) {
return "paste".indexOf(fieldEntry) === 0;
};
Enter.prototype.handleClipboard = function (field) {
var _this = this;
var ref = this.ciceroContext.ciceroClipboard;
if (!ref) {
return this.returnResult("", Usermessages.emptyClipboard);
}
var paramType = field.extensions().returnType();
var refType = ref.domainType();
return this.context.isSubTypeOf(refType, paramType).then(function (isSubType) {
if (isSubType) {
var obj = _this.ciceroContext.ciceroClipboard;
var selfLink = obj.selfLink();
//Need to add a title to the SelfLink as not there by default
selfLink.setTitle(obj.title());
var value = new Models.Value(selfLink);
_this.setFieldValue(field, value);
return _this.returnResult("", "", function () { return _this.urlManager.triggerPageReloadByFlippingReloadFlagInUrl(); });
}
else {
return _this.returnResult("", Usermessages.incompatibleClipboard);
}
});
};
Enter.prototype.handleAutoComplete = function (field, fieldEntry) {
var _this = this;
//TODO: Need to check that the minimum number of characters has been entered or fail validation
if (!field.isScalar() && this.isPaste(fieldEntry)) {
return this.handleClipboard(field);
}
else {
return this.context.autoComplete(field, field.id(), function () { return ({}); }, fieldEntry).then(function (choices) {
var matches = _this.findMatchingChoicesForRef(choices, fieldEntry);
var allFields = Commandresult.getFields(field);
return _this.switchOnMatches(field, allFields, fieldEntry, matches);
});
}
};
Enter.prototype.handleChoices = function (field, fieldEntry) {
var matches;
if (field.isScalar()) {
matches = this.findMatchingChoicesForScalar(field.choices(), fieldEntry);
}
else {
matches = this.findMatchingChoicesForRef(field.choices(), fieldEntry);
}
var allFields = Commandresult.getFields(field);
return this.switchOnMatches(field, allFields, fieldEntry, matches);
};
Enter.prototype.updateDependentField = function (field) {
return this.handleConditionalChoices(field, true);
};
Enter.prototype.setFieldAndCheckDependencies = function (field, allFields, match) {
var _this = this;
this.setFieldValue(field, match);
var promises = [];
// find any dependent multi choice fields and update
// non multi choice we will have just cleared
forEach(allFields, function (depField) {
if (_this.isMultiChoiceField(depField)) {
if (_this.isDependentField(field.id().toLowerCase(), depField)) {
promises.push(_this.updateDependentField(depField));
}
}
});
promises.push(this.returnResult("", "", function () { return _this.urlManager.triggerPageReloadByFlippingReloadFlagInUrl(); }));
return Promise.all(promises);
};
Enter.prototype.switchOnMatches = function (field, allFields, fieldEntry, matches) {
switch (matches.length) {
case 0:
return this.returnResult("", Usermessages.noMatch(fieldEntry));
case 1:
return this.setFieldAndCheckDependencies(field, allFields, matches[0]).then(function (crs) { return last(crs); });
default:
var msg_1 = Usermessages.multipleMatches;
forEach(matches, function (m) { return msg_1 += m.toString() + "\n"; });
return this.returnResult("", msg_1);
}
};
Enter.prototype.getPropertiesAndCurrentValue = function (obj) {
var props = obj.propertyMembers();
var values = mapValues(props, function (p) { return p.value(); });
var modifiedProps = this.context.getObjectCachedValues(obj.id());
forEach(values, function (v, k) {
var newValue = modifiedProps[k];
if (newValue) {
values[k] = newValue;
}
});
return mapKeys(values, function (v, k) { return k.toLowerCase(); });
};
Enter.prototype.updateOnMatches = function (field, allFields, fieldEntry, matches) {
switch (matches.length) {
case 0:
case 1:
var match = matches.length === 0 ? new Models.Value(null) : matches[0];
return this.setFieldAndCheckDependencies(field, allFields, match).then(function (crs) { return last(crs); });
default:
// shouldn't happen - ignore
return this.returnResult("", "");
}
};
Enter.prototype.handleConditionalChoices = function (field, updating, fieldEntry) {
var _this = this;
var enteredFields;
var allFields = Commandresult.getFields(field);
if (field instanceof Models.Parameter) {
enteredFields = Commandresult.getParametersAndCurrentValue(field.parent, this.context);
}
if (field instanceof Models.PropertyMember) {
enteredFields = this.getPropertiesAndCurrentValue(field.parent);
}
var args = fromPairs(map(field.promptLink().arguments(), function (v, key) { return [key, new Models.Value(v.value)]; }));
forEach(keys(args), function (key) { return args[key] = enteredFields[key]; });
var fieldEntryOrExistingValue;
if (fieldEntry === undefined) {
var def = args[field.id()];
fieldEntryOrExistingValue = def ? def.toValueString() : "";
}
else {
fieldEntryOrExistingValue = fieldEntry;
}
return this.context.conditionalChoices(field, field.id(), function () { return ({}); }, args).then(function (choices) {
var matches = _this.findMatchingChoicesForRef(choices, fieldEntryOrExistingValue);
if (updating) {
return _this.updateOnMatches(field, allFields, fieldEntryOrExistingValue, matches);
}
return _this.switchOnMatches(field, allFields, fieldEntryOrExistingValue, matches);
});
};
Enter.prototype.renderFieldDetails = function (field, value) {
var fieldName = Usermessages.fieldName(field.extensions().friendlyName());
var desc = field.extensions().description();
var descAndPrefix = desc ? "\n" + Usermessages.descriptionFieldPrefix + " " + desc : "";
var types = "\n" + Usermessages.typePrefix + " " + Models.friendlyTypeName(field.extensions().returnType());
var postFix = "";
if (field instanceof Models.PropertyMember && field.disabledReason()) {
postFix = "\n" + Usermessages.unModifiablePrefix(field.disabledReason());
}
else {
postFix = field.extensions().optional() ? "\n" + Usermessages.optional : "\n" + Usermessages.mandatory;
var choices = field.choices();
if (choices) {
var label = "\n" + Usermessages.choices + ": ";
var labelAndChoices = reduce(choices, function (ss, cho) { return ss + cho + " "; }, label);
postFix = "" + postFix + labelAndChoices;
}
}
return "" + fieldName + descAndPrefix + types + postFix;
};
return Enter;
}(Command));
export { Enter };
//# sourceMappingURL=enter.js.map