public static IActionResult ProduceErrorResponse(ActionContext context)
        {
            var errors   = context.ModelState.SelectMany(x => x.Value.Errors).Select(m => m.ErrorMessage).ToList();
            var response = new ErrorResources(errors);

            return(new BadRequestObjectResult(response));
        }
        /// <inheritdoc/>
        public virtual void DeriveWantAction <TFactRule, TFactRuleCollection, TWantAction, TFactContainer>(List <DeriveWantActionRequest <TFactRule, TFactRuleCollection, TWantAction, TFactContainer> > requests)
            where TFactRule : IFactRule
            where TFactRuleCollection : IFactRuleCollection <TFactRule>
            where TWantAction : IWantAction
            where TFactContainer : IFactContainer
        {
            Validate(requests);

            var treesByActions     = new Dictionary <WantActionInfo <TWantAction, TFactContainer>, List <TreeByFactRule <TFactRule, TWantAction, TFactContainer> > >();
            var deriveErrorDetails = new List <DeriveErrorDetail>();


            foreach (DeriveWantActionRequest <TFactRule, TFactRuleCollection, TWantAction, TFactContainer> request in requests)
            {
                var context = request.Context;

                if (!context.WantAction.Option.HasFlag(FactWorkOption.CanExecuteSync))
                {
                    deriveErrorDetails.Add(new DeriveErrorDetail(
                                               ErrorCode.InvalidOperation,
                                               ErrorResources.OnWantActionCannotBePerformedSynchronously(context.WantAction),
                                               context.WantAction,
                                               context.Container,
                                               null));
                    continue;
                }

                var requestForAction = new BuildTreesForWantActionRequest <TFactRule, TWantAction, TFactContainer>
                {
                    Context   = context,
                    FactRules = request
                                .Rules
                                .FindAll(factRule => factRule.Option.HasFlag(FactWorkOption.CanExecuteSync))
                                .SortByDescending(r => r, context.SingleEntity.GetRuleComparer <TFactRule, TWantAction, TFactContainer>(context)),
                };

                if (context.TreeBuilding.TryBuildTreesForWantAction(requestForAction, out var resultForAction))
                {
                    treesByActions.Add(resultForAction.WantActionInfo, resultForAction.TreesResult);
                }
                else
                {
                    deriveErrorDetails.Add(resultForAction.DeriveErrorDetail);
                }
            }

            // Check that we were able to adequately build the tree.
            if (deriveErrorDetails.Count != 0)
            {
                throw CommonHelper.CreateDeriveException(deriveErrorDetails);
            }

            foreach (var item in treesByActions)
            {
                item.Key.Context.TreeBuilding.CalculateTreeAndDeriveWantFacts(item.Key, item.Value);
            }
        }