internal object GetParameterValue(IActionParameterFacade parm, object value)
{
if (value == null)
{
return(null);
}
if (parm.Specification.IsStream)
{
return((HttpPostedFileBase)value);
}
var stringValue = value as string;
if (parm.Specification.IsParseable)
{
return(string.IsNullOrEmpty(stringValue) ? null : stringValue);
}
var collectionValue = value as IEnumerable;
if (!parm.Specification.IsCollection || collectionValue == null)
{
return(GetNakedObjectFromId(stringValue).GetDomainObject <object>());
}
return(Facade.GetTypedCollection(parm, collectionValue));
}
protected ParameterRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags)
: base(oidStrategy, flags) {
SetName(parameter);
SetExtensions(req, objectFacade, parameter, flags);
SetLinks(req, objectFacade, parameter);
SetHeader(objectFacade);
}
public string GetParameterAutoCompleteId(IActionFacade action, IActionParameterFacade parameterFacade)
{
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
var id = GetParameterInputId(action, parameterFacade);
return(parameter.Spec.IsParseable ? id : id + Sep + AutoCompleteName);
}
private LinkRepresentation CreatePromptLink(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter) {
var opts = new List<OptionalProperty>();
var parameterContext = new ParameterContextFacade {
Action = parameter.Action,
Target = objectFacade,
Parameter = parameter
};
if (parameter.IsAutoCompleteEnabled) {
var arguments = new OptionalProperty(JsonPropertyNames.Arguments, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.XRoSearchTerm, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.Value, null, typeof (object))))));
var extensions = new OptionalProperty(JsonPropertyNames.Extensions, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.MinLength, parameter.AutoCompleteMinLength)));
opts.Add(arguments);
opts.Add(extensions);
}
else {
Tuple<string, ITypeFacade>[] parms = parameter.GetChoicesParameters();
OptionalProperty[] args = parms.Select(tuple => RestUtils.CreateArgumentProperty(OidStrategy ,req, tuple, Flags)).ToArray();
var arguments = new OptionalProperty(JsonPropertyNames.Arguments, MapRepresentation.Create(args));
opts.Add(arguments);
}
return LinkRepresentation.Create(OidStrategy ,new PromptRelType(new UriMtHelper(OidStrategy ,req, parameterContext)), Flags, opts.ToArray());
}
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));
}
public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, ParameterTypeContextFacade parameterTypeContext)
: this(oidStrategy, req)
{
action = parameterTypeContext.Action;
spec = parameterTypeContext.OwningSpecification;
param = parameterTypeContext.Parameter;
cachedId = "";
CachedType = spec.DomainTypeName(oidStrategy);
}
private INakedObjectAdapter SafeGetValue(IActionParameterFacade parm, object rawValue)
{
try {
return(GetValue(parm, rawValue));
}
catch (Exception) {
return(null);
}
}
public void ValidateParameter(IActionFacade action, IActionParameterFacade parm, IObjectFacade targetNakedObject, object value)
{
var isValid = parm.IsValid(targetNakedObject, value);
if (!isValid.IsAllowed)
{
ModelState.AddModelError(IdHelper.GetParameterInputId(action, parm), isValid.Reason);
}
}
public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, ParameterContextFacade parameterContext)
: this(oidStrategy, req)
{
action = parameterContext.Action;
param = parameterContext.Parameter;
objectFacade = parameterContext.Target;
spec = objectFacade.Specification;
IOidTranslation oid = oidStrategy.FrameworkFacade.OidTranslator.GetOidTranslation(objectFacade);
cachedId = oid.InstanceId;
CachedType = oid.DomainType;
}
public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, ParameterContextFacade parameterContext)
: this(oidStrategy, req)
{
action = parameterContext.Action;
param = parameterContext.Parameter;
objectFacade = parameterContext.Target;
spec = objectFacade.Specification;
if (objectFacade.Specification.IsParseable)
{
throw new ArgumentException($"Cannot build URI for parseable specification : {objectFacade.Specification.FullName}");
}
IOidTranslation oid = oidStrategy.FrameworkFacade.OidTranslator.GetOidTranslation(objectFacade);
cachedId = oid.InstanceId;
CachedType = oid.DomainType;
}
private void SetLinks(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter) {
var tempLinks = new List<LinkRepresentation>();
if (Flags.FormalDomainModel) {
var parameterTypeContext = new ParameterTypeContextFacade {
Action = parameter.Action,
OwningSpecification = objectFacade.Specification,
Parameter = parameter
};
LinkRepresentation describedBy = LinkRepresentation.Create(OidStrategy ,new ParamTypeRelType(RelValues.DescribedBy, new UriMtHelper(OidStrategy, req, parameterTypeContext)), Flags);
tempLinks.Add(describedBy);
}
if (parameter.IsAutoCompleteEnabled || parameter.GetChoicesParameters().Any()) {
tempLinks.Add(CreatePromptLink(req, objectFacade, parameter));
}
Links = tempLinks.ToArray();
}
private static object GetRawParameterValue(IActionParameterFacade parm, ObjectAndControlData controlData, string name)
{
var form = controlData.Form;
ValueProviderResult vp = form.GetValue(name);
string[] values = vp == null ? null : (string[])vp.RawValue;
if (values == null)
{
if (controlData.Files.ContainsKey(name))
{
return(controlData.Files[name]);
}
return(null);
}
if (parm.Specification.IsCollection && !parm.Specification.IsParseable)
{
return(values.All(string.IsNullOrEmpty) ? null : values);
}
return(values.First());
}
private INakedObjectAdapter GetValue(IActionParameterFacade parm, object rawValue)
{
if (rawValue == null || rawValue is string && string.IsNullOrEmpty(rawValue as string))
{
return(null);
}
if (parm.Specification.IsParseable)
{
return(parm.WrappedSpec().Spec.GetFacet <IParseableFacet>().ParseTextEntry((string)rawValue, framework.NakedObjectManager));
}
var collectionParm = parm.WrappedSpec() as IOneToManyActionParameterSpec;
if (collectionParm != null && collectionParm.ElementSpec.IsParseable)
{
var stringArray = rawValue as string[];
if (stringArray == null || !stringArray.Any())
{
return(null);
}
var eSpec = collectionParm.ElementSpec;
var objectArray = stringArray.Select(i => i == null ? null : eSpec.GetFacet <IParseableFacet>().ParseTextEntry(i, framework.NakedObjectManager).Object).Where(o => o != null).ToArray();
if (!objectArray.Any())
{
return(null);
}
var typedArray = Array.CreateInstance(objectArray.First().GetType(), objectArray.Length);
Array.Copy(objectArray, typedArray, typedArray.Length);
return(framework.GetNakedObject(typedArray));
}
return(framework.GetNakedObject(rawValue));
}
private void SetLinks(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter)
{
var tempLinks = new List <LinkRepresentation>();
if (Flags.FormalDomainModel)
{
var parameterTypeContext = new ParameterTypeContextFacade {
Action = parameter.Action,
OwningSpecification = objectFacade.Specification,
Parameter = parameter
};
LinkRepresentation describedBy = LinkRepresentation.Create(OidStrategy, new ParamTypeRelType(RelValues.DescribedBy, new UriMtHelper(OidStrategy, req, parameterTypeContext)), Flags);
tempLinks.Add(describedBy);
}
if (parameter.IsAutoCompleteEnabled || parameter.GetChoicesParameters().Any())
{
tempLinks.Add(CreatePromptLink(req, objectFacade, parameter));
}
Links = tempLinks.ToArray();
}
private static RouteValueDictionary CreateAutoCompleteAttributes(IActionParameterFacade holder, string completionAjaxUrl) {
int minLength = holder.AutoCompleteMinLength;
var attrs = new RouteValueDictionary { { "data-completions", completionAjaxUrl }, { "data-completions-minlength", minLength } };
return attrs;
}
private void SetName(IActionParameterFacade parameter) {
Name = parameter.Id;
}
public static ParameterRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags) {
var optionals = new List<OptionalProperty>();
if (parameter.IsChoicesEnabled != Choices.NotEnabled && !parameter.GetChoicesParameters().Any()) {
IObjectFacade[] choices = parameter.GetChoices(objectFacade, null);
object[] choicesArray = choices.Select(c => RestUtils.GetChoiceValue(oidStrategy ,req, c, parameter, flags)).ToArray();
optionals.Add(new OptionalProperty(JsonPropertyNames.Choices, choicesArray));
}
if (parameter.DefaultTypeIsExplicit(objectFacade)) {
IObjectFacade defaultNakedObject = parameter.GetDefault(objectFacade);
if (defaultNakedObject != null) {
string title = defaultNakedObject.TitleString;
object value = RestUtils.ObjectToPredefinedType(defaultNakedObject.GetDomainObject());
var isValue = defaultNakedObject.Specification.IsParseable || (defaultNakedObject.Specification.IsCollection && defaultNakedObject.ElementSpecification.IsParseable);
object defaultValue = isValue ? value : CreateDefaultLinks(oidStrategy ,req, parameter, defaultNakedObject, title, flags);
optionals.Add(new OptionalProperty(JsonPropertyNames.Default, defaultValue));
}
}
if (optionals.Count == 0) {
return new ParameterRepresentation(oidStrategy ,req, objectFacade, parameter, flags);
}
return CreateWithOptionals<ParameterRepresentation>(new object[] {oidStrategy ,req, objectFacade, parameter, flags}, optionals);
}
private static LinkRepresentation CreateDefaultLink(IOidStrategy oidStrategy, HttpRequestMessage req, IActionParameterFacade parameter, IObjectFacade defaultNakedObject, string title, RestControlFlags flags) {
return LinkRepresentation.Create(oidStrategy ,new DefaultRelType(parameter, new UriMtHelper(oidStrategy ,req, defaultNakedObject)), flags, new OptionalProperty(JsonPropertyNames.Title, title));
}
public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, ParameterContextFacade parameterContext)
: this(oidStrategy ,req) {
action = parameterContext.Action;
param = parameterContext.Parameter;
objectFacade = parameterContext.Target;
spec = objectFacade.Specification;
IOidTranslation oid = oidStrategy.FrameworkFacade.OidTranslator.GetOidTranslation(objectFacade);
cachedId = oid.InstanceId;
CachedType = oid.DomainType;
}
public ChoiceRelType(IActionParameterFacade parameter, UriMtHelper helper)
: this(helper) {
this.parameter = parameter;
}
public ParameterContext(IIdHelper idhelper, bool embeddedInObject, IObjectFacade target, IActionFacade action, IActionParameterFacade parameter, bool isEdit)
: base(idhelper, embeddedInObject, target, action)
{
Parameter = parameter;
IsParameterEdit = isEdit;
}
private static object CreateDefaultLinks(IOidStrategy oidStrategy, HttpRequestMessage req, IActionParameterFacade parameter, IObjectFacade defaultNakedObject, string title, RestControlFlags flags)
{
if (defaultNakedObject.Specification.IsCollection)
{
return(defaultNakedObject.ToEnumerable().Select(i => CreateDefaultLink(oidStrategy, req, parameter, i, i.TitleString, flags)).ToArray());
}
return(CreateDefaultLink(oidStrategy, req, parameter, defaultNakedObject, title, flags));
}
private static LinkRepresentation CreateDefaultLink(IOidStrategy oidStrategy, HttpRequestMessage req, IActionParameterFacade parameter, IObjectFacade defaultNakedObject, string title, RestControlFlags flags)
{
return(LinkRepresentation.Create(oidStrategy, new DefaultRelType(parameter, new UriMtHelper(oidStrategy, req, defaultNakedObject)), flags, new OptionalProperty(JsonPropertyNames.Title, title)));
}
private static bool IsUnconditionalChoices(IActionParameterFacade parameter)
{
return(parameter.IsChoicesEnabled != Choices.NotEnabled &&
(parameter.Specification.IsParseable || (parameter.Specification.IsCollection && parameter.ElementType.IsParseable)) &&
!parameter.GetChoicesParameters().Any());
}
private void SetExtensions(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags)
{
IDictionary <string, object> custom = parameter.ExtensionData;
if (IsUnconditionalChoices(parameter))
{
Tuple <IObjectFacade, string>[] choices = parameter.GetChoicesAndTitles(objectFacade, null);
Tuple <object, string>[] choicesArray = choices.Select(tuple => new Tuple <object, string>(RestUtils.GetChoiceValue(OidStrategy, req, tuple.Item1, parameter, flags), tuple.Item2)).ToArray();
OptionalProperty[] op = choicesArray.Select(tuple => new OptionalProperty(tuple.Item2, tuple.Item1)).ToArray();
MapRepresentation map = MapRepresentation.Create(op);
custom = custom ?? new Dictionary <string, object>();
custom[JsonPropertyNames.CustomChoices] = map;
}
string mask = parameter.Mask;
if (!string.IsNullOrWhiteSpace(mask))
{
custom = custom ?? new Dictionary <string, object>();
custom[JsonPropertyNames.CustomMask] = mask;
}
if (Flags.SimpleDomainModel)
{
Extensions = RestUtils.GetExtensions(parameter.Name, parameter.Description, null, null, null, null, !parameter.IsMandatory, parameter.MaxLength, parameter.Pattern, null, custom, parameter.Specification, parameter.ElementType, OidStrategy);
}
else
{
Extensions = MapRepresentation.Create();
}
}
public DefaultRelType(IActionParameterFacade parameter, UriMtHelper helper)
: this(helper) {
this.parameter = parameter;
}
public UriMtHelper(IOidStrategy oidStrategy, HttpRequestMessage req, ParameterTypeContextFacade parameterTypeContext)
: this(oidStrategy ,req) {
action = parameterTypeContext.Action;
spec = parameterTypeContext.OwningSpecification;
param = parameterTypeContext.Parameter;
cachedId = "";
CachedType = spec.DomainTypeName(oidStrategy);
}
private ParameterRepresentation GetParameter(IActionParameterFacade parameter) {
IObjectFacade objectFacade = actionContext.Target;
return ParameterRepresentation.Create(OidStrategy,req, objectFacade, parameter, Flags);
}
public static bool IsParseableOrCollectionOfParseable(IFrameworkFacade facade, IActionParameterFacade parmSpec)
{
var spec = parmSpec.Specification;
return(spec.IsParseable || (spec.IsCollection && parmSpec.ElementType.IsParseable));
}
protected ParameterRepresentation(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags)
: base(oidStrategy, flags)
{
SetName(parameter);
SetExtensions(req, objectFacade, parameter, flags);
SetLinks(req, objectFacade, parameter);
SetHeader(objectFacade);
}
public static bool IsParseableOrCollectionOfParseable(IFrameworkFacade facade, IActionParameterFacade parmSpec) {
var spec = parmSpec.Specification;
return spec.IsParseable || (spec.IsCollection && parmSpec.ElementType.IsParseable);
}
private void SetName(IActionParameterFacade parameter)
{
Name = parameter.Id;
}
public string GetRelParametersFor(IActionParameterFacade actionParameterFacade) {
return GetRelParametersFor(actionParameterFacade.Action.Id, actionParameterFacade.Id);
}
private LinkRepresentation CreatePromptLink(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter)
{
var opts = new List <OptionalProperty>();
var parameterContext = new ParameterContextFacade {
Action = parameter.Action,
Target = objectFacade,
Parameter = parameter
};
if (parameter.IsAutoCompleteEnabled)
{
var arguments = new OptionalProperty(JsonPropertyNames.Arguments, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.XRoSearchTerm, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.Value, null, typeof(object))))));
var extensions = new OptionalProperty(JsonPropertyNames.Extensions, MapRepresentation.Create(new OptionalProperty(JsonPropertyNames.MinLength, parameter.AutoCompleteMinLength)));
opts.Add(arguments);
opts.Add(extensions);
}
else
{
Tuple <string, ITypeFacade>[] parms = parameter.GetChoicesParameters();
OptionalProperty[] args = parms.Select(tuple => RestUtils.CreateArgumentProperty(OidStrategy, req, tuple, Flags)).ToArray();
var arguments = new OptionalProperty(JsonPropertyNames.Arguments, MapRepresentation.Create(args));
opts.Add(arguments);
}
return(LinkRepresentation.Create(OidStrategy, new PromptRelType(new UriMtHelper(OidStrategy, req, parameterContext)), Flags, opts.ToArray()));
}
private static bool IsUnconditionalChoices(IActionParameterFacade parameter) {
return parameter.IsChoicesEnabled != Choices.NotEnabled &&
(parameter.Specification.IsParseable || (parameter.Specification.IsCollection && parameter.ElementType.IsParseable)) &&
!parameter.GetChoicesParameters().Any();
}
private INakedObjectAdapter SafeGetValue(IActionParameterFacade parm, object rawValue) {
try {
return GetValue(parm, rawValue);
}
catch (Exception) {
return null;
}
}
private static object CreateDefaultLinks(IOidStrategy oidStrategy, HttpRequestMessage req, IActionParameterFacade parameter, IObjectFacade defaultNakedObject, string title, RestControlFlags flags) {
if (defaultNakedObject.Specification.IsCollection) {
return defaultNakedObject.ToEnumerable().Select(i => CreateDefaultLink(oidStrategy, req, parameter, i, i.TitleString, flags)).ToArray();
}
return CreateDefaultLink(oidStrategy, req, parameter, defaultNakedObject, title, flags);
}
public static ParameterRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags)
{
var optionals = new List <OptionalProperty>();
if (parameter.IsChoicesEnabled != Choices.NotEnabled && !parameter.GetChoicesParameters().Any())
{
IObjectFacade[] choices = parameter.GetChoices(objectFacade, null);
object[] choicesArray = choices.Select(c => RestUtils.GetChoiceValue(oidStrategy, req, c, parameter, flags)).ToArray();
optionals.Add(new OptionalProperty(JsonPropertyNames.Choices, choicesArray));
}
var adapter = new FieldFacadeAdapter(parameter);
// include default value for for nonnullable boolean so we can distinguish from nullable on client
if (parameter.DefaultTypeIsExplicit(objectFacade) || (parameter.Specification.IsBoolean && !parameter.IsNullable))
{
IObjectFacade defaultNakedObject = parameter.GetDefault(objectFacade);
if (defaultNakedObject != null)
{
string title = defaultNakedObject.TitleString;
object value = RestUtils.ObjectToPredefinedType(defaultNakedObject.Object, true);
var isValue = defaultNakedObject.Specification.IsParseable || (defaultNakedObject.Specification.IsCollection && defaultNakedObject.ElementSpecification.IsParseable);
object defaultValue = isValue ? value : CreateDefaultLinks(oidStrategy, req, adapter, parameter.Action, defaultNakedObject, title, flags);
optionals.Add(new OptionalProperty(JsonPropertyNames.Default, defaultValue));
}
}
if (optionals.Count == 0)
{
return(new ParameterRepresentation(oidStrategy, req, objectFacade, adapter, flags));
}
return(CreateWithOptionals <ParameterRepresentation>(new object[] { oidStrategy, req, objectFacade, adapter, flags }, optionals));
}
public void ValidateParameter(IActionFacade action, IActionParameterFacade parm, IObjectFacade targetNakedObject, object value) {
var isValid = parm.IsValid(targetNakedObject, value);
if (!isValid.IsAllowed) {
ModelState.AddModelError(IdHelper.GetParameterInputId(action, parm), isValid.Reason);
}
}
private INakedObjectAdapter GetValue(IActionParameterFacade parm, object rawValue) {
if (rawValue == null || rawValue is string && string.IsNullOrEmpty(rawValue as string)) {
return null;
}
if (parm.Specification.IsParseable) {
return nakedObjectActionParameter.Spec.GetFacet<IParseableFacet>().ParseTextEntry((string) rawValue, framework.NakedObjectManager);
}
var collectionParm = nakedObjectActionParameter as IOneToManyActionParameterSpec;
if (collectionParm != null && collectionParm.ElementSpec.IsParseable) {
var stringArray = rawValue as string[];
if (stringArray == null || !stringArray.Any()) {
return null;
}
var eSpec = collectionParm.ElementSpec;
var objectArray = stringArray.Select(i => i == null ? null : eSpec.GetFacet<IParseableFacet>().ParseTextEntry(i, framework.NakedObjectManager).Object).Where(o => o != null).ToArray();
if (!objectArray.Any()) {
return null;
}
var typedArray = Array.CreateInstance(objectArray.First().GetType(), objectArray.Length);
Array.Copy(objectArray, typedArray, typedArray.Length);
return framework.GetNakedObject(typedArray);
}
return framework.GetNakedObject(rawValue);
}
private static string GetDisplayTitle(this HtmlHelper html, IActionParameterFacade holder, IObjectFacade nakedObject) {
return holder.GetMaskedValue(nakedObject);
}
public static IActionParameterSpec WrappedSpec(this IActionParameterFacade actionParameterFacade)
{
return(actionParameterFacade == null ? null : ((ActionParameterFacade)actionParameterFacade).WrappedSpec);
}
private void SetExtensions(HttpRequestMessage req, IObjectFacade objectFacade, IActionParameterFacade parameter, RestControlFlags flags) {
IDictionary<string, object> custom = parameter.ExtensionData;
if (IsUnconditionalChoices(parameter)) {
Tuple<IObjectFacade, string>[] choices = parameter.GetChoicesAndTitles(objectFacade, null);
Tuple<object, string>[] choicesArray = choices.Select(tuple => new Tuple<object, string>(RestUtils.GetChoiceValue(OidStrategy ,req, tuple.Item1, parameter, flags), tuple.Item2)).ToArray();
OptionalProperty[] op = choicesArray.Select(tuple => new OptionalProperty(tuple.Item2, tuple.Item1)).ToArray();
MapRepresentation map = MapRepresentation.Create(op);
custom = custom ?? new Dictionary<string, object>();
custom[JsonPropertyNames.CustomChoices] = map;
}
string mask = parameter.Mask;
if (!string.IsNullOrWhiteSpace(mask)) {
custom = custom ?? new Dictionary<string, object>();
custom[JsonPropertyNames.CustomMask] = mask;
}
if (Flags.SimpleDomainModel) {
Extensions = RestUtils.GetExtensions(parameter.Name, parameter.Description, null, null, null, null, !parameter.IsMandatory, parameter.MaxLength, parameter.Pattern, null, custom, parameter.Specification, parameter.ElementType, OidStrategy);
}
else {
Extensions = MapRepresentation.Create();
}
}
public string GetParameterInputId(IActionFacade action, IActionParameterFacade parameterFacade) {
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
return GetParameterId(action, parameterFacade) + Sep + InputOrSelect(parameter.Spec);
}
private object GetValue(string[] values, IActionParameterFacade parameterSpec, ITypeFacade spec)
{
object domainObject;
return(GetValue(values, spec, true, out domainObject) ? domainObject : Facade.GetTypedCollection(parameterSpec, values));
}
private static object GetRawParameterValue(IActionParameterFacade parm, ObjectAndControlData controlData, string name) {
var form = controlData.Form;
ValueProviderResult vp = form.GetValue(name);
string[] values = vp == null ? null : (string[]) vp.RawValue;
if (values == null) {
if (controlData.Files.ContainsKey(name)) {
return controlData.Files[name];
}
return null;
}
if (parm.Specification.IsCollection && !parm.Specification.IsParseable) {
return values.All(string.IsNullOrEmpty) ? null : values;
}
return values.First();
}
public static object GetChoiceValue(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade item, IActionParameterFacade parameter, RestControlFlags flags) {
return GetChoiceValue(oidStrategy, item, () => new ChoiceRelType(parameter, new UriMtHelper(oidStrategy, req, item)), flags);
}
public FieldFacadeAdapter(IActionParameterFacade parameter)
{
this.parameter = parameter;
}
public FieldFacadeAdapter(IActionParameterFacade parameter) {
this.parameter = parameter;
}
internal object GetParameterValue(IActionParameterFacade parm, object value) {
if (value == null) {
return null;
}
if (parm.Specification.IsStream) {
return (HttpPostedFileBase) value;
}
var stringValue = value as string;
if (parm.Specification.IsParseable) {
return string.IsNullOrEmpty(stringValue) ? null : stringValue;
}
var collectionValue = value as IEnumerable;
if (!parm.Specification.IsCollection || collectionValue == null) {
return GetNakedObjectFromId(stringValue).GetDomainObject<object>();
}
return Facade.GetTypedCollection(parm, collectionValue);
}
private object GetValue(string[] values, IActionParameterFacade parameterSpec, ITypeFacade spec) {
object domainObject;
return GetValue(values, spec, true, out domainObject) ? domainObject : Facade.GetTypedCollection(parameterSpec, values);
}
internal object GetParameterValue(IActionParameterFacade parm, string name, ObjectAndControlData controlData) {
object value = GetRawParameterValue(parm, controlData, name);
return GetParameterValue(parm, value);
}
public static object GetTypedCollection(this IFrameworkFacade surface, IActionParameterFacade featureSpec, IEnumerable collectionValue)
{
var collectionitemSpec = featureSpec.ElementType;
return(GetTypedCollection(surface, collectionValue, collectionitemSpec));
}
public string GetRelParametersFor(IActionParameterFacade actionParameterFacade)
{
return(FormatParameter(RelParamValues.Action, actionParameterFacade.Action.Id) + FormatParameter(RelParamValues.Param, actionParameterFacade.Id));
}
private ParameterRepresentation GetParameter(IActionParameterFacade parameter)
{
IObjectFacade objectFacade = actionContext.Target;
return(ParameterRepresentation.Create(OidStrategy, req, objectFacade, parameter, Flags));
}
public string GetRelParametersFor(IActionParameterFacade actionParameterFacade) {
return FormatParameter(RelParamValues.Action, actionParameterFacade.Action.Id) + FormatParameter(RelParamValues.Param, actionParameterFacade.Id);
}
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);
}
public static object GetChoiceValue(IOidStrategy oidStrategy, HttpRequestMessage req, IObjectFacade item, IActionParameterFacade parameter, RestControlFlags flags)
{
return(GetChoiceValue(oidStrategy, item, () => new ChoiceRelType(parameter, new UriMtHelper(oidStrategy, req, item)), flags));
}
public string GetParameterAutoCompleteId(IActionFacade action, IActionParameterFacade parameterFacade) {
IActionParameterSpec parameter = parameterFacade.WrappedSpec();
var id = GetParameterInputId(action, parameterFacade);
return parameter.Spec.IsParseable ? id : id + Sep + AutoCompleteName;
}
protected ParameterRepresentation GetParameter(IActionParameterFacade parameter)
{
var objectFacade = ActionContext.Target;
return(ParameterRepresentation.Create(OidStrategy, Req, objectFacade, parameter, Flags));
}
