public bool Run(TimeSpan tCurrentTime, bool tManageCamera = false)
{
bool ret = StartTime.TotalMilliseconds <= tCurrentTime.TotalMilliseconds && tCurrentTime.TotalMilliseconds <= EndTime.TotalMilliseconds;
if (ret)
{
if (_executionCount < 2)
{
_executionCount += 1;
}
if (_setSpeed)
{
CalculateCurrentSpeed();
}
if (_setFloat)
{
CalculateCurrentFloat();
}
if (tManageCamera && IsSettingCamera && !_disableUpdate)
{
PlaceCamera();
}
OnExecute?.Invoke(this);
}
return(ret);
}
public virtual void Schedule(ushort step)
{
if (Trigger(step))
{
OnExecute?.Invoke(this, null);
}
}
public void Execute()
{
try
{
if (!Api.IsAuthorized)
{
Auth();
}
OnExecute?.Invoke();
}
catch (Exception e)
{
if (e is AccessTokenInvalidException)
{
Logger.Error("Trying to renew token...");
Auth();
OnExecute?.Invoke();
}
else
{
Logger.Error(e);
}
}
}
/// <summary>
/// Logic to determine when to execute the actions tied to this processor.
/// </summary>
public bool Process(T t)
{
if (IsFulfilled(t))
{
OnExecute?.Invoke(t);
return(true);
}
return(false);
}
public void Execute(object parameter = default)
{
Parameter = parameter.Cast <TParameter>();
Result = _execute.Invoke(Parameter, Result);
History.Snapshot(ToSnapShot());
Result = default;
OnExecute?.Invoke(Parameter);
Parameter = default;
}
public Specter Execute(string code, string filename, IEnumerable <string> args)
{
Filename = filename;
Arguments = args;
OnExecute?.Invoke();
engine.Execute(filename, code);
return(this);
}
private void ExecuteProc()
{
try
{
OnExecute?.Invoke(m_client);
OnCompleted?.Invoke(m_client);
}
catch (Exception)
{
OnCompleted?.Invoke(m_client);
}
}
private void InnerWork()
{
_lock.Wait();
for (int i = 0; i < _stubCounter; i++)
{
Thread.Sleep(Random.Get(max: 1200));
_lock.Wait();
OnExecute?.Invoke(Id);
}
_lock.Wait();
Thread.Sleep(Random.Get(max: 1200));
OnComplete?.Invoke(Id);
}
/// <summary>
/// Starts the Task with the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="interval">The interval.</param>
/// <returns></returns>
private async Task Start(CancellationToken token, int interval)
{
while (true)
{
if (token.IsCancellationRequested)
{
break;
}
OnExecute?.Invoke();
await Task.Delay(interval, token);
}
}
public Task ExecuteAsync(QueryContext query)
{
if (OnExecute != null)
{
OnExecute.Invoke(query);
return(Task.CompletedTask);
}
if (OnExecuteAsync != null)
{
return(OnExecuteAsync.Invoke(query));
}
return(Task.CompletedTask);
}
public void Execute(object parameter = default)
{
Parameters = parameter.Cast <TParameter>();
Result = this._execute(Parameters, Result).Cast <TResult>();
ICommandWithUndoRedo.AddInUndo(this.Clone() as ICommandWithUndoRedo);
ICommandWithUndoRedo.StackRedo.Clear();
Result = default(TResult);
Parameters = default(TParameter);
OnExecute?.Invoke();
}
// TODO Kill generator if any part of execution fails?
public void Execute()
{
List <UserMoneyTransfer> transfersToExecute;
lock (_locker)
{
transfersToExecute = new List <UserMoneyTransfer>(_openTransfers);
_openTransfers.Clear();
OnExecute?.Invoke(this, new EventArgs());
}
var groups = transfersToExecute.GroupBy(transfer => new { transfer.UserId, transfer.UserAccount, transfer.Currency }).ToList();
foreach (var group in groups)
{
var taskData = new UserMoneyTransferTask
{
Amount = group.Sum(transfer => transfer.Amount),
Currency = group.Key.Currency,
Status = UserMoneyTransferTaskStatus.Open,
UserId = group.Key.UserId,
UserAccount = group.Key.UserAccount,
Transfers = group.ToList()
};
using (var scope = new TransactionScope())
{
_dalTask.Insert(taskData);
taskData.Transfers.ForEach(transfer => _dalTransfer.UpdateStatus(transfer, UserMoneyTransferStatus.Tasked));
scope.Complete();
}
new Tasks.UserMoneyTransferTask(_dependencyFactory, _engine, taskData).Enqueue();
}
}
internal override void OnCommand(ICommandArgs command)
{
OnExecute?.Invoke(command);
}
public void Execute()
{
executed = true;
orderAction.Invoke(Target);
OnExecute?.Invoke();
}
public Task <ExecutionResult> ExecuteCodeAsync(string text)
{
OnExecute?.Invoke(this, text);
return(Task.FromResult(ExecutionResult.Success));
}
public void ExecuteAction(EventArgs e)
{
btnExecute.Enabled = false;
OnExecute?.Invoke(this, e);
btnExecute.Enabled = true;
}
public async Task Execute(PageAction pageAction, IEnumerable <ImageEntity> images, UserEntity user,
SettingEntity settings, CancellationToken ct)
{
try
{
foreach (var image in images)
{
try
{
OnStartExecuted.Invoke(image, pageAction);
image.ImageState = ImageState.InProcesses;
var pageContext = new ImageContext {
User = user, Settings = settings
};
foreach (var page in _pages.Where(a => a.Action == pageAction).OrderBy(a => a.Order))
{
if (ct.IsCancellationRequested)
{
break;
}
await page.ExecuteAsync(image, pageContext, ct);
if (page.GetImageState(image) == ImageState.Failed)
{
_logger.LogWarning(string.Format(LogTemplate, page.Order, page.Action));
break;
}
_logger.LogStep(page.Action.ToString(), image.ImagePath, page.Order.ToString());
OnStateChanged.Invoke(image.ImageState, image.Id);
await Task.Delay(TimeSpan.FromSeconds(2), ct); // to simulate user action
}
await _repository.AddOrUpdateAsync(image, ct);
OnExecute.Invoke(image, pageAction);
await Task.Delay(TimeSpan.FromSeconds(settings.WaitingBetweenUploadingImage), ct);
}
catch (TaskCanceledException)
{
break;
}
catch (Exception ex)
{
_logger.LogWarning(ex.Message);
image.ImageState = ImageState.Failed;
}
}
if (images.Any(entity => entity.ImageState == ImageState.Failed) &&
_retryCount < settings.RetryCount)
{
_retryCount++;
await Execute(pageAction, user.Images !.Where(entity => entity.ImageState == ImageState.Failed),
user, settings, ct);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
if (_retryCount > settings.RetryCount)
{
throw;
}
}
}
private void ExecuteCommand(object sender, EventArgs e)
{
OnExecute?.Invoke(Type);
}
public void Trigger(IGraphFlow flow)
{
OnExecute?.Invoke();
}
protected virtual void Execute()
{
OnExecute?.Invoke(this, null);
}
public override void Execute(params string[] args)
{
OnExecute?.Invoke(args);
}
public void Execute()
{
OnExecute?.Invoke();
}
public void Execute(object parameter)
{
OnExecute?.Invoke(this, parameter);
}
public void Execute(object parameter = null)
{
OnExecute?.Invoke(parameter);
}
public void OnCommandExecute(CommandArguments cmdArgs)
{
OnExecute?.Invoke(cmdArgs);
}
public void Execute(TSender sender, TEventArgs eventArgs)
{
OnExecute?.Invoke(sender, eventArgs);
}
public override void Execute(object parameter)
{
OnExecute?.Invoke();
Action?.Invoke((T)parameter);
}
public void Execute(EventArgs args) => OnExecute?.Invoke(args);
