Esempio n. 1
0
        /// <inheritdoc />
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            var services = context.ActionContext.HttpContext.RequestServices;
            var filters  = services.GetService <IEnumerable <IFilterMetadata> >();

            if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
            {
                foreach (var filter in filters)
                {
                    var filterItem = new FilterItem(new FilterDescriptor(filter, FilterScope.Global), filter)
                    {
                        IsReusable = false
                    };

                    // TODO: Remove this when https://github.com/aspnet/Mvc/issues/4504
                    // is fixed
                    for (var i = 0; i < context.Results.Count; i++)
                    {
                        if (context.Results[i].Filter.GetType() == filter.GetType())
                        {
                            context.Results.RemoveAt(i);
                            break;
                        }
                    }

                    context.Results.Add(filterItem);
                }
            }
        }
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            if (context.ActionContext.ActionDescriptor.FilterDescriptors == null)
            {
                return;
            }

            var overrideFilters = context.Results.Where(filterItem => filterItem.Filter is OverrideFilter).ToArray();

            foreach (var overrideFilter in overrideFilters)
            {
                var filter = (overrideFilter.Filter as OverrideFilter);

                if (filter == null)
                {
                    continue;
                }

                if (filter.GetType() == filter.Type)
                {
                    throw new ProviderException($"It is not allowed to override the type itself. Filter Type: {filter.GetType()} -> Overwritten Filter: {filter.Type}");
                }

                var filters = context.Results.Where(filterItem =>
                                                    filterItem.Filter.GetType() == filter.Type &&
                                                    filterItem.Descriptor.Scope <= overrideFilter.Descriptor.Scope).ToList();

                foreach (var filterItem in filters)
                {
                    context.Results.Remove(filterItem);
                }
            }
        }
        public virtual void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
        {
            if (filterItem.Filter != null)
            {
                return;
            }

            var filter = filterItem.Descriptor.Filter;

            var filterFactory = filter as IFilterFactory;

            if (filterFactory == null)
            {
                filterItem.Filter     = filter;
                filterItem.IsReusable = true;
            }
            else
            {
                var services = context.ActionContext.HttpContext.RequestServices;
                filterItem.Filter     = filterFactory.CreateInstance(services);
                filterItem.IsReusable = filterFactory.IsReusable;

                if (filterItem.Filter == null)
                {
                    throw new InvalidOperationException(Resources.FormatTypeMethodMustReturnNotNullValue(
                                                            "CreateInstance",
                                                            typeof(IFilterFactory).Name));
                }

                ApplyFilterToContainer(filterItem.Filter, filterFactory);
            }
        }
Esempio n. 4
0
        public static bool ContainsMatch(this List <AreaNode> routeTree, FilterProviderContext context)
        {
            ControllerActionDescriptor cad = (ControllerActionDescriptor)context.ActionContext.ActionDescriptor;
            string area = (string)context.ActionContext.RouteData.Values["area"];

            var areaNode = routeTree.Find(x =>
            {
                if (string.IsNullOrEmpty(x.Area) && string.IsNullOrEmpty(area))
                {
                    return(true);
                }
                return(String.Compare(area, x.Area, StringComparison.OrdinalIgnoreCase) == 0);
            });

            if (areaNode != null)
            {
                if (areaNode.Controllers == null || !areaNode.Controllers.Any())
                {
                    return(true);
                }

                var controllerNode = areaNode.Controllers.Find(x => String.Compare(cad.ControllerName, x.Controller, StringComparison.OrdinalIgnoreCase) == 0);
                if (controllerNode != null)
                {
                    if (controllerNode.Actions == null || !controllerNode.Actions.Any())
                    {
                        return(true);
                    }

                    var action = controllerNode.Actions.Find(x => String.Compare(cad.Name, x.Action, StringComparison.OrdinalIgnoreCase) == 0);
                    return(action != null);
                }
            }
            return(false);
        }
        public static bool ContainsMatch(this List<AreaNode> routeTree, FilterProviderContext context)
        {
            ControllerActionDescriptor cad = (ControllerActionDescriptor)context.ActionContext.ActionDescriptor;
            string area = (string)context.ActionContext.RouteData.Values["area"];

            var areaNode = routeTree.Find(x =>
            {
                if (string.IsNullOrEmpty(x.Area) && string.IsNullOrEmpty(area))
                    return true;
                return String.Compare(area, x.Area, StringComparison.OrdinalIgnoreCase) == 0;

            });

            if (areaNode != null)
            {
                if (areaNode.Controllers == null || !areaNode.Controllers.Any())
                    return true;

                var controllerNode = areaNode.Controllers.Find(x => String.Compare(cad.ControllerName, x.Controller, StringComparison.OrdinalIgnoreCase) == 0);
                if (controllerNode != null)
                {
                    if (controllerNode.Actions == null || !controllerNode.Actions.Any())
                        return true;

                    var action = controllerNode.Actions.Find(x => String.Compare(cad.Name, x.Action, StringComparison.OrdinalIgnoreCase) == 0);
                    return action != null;
                }
            }
            return false;
        }
        public static bool ContainsMatch(this List <AreaNode> routeTree, FilterProviderContext context)
        {
            ControllerActionDescriptor cad = (ControllerActionDescriptor)context.ActionContext.ActionDescriptor;
            string area = (string)context.ActionContext.RouteData.Values["area"];

            return(routeTree.ContainsMatch(area, cad.ControllerName, cad.ActionName));
        }
Esempio n. 7
0
 public void OnProvidersExecuted(FilterProviderContext context)
 {
     if (WrappedFilter != null)
     {
         QueryFilterProvider filterProvider = new QueryFilterProvider(WrappedFilter);
         filterProvider.OnProvidersExecuted(context);
     }
 }
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            // remove authorize filters
            var authFilters = context.Results.Where(x => x.Descriptor.Filter.GetType() == typeof(AuthorizeFilter)).ToList();

            foreach (var filter in authFilters)
            {
                context.Results.Remove(filter);
            }
        }
 private bool TryFetchAuthFilterItem(FilterProviderContext context, out FilterItem filterItem)
 {
     if (RequiresAuth(context))
     {
         filterItem = TypeToFilterItem[_settings.Value.Authorization.Filter];
         return(true);
     }
     filterItem = null;
     return(false);
 }
Esempio n. 10
0
 public virtual void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
 {
     if (filterItem.Descriptor.Filter is AuthorizeFilter && (object)filterItem.Filter == null)
     {
         AuthorizeFilter val = filterItem.Descriptor.Filter as AuthorizeFilter;
         IEnumerable <IAuthorizeData> enumerable = val.AuthorizeData;
         if (enumerable == null && (object)val.Policy != null)
         {
             List <IAuthorizeData> list = new List <IAuthorizeData>();
             string text = val.Policy.AuthenticationSchemes.FirstOrDefault();
             if (!string.IsNullOrEmpty(text))
             {
                 List <IAuthorizeData> list2 = list;
                 MvcAuthorizeAttribute mvcAuthorizeAttribute = new MvcAuthorizeAttribute();
                 mvcAuthorizeAttribute.AuthenticationSchemes = text;
                 list2.Add(mvcAuthorizeAttribute);
             }
             enumerable = list;
         }
         filterItem.Filter     = new MvcAuthorizeFilter(enumerable).CreateInstance(context.ActionContext.HttpContext.RequestServices);
         filterItem.IsReusable = true;
     }
     if ((object)filterItem.Filter != null)
     {
         AuthorizeFilter    val2;
         MvcAuthorizeFilter mvcAuthorizeFilter = default(MvcAuthorizeFilter);
         if ((val2 = (filterItem.Filter as AuthorizeFilter)) != null && (mvcAuthorizeFilter = (filterItem.Descriptor.Filter as MvcAuthorizeFilter)) != null)
         {
             filterItem.Filter = mvcAuthorizeFilter.CreateInstance(context.ActionContext.HttpContext.RequestServices);
         }
     }
     else
     {
         IFilterMetadata val3 = filterItem.Descriptor.Filter;
         IFilterFactory  val4;
         if ((val4 = (val3 as IFilterFactory)) == null)
         {
             filterItem.Filter     = val3;
             filterItem.IsReusable = true;
         }
         else
         {
             IServiceProvider requestServices = context.ActionContext.HttpContext.RequestServices;
             filterItem.Filter     = val4.CreateInstance(requestServices);
             filterItem.IsReusable = val4.IsReusable;
             if ((object)filterItem.Filter == null)
             {
                 throw new InvalidOperationException("The 'CreateInstance' method of type '" + typeof(IFilterFactory).Name + "' cannot return a null value.");
             }
             ApplyFilterToContainer((object)filterItem.Filter, val4);
         }
     }
 }
Esempio n. 11
0
        public override void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
        {
            FilterRecord record;

            FilterCollectionExtensions.Records.TryGetValue(filterItem.Descriptor.Filter, out record);
            if (record != null && !record.Match(context))
            {
                return;
            }

            base.ProvideFilter(context, filterItem);
        }
Esempio n. 12
0
        public bool Match(FilterProviderContext context)
        {
            var currentArea = context.ActionContext.RouteData.DataTokens["area"];

            // Apply if root area
            if (currentArea == null && string.IsNullOrEmpty(_areaName))
            {
                return(true);
            }

            // Apply for specified area
            return(currentArea != null && string.Equals(currentArea.ToString(), _areaName, StringComparison.OrdinalIgnoreCase));
        }
Esempio n. 13
0
        private IFilterMetadata[] GetFilters()
        {
            var filterDescriptors = Context.ActionDescriptor.FilterDescriptors;
            var items             = new List <FilterItem>(filterDescriptors.Count);

            for (var i = 0; i < filterDescriptors.Count; i++)
            {
                items.Add(new FilterItem(filterDescriptors[i]));
            }

            var context = new FilterProviderContext(Context, items);

            for (var i = 0; i < _filterProviders.Count; i++)
            {
                _filterProviders[i].OnProvidersExecuting(context);
            }

            for (var i = _filterProviders.Count - 1; i >= 0; i--)
            {
                _filterProviders[i].OnProvidersExecuted(context);
            }

            var count = 0;

            for (var i = 0; i < items.Count; i++)
            {
                if (items[i].Filter != null)
                {
                    count++;
                }
            }

            if (count == 0)
            {
                return(new IFilterMetadata[0]);
            }
            else
            {
                var filters = new IFilterMetadata[count];
                for (int i = 0, j = 0; i < items.Count; i++)
                {
                    var filter = items[i].Filter;
                    if (filter != null)
                    {
                        filters[j++] = filter;
                    }
                }

                return(filters);
            }
        }
        private void ExecuteProviders(ActionContext actionContext, List <FilterItem> items)
        {
            var context = new FilterProviderContext(actionContext, items);

            for (var i = 0; i < _filterProviders.Length; i++)
            {
                _filterProviders[i].OnProvidersExecuting(context);
            }

            for (var i = _filterProviders.Length - 1; i >= 0; i--)
            {
                _filterProviders[i].OnProvidersExecuted(context);
            }
        }
Esempio n. 15
0
        private IFilterMetadata[] GetFilters(ActionContext actionContext, List <FilterItem> staticFilterItems)
        {
            // Create a separate collection as we want to hold onto the statically defined filter items
            // in order to cache them
            var filterItems = new List <FilterItem>(staticFilterItems);

            // Execute providers
            var context = new FilterProviderContext(actionContext, filterItems);

            for (var i = 0; i < _filterProviders.Length; i++)
            {
                _filterProviders[i].OnProvidersExecuting(context);
            }

            for (var i = _filterProviders.Length - 1; i >= 0; i--)
            {
                _filterProviders[i].OnProvidersExecuted(context);
            }

            // Extract filter instances from statically defined filters and filter providers
            var count = 0;

            for (var i = 0; i < filterItems.Count; i++)
            {
                if (filterItems[i].Filter != null)
                {
                    count++;
                }
            }

            if (count == 0)
            {
                return(EmptyFilterArray);
            }
            else
            {
                var filters     = new IFilterMetadata[count];
                var filterIndex = 0;
                for (int i = 0; i < filterItems.Count; i++)
                {
                    var filter = filterItems[i].Filter;
                    if (filter != null)
                    {
                        filters[filterIndex++] = filter;
                    }
                }

                return(filters);
            }
        }
Esempio n. 16
0
    public static void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
    {
        if (filterItem.Filter != null)
        {
            return;
        }

        var filter = filterItem.Descriptor.Filter;

        if (filter is not IFilterFactory filterFactory)
        {
            filterItem.Filter     = filter;
            filterItem.IsReusable = true;
        }
Esempio n. 17
0
 public void OnProvidersExecuting(FilterProviderContext context)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
     {
         for (int i = 0; i < context.Results.Count; i++)
         {
             ProvideFilter(context, context.Results[i]);
         }
     }
 }
Esempio n. 18
0
    private static IFilterMetadata[] CreateUncachedFiltersCore(
        IFilterProvider[] filterProviders,
        ActionContext actionContext,
        List <FilterItem> filterItems)
    {
        // Execute providers
        var context = new FilterProviderContext(actionContext, filterItems);

        for (var i = 0; i < filterProviders.Length; i++)
        {
            filterProviders[i].OnProvidersExecuting(context);
        }

        for (var i = filterProviders.Length - 1; i >= 0; i--)
        {
            filterProviders[i].OnProvidersExecuted(context);
        }

        // Extract filter instances from statically defined filters and filter providers
        var count = 0;

        for (var i = 0; i < filterItems.Count; i++)
        {
            if (filterItems[i].Filter != null)
            {
                count++;
            }
        }

        if (count == 0)
        {
            return(Array.Empty <IFilterMetadata>());
        }
        else
        {
            var filters     = new IFilterMetadata[count];
            var filterIndex = 0;
            for (int i = 0; i < filterItems.Count; i++)
            {
                var filter = filterItems[i].Filter;
                if (filter != null)
                {
                    filters[filterIndex++] = filter;
                }
            }

            return(filters);
        }
    }
Esempio n. 19
0
 private List <FilterItem> FetchFilters(FilterProviderContext context)
 {
     lock (locker)
     {
         List <FilterItem> filters;
         if (!ActionFilterMap.TryGetValue(context.ActionContext.ActionDescriptor.DisplayName, out filters))
         {
             ControllerActionDescriptor cad = (ControllerActionDescriptor)context.ActionContext.ActionDescriptor;
             string area = (string)context.ActionContext.RouteData.Values["area"];
             filters = _authorizeStore.GetFilterItems(area, cad.ControllerName, cad.ActionName).ToList();
             ActionFilterMap.Add(context.ActionContext.ActionDescriptor.DisplayName, filters);
         }
         return(filters);
     }
 }
        public override void ProvideFilter(FilterProviderContext context, FilterItem filterItem)
        {
            var route = context.ActionContext.ActionDescriptor.AttributeRouteInfo.Template;

            var filter = options.FirstOrDefault(option => route.StartsWith(option.RoutePrefix))?.Filter;

            if (filter != null)
            {
                if (context.Results.All(r => r.Descriptor.Filter != filter))
                {
                    context.Results.Add(new FilterItem(new FilterDescriptor(filter, (int)FilterScope.Controller)));
                }
            }

            base.ProvideFilter(context, filterItem);
        }
Esempio n. 21
0
        /// <summary>
        /// Provides filters to apply to the specified action.
        /// </summary>
        /// <param name="context">The filter context.</param>
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            // 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
            ControllerActionDescriptor controllerActionDescriptor = context.ActionContext.ActionDescriptor as ControllerActionDescriptor;

            if (controllerActionDescriptor != null)
            {
                Type returnType = controllerActionDescriptor.MethodInfo.ReturnType;
                if (ShouldAddFilter(context, returnType, controllerActionDescriptor))
                {
                    var filterDesc = new FilterDescriptor(QueryFilter, FilterScope.Global);
                    context.Results.Add(new FilterItem(filterDesc, QueryFilter));
                }
            }
        }
        /// <inheritdoc />
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
            {
                // Perf: Avoid allocations
                for (var i = 0; i < context.Results.Count; i++)
                {
                    ProvideFilter(context, context.Results[i]);
                }
            }
        }
Esempio n. 23
0
        //all framework providers have negative orders, so ours will come later
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            ControllerActionDescriptor cad = (ControllerActionDescriptor)context.ActionContext.ActionDescriptor;

            System.Diagnostics.Debug.WriteLine("Controller: " + cad.ControllerTypeInfo.FullName);
            System.Diagnostics.Debug.WriteLine("ActionName: " + cad.ActionName);
            System.Diagnostics.Debug.WriteLine("DisplayName: " + cad.DisplayName);
            System.Diagnostics.Debug.WriteLine("Area: " + context.ActionContext.RouteData.Values["area"]);

            var filters = FetchFilters(context);

            foreach (var filter in filters)
            {
                context.Results.Add(filter);
            }
        }
        private bool ShouldAddFilter(FilterProviderContext context, Type returnType, ControllerActionDescriptor controllerActionDescriptor)
        {
            if (returnType == null)
            {
                return(false);
            }

            // Get the inner return type if type is a task.
            Type innerReturnType = returnType;

            if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>))
            {
                innerReturnType = returnType.GetGenericArguments().First();
            }

            // See if this type is a SingleResult or is derived from SingleResult.
            bool isSingleResult = false;

            if (innerReturnType.IsGenericType)
            {
                Type genericType = innerReturnType.GetGenericTypeDefinition();
                Type baseType    = innerReturnType.BaseType;
                isSingleResult = (genericType == typeof(SingleResult <>) || baseType == typeof(SingleResult));
            }

            // Don't apply the filter if the result is not IQueryable() or SingleReult().
            if (!IsIQueryable(innerReturnType) && !isSingleResult)
            {
                return(false);
            }

            // If the controller takes a ODataQueryOptions, don't apply the filter.
            if (controllerActionDescriptor.Parameters
                .Any(parameter => TypeHelper.IsTypeAssignableFrom(typeof(ODataQueryOptions), parameter.ParameterType)))
            {
                return(false);
            }

            // Don't apply a global filter if one of the same type exists.
            if (context.Results.Where(f => f.Filter?.GetType() == QueryFilter.GetType()).Any())
            {
                return(false);
            }

            return(true);
        }
        private IFilterMetadata[] GetFilters(ActionContext actionContext, List<FilterItem> filterItems)
        {
            // Execute providers
            var context = new FilterProviderContext(actionContext, filterItems);

            for (var i = 0; i < _filterProviders.Length; i++)
            {
                _filterProviders[i].OnProvidersExecuting(context);
            }

            for (var i = _filterProviders.Length - 1; i >= 0; i--)
            {
                _filterProviders[i].OnProvidersExecuted(context);
            }

            // Extract filter instances from statically defined filters and filter providers
            var count = 0;
            for (var i = 0; i < filterItems.Count; i++)
            {
                if (filterItems[i].Filter != null)
                {
                    count++;
                }
            }

            if (count == 0)
            {
                return EmptyArray<IFilterMetadata>.Instance;
            }
            else
            {
                var filters = new IFilterMetadata[count];
                var filterIndex = 0;
                for (int i = 0; i < filterItems.Count; i++)
                {
                    var filter = filterItems[i].Filter;
                    if (filter != null)
                    {
                        filters[filterIndex++] = filter;
                    }
                }

                return filters;
            }
        }
Esempio n. 26
0
        public bool Match(FilterProviderContext context)
        {
            int lastLevel = _requireCriteria.Aggregate(0, (prev, c) => c.Level > prev ? c.Level : prev);

            for (int level = 0; level <= lastLevel; level++)
            {
                // Gets criteria results by current level
                var criteria = _requireCriteria.Where(c => c.Level.Equals(level));
                if (!criteria.Count().Equals(0))
                {
                    bool match = criteria.Aggregate(true, (prev, f) => prev ? f.Criteria.Match(context) : prev);

                    // If match exit from loop
                    if (match)
                    {
                        break;
                    }

                    // If not match and this last level, then return false
                    if (level.Equals(lastLevel))
                    {
                        return(false);
                    }
                }
            }

            lastLevel = _excludeCriteria.Aggregate(0, (prev, c) => c.Level > prev ? c.Level : prev);
            for (int level = 0; level <= lastLevel; level++)
            {
                // Gets criteria results by current level
                var criteria = _excludeCriteria.Where(c => c.Level.Equals(level));
                if (!criteria.Count().Equals(0))
                {
                    bool exclude = criteria.Aggregate(true, (prev, f) => prev ? f.Criteria.Match(context) : prev);

                    // If match return false
                    if (exclude)
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Esempio n. 27
0
    /// <inheritdoc />
    public void OnProvidersExecuting(FilterProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
        {
            var results = context.Results;
            // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
            var resultsCount = results.Count;
            for (var i = 0; i < resultsCount; i++)
            {
                ProvideFilter(context, results[i]);
            }
        }
    }
Esempio n. 28
0
        private IFilterMetadata[] GetFilters()
        {
            var context = new FilterProviderContext(
                ActionContext,
                ActionContext.ActionDescriptor.FilterDescriptors.Select(fd => new FilterItem(fd)).ToList());

            foreach (var provider in _filterProviders)
            {
                provider.OnProvidersExecuting(context);
            }

            for (var i = _filterProviders.Count - 1; i >= 0; i--)
            {
                _filterProviders[i].OnProvidersExecuted(context);
            }

            return(context.Results.Select(item => item.Filter).Where(filter => filter != null).ToArray());
        }
Esempio n. 29
0
        /// <inheritdoc />
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            var services = context.ActionContext.HttpContext.RequestServices;
            var filters  = services.GetService <IEnumerable <IFilterMetadata> >();

            if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
            {
                foreach (var filter in filters)
                {
                    var filterItem = new FilterItem(new FilterDescriptor(filter, FilterScope.Global), filter);
                    context.Results.Add(filterItem);
                }
            }
        }
        private List <FilterItem> FetchFilters(FilterProviderContext context)
        {
            lock (locker)
            {
                List <FilterItem> filters;
                if (!ActionFilterMap.TryGetValue(context.ActionContext.ActionDescriptor.DisplayName, out filters))
                {
                    filters = new List <FilterItem>();

                    FilterItem filterItem;

                    // Authorzation is a special case.
                    if (RequiresAuth(context))
                    {
                        filterItem = TypeToFilterItem[_settings.Value.Authorization.Filter];
                        filters.Add(filterItem);
                    }

                    // the following are generic optin and optout
                    foreach (var record in _settings.Value.SimpleMany.OptOut)
                    {
                        var match = record.RouteTree.ContainsMatch(context);
                        if (!match)
                        {
                            filterItem = TypeToFilterItem[record.Filter];
                            filters.Add(filterItem);
                        }
                    }

                    foreach (var record in _settings.Value.SimpleMany.OptIn)
                    {
                        var match = record.RouteTree.ContainsMatch(context);
                        if (match)
                        {
                            filterItem = TypeToFilterItem[record.Filter];
                            filters.Add(filterItem);
                        }
                    }
                    ActionFilterMap.Add(context.ActionContext.ActionDescriptor.DisplayName, filters);
                }
                return(filters);
            }
        }
Esempio n. 31
0
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (context.ActionContext.ActionDescriptor.FilterDescriptors != null)
            {
                var factory = context.ActionContext.HttpContext.RequestServices.GetRequiredService <IFeatureActionFilterFactory <TFeature> >();

                var results = context.Results;
                // Perf: Avoid allocating enumerator and read interface .Count once rather than per iteration
                var resultsCount = results.Count;
                for (var i = 0; i < resultsCount; i++)
                {
                    ProvideFilter(results[i], factory);
                }
            }
        }
 private bool TryFetchAuthFilterItem(FilterProviderContext context, out FilterItem filterItem)
 {
     if (RequiresAuth(context))
     {
         filterItem = TypeToFilterItem[_settings.Value.Authorization.Filter];
         return true;
     }
     filterItem = null;
     return false;
 }
        private List<FilterItem> FetchFilters(FilterProviderContext context)
        {
            lock (locker)
            {
                List<FilterItem> filters;
                if (!ActionFilterMap.TryGetValue(context.ActionContext.ActionDescriptor.DisplayName, out filters))
                {
                    filters = new List<FilterItem>();

                    FilterItem filterItem;

                    // Authorzation is a special case.
                    if (RequiresAuth(context))
                    {
                        filterItem = TypeToFilterItem[_settings.Value.Authorization.Filter];
                        filters.Add(filterItem);
                    }

                    // the following are generic optin and optout
                    foreach (var record in _settings.Value.SimpleMany.OptOut)
                    {
                        var match = record.RouteTree.ContainsMatch(context);
                        if (!match)
                        {
                            filterItem = TypeToFilterItem[record.Filter];
                            filters.Add(filterItem);
                        }
                    }

                    foreach (var record in _settings.Value.SimpleMany.OptIn)
                    {
                        var match = record.RouteTree.ContainsMatch(context);
                        if (match)
                        {
                            filterItem = TypeToFilterItem[record.Filter];
                            filters.Add(filterItem);
                        }
                    }
                    ActionFilterMap.Add(context.ActionContext.ActionDescriptor.DisplayName, filters);
                }
                return filters;
            }
        }
        //all framework providers have negative orders, so ours will come later
        public void OnProvidersExecuting(FilterProviderContext context)
        {
            ControllerActionDescriptor cad = (ControllerActionDescriptor) context.ActionContext.ActionDescriptor;
            System.Diagnostics.Debug.WriteLine("Controller: " + cad.ControllerTypeInfo.FullName);
            System.Diagnostics.Debug.WriteLine("ActionName: " + cad.Name);
            System.Diagnostics.Debug.WriteLine("DisplayName: " + cad.DisplayName);
            System.Diagnostics.Debug.WriteLine("Area: " + context.ActionContext.RouteData.Values["area"]);

            var filters = FetchFilters(context);
            foreach (var filter in filters)
            {
                context.Results.Add(filter);
            }

        }
 public void OnProvidersExecuted(FilterProviderContext context)
 {
 }
 private bool RequiresAuth(FilterProviderContext context)
 {
     return !_settings.Value.Authorization.OptOut.RouteTree.ContainsMatch(context);  
 }