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 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)); }