Esempio n. 1
0
        /// <summary>
        /// Ação antes da action executar.
        /// Atribui o protocolo do header da requisição .
        /// Atribui também ao comando, quando houver.
        /// Garante também que um comando não chegue nulo à action.
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            InitializeProtocol(context.HttpContext.Request);

            var keys = context.ActionArguments.Keys.ToList();

            foreach (string key in keys)
            {
                object paramValue = context.ActionArguments[key];

                Microsoft.AspNetCore.Mvc.Abstractions.ParameterDescriptor paramDescriptor = context.ActionDescriptor.Parameters.Where(it => it.Name == key).FirstOrDefault();

                if (!paramDescriptor.ParameterType.IsSubclassOfRawGeneric(typeof(BaseCommand <>)))
                {
                    continue;
                }

                if (paramValue == null)
                {
                    paramValue = Activator.CreateInstance(paramDescriptor.ParameterType);
                    context.ActionArguments[key] = paramValue;
                }

                ConfigureProtocolForCommand(context, paramValue);
                ConfigureAuthorizationForCommand(context, paramValue);
                ConfigureAuthorizationUserForCommand(context, paramValue);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Ocorre antes da action ser executada. Percorre os parâmetros da action e verifica se há algum comando inválido.
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (context.ActionArguments.Any())
            {
                foreach (KeyValuePair <string, object> kvp in context.ActionArguments)
                {
                    if (kvp.Value != null && kvp.Value.GetType().IsSubclassOfRawGeneric(typeof(BaseCommand <>)))
                    {
                        ExecuteValidationInArgument(context, kvp.Value);
                    }
                }
            }
            else
            {
                // Esse caso acontece quando um valor passado não pode ser convertido para a propriedade adequada pelo ModelBinder. Quando isso acontece, o parametro da action fica nulo, o que quebra o padrao da arquitetura
                // Então, quando for detectado que não há um argumento para a action, mas ela espera um command, criamos uma instancia vazia para receber os erros de validação e retornar no padrão da arquitetura
                if (context.ActionDescriptor.Parameters.Any() && !context.ModelState.IsValid)
                {
                    Microsoft.AspNetCore.Mvc.Abstractions.ParameterDescriptor paramDescriptor = context.ActionDescriptor.Parameters
                                                                                                .FirstOrDefault(it => it.ParameterType.IsSubclassOfRawGeneric(typeof(BaseCommand <>)));

                    if (paramDescriptor == null)
                    {
                        return;
                    }

                    object request = Activator.CreateInstance(paramDescriptor.ParameterType);
                    context.ActionArguments.Add(paramDescriptor.Name, request);
                    ExecuteValidationInArgument(context, request);
                }
            }
        }