public StateCanExecuteResponse StateCanExecutes(StateCanExecuteRequest request)
{
var result = OperationLogic.GetContextualCanExecute(request.lites, request.operationKeys.Select(BaseOperationRequest.ParseOperationAssert).ToList());
return(new StateCanExecuteResponse {
canExecutes = result.SelectDictionary(a => a.Key, v => v)
});
}
public StateCanExecuteResponse StateCanExecutes(StateCanExecuteRequest request)
{
var types = request.lites.Select(a => a.EntityType).ToHashSet();
var operationSymbols = request.operationKeys
.Select(operationKey => types.Select(t => BaseOperationRequest.ParseOperationAssert(operationKey, t)).Distinct().SingleEx())
.ToList();
var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols);
return(new StateCanExecuteResponse {
canExecutes = result.SelectDictionary(a => a.Key, v => v)
});
}
public StateCanExecuteResponse StateCanExecutes([Required, FromBody] StateCanExecuteRequest request)
{
var types = request.lites.Select(a => a.EntityType).ToHashSet();
var operationSymbols = request.operationKeys
.Select(operationKey => types.Select(t => BaseOperationRequest.ParseOperationAssert(operationKey, t)).Distinct().SingleEx())
.ToList();
var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols) !;
var anyReadonly = AnyReadonly.GetInvocationListTyped().Any(f => f(request.lites));
return(new StateCanExecuteResponse(result.SelectDictionary(a => a.Key, v => v))
{
anyReadonly = anyReadonly
});
}
public Dictionary <OperationSymbol, string> GetContextualCanExecute(IEnumerable <Lite <IEntity> > lite, List <OperationSymbol> operatonSymbols)
{
return(Return(MethodInfo.GetCurrentMethod(), null,
() => OperationLogic.GetContextualCanExecute(lite, operatonSymbols)));
}
public virtual MenuItemBlock ContextualItemsHelper_GetEntityOperationMenuItem(SelectedItemsMenuContext ctx)
{
if (ctx.Lites.IsNullOrEmpty())
{
return(null);
}
if (ctx.Implementations.IsByAll)
{
return(null);
}
var type = ctx.Lites.Select(a => a.EntityType).Distinct().Only();
if (type == null)
{
return(null);
}
var context = (from oi in OperationInfos(type)
where oi.IsEntityOperation
let os = GetSettings <EntityOperationSettingsBase>(type, oi.OperationSymbol)
let osc = os == null ? null :
ctx.Lites.Count == 1 ? os.ContextualUntyped: os.ContextualFromManyUntyped
let coc = newContextualOperationContext.GetInvoker(os?.OverridenType ?? type)(ctx, oi, osc, os)
let defaultBehaviour = oi.Lite == true && (ctx.Lites.Count == 1 || oi.OperationType != OperationType.ConstructorFrom)
where os == null ? defaultBehaviour :
!os.ContextualUntyped.HasIsVisible ? defaultBehaviour && !os.HasIsVisible && (!os.HasClick || os.ContextualUntyped.HasClick) :
os.ContextualUntyped.OnIsVisible(coc)
select coc).ToList();
if (context.IsEmpty())
{
return(null);
}
if (ctx.Lites.Count == 1)
{
if (context.Any(eomi => eomi.OperationInfo.HasCanExecute == true))
{
Dictionary <OperationSymbol, string> canExecutes = OperationLogic.ServiceCanExecute(Database.Retrieve(ctx.Lites.Single()));
foreach (var coc in context)
{
var ce = canExecutes.TryGetC(coc.OperationInfo.OperationSymbol);
if (ce != null)
{
coc.CanExecute = ce;
}
}
}
}
else
{
var cleanKeys = context.Where(cod => cod.CanExecute == null && cod.OperationInfo.HasStates == true)
.Select(kvp => kvp.OperationInfo.OperationSymbol).ToList();
if (cleanKeys.Any())
{
Dictionary <OperationSymbol, string> canExecutes = OperationLogic.GetContextualCanExecute(ctx.Lites, cleanKeys);
foreach (var cod in context)
{
var ce = canExecutes.TryGetC(cod.OperationInfo.OperationSymbol);
if (ce.HasText())
{
cod.CanExecute = ce;
}
}
}
}
List <IMenuItem> menuItems = context
.Where(coc => !coc.HideOnCanExecute || coc.CanExecute == null)
.Select(coc => CreateContextual(coc, DefaultEntityClick))
.OrderBy(a => a.Order).Cast <IMenuItem>().ToList();
if (menuItems.IsEmpty())
{
return(null);
}
return(new MenuItemBlock {
Header = SearchMessage.Operation.NiceToString(), Items = menuItems
});
}
