/// <summary> /// Get the unvalidated string of a model property posted in Request. /// </summary> /// <typeparam name="M">The type of the model</typeparam> /// <param name="propertySelector">An expression to select the property from the model.</param> /// <returns>Returns the string in the request for the property.</returns> protected string GetUnvalidatedPropertyFromRequest <M>(Expression <Func <M, object> > propertySelector) { if (propertySelector == null) { throw new ArgumentNullException(nameof(propertySelector)); } string requestKey = GenericExpressionHelper.GetExpressionText(propertySelector); return(this.Request.Unvalidated[requestKey]); }
/// <summary> /// Attempt to update the specified model instance using values from the controller's current value provider. /// </summary> /// <typeparam name="M">The type of the model.</typeparam> /// <typeparam name="VM">The type of object which contains the model.</typeparam> /// <param name="modelSelector">The expression which extracts the model from which container.</param> /// <param name="model">The model to update.</param> /// <returns>Returns true when the included model properties were valid.</returns> protected bool TryUpdateModel <M, VM>(M model, Expression <Func <VM, M> > modelSelector) where M : class { if (modelSelector == null) { throw new ArgumentNullException(nameof(modelSelector)); } string modelPrefix = GenericExpressionHelper.GetExpressionText(modelSelector); return(TryUpdateModel(model, modelPrefix)); }
private static string[] GetPropertyNames <M>(Expression <Func <M, object> >[] propertySelectors) where M : class { string[] propertyNames = new string[propertySelectors.Length]; for (int i = 0; i < propertySelectors.Length; i++) { propertyNames[i] = GenericExpressionHelper.GetExpressionText(propertySelectors[i]); } return(propertyNames); }
/// <summary> /// Updates the specified model instance using values from the controller's current value provider /// and included properties. /// </summary> /// <typeparam name="M">The type of the model.</typeparam> /// <typeparam name="VM">The type of object which contains the model.</typeparam> /// <param name="modelSelector">The expression to extract the model the view model of type <typeparamref name="VM"/>.</param> /// <param name="model">The model to update.</param> /// <param name="excludedPropertiesSelectors">Array of expressions of excluded properties.</param> /// <exception cref="InvalidOperationException">Thrown when the included properties are not valid.</exception> protected void UpdateModelExcluding <M, VM>( Expression <Func <VM, M> > modelSelector, M model, params Expression <Func <M, object> >[] excludedPropertiesSelectors) where M : class { if (modelSelector == null) { throw new ArgumentNullException(nameof(modelSelector)); } string prefix = GenericExpressionHelper.GetExpressionText(modelSelector); UpdateModelExcluding(prefix, model, excludedPropertiesSelectors); }
/// <summary> /// Using the controller's value provider, Bind a <see cref="IStatefulObjectExecutionModel"/> for executing a path on a stateful object. /// Any validation errors are capured in ModelState. /// </summary> /// <typeparam name="ST">The type of state transitions of the stateful object.</typeparam> /// <typeparam name="SO">The type of the stateful object.</typeparam> /// <typeparam name="WM">The type of the workflow manager for the stateful object.</typeparam> /// <typeparam name="VM">The type of the view model containing the <see cref="IStatefulObjectExecutionModel"/>.</typeparam> /// <param name="workflowManager">he workflow manager for the stateful object.</param> /// <param name="modelSelector">The expression to extract <see cref="IStatefulObjectExecutionModel"/> from the view model of type <typeparamref name="VM"/>.</param> /// <returns>Returns the model requested. Check ModelState for any validation errors.</returns> protected async Task <StatefulObjectExecutionModel <U, ST, SO> > BindStatefulObjectExecutionModelAsync <ST, SO, WM, VM>( WM workflowManager, Expression <Func <VM, IStatefulObjectExecutionModel> > modelSelector) where ST : StateTransition <U> where SO : IStateful <U, ST> where WM : IWorkflowManager <U, ST, SO> { if (modelSelector == null) { throw new ArgumentNullException(nameof(modelSelector)); } string prefix = GenericExpressionHelper.GetExpressionText(modelSelector); return(await BindStatefulObjectExecutionModelAsync <ST, SO, WM>(workflowManager, prefix)); }
/// <summary> /// Attempt to get the value of a model property from a value provider, /// else return null if the value was not specified. /// </summary> /// <typeparam name="M">The type of the model being bound to the value provider.</typeparam> /// <param name="valueProvider">The Value provoder.</param> /// <param name="modelPropertyExpression">Expression for selecting the property from the bound model.</param> /// <returns>Returns the result found if the value exists, else null.</returns> public static ValueProviderResult GetValue <M>( this IValueProvider valueProvider, Expression <Func <M, object> > modelPropertyExpression) { if (valueProvider == null) { throw new ArgumentNullException(nameof(valueProvider)); } if (modelPropertyExpression == null) { throw new ArgumentNullException(nameof(modelPropertyExpression)); } string propertyKey = GenericExpressionHelper.GetExpressionText(modelPropertyExpression); return(valueProvider.GetValue(propertyKey)); }
/// <summary> /// Adds the specified exception to the errors collection for the model-state /// dictionary that is associated with the specified property. /// </summary> /// <typeparam name="M">The type of the model being bound.</typeparam> /// <param name="modelState">The model state.</param> /// <param name="propertySelector">Expression specifying the property having the error.</param> /// <param name="exception">The exception.</param> public static void AddModelError <M>( this ModelStateDictionary modelState, Expression <Func <M, object> > propertySelector, Exception exception) { if (modelState == null) { throw new ArgumentNullException(nameof(modelState)); } if (propertySelector == null) { throw new ArgumentNullException(nameof(propertySelector)); } if (exception == null) { throw new ArgumentNullException(nameof(exception)); } string propertyKey = GenericExpressionHelper.GetExpressionText(propertySelector); modelState.AddModelError(propertyKey, exception); }