public string GetParameterAutoCompleteId(IActionFacade action, IActionParameterFacade parameterFacade)
{
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
var id = GetParameterInputId(action, parameterFacade);
return(parameter.Spec.IsParseable ? id : id + Sep + AutoCompleteName);
}
public ActionParameterFacade(IActionParameterSpec nakedObjectActionParameter, IFrameworkFacade frameworkFacade, INakedObjectsFramework framework, string overloadedUniqueId)
{
WrappedSpec = nakedObjectActionParameter ?? throw new NullReferenceException($"{nameof(nakedObjectActionParameter)} is null");
this.framework = framework ?? throw new NullReferenceException($"{nameof(framework)} is null");
this.overloadedUniqueId = overloadedUniqueId ?? throw new NullReferenceException($"{nameof(overloadedUniqueId)} is null");
FrameworkFacade = frameworkFacade ?? throw new NullReferenceException($"{nameof(frameworkFacade)} is null");
}
public string GetParameterId(IActionFacade actionFacade, IActionParameterFacade parameterFacade)
{
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
IActionSpec action = actionFacade.WrappedSpec();
return(action.OnSpec.ShortName + Sep + action.Id + Sep + NameUtils.CapitalizeName(parameter.Id));
}
private static bool ContextParameterIsCollection(IActionSpec contextAction, string propertyName)
{
if (contextAction != null)
{
IActionParameterSpec parameter = contextAction.Parameters.Single(p => p.Id == propertyName);
return(parameter.Spec.IsCollection);
}
return(false);
}
public ActionParameterFacade(IActionParameterSpec nakedObjectActionParameter, IFrameworkFacade frameworkFacade, INakedObjectsFramework framework, string overloadedUniqueId) {
FacadeUtils.AssertNotNull(nakedObjectActionParameter, "Action Parameter is null");
FacadeUtils.AssertNotNull(framework, "framework is null");
FacadeUtils.AssertNotNull(overloadedUniqueId, "overloadedUniqueId is null");
FacadeUtils.AssertNotNull(frameworkFacade, "FrameworkFacade is null");
this.nakedObjectActionParameter = nakedObjectActionParameter;
this.framework = framework;
this.overloadedUniqueId = overloadedUniqueId;
FrameworkFacade = frameworkFacade;
}
public NakedObjectActionParameterWrapper(IActionParameterSpec nakedObjectActionParameter, INakedObjectsSurface surface, INakedObjectsFramework framework, string overloadedUniqueId)
{
SurfaceUtils.AssertNotNull(nakedObjectActionParameter, "Action Parameter is null");
SurfaceUtils.AssertNotNull(framework, "framework is null");
SurfaceUtils.AssertNotNull(overloadedUniqueId, "overloadedUniqueId is null");
SurfaceUtils.AssertNotNull(surface, "surface is null");
this.nakedObjectActionParameter = nakedObjectActionParameter;
this.framework = framework;
this.overloadedUniqueId = overloadedUniqueId;
Surface = surface;
}
public ActionParameterFacade(IActionParameterSpec nakedObjectActionParameter, IFrameworkFacade frameworkFacade, INakedObjectsFramework framework, string overloadedUniqueId)
{
FacadeUtils.AssertNotNull(nakedObjectActionParameter, "Action Parameter is null");
FacadeUtils.AssertNotNull(framework, "framework is null");
FacadeUtils.AssertNotNull(overloadedUniqueId, "overloadedUniqueId is null");
FacadeUtils.AssertNotNull(frameworkFacade, "FrameworkFacade is null");
WrappedSpec = nakedObjectActionParameter;
this.framework = framework;
this.overloadedUniqueId = overloadedUniqueId;
FrameworkFacade = frameworkFacade;
}
private IActionParameterSpec GetParameterInternal(string actionName, string parmName, INakedObject nakedObject) {
var actionAndUid = GetActionInternal(actionName, nakedObject);
if (string.IsNullOrWhiteSpace(parmName) || string.IsNullOrWhiteSpace(parmName)) {
throw new BadRequestNOSException();
}
IActionParameterSpec parm = actionAndUid.Item1.Parameters.SingleOrDefault(p => p.Id == parmName);
if (parm == null) {
// throw something;
}
return parm;
}
public virtual JsonResult GetActionCompletions(string id, string actionName, int parameterIndex, string autoCompleteParm)
{
INakedObject nakedObject = NakedObjectsContext.GetNakedObjectFromId(id);
IActionSpec action = NakedObjectsContext.GetActions(nakedObject).SingleOrDefault(a => a.Id == actionName);
IList <object> completions = new List <object>();
IActionParameterSpec p = action.Parameters[parameterIndex];
if (p.IsAutoCompleteEnabled)
{
INakedObject[] nakedObjectCompletions = p.GetCompletions(nakedObject, autoCompleteParm);
completions = nakedObjectCompletions.Select(no => GetCompletionData(no, p.Spec)).ToList();
}
return(Jsonp(completions));
}
private Tuple<IActionSpec, ITypeSpec, IActionParameterSpec, string> GetActionParameterTypeInternal(string typeName, string actionName, string parmName) {
if (string.IsNullOrWhiteSpace(typeName) || string.IsNullOrWhiteSpace(actionName) || string.IsNullOrWhiteSpace(parmName)) {
throw new BadRequestNOSException();
}
ITypeSpec spec = GetDomainTypeInternal(typeName);
Tuple<IActionSpec, string> actionAndUid = SurfaceUtils.GetActionandUidFromSpec(spec, actionName, typeName);
IActionParameterSpec parm = actionAndUid.Item1.Parameters.SingleOrDefault(p => p.Id == parmName);
if (parm == null) {
throw new TypeActionParameterResourceNotFoundNOSException(parmName, actionName, typeName);
}
return new Tuple<IActionSpec, ITypeSpec, IActionParameterSpec, string>(actionAndUid.Item1, spec, parm, actionAndUid.Item2);
}
private T InvokeAction <T>(INakedObject nakedObject, IActionSpec action, FormCollection parameters, out bool valid)
{
if (ActionExecutingAsContributed(action, nakedObject))
{
if (action.ParameterCount == 1)
{
// contributed action being invoked with a single parm that is the current target
// no dialog - go straight through
INakedObject result = action.Execute(nakedObject, new[] { nakedObject });
valid = true;
return(result.GetDomainObject <T>());
}
if (action.ParameterCount > 1)
{
// contributed action being invoked with multiple parms - populate first that match the target
IActionParameterSpec parmToPopulate = action.Parameters.FirstOrDefault(p => nakedObject.Spec.IsOfType(p.Spec));
if (parmToPopulate != null)
{
ViewData[IdHelper.GetParameterInputId(action, parmToPopulate)] = NakedObjectsContext.GetObjectId(nakedObject.Object);
}
}
}
if (ValidateParameters(nakedObject, action, new ObjectAndControlData {
Form = parameters
}))
{
IEnumerable <INakedObject> parms = GetParameterValues(action, new ObjectAndControlData {
Form = parameters
});
INakedObject result = action.Execute(nakedObject, parms.ToArray());
valid = true;
return(result.GetDomainObject <T>());
}
valid = false;
return(default(T));
}
public virtual JsonResult ValidateParameter(string id, string value, string actionName, string parameterName)
{
INakedObject nakedObject = NakedObjectsContext.GetNakedObjectFromId(id);
IActionSpec action = NakedObjectsContext.GetActions(nakedObject).SingleOrDefault(a => a.Id == actionName);
bool isValid = false;
string parmId = "";
if (action != null)
{
IActionParameterSpec parameter = action.Parameters.Where(p => p.Id.Equals(parameterName, StringComparison.InvariantCultureIgnoreCase)).Single();
parmId = IdHelper.GetParameterInputId(action, parameter);
if (value == null)
{
value = Request.Params[parmId];
}
try {
INakedObject valueNakedObject = GetParameterValue(parameter, value);
ValidateParameter(action, parameter, nakedObject, valueNakedObject);
}
catch (InvalidEntryException) {
ModelState.AddModelError(parmId, MvcUi.InvalidEntry);
}
isValid = ModelState.IsValid;
}
if (isValid)
{
return(Jsonp(true));
}
ModelError error = ModelState[parmId].Errors.FirstOrDefault();
return(Jsonp(error == null ? "" : error.ErrorMessage));
}
private bool ValidateParameters(ActionContext actionContext, IDictionary<string, object> rawParms) {
if (rawParms.Any(kvp => !actionContext.Action.Parameters.Select(p => p.Id).Contains(kvp.Key))) {
throw new BadRequestNOSException("Malformed arguments");
}
bool isValid = true;
var orderedParms = new Dictionary<string, ParameterContext>();
// handle contributed actions
if (actionContext.Action.IsContributedMethod && !actionContext.Action.OnSpec.Equals(actionContext.Target.Spec)) {
IActionParameterSpec parm = actionContext.Action.Parameters.FirstOrDefault(p => actionContext.Target.Spec.IsOfType(p.Spec));
if (parm != null) {
rawParms.Add(parm.Id, actionContext.Target.Object);
}
}
// check mandatory fields first as standard NO behaviour is that no validation takes place until
// all mandatory fields are set.
foreach (IActionParameterSpec parm in actionContext.Action.Parameters) {
orderedParms[parm.Id] = new ParameterContext();
object value = rawParms.ContainsKey(parm.Id) ? rawParms[parm.Id] : null;
orderedParms[parm.Id].ProposedValue = value;
orderedParms[parm.Id].Parameter = parm;
orderedParms[parm.Id].Action = actionContext.Action;
var stringValue = value as string;
if (parm.IsMandatory && (value == null || (value is string && string.IsNullOrEmpty(stringValue)))) {
isValid = false;
orderedParms[parm.Id].Reason = "Mandatory"; // i18n
}
}
//check for individual parameter validity, including parsing of text input
if (isValid) {
foreach (IActionParameterSpec parm in actionContext.Action.Parameters) {
try {
INakedObject valueNakedObject = GetValue((IObjectSpec) parm.Spec, rawParms.ContainsKey(parm.Id) ? rawParms[parm.Id] : null);
orderedParms[parm.Id].ProposedNakedObject = valueNakedObject;
IConsent consent = parm.IsValid(actionContext.Target, valueNakedObject);
if (!consent.IsAllowed) {
orderedParms[parm.Id].Reason = consent.Reason;
isValid = false;
}
}
catch (InvalidEntryException) {
isValid = false;
orderedParms[parm.Id].ErrorCause = Cause.WrongType;
orderedParms[parm.Id].Reason = "Invalid Entry"; // i18n
}
}
}
// check for validity of whole set, including any 'co-validation' involving multiple parameters
if (isValid) {
IConsent consent = actionContext.Action.IsParameterSetValid(actionContext.Target, orderedParms.Select(kvp => kvp.Value.ProposedNakedObject).ToArray());
if (!consent.IsAllowed) {
actionContext.Reason = consent.Reason;
isValid = false;
}
}
actionContext.VisibleParameters = orderedParms.Select(p => p.Value).ToArray();
return isValid;
}
private ListContext GetParameterCompletions(INakedObject nakedObject, string actionName, string parmName, ArgumentsContext arguments) {
IActionParameterSpec parm = GetParameterInternal(actionName, parmName, nakedObject);
return GetCompletions(new PropParmAdapter(parm, this, framework), nakedObject, arguments);
}
public ITestParameter CreateTestParameter(IActionSpec actionSpec, IActionParameterSpec parameterSpec, ITestHasActions owningObject) => new TestParameter(parameterSpec, owningObject, this);
public static string GetParameterAutoCompleteId(IActionSpec action, IActionParameterSpec parameter)
{
var id = GetParameterInputId(action, parameter);
return(parameter.Spec.IsParseable ? id : id + sep + autoCompleteName);
}
public ParameterContext(bool embeddedInObject, INakedObject target, IActionSpec action, IActionParameterSpec parameter, bool isEdit)
: base(embeddedInObject, target, action)
{
Parameter = parameter;
IsParameterEdit = isEdit;
}
public static bool IsParseableOrCollectionOfParseable(this INakedObjectsFramework framework, IActionParameterSpec parmSpec)
{
var spec = parmSpec.Spec;
return(spec.IsParseable || (spec.IsCollection && parmSpec.GetFacet <IElementTypeFacet>().ValueSpec.IsParseable));
}
public TestParameter(IActionParameterSpec parameterSpec, ITestHasActions owningObject, ITestObjectFactory factory) {
this.parameterSpec = parameterSpec;
this.owningObject = owningObject;
this.factory = factory;
}
public string GetParameterInputId(IActionFacade action, IActionParameterFacade parameterFacade)
{
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
return(GetParameterId(action, parameterFacade) + Sep + InputOrSelect(parameter.Spec));
}
public ITestParameter CreateTestParameter(IActionSpec actionSpec, IActionParameterSpec parameterSpec, ITestHasActions owningObject) {
return new TestParameter(parameterSpec, owningObject, this);
}
public static string GetParameterInputId(IActionSpec action, IActionParameterSpec parameter)
{
return(GetParameterId(action, parameter) + sep + InputOrSelect(parameter.Spec));
}
public TestParameter(IActionParameterSpec parameterSpec, ITestHasActions owningObject, ITestObjectFactory factory)
{
this.parameterSpec = parameterSpec;
this.owningObject = owningObject;
this.factory = factory;
}
public PropParmAdapter(IActionParameterSpec parm, INakedObjectsSurface surface, INakedObjectsFramework framework)
: this((object) parm, surface, framework) {
this.parm = parm;
CheckAutocompleOrConditional();
}
public static string GetParameterId(IActionSpec action, IActionParameterSpec parameter)
{
return(action.OnSpec.ShortName + sep + action.Id + sep + NameUtils.CapitalizeName(parameter.Id));
}
