public static IOperationBuilder WithPreventRepetitiveExecutions(
this IOperationBuilder operationBuilder)
{
return(operationBuilder
.WithCondition(new PreventRepetitiveExecutionsCondition())
.WithNotification(new PreventRepetitiveExecutionsNotification()));
}
public static IOperationBuilder WithBusyNotification(
this IOperationBuilder builder,
int delay = 100,
int minDuration = 1000,
bool isCancellable = false)
{
return(builder.WithNotification(new BusyOperationNotification(delay, minDuration, isCancellable)));
}
public static IOperationBuilder WithRefreshNotification(
this IOperationBuilder builder,
int delay = 0,
int minDuration = 0,
bool isCancellable = false)
{
return(builder.WithNotification(new RefreshOperationNotification(delay, minDuration, isCancellable)));
}
public Scaffolder(GeneratorContext generatorContext,
IOperationBuilder operationBuilder, IOperationExecutor operationExecutor, IConfigurationResolver configurationResolver)
{
_generatorContext = generatorContext;
_operationBuilder = operationBuilder;
_operationExecutor = operationExecutor;
_configurationResolver = configurationResolver;
}
public static IOperationBuilder WithLoadingNotification(
this IOperationBuilder operationBuilder,
int delay = 0,
int duration = 0,
bool isCancellable = false)
{
return(operationBuilder
.WithNotification(new LoadingOperationNotification(delay, duration, isCancellable)));
}
void IOperationInitializer.InitializeOperation(IOperationBuilder operationBuilder)
{
var operationName = operationBuilder.Name;
if (_operationBuilderDictionary.ContainsKey(operationName))
{
this.Log().Warn($"操作-{operationName}-已存在");
return;
}
_operationBuilderDictionary.Add(operationName, operationBuilder);
}
public override void AppendToOperation(IOperationBuilder operationBuilder)
{
var builder = (MudLikeOperationBuilder)operationBuilder;
if (TargetEntities.Count == 0)
{
return;
}
builder
.StartContainer("action");
foreach (var target in TargetEntities)
{
var primaryAffectedStat = Modifiers.FirstOrDefault();
if (primaryAffectedStat == null)
{
continue;
}
var elementInfo = Element.GetRange(primaryAffectedStat.Value);
// dude's actionName hits target for # statname
builder.AddText($"{SourceEntity.Name}'s ")
.AddText($"{Name}", Element.TextColor)
.AddText($" {elementInfo.Text}", elementInfo.TextColor)
.AddText($" {target.Name} for ")
.AddTextLine($" {Math.Abs(primaryAffectedStat.Value)}", TextColor.Red)
// .AddText(" for ")
// .AddTextLine($" {Math.Abs(primaryAffectedStat.Value)}", elementInfo.TextColor)
;
}
// .AddText($"{DamageDone}", TextColor.Red)
// .AddTextLine(" damage")
builder.EndContainer("action");
//return $"{SourceEntity?.Name} spit on {TargetEntity?.Name} for {_damageDone}";
}
public static IOperationResultBuilder <Void> WithExpression(
[NotNull] this IOperationBuilder operationBuilder,
[NotNull] Action expression)
{
if (operationBuilder == null)
{
throw new ArgumentNullException(nameof(operationBuilder));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
return(operationBuilder.WithExpression(() =>
{
expression();
return default(Void);
}));
}
public static IOperationResultBuilder <Void> WithExpressionAsync(
[NotNull] this IOperationBuilder operationBuilder,
[NotNull] Func <CancellationToken, Task> expression)
{
if (operationBuilder == null)
{
throw new ArgumentNullException(nameof(operationBuilder));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
return(operationBuilder.WithExpressionAsync(async cancellationToken =>
{
await expression(cancellationToken).NotNull();
return default(Void);
}));
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected OperationProvider(IOperationBuilder <Action <IDatabase, DbCommand, TOperationArg> > builder) : base(builder)
{
}
public virtual void AppendToOperation(IOperationBuilder operationBuilder)
{
}
public static IReturnTypeBuilder WithParameters(this IOperationBuilder builder, params Func <MBeanParameterInfo>[] parameters)
{
return(builder.WithParameters(() => parameters.Select(x => x())));
}
public PropertyQuery(IOperationBuilder <PropertyQuery> builder, int propertyId) : base(builder)
{
PropertyId = propertyId;
}
public TypeQuery(IOperationBuilder <TypeQuery> builder, string name) : base(builder)
{
Name = name;
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected OperationProvider(IOperationBuilder <Func <IDatabase, DbCommand, TOperationArg, TResult> > builder) : base(builder)
{
}
public static IOperationBuilder WithInternetConnectionCondition(
this IOperationBuilder operationBuilder)
{
return(operationBuilder
.WithCondition(new InternetConnectionCondition()));
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected BuildableOperationProvider(IOperationBuilder <TInvoker> builder)
{
_builder = builder;
}
public void Push(IOperationBuilder operationBuilder)
{
if (preParam == null && operationBuilder.Definition.Type == OperationType.Operator &&
((operationBuilder.Definition.ParameterOrder & ParameterOrder.LeftRight) == ParameterOrder.LeftRight || (operationBuilder.Definition.ParameterOrder & ParameterOrder.Left) == ParameterOrder.Left))
{
throw new Exception("there must be expression or number");
}
if (operationBuilder.IsEnoughParameters)
{
Push(new CalculableExpression(operationBuilder.Build()));
return;
}
if (preParam == null && operationBuilder.Definition.Type == OperationType.Operator)
{
if ((!stack.Any() || stack.First().Definition.Type != OperationType.Agregator) && (operationBuilder.Definition.ParameterOrder & ParameterOrder.Right) == ParameterOrder.Right)
{
throw new OpenedUnarOperatorException(operationBuilder.Definition);
}
if ((operationBuilder.Definition.ParameterOrder & ParameterOrder.Right) != ParameterOrder.Right)
{
throw new Exception("there is no appropriate unar operator");
}
if (operationBuilder.Definition.Token == "-" || operationBuilder.Definition.Token == "+")
{
operationBuilder.PushParameter(new SimpleExpression(0));
}
}
while (preParam != null && operationBuilder.Definition.Type == OperationType.Operator)
{
if (!stack.Any())
{
operationBuilder.PushParameter(preParam);
preParam = null;
}
else
{
var first = stack.First();
if (first.Definition.Type == OperationType.Agregator || comparer.IsLess(first.Definition, operationBuilder.Definition) || operationBuilder.Definition.Associativity == Associativity.Right)
{
operationBuilder.PushParameter(preParam);
preParam = null;
}
else
{
first.PushParameter(preParam);
preParam = null;
if (first.IsEnoughParameters && !comparer.IsLess(first.Definition, operationBuilder.Definition))
{
var item = stack.Pop();
preParam = new CalculableExpression(item.Build());
}
}
}
}
stack.Push(operationBuilder);
}
/// <summary>
///
/// </summary>
protected CommonDeleteOperationBuilder()
{
builder = new Normal();
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected TransactionalOperationProvider(IOperationBuilder <Action <IDatabase, DbCommand, TOperationArgElement> > builder) : base(builder)
{
}
/// <summary>
///
/// </summary>
/// <param name="quote"></param>
/// <param name="buildParameter"></param>
protected CommonDeleteOperationBuilder(Func <string, string> quote, Func <string, string> buildParameter)
{
builder = new Optmized(quote, buildParameter);
}
public void RegisterOperation <T>(IOperationBuilder builder) where T : IOperation
{
RegisterOperation(typeof(T), builder);
}
public static IOperationBuilder WhenConnectedToInternet(this IOperationBuilder builder)
{
return(builder.WithCondition(new InternetConnectionOperationCondition()));
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected TransactionalOperationProvider(IOperationBuilder <Func <IDatabase, DbCommand, TOperationArg, TResultElement> > builder) : base(builder)
{
}
public static IOperationBuilder WithLoadingNotification(
this IOperationBuilder operationBuilder)
{
return(operationBuilder
.WithNotification(new LoadingNotification(0, 0, false)));
}
protected OperationBase(IOperationBuilder builder)
{
_graphQL = new Lazy <string>(builder.ToGraphQL);
}
public void RegisterOperation(Type operationType, IOperationBuilder builder)
{
_registeredOperations.Add(operationType, builder);
}
