public ODataFormatterParameterBinding(HttpParameterDescriptor descriptor, MediaTypeFormatter formatter) : base(descriptor) { if (formatter == null) { throw Error.ArgumentNull("formatter"); } _formatter = formatter; }
public string GetDocumentation(HttpParameterDescriptor parameterDescriptor) { var reflectedParameterDescriptor = parameterDescriptor as ReflectedHttpParameterDescriptor; if (reflectedParameterDescriptor != null) { XPathNavigator memberNode = GetMemberNode(reflectedParameterDescriptor.ActionDescriptor); if (memberNode != null) { string parameterName = reflectedParameterDescriptor.ParameterInfo.Name; XPathNavigator parameterNode = memberNode.SelectSingleNode(string.Format("param[@name='{0}']", parameterName)); if (parameterNode != null) { return parameterNode.Value.Trim(); } } } return string.Empty; }
public BodyAndUriParameterBinding(HttpParameterDescriptor descriptor) : base(descriptor) { var httpConfiguration = descriptor.Configuration; Formatters = httpConfiguration.Formatters; BodyModelValidator = httpConfiguration.Services.GetBodyModelValidator(); }
public ResourceParameterBinding( ScimServerConfiguration serverConfiguration, HttpParameterDescriptor parameter) : base(parameter) { _ServerConfiguration = serverConfiguration; }
public ODataParameterDescriptor(string parameterName, Type parameterType, bool isOptional, HttpParameterDescriptor reflectedHttpParameterDescriptor) { ParameterName = parameterName; ParameterType = parameterType; IsOptional = isOptional; ReflectedHttpParameterDescriptor = reflectedHttpParameterDescriptor; }
public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { if (parameter == null) throw new ArgumentException("Invalid parameter"); return new TransferujPlResponseModelBinder(parameter); }
/// <summary> /// Method that implements parameter binding hookup to the global configuration object's /// ParameterBindingRules collection delegate. /// /// This routine filters based on POST/PUT method status and simple parameter /// types. /// </summary> /// <example> /// GlobalConfiguration.Configuration. /// .ParameterBindingRules /// .Insert(0,SimplePostVariableParameterBinding.HookupParameterBinding); /// </example> /// <param name="descriptor"></param> /// <returns></returns> public static HttpParameterBinding HookupParameterBinding(HttpParameterDescriptor descriptor) { //To see is it mark the flag if (descriptor.ActionDescriptor.GetCustomAttributes<System.Web.Http.MultiParameterSupportAttribute>().Count <= 0) return null; var supportedMethods = descriptor.ActionDescriptor.SupportedHttpMethods; // Only apply this binder on POST and PUT operations if (supportedMethods.Contains(HttpMethod.Post) || supportedMethods.Contains(HttpMethod.Put)) { var supportedTypes = new Type[] { typeof(string), typeof(int), typeof(int?), typeof(decimal), typeof(decimal?), typeof(double), typeof(double?), typeof(long), typeof(long?), typeof(bool), typeof(bool?), typeof(DateTime), typeof(DateTime?), typeof(byte[]) }; if (supportedTypes.Count(typ => typ == descriptor.ParameterType) > 0) return new SimplePostVariableParameterBinding(descriptor); } return null; }
/// <summary> /// Gets the parameter binding. /// </summary> /// <returns>The parameter binding.</returns> /// <param name="parameter">The parameter description.</param> public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { // Preconditions Raise.ArgumentNullException.IfIsNull(parameter, nameof(parameter)); return new NakedBodyParameterBinding(parameter); }
public CatchAllRouteParameterBinding( HttpParameterDescriptor descriptor, char delimiter) : base(descriptor) { _parameterName = descriptor.ParameterName; _delimiter = delimiter; }
// Determine how a single parameter will get bound. // This is all sync. We don't need to actually read the body just to determine that we'll bind to the body. protected virtual HttpParameterBinding GetParameterBinding(HttpParameterDescriptor parameter) { // Attribute has the highest precedence // Presence of a model binder attribute overrides. ParameterBindingAttribute attr = parameter.ParameterBinderAttribute; if (attr != null) { return attr.GetBinding(parameter); } // No attribute, so lookup in global map. ParameterBindingRulesCollection pb = parameter.Configuration.ParameterBindingRules; if (pb != null) { HttpParameterBinding binding = pb.LookupBinding(parameter); if (binding != null) { return binding; } } // Not explicitly specified in global map or attribute. // Use a default policy to determine it. These are catch-all policies. Type type = parameter.ParameterType; if (TypeHelper.IsSimpleUnderlyingType(type) || TypeHelper.HasStringConverter(type)) { // For simple types, the default is to look in URI. Exactly as if the parameter had a [FromUri] attribute. return parameter.BindWithAttribute(new FromUriAttribute()); } // Fallback. Must be a complex type. Default is to look in body. Exactly as if this type had a [FromBody] attribute. attr = new FromBodyAttribute(); return attr.GetBinding(parameter); }
/// <summary> /// Gets the documentation based on <see cref="System.Web.Http.Controllers.HttpParameterDescriptor" />. /// </summary> /// <param name="parameterDescriptor">The parameter descriptor.</param> /// <returns>The documentation for the controller.</returns> public string GetDocumentation(HttpParameterDescriptor parameterDescriptor) { return this.sources .Select(source => source.GetDocumentation(parameterDescriptor)) .Where(documentation => !string.IsNullOrEmpty(documentation)) .FirstOrDefault(); }
public SimpleApiParameterDescriptor(HttpParameterDescriptor arg, string routePath) { this.Name = arg.ParameterName; this.IsOptional = arg.IsOptional; if (this.IsOptional) { this.DefaultValue = arg.DefaultValue; } var indexOfQueryString = routePath.IndexOf('?'); if (arg.ParameterBinderAttribute is FromBodyAttribute) { this.CallingConvention = "body"; } else { var indexOfParameter = routePath.IndexOf("{" + arg.ParameterName + "}", StringComparison.InvariantCultureIgnoreCase); if (indexOfQueryString > 0 && indexOfParameter > indexOfQueryString) { this.CallingConvention = "query-string"; } else if (indexOfParameter > 0) { this.CallingConvention = "uri"; } else { this.CallingConvention = "unknown"; } } }
public ScimQueryOptionsParameterBinding( HttpParameterDescriptor descriptor, ScimServerConfiguration serverConfiguration) : base(descriptor) { _ServerConfiguration = serverConfiguration; }
public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { if (parameter == null) throw new ArgumentException("Invalid parameter"); return new NakedBodyParameterBinding(parameter); }
public string GetDocumentation(HttpParameterDescriptor parameterDescriptor) { var attr = parameterDescriptor.ActionDescriptor .GetCustomAttributes<ApiParameterDocAttribute>() .FirstOrDefault(p => p.Parameter == parameterDescriptor.ParameterName); return attr != null ? attr.Documentation : ""; }
protected HttpParameterBinding(HttpParameterDescriptor descriptor) { if (descriptor == null) { throw Error.ArgumentNull("descriptor"); } _descriptor = descriptor; }
public string GetDocumentation(HttpParameterDescriptor parameterDescriptor) { var parameterName = parameterDescriptor.ParameterName; var selector = string.Format(MEMBER_PARAM_XPATH_QUERY, parameterName); var rtn = GetActionDocumentation(parameterDescriptor.ActionDescriptor, selector); return rtn; }
public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { if (parameter.ParameterType == typeof(ETag)) { return new ETagParameterBinding(parameter, match); } return parameter.BindAsError("Wrong parameter type"); }
/// <summary> /// Get Binding Process /// </summary> /// <param name="parameter">Parameter Descriptor</param> /// <returns></returns> public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { if(String.IsNullOrEmpty(this._name)){ this._name = parameter.ParameterName; } return new Gale.REST.Http.Binding.FromHeaderBinding(parameter, this._name ); }
internal static bool IsChangeSetEntityParameter(HttpParameterDescriptor parameterDescriptor) { Contract.Assert(parameterDescriptor != null); ModelBinderAttribute modelBinderAttr = parameterDescriptor.ParameterBinderAttribute as ModelBinderAttribute; return (modelBinderAttr != null) && (modelBinderAttr.BinderType == typeof(ChangeSetEntityModelBinder)); }
public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { HttpConfiguration config = parameter.Configuration; IModelBinder binder = GetModelBinder(config, parameter.ParameterType); IEnumerable<ValueProviderFactory> valueProviderFactories = GetValueProviderFactories(config); return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories); }
public PerRequestParameterBinding(HttpParameterDescriptor descriptor, IEnumerable<MediaTypeFormatter> formatters) : base(descriptor) { if (formatters == null) throw new ArgumentNullException("formatters"); _formatters = formatters; }
public ErrorParameterBinding(HttpParameterDescriptor descriptor, string message) : base(descriptor) { if (message == null) { throw Error.ArgumentNull(message); } _message = message; }
public string GetDocumentation(HttpParameterDescriptor parameterDescriptor) { var parameterDocumentation = parameterDescriptor.ActionDescriptor.GetCustomAttributes<ApiParameterDocumentationAttribute>().FirstOrDefault(param => param.ParameterName == parameterDescriptor.ParameterName); if (parameterDocumentation != null) { return parameterDocumentation.Description; } return String.Empty; }
string IDocumentationProvider.GetDocumentation(HttpParameterDescriptor parameterDescriptor) { var actionDoc = parameterDescriptor.GetCustomAttributes<ParameterDocAttribute>().FirstOrDefault(); if (actionDoc != null) { return actionDoc.Documentation; } return string.Format("Documentation for '{0}'.", parameterDescriptor.ParameterName); }
public virtual bool GetRequired(HttpParameterDescriptor parameterDescriptor) { ReflectedHttpParameterDescriptor reflectedParameterDescriptor = parameterDescriptor as ReflectedHttpParameterDescriptor; if (reflectedParameterDescriptor != null) { return !reflectedParameterDescriptor.ParameterInfo.IsOptional; } return true; }
public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter) { IEdmModel model; MediaTypeFormatter formatter = parameter.Configuration.GetODataFormatter(out model); if (formatter == null) { throw Error.InvalidOperation(SRResources.NoODataMediaTypeFormatterFound); } return new ODataFormatterParameterBinding(parameter, formatter); }
public FormatterParameterBinding(HttpParameterDescriptor descriptor, IEnumerable<MediaTypeFormatter> formatters, IBodyModelValidator bodyModelValidator) : base(descriptor) { if (descriptor.IsOptional) { _errorMessage = Error.Format(SRResources.OptionalBodyParameterNotSupported, descriptor.Prefix ?? descriptor.ParameterName, GetType().Name); } Formatters = formatters; BodyModelValidator = bodyModelValidator; }
public FromHeaderBinding(HttpParameterDescriptor parameter, string headerName) : base(parameter) { if (string.IsNullOrEmpty(headerName)) { throw new ArgumentNullException("Header Name"); } this.name = headerName; }
public ODataFormatterParameterBinding(HttpParameterDescriptor descriptor, IEnumerable<MediaTypeFormatter> formatters) : base(descriptor) { if (formatters == null) { throw Error.ArgumentNull("formatters"); } _formatters = formatters; }