コード例 #1
0
        public new HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor.GetParameters().Any(p => p.ParameterName.Equals("values", StringComparison
                                                                                 .InvariantCultureIgnoreCase)))
            {
                var bindings      = Array.ConvertAll(actionDescriptor.GetParameters().ToArray(), new Converter <HttpParameterDescriptor, HttpParameterBinding>(GetCustomParameterBinding));
                var actionBinding = new HttpActionBinding(actionDescriptor, bindings);
                return(actionBinding);
            }

            return(base.GetBinding(actionDescriptor));
        }
コード例 #2
0
        private static bool ActionParametersMatchRequest(HttpActionDescriptor action, HttpControllerContext context)
        {
            // if attribute routing was used, accept the method
            // regardless of parameters
            if (action.GetCustomAttributes <ODataRouteAttribute>().Any())
            {
                return(true);
            }

            var parameters = action.GetParameters();
            var routeData  = context.RouteData;
            var routingConventionsStore = context.Request.ODataProperties().RoutingConventionsStore;

            int keyCount = 0;

            if (routingConventionsStore.ContainsKey(ODataRouteConstants.KeyCount))
            {
                keyCount = (int)routingConventionsStore[ODataRouteConstants.KeyCount];
            }

            // navigationProperty is optional in some cases, therefore an action
            // should not be rejected simply because it does not declare a navigationProperty parameter
            if (routeData.Values.ContainsKey(ODataRouteConstants.NavigationProperty))
            {
                keyCount -= 1;
            }

            if (parameters.Count < keyCount)
            {
                return(false);
            }

            return(true);
        }
コード例 #3
0
        public static ApiDescription GetApiDescription(HttpConfiguration config, string controllerName, string actionName, params string[] parameterNames)
        {
            if (config == null)
            {
                config = new HttpConfiguration();
                config.Formatters.Clear();
                config.Formatters.Add(new XmlMediaTypeFormatter());
                config.Formatters.Add(new JsonMediaTypeFormatter());
                config.Routes.MapHttpRoute("Default", "{controller}");
            }
            HashSet <string> parameterSet = new HashSet <string>(parameterNames, StringComparer.OrdinalIgnoreCase);

            foreach (var apiDescription in config.Services.GetApiExplorer().ApiDescriptions)
            {
                HttpActionDescriptor actionDescriptor = apiDescription.ActionDescriptor;
                if (String.Equals(actionDescriptor.ControllerDescriptor.ControllerName, controllerName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(actionDescriptor.ActionName, actionName, StringComparison.OrdinalIgnoreCase))
                {
                    HashSet <string> actionParameterSet = new HashSet <string>(actionDescriptor.GetParameters().Select(p => p.ParameterName), StringComparer.OrdinalIgnoreCase);
                    if (parameterSet.SetEquals(actionParameterSet))
                    {
                        return(apiDescription);
                    }
                }
            }

            return(null);
        }
コード例 #4
0
        private static IList <ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor)
        {
            IList <ApiParameterDescription> parameterDescriptions = new List <ApiParameterDescription>();
            var actionBinding = GetActionBinding(actionDescriptor);

            // try get parameter binding information if available
            if (actionBinding != null)
            {
                var parameterBindings = actionBinding.ParameterBindings;
                if (parameterBindings != null)
                {
                    foreach (var parameter in parameterBindings)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
                    }
                }
            }
            else
            {
                var parameters = actionDescriptor.GetParameters();
                if (parameters != null)
                {
                    foreach (var parameter in parameters)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
                    }
                }
            }

            return(parameterDescriptions);
        }
コード例 #5
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     // Maybe the parameter is a key parameter, e.g., where Id in the URI path maps to a parameter named 'key'
     if (swaggerParameter.description != null && swaggerParameter.description.StartsWith("key:"))
     {
         // Find either a single 'key' in the route or composite keys
         // which take the form of key<parameter name>
         var keyParameterName = swaggerParameter
                                 .description
                                 .Replace(FindKeyReplacementSubStr, 
                                             String.Empty)
                                 .ToLower();
         var parameterDescriptor = 
             actionDescriptor
                 .GetParameters()?
                 .SingleOrDefault(descriptor =>
                     descriptor.ParameterName.ToLower() == KeyName
                     || descriptor.ParameterName.ToLower().Equals(keyParameterName)
                 );
         if (parameterDescriptor != null && !parameterDescriptor.IsODataLibraryType())
         {
             var httpControllerDescriptor = actionDescriptor.ControllerDescriptor;
             Contract.Assume(httpControllerDescriptor != null);
             return new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional, parameterDescriptor)
             {
                 Configuration = httpControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             };
         }
     }
     return null;
 }
コード例 #6
0
        /// <summary>
        /// <see cref="ExtendedODataDeserializerProvider.GetODataDeserializer(System.Type, HttpRequestMessage)"/>
        /// <see cref="DefaultODataActionCreateUpdateParameterDeserializer.Read(Microsoft.OData.ODataMessageReader, System.Type, Microsoft.AspNet.OData.Formatter.Deserialization.ODataDeserializerContext)"/>
        /// </summary>
        public override async Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            HttpActionDescriptor actionDescriptor = actionContext.Request.GetActionDescriptor();

            HttpContentHeaders requestContentHeaders = actionContext?.Request?.Content?.Headers;

            if (requestContentHeaders != null)
            {
                bool contentLengthHasValue = requestContentHeaders.ContentLength.HasValue;
                bool contentTypeIsJson     = requestContentHeaders.ContentType?.MediaType?.Contains("json") == true; // https://github.com/aspnet/AspNetWebStack/issues/232

                if (((contentLengthHasValue && requestContentHeaders.ContentLength > 0) || (!contentLengthHasValue && contentTypeIsJson)) && (actionDescriptor.GetCustomAttributes <ActionAttribute>().Any() ||
                                                                                                                                              actionDescriptor.GetCustomAttributes <CreateAttribute>().Any() ||
                                                                                                                                              actionDescriptor.GetCustomAttributes <UpdateAttribute>().Any() ||
                                                                                                                                              actionDescriptor.GetCustomAttributes <PartialUpdateAttribute>().Any()))
                {
                    using (StreamReader requestStreamReader = new StreamReader(await actionContext.Request.Content.ReadAsStreamAsync().ConfigureAwait(false)))
                    {
                        using (JsonReader jsonReader = new JsonTextReader(requestStreamReader))
                        {
                            JToken contentStreamAsJson = await JToken.LoadAsync(jsonReader, cancellationToken).ConfigureAwait(false);

                            if (contentStreamAsJson.First is JProperty prop && actionDescriptor.GetParameters().Any(p => p.ParameterName == prop.Name))
                            {
                                contentStreamAsJson = contentStreamAsJson[prop.Name];
                            }

                            actionContext.Request.Properties["ContentStreamAsJson"] = contentStreamAsJson;
                        }
                    }
                }
            }

            await base.OnAuthorizationAsync(actionContext, cancellationToken).ConfigureAwait(false);
        }
コード例 #7
0
        private void InvokeAction(HttpActionDescriptor action, object[] parameters, ChangeSetEntry changeSetEntry)
        {
            try
            {
                Collection <HttpParameterDescriptor> pds      = action.GetParameters();
                Dictionary <string, object>          paramMap = new Dictionary <string, object>(pds.Count);
                for (int i = 0; i < pds.Count; i++)
                {
                    paramMap.Add(pds[i].ParameterName, parameters[i]);
                }

                // TODO this method is not correctly observing the execution results, the catch block below is wrong. 385801
                action.ExecuteAsync(ActionContext.ControllerContext, paramMap);
            }
            catch (TargetInvocationException tie)
            {
                ValidationException vex = tie.GetBaseException() as ValidationException;
                if (vex != null)
                {
                    ValidationResultInfo error = new ValidationResultInfo(vex.Message, 0, String.Empty, vex.ValidationResult.MemberNames);
                    if (changeSetEntry.ValidationErrors != null)
                    {
                        changeSetEntry.ValidationErrors = changeSetEntry.ValidationErrors.Concat(new ValidationResultInfo[] { error }).ToArray();
                    }
                    else
                    {
                        changeSetEntry.ValidationErrors = new ValidationResultInfo[] { error };
                    }
                }
                else
                {
                    throw;
                }
            }
        }
コード例 #8
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     // Maybe the parameter is a key parameter, e.g., where Id in the URI path maps to a parameter named 'key'
     if (swaggerParameter.description != null && swaggerParameter.description.StartsWith("key:"))
     {
         // Find either a single 'key' in the route or composite keys
         // which take the form of key<parameter name>
         var keyParameterName = swaggerParameter
                                .description
                                .Replace(FindKeyReplacementSubStr,
                                         String.Empty)
                                .ToLower();
         var parameterDescriptor =
             actionDescriptor
             .GetParameters()?
             .SingleOrDefault(descriptor =>
                              descriptor.ParameterName.ToLower() == KeyName ||
                              descriptor.ParameterName.ToLower().Equals(keyParameterName)
                              );
         if (parameterDescriptor != null && !parameterDescriptor.IsODataLibraryType())
         {
             var httpControllerDescriptor = actionDescriptor.ControllerDescriptor;
             Contract.Assume(httpControllerDescriptor != null);
             return(new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional, parameterDescriptor)
             {
                 Configuration = httpControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             });
         }
     }
     return(null);
 }
コード例 #9
0
        private IDictionary<string, object> GetParameterValuePairs(HttpActionDescriptor actionDescriptor)
        {
            IDictionary<string, object> parameterValuePairs = new Dictionary<string, object>();

            foreach (SwaggerDefaultValue defaultValue in actionDescriptor.GetCustomAttributes<SwaggerDefaultValue>())
            {
                parameterValuePairs.Add(defaultValue.Name, defaultValue.Value);
            }

            foreach (var parameter in actionDescriptor.GetParameters())
            {
                if (!parameter.ParameterType.IsPrimitive)
                {
                    foreach (PropertyInfo property in parameter.ParameterType.GetProperties())
                    {
                        var defaultValue = GetDefaultValue(property);

                        if (defaultValue != null)
                        {
                            parameterValuePairs.Add(property.Name, defaultValue);
                        }
                    }
                }
            }

            return parameterValuePairs;
        }
コード例 #10
0
        private IList <ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor, HttpParsedRoute parsedRoute, IDictionary <string, object> routeDefaults)
        {
            IList <ApiParameterDescription> parameterDescriptions = new List <ApiParameterDescription>();
            HttpActionBinding actionBinding = GetActionBinding(actionDescriptor);

            // try get parameter binding information if available
            if (actionBinding != null)
            {
                HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
                if (parameterBindings != null)
                {
                    foreach (HttpParameterBinding parameter in parameterBindings)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
                    }
                }
            }
            else
            {
                Collection <HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
                if (parameters != null)
                {
                    foreach (HttpParameterDescriptor parameter in parameters)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
                    }
                }
            }

            // Adding route parameters not declared on the action. We're doing this because route parameters may or
            // may not be part of the action parameters and we want to have them in the description.
            AddUndeclaredRouteParameters(parsedRoute, routeDefaults, parameterDescriptions);

            return(parameterDescriptions);
        }
コード例 #11
0
		internal static bool ActionHasChangeSetEntityParameter(HttpActionDescriptor actionDescriptor)
		{
			Contract.Assert(actionDescriptor != null);

			var parameters = actionDescriptor.GetParameters();
			return (parameters.Count > 0) && IsChangeSetEntityParameter(parameters[0]);
		}
コード例 #12
0
        private IList<ApiParameterDescription> CreateParameterDescription(HttpActionBinding actionBinding,HttpActionDescriptor actionDescriptor)
        {
            IList<ApiParameterDescription> parameterDescriptions = new List<ApiParameterDescription>();
            // try get parameter binding information if available
            if (actionBinding != null)
            {
                HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
                if (parameterBindings != null)
                {
                    foreach (HttpParameterBinding parameter in parameterBindings)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
                    }
                }
            }
            else
            {
                Collection<HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
                if (parameters != null)
                {
                    foreach (HttpParameterDescriptor parameter in parameters)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
                    }
                }
            }

            return parameterDescriptions;
        }
コード例 #13
0
        private IDictionary <string, object> GetParameterValuePairs(HttpActionDescriptor actionDescriptor)
        {
            IDictionary <string, object> parameterValuePairs = new Dictionary <string, object>();

            foreach (SwaggerDefaultValue defaultValue in actionDescriptor.GetCustomAttributes <SwaggerDefaultValue>())
            {
                parameterValuePairs.Add(defaultValue.Name, defaultValue.Value);
            }

            foreach (var parameter in actionDescriptor.GetParameters())
            {
                if (!parameter.ParameterType.IsPrimitive)
                {
                    foreach (PropertyInfo property in parameter.ParameterType.GetProperties())
                    {
                        var defaultValue = GetDefaultValue(property);

                        if (defaultValue != null)
                        {
                            parameterValuePairs.Add(property.Name, defaultValue);
                        }
                    }
                }
            }

            return(parameterValuePairs);
        }
コード例 #14
0
        private IList <ApiParameterDescription> CreateParameterDescription(HttpActionBinding actionBinding, HttpActionDescriptor actionDescriptor)
        {
            IList <ApiParameterDescription> parameterDescriptions = new List <ApiParameterDescription>();

            // try get parameter binding information if available
            if (actionBinding != null)
            {
                HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
                if (parameterBindings != null)
                {
                    foreach (HttpParameterBinding parameter in parameterBindings)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
                    }
                }
            }
            else
            {
                Collection <HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
                if (parameters != null)
                {
                    foreach (HttpParameterDescriptor parameter in parameters)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
                    }
                }
            }


            return(parameterDescriptions);
        }
コード例 #15
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     var httpParameterDescriptors = actionDescriptor.GetParameters();
     Contract.Assume(httpParameterDescriptors != null);
     return httpParameterDescriptors
         .SingleOrDefault(descriptor => string.Equals(descriptor.ParameterName, swaggerParameter.name, StringComparison.CurrentCultureIgnoreCase));
 }
        /// <summary>
        /// <see cref="ExtendedODataDeserializerProvider.GetODataDeserializer(System.Type, HttpRequestMessage)"/>
        /// <see cref="DefaultODataActionCreateUpdateParameterDeserializer.Read(Microsoft.OData.ODataMessageReader, System.Type, Microsoft.AspNet.OData.Formatter.Deserialization.ODataDeserializerContext)"/>
        /// </summary>
        public override async Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            HttpActionDescriptor actionDescriptor = actionContext.Request.GetActionDescriptor();

            if (actionDescriptor != null && actionContext.Request?.Content?.Headers?.ContentLength != 0 && (actionDescriptor.GetCustomAttributes <ActionAttribute>().Any() ||
                                                                                                            actionDescriptor.GetCustomAttributes <CreateAttribute>().Any() ||
                                                                                                            actionDescriptor.GetCustomAttributes <UpdateAttribute>().Any() ||
                                                                                                            actionDescriptor.GetCustomAttributes <PartialUpdateAttribute>().Any()))
            {
                using (StreamReader requestStreamReader = new StreamReader(await actionContext.Request.Content.ReadAsStreamAsync().ConfigureAwait(false)))
                {
                    using (JsonReader jsonReader = new JsonTextReader(requestStreamReader))
                    {
                        JToken contentStreamAsJson = await JToken.LoadAsync(jsonReader, cancellationToken).ConfigureAwait(false);

                        if (contentStreamAsJson.First is JProperty prop && actionDescriptor.GetParameters().Any(p => p.ParameterName == prop.Name))
                        {
                            contentStreamAsJson = contentStreamAsJson[prop.Name];
                        }

                        actionContext.Request.Properties["ContentStreamAsJson"] = contentStreamAsJson;
                    }
                }
            }

            await base.OnAuthorizationAsync(actionContext, cancellationToken).ConfigureAwait(false);
        }
コード例 #17
0
        public HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            var binders       = actionDescriptor.GetParameters().Select(GetParameterBinding).ToArray();
            var actionBinding = new HttpActionBinding(actionDescriptor, binders);

            _ensureOneBodyParameter(actionBinding);
            return(actionBinding);
        }
コード例 #18
0
	public override HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
	{
		var actionBinding = new MvcActionBinding(serializerSettings);
		HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
		HttpParameterBinding[] binders = Array.ConvertAll(parameters, DetermineBinding);
		actionBinding.ParameterBindings = binders;
		return actionBinding;
	}
コード例 #19
0
        public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
        {
            var httpParameterDescriptors = actionDescriptor.GetParameters();

            Contract.Assume(httpParameterDescriptors != null);
            return(httpParameterDescriptors
                   .SingleOrDefault(descriptor => string.Equals(descriptor.ParameterName, swaggerParameter.name, StringComparison.CurrentCultureIgnoreCase)));
        }
コード例 #20
0
 public HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
 {
     return(new HttpActionBinding(
                actionDescriptor,
                actionDescriptor.GetParameters()
                .Select(p => GetParameterBinding(p)).ToArray()
                ));
 }
コード例 #21
0
        internal static bool ActionHasChangeSetEntityParameter(HttpActionDescriptor actionDescriptor)
        {
            Contract.Assert(actionDescriptor != null);

            var parameters = actionDescriptor.GetParameters();

            return((parameters.Count > 0) && IsChangeSetEntityParameter(parameters[0]));
        }
コード例 #22
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     if (swaggerParameter.@in != "query" && parameterIndex < actionDescriptor.GetParameters().Count)
     {
         var parameterDescriptor = actionDescriptor.GetParameters()[parameterIndex];
         if (parameterDescriptor != null)
         {
             // Need to assign the correct name expected by OData
             return(new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional)
             {
                 Configuration = actionDescriptor.ControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             });
         }
     }
     return(null);
 }
コード例 #23
0
        /// <summary>
        /// Returns an enumeration of filters.
        /// </summary>
        /// <param name="configuration">The HTTP configuration.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>
        /// An enumeration of filters.
        /// </returns>
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor) {
            if (actionDescriptor == null ||
                (!IsIQueryable(actionDescriptor.ReturnType)) ||
                actionDescriptor.GetCustomAttributes<QueryableAttribute>().Any() ||
                actionDescriptor.GetParameters().Any(parameter => typeof (ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
                return Enumerable.Empty<FilterInfo>();

            return new[] {new FilterInfo(_filter, FilterScope.Global)};
        }
コード例 #24
0
 private static string ParameterDescriptions(HttpActionDescriptor actionDescripton)
 {
     var description = new StringBuilder();
     foreach (var parameter in actionDescripton.GetParameters())
     {
         description.AppendFormat("{0}:{1}/", parameter.ParameterType, parameter.ParameterName);
     }
     return description.ToString();
 }
コード例 #25
0
        private XPathNavigator GetNodeFor(HttpActionDescriptor actionDescriptor)
        {
            var controllerName = actionDescriptor.ControllerDescriptor.ControllerType.FullName;
            var actionName = actionDescriptor.ActionName;
            var parameters = String.Join(",", actionDescriptor.GetParameters()
                .Select(paramDesc => TypeNameFor(paramDesc.ParameterType)));

            var xpath = String.Format(MethodExpression, controllerName, actionName, parameters);
            return _navigator.SelectSingleNode(xpath);
        }
コード例 #26
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     if (swaggerParameter.@in != "query" && parameterIndex < actionDescriptor.GetParameters().Count)
     {
         var parameterDescriptor = actionDescriptor.GetParameters()[parameterIndex];
         if (parameterDescriptor != null && !parameterDescriptor.IsODataLibraryType())
         {
             var httpControllerDescriptor = actionDescriptor.ControllerDescriptor;
             Contract.Assume(httpControllerDescriptor != null);
             return new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional, parameterDescriptor)
             {
                 Configuration = httpControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             };
         }
     }
     return null;
 }
コード例 #27
0
        public static string ActionDescriptorToString(HttpActionDescriptor actionDescriptor)
        {
            Contract.Assert(actionDescriptor != null);

            string parameterList = String.Join(", ",
                                               actionDescriptor.GetParameters().Select<HttpParameterDescriptor, string>(
                                                   (p) => p.ParameterType.Name + " " + p.ParameterName));

            return actionDescriptor.ActionName + "(" + parameterList + ")";
        }
コード例 #28
0
        public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
        {
            Contract.Requires(swaggerParameter != null);
            Contract.Requires(parameterIndex >= 0);
            Contract.Requires(actionDescriptor != null);
            Contract.Requires(actionDescriptor.GetParameters() != null);
            //Contract.Ensures(Contract.Result<HttpParameterDescriptor>() == null || Contract.Result<HttpParameterDescriptor>().Configuration != null);

            throw new NotImplementedException();
        }
コード例 #29
0
        public static string ActionDescriptorToString(HttpActionDescriptor actionDescriptor)
        {
            Contract.Assert(actionDescriptor != null);

            string parameterList = string.Join(", ",
                                               actionDescriptor.GetParameters().Select <HttpParameterDescriptor, string>(
                                                   (p) => p.ParameterType.Name + " " + p.ParameterName));

            return(actionDescriptor.ActionName + "(" + parameterList + ")");
        }
コード例 #30
0
        public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
        {
            Contract.Requires(swaggerParameter != null);
            Contract.Requires(parameterIndex >= 0);
            Contract.Requires(actionDescriptor != null);
            Contract.Requires(actionDescriptor.GetParameters() != null);
            //Contract.Ensures(Contract.Result<HttpParameterDescriptor>() == null || Contract.Result<HttpParameterDescriptor>().Configuration != null);

            throw new NotImplementedException();
        }
コード例 #31
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     if (swaggerParameter.@in != "query" && parameterIndex < actionDescriptor.GetParameters().Count)
     {
         var parameterDescriptor = actionDescriptor.GetParameters()[parameterIndex];
         if (parameterDescriptor != null && !parameterDescriptor.IsODataQueryOptions())
         {
             var httpControllerDescriptor = actionDescriptor.ControllerDescriptor;
             Contract.Assume(httpControllerDescriptor != null);
             return(new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional)
             {
                 Configuration = httpControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             });
         }
     }
     return(null);
 }
コード例 #32
0
        public override HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            MvcActionBinding actionBinding = new MvcActionBinding();

            HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
            HttpParameterBinding[]    binders    = Array.ConvertAll(parameters, p => DetermineBinding(actionBinding, p));

            actionBinding.ParameterBindings = binders;

            return(actionBinding);
        }
コード例 #33
0
ファイル: MvcActionValueBinder.cs プロジェクト: liumeifu/OSky
        public override HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            var actionBinding = new MvcActionBinding();

            HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
            HttpParameterBinding[] binders = Array.ConvertAll(parameters, DetermineBinding);

            actionBinding.ParameterBindings = binders;

            return actionBinding;
        }
コード例 #34
0
        /// <summary>
        /// Provides filters to apply to the specified action.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="actionDescriptor">The action descriptor for the action to provide filters for.</param>
        /// <returns>
        /// The filters to apply to the specified action.
        /// </returns>
        public IEnumerable <FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            // Actions with a bound parameter of type ODataQueryOptions do not support the query filter
            // The assumption is that the action will handle the querying within the action implementation
            if (actionDescriptor != null && IsIQueryable(actionDescriptor.ReturnType) &&
                !actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
            {
                return(new FilterInfo[] { new FilterInfo(QueryFilter, FilterScope.Global) });
            }

            return(Enumerable.Empty <FilterInfo>());
        }
コード例 #35
0
        public IEnumerable <FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null ||
                actionDescriptor.GetCustomAttributes <QueryableAttribute>().Any() || // if method already has a QueryableAttribute (or subclass) then skip it.
                actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType))
                )
            {
                return(Enumerable.Empty <FilterInfo>());
            }

            return(new[] { new FilterInfo(_filter, FilterScope.Global) });
        }
コード例 #36
0
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null ||
              actionDescriptor.GetCustomAttributes<QueryableAttribute>().Any() || // if method already has a QueryableAttribute (or subclass) then skip it.
              actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType))
            )
            {
                return Enumerable.Empty<FilterInfo>();
            }

            return new[] { new FilterInfo(_filter, FilterScope.Global) };
        }
コード例 #37
0
        /// <summary>
        /// Provides filters to apply to the specified action.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="actionDescriptor">The action descriptor for the action to provide filters for.</param>
        /// <returns>
        /// The filters to apply to the specified action.
        /// </returns>
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            // Actions with a bound parameter of type ODataQueryOptions do not support the query filter
            // The assumption is that the action will handle the querying within the action implementation
            if (actionDescriptor != null && IsIQueryable(actionDescriptor.ReturnType) &&
                !actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
            {
                return new FilterInfo[] { new FilterInfo(QueryFilter, FilterScope.Global) };
            }

            return Enumerable.Empty<FilterInfo>();
        }
コード例 #38
0
        IList <ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor, IHttpRoute route)
        {
            Contract.Requires(actionDescriptor != null);
            Contract.Requires(route != null);
            Contract.Ensures(Contract.Result <IList <ApiParameterDescription> >() != null);

            var list          = new List <ApiParameterDescription>();
            var actionBinding = GetActionBinding(actionDescriptor);

            if (actionBinding != null)
            {
                var configuration      = actionDescriptor.Configuration;
                var serviceProvider    = configuration.GetODataRootContainer(route);
                var assembliesResolver = configuration.Services.GetAssembliesResolver();
                var parameterBindings  = actionBinding.ParameterBindings;

                if (parameterBindings != null)
                {
                    foreach (var binding in parameterBindings)
                    {
                        list.Add(CreateParameterDescriptionFromBinding(binding, serviceProvider, assembliesResolver));
                    }
                }
            }
            else
            {
                var parameters = actionDescriptor.GetParameters();

                if (parameters != null)
                {
                    foreach (var descriptor in parameters)
                    {
                        list.Add(CreateParameterDescription(descriptor));
                    }
                }
            }

            foreach (var entry in route.Constraints)
            {
                if (entry.Value is ApiVersionRouteConstraint constraint)
                {
                    list.Add(new ApiParameterDescription()
                    {
                        Name = entry.Key, Source = FromUri
                    });
                    break;
                }
            }

            return(list);
        }
コード例 #39
0
        private static string GetXPathFor(HttpActionDescriptor actionDescriptor)
        {
            var controllerName = actionDescriptor.ControllerDescriptor.ControllerType.FullName;
            var actionName = actionDescriptor.ActionName;

            var paramTypeNames = actionDescriptor.GetParameters()
                .Select(paramDesc => TypeNameFor(paramDesc.ParameterType))
                .ToArray();

            var parameters = (paramTypeNames.Any())
                ? String.Format("({0})", String.Join(",", paramTypeNames))
                : String.Empty;

            return String.Format(MethodExpression, controllerName, actionName, parameters);
        }
コード例 #40
0
        private static string GetXPathFor(HttpActionDescriptor actionDescriptor)
        {
            var controllerName = actionDescriptor.ControllerDescriptor.ControllerType.FullName;
            var actionName     = actionDescriptor.ActionName;

            var paramTypeNames = actionDescriptor.GetParameters()
                                 .Select(paramDesc => TypeNameFor(paramDesc.ParameterType))
                                 .ToArray();

            var parameters = (paramTypeNames.Any())
                ? String.Format("({0})", String.Join(",", paramTypeNames))
                : String.Empty;

            return(String.Format(MethodExpression, controllerName, actionName, parameters));
        }
コード例 #41
0
        IReadOnlyList <ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor, IHttpRoute route)
        {
            Contract.Requires(actionDescriptor != null);
            Contract.Requires(route != null);
            Contract.Ensures(Contract.Result <IList <ApiParameterDescription> >() != null);

            var list          = new List <ApiParameterDescription>();
            var actionBinding = GetActionBinding(actionDescriptor);

            if (actionBinding != null)
            {
                var parameterBindings = actionBinding.ParameterBindings;

                if (parameterBindings != null)
                {
                    foreach (var binding in parameterBindings)
                    {
                        list.Add(CreateParameterDescriptionFromBinding(binding));
                    }
                }
            }
            else
            {
                var parameters = actionDescriptor.GetParameters();

                if (parameters != null)
                {
                    foreach (var descriptor in parameters)
                    {
                        list.Add(CreateParameterDescription(descriptor));
                    }
                }
            }

            foreach (var entry in route.Constraints)
            {
                if (entry.Value is ApiVersionRouteConstraint constraint)
                {
                    list.Add(new ApiParameterDescription()
                    {
                        Name = entry.Key, Source = FromUri
                    });
                    break;
                }
            }

            return(list);
        }
コード例 #42
0
        private AccessControlAttribute GetActionAttribute(HttpActionDescriptor actionDescriptor, out string idParamName)
        {
            idParamName = null;
            var result = actionDescriptor
                         .GetCustomAttributes <AccessControlAttribute>(true)
                         .SingleOrDefault();

            if (result != null)
            {
                var idParam = actionDescriptor.GetParameters().SingleOrDefault(x => x.GetCustomAttributes <PlayerIdAttribute>().SingleOrDefault() != null);
                idParamName = idParam?.ParameterName;
                return(result);
            }

            return(null);
        }
コード例 #43
0
        /// <summary>
        /// Implementation of <see cref="IActionValueBinder"/>, Primary entry point for binding parameters for an action.
        /// </summary>           
        public virtual HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
            HttpParameterBinding[] binders = Array.ConvertAll(parameters, GetParameterBinding);

            HttpActionBinding actionBinding = new HttpActionBinding(actionDescriptor, binders);

            EnsureOneBodyParameter(actionBinding);

            return actionBinding;
        }
コード例 #44
0
        /// <summary>
        /// Implementation of <see cref="IActionValueBinder"/>, Primary entry point for binding parameters for an action.
        /// </summary>
        public virtual HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
            HttpParameterBinding[]    binders    = Array.ConvertAll(parameters, GetParameterBinding);

            HttpActionBinding actionBinding = new HttpActionBinding(actionDescriptor, binders);

            EnsureOneBodyParameter(actionBinding);

            return(actionBinding);
        }
コード例 #45
0
        /// <summary>
        /// Provides filters to apply to the specified action.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="actionDescriptor">The action descriptor for the action to provide filters for.</param>
        /// <returns>
        /// The filters to apply to the specified action.
        /// </returns>
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            // Actions with a bound parameter of type ODataQueryOptions do not support the query filter
            // The assumption is that the action will handle the querying within the action implementation

            // Skip actions that contain QueryableAttribute as it causes problems in some scenarios. See
            // #2047 for details.
            if (actionDescriptor != null &&
                !(_skipQueryableAttribute && HasQueryableAttribute(actionDescriptor)) &&
                (IsIQueryable(actionDescriptor.ReturnType) || typeof(SingleResult).IsAssignableFrom(actionDescriptor.ReturnType)) &&
                !actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
            {
                return new FilterInfo[] { new FilterInfo(QueryFilter, FilterScope.Global) };
            }

            return Enumerable.Empty<FilterInfo>();
        }
コード例 #46
0
        /// <summary>
        /// Provides filters to apply to the specified action.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="actionDescriptor">The action descriptor for the action to provide filters for.</param>
        /// <returns>
        /// The filters to apply to the specified action.
        /// </returns>
        public IEnumerable <FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            // Actions with a bound parameter of type ODataQueryOptions do not support the query filter
            // The assumption is that the action will handle the querying within the action implementation

            // Skip actions that contain QueryableAttribute as it causes problems in some scenarios. See
            // #2047 for details.
            if (actionDescriptor != null &&
                !(_skipQueryableAttribute && HasQueryableAttribute(actionDescriptor)) &&
                (IsIQueryable(actionDescriptor.ReturnType) || typeof(SingleResult).IsAssignableFrom(actionDescriptor.ReturnType)) &&
                !actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
            {
                return(new FilterInfo[] { new FilterInfo(QueryFilter, FilterScope.Global) });
            }

            return(Enumerable.Empty <FilterInfo>());
        }
コード例 #47
0
        public static string keyForAction(HttpActionDescriptor action)
        {
            var sb = new StringBuilder();

            sb.Append(action.ControllerDescriptor.ControllerType.FullName);
            sb.Append("$");
            sb.Append(action.ActionName);
            sb.Append("$");
            foreach (var param in action.GetParameters())
            {
                sb.Append(param.ParameterName);
                sb.Append(":");
                sb.Append(param.ParameterType.ToString());
                sb.Append("|");
            }
            return(sb.ToString());
        }
コード例 #48
0
        public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
        {
            var required = swaggerParameter.required;
            Contract.Assume(required != null);

            if (swaggerParameter.@in == "body" && swaggerParameter.schema != null && swaggerParameter.schema.type == "object")
            {
                var odataActionParametersDescriptor = actionDescriptor.GetParameters().SingleOrDefault(descriptor => descriptor.ParameterType == typeof (ODataActionParameters));
                Contract.Assume(odataActionParametersDescriptor != null);
                return new ODataActionParameterDescriptor(odataActionParametersDescriptor.ParameterName, typeof(ODataActionParameters), !required.Value, swaggerParameter.schema, odataActionParametersDescriptor)
                {
                    Configuration = actionDescriptor.ControllerDescriptor.Configuration,
                    ActionDescriptor = actionDescriptor
                };
            }
            return null;
        }
コード例 #49
0
		private static string XPathFor(HttpActionDescriptor actionDescriptor)
        {
            var controllerName = actionDescriptor.ControllerDescriptor.ControllerType.FullName;
            var reflectedActionDescriptor = actionDescriptor as ReflectedHttpActionDescriptor;
            var actionName = (reflectedActionDescriptor != null)
                ? reflectedActionDescriptor.MethodInfo.Name
                : actionDescriptor.ActionName;

            var paramTypeNames = actionDescriptor.GetParameters()
                .Select(paramDesc => paramDesc.ParameterType.XmlCommentsId())
                .ToArray();

            var parameters = (paramTypeNames.Any())
                ? String.Format("({0})", String.Join(",", paramTypeNames))
                : String.Empty;

            return String.Format(MethodExpression, controllerName, actionName, parameters);
        }
コード例 #50
0
 public HttpParameterDescriptor Map(Parameter swaggerParameter, int parameterIndex, HttpActionDescriptor actionDescriptor)
 {
     // Maybe the parameter is a key parameter, e.g., where Id in the URI path maps to a parameter named 'key'
     if (swaggerParameter.description != null && swaggerParameter.description.StartsWith("key:"))
     {
         var parameterDescriptor = actionDescriptor.GetParameters()?.SingleOrDefault(descriptor => descriptor.ParameterName == "key");
         if (parameterDescriptor != null && !parameterDescriptor.IsODataLibraryType())
         {
             var httpControllerDescriptor = actionDescriptor.ControllerDescriptor;
             Contract.Assume(httpControllerDescriptor != null);
             return new ODataParameterDescriptor(swaggerParameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional, parameterDescriptor)
             {
                 Configuration = httpControllerDescriptor.Configuration,
                 ActionDescriptor = actionDescriptor,
                 ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
             };
         }
     }
     return null;
 }
コード例 #51
0
		public static void PrepareByOptionAttribute(ResourceApi resource, HttpActionDescriptor actionDescriptor)
		{
			var parameters = actionDescriptor.GetParameters();

			foreach (var p in parameters)
			{
				var attributes = p.GetCustomAttributes<SwaggerOptionsAttribute>();

				if (attributes.Count > 0)
				{
					var att = attributes[0] as SwaggerOptionsAttribute;

					if (!String.IsNullOrWhiteSpace(att.Name))
					{
						resource.path = resource.path.Replace(
							String.Format(CultureInfo.InvariantCulture, "{{{0}}}", p.ParameterName), 
							String.Format(CultureInfo.InvariantCulture, "{{{0}}}", att.Name));
					}
				}
			}
		}	
コード例 #52
0
        private void InvokeAction(HttpActionDescriptor action, object[] parameters, ChangeSetEntry changeSetEntry)
        {
            try
            {
                Collection<HttpParameterDescriptor> pds = action.GetParameters();
                Dictionary<string, object> paramMap = new Dictionary<string, object>(pds.Count);
                for (int i = 0; i < pds.Count; i++)
                {
                    paramMap.Add(pds[i].ParameterName, parameters[i]);
                }

                // TODO this method is not correctly observing the execution results, the catch block below is wrong. 385801
                action.ExecuteAsync(ActionContext.ControllerContext, paramMap);
            }
            catch (TargetInvocationException tie)
            {
                ValidationException vex = tie.GetBaseException() as ValidationException;
                if (vex != null)
                {
                    ValidationResultInfo error = new ValidationResultInfo(vex.Message, 0, String.Empty, vex.ValidationResult.MemberNames);
                    if (changeSetEntry.ValidationErrors != null)
                    {
                        changeSetEntry.ValidationErrors = changeSetEntry.ValidationErrors.Concat(new ValidationResultInfo[] { error }).ToArray();
                    }
                    else
                    {
                        changeSetEntry.ValidationErrors = new ValidationResultInfo[] { error };
                    }
                }
                else
                {
                    throw;
                }
            }
        }
コード例 #53
0
        private void InvokeAction(HttpActionDescriptor action, object[] parameters, ChangeSetEntry changeSetEntry)
        {
            try
            {
                Collection<HttpParameterDescriptor> pds = action.GetParameters();
                Dictionary<string, object> paramMap = new Dictionary<string, object>(pds.Count);
                for (int i = 0; i < pds.Count; i++)
                {
                    paramMap.Add(pds[i].ParameterName, parameters[i]);
                }

                // TODO - Issue #103
                // This method is not correctly observing the execution results, the catch block below is wrong.
                // Submit should be Task<bool>, not bool, and should model bind for the CancellationToken which would then
                // be propagated through to all the helper methods (one or more of which might also need to be made async,
                // once we start respecting the fact that the read/write actions should be allowed to be async).
                action.ExecuteAsync(ActionContext.ControllerContext, paramMap, CancellationToken.None);
            }
            catch (TargetInvocationException tie)
            {
                ValidationException vex = tie.GetBaseException() as ValidationException;
                if (vex != null)
                {
                    ValidationResultInfo error = new ValidationResultInfo(vex.Message, 0, String.Empty, vex.ValidationResult.MemberNames);
                    if (changeSetEntry.ValidationErrors != null)
                    {
                        changeSetEntry.ValidationErrors = changeSetEntry.ValidationErrors.Concat(new ValidationResultInfo[] { error }).ToArray();
                    }
                    else
                    {
                        changeSetEntry.ValidationErrors = new ValidationResultInfo[] { error };
                    }
                }
                else
                {
                    throw;
                }
            }
        }
コード例 #54
0
		/// <summary>
		/// Determines the relative order of an action - used to select the lowest priority action in <see cref="SelectAction"/>.
		/// </summary>
		/// <param name="actionDescriptor"></param>
		/// <returns></returns>
		private static int DetermineActionOrder(HttpActionDescriptor actionDescriptor)
		{
			// Hard-coded rule: An action with first parameter "TEntity entity" is order 1
			// All others are order 2
			var parameters = actionDescriptor.GetParameters();
			if (parameters.Count >= 1)
			{
				if (ChangeSetEntityModelBinder.IsChangeSetEntityParameter(parameters[0]))
				{
					// Takes precedence
					return 1;
				}
			}

			return 2;
		}
コード例 #55
0
 private HttpActionRequestDocumentation CreateDefaultRequestDocumentation(HttpActionDescriptor actionDescriptor)
 {
     return new HttpActionRequestDocumentation(
         actionDescriptor.GetParameters()
                         .Where(p => p.ParameterBinderAttribute is FromUriAttribute || TypeHelper.CanConvertFromString(p.ParameterType))
                         .Select(p => new HttpActionRequestParameterDocumentation(p.ParameterName, GetProperyTypeName(p.ParameterType), String.Empty, !p.IsOptional)),
         CreateHttpActionRequestBody(actionDescriptor));
 }
コード例 #56
0
 public ActionSelectionInfo(HttpActionDescriptor descriptor)
 {
     ActionName = descriptor.ActionName;
     SupportedHttpMethods = descriptor.SupportedHttpMethods.ToArray();
     Parameters = descriptor.GetParameters().Select(p => new HttpParameterDescriptorInfo(p)).ToArray();
 }
コード例 #57
0
 private IEnumerable<HttpActionRequestParameterDocumentation> CreateHttpActionRequestParameters(HttpActionDescriptor httpActionDescriptor, HttpActionDocumentationMetadata actionDocumentationMetadata)
 {
     return
         from parameterDescriptor in httpActionDescriptor.GetParameters()
         where parameterDescriptor.ParameterBinderAttribute is FromUriAttribute || TypeHelper.CanConvertFromString(parameterDescriptor.ParameterType)
         let parameterDescription =
             actionDocumentationMetadata.HttpActionParameters
                                        .Any(parameterDocumentation =>
                                             parameterDocumentation.Name.Equals(parameterDescriptor.ParameterName) &&
                                             parameterDocumentation.Type.Equals(parameterDescriptor.ParameterType))
                 ? actionDocumentationMetadata.HttpActionParameters
                                              .Single(parameterDocumentation =>
                                                      parameterDocumentation.Name.Equals(parameterDescriptor.ParameterName) &&
                                                      parameterDocumentation.Type.Equals(parameterDescriptor.ParameterType)).Description
                 : String.Empty
         select new HttpActionRequestParameterDocumentation(
             parameterDescriptor.ParameterName,
             GetProperyTypeName(parameterDescriptor.ParameterType),
             parameterDescription,
             !parameterDescriptor.IsOptional);
 }