protected override void Execute(
IExecutionService executionService
)
{
if (Status == Status.NotExecuted)
{
ChangeStatus(
executionService,
Status.Executing);
var children = Definition.As <Definition.SequenceBase>().NewChildren(this).ToList();
Children = children;
children.ForEach(executionService.Save);
}
if (Status == Status.Executing)
{
var current = Children.FirstOrDefault(child => child.Status != Status.Executed);
if (current == null)
{
ChangeStatus(
executionService,
Status.Executed);
}
else if (current.Status == Status.NotExecuted)
{
executionService.Execute(current);
}
}
}
private void Reset(long _)
{
_analyticsService.Reset();
_tradeRepository.Reset();
// make 3 trades
// eurusd
// gbpusd
// nzdusd
foreach (var ccyPair in new [] { "EURUSD", "GBPUSD", "NZDUSD" })
{
try
{
var price = _priceLastValueCache.GetLastValue(ccyPair);
var trade = new TradeRequestDto()
{
DealtCurrency = "EUR",
Direction = DirectionDto.Buy,
Notional = 500000,
SpotRate = price.Bid,
Symbol = ccyPair,
ValueDate = DateTime.Now.ToNextWeekday(2)
};
_executionService.Execute(trade, "CPU-007").Wait(TimeSpan.FromSeconds(10));
}
catch
{
// swallow exception
}
}
}
/// <summary>
/// Executes the reference upon its parent package. Descendants can change this
/// behavior if something needs to be done before or after execution.
/// </summary>
/// <returns>An <see cref="ExecutionResult"/> that represents the result of the execution of the recipe.</returns>
protected override ExecutionResult OnExecute()
{
IExecutionService executor = (IExecutionService)
ServiceHelper.GetService(this, typeof(IExecutionService));
return(executor.Execute(this));
}
protected virtual void ChangeStatus(
IExecutionService executionService,
Status status
)
{
var previousStatus = Status;
Status = status;
if (Status != previousStatus)
{
switch (Status)
{
case Status.Executing:
OnExecuting(executionService);
break;
case Status.Executed:
OnExecuted(executionService);
if (Parent != null)
{
executionService.Execute(Parent);
}
break;
default: break;
}
}
}
public Task <TradeDto> Execute(TradeRequestDto tradeRequest)
{
var user = ContextUtil.GetUserName(Context);
Log.InfoFormat("Received trade request {0} from user {1}", tradeRequest, user);
var trade = _executionService.Execute(tradeRequest, user);
Log.InfoFormat("Trade executed: {0}", trade);
return(trade);
}
protected override void Execute(
IExecutionService executionService
)
{
var definition = Definition.As <Definition.GuardedProcess>();
if (Status == Status.NotExecuted)
{
if (definition.GuardExpression == null ||
definition.GuardExpression(this))
{
ChangeStatus(
executionService,
Status.AwaitChoice);
Guard = (IO)definition.Guard.New(this);
executionService.Save(Guard);
((IExecutable)Guard).Execute(executionService);
}
else
{
ChangeStatus(
executionService,
Status.NotChosen);
}
}
if (Status == Status.Executing)
{
if (definition.Guarded != null)
{
if (Guarded == null)
{
Guarded = definition.Guarded.New(this);
executionService.Save(Guarded);
executionService.Execute(Guarded);
}
if (Guarded.Status == Status.Executed)
{
ChangeStatus(
executionService,
Status.Executed);
}
}
else
{
ChangeStatus(
executionService,
Status.Executed);
}
}
}
private void HandleNlpRequestMessage(IMessage message)
{
var request = (NlpRequestMessage)message;
Console.WriteLine("Got a ! Text=" + request.Text);
// use SimpleParser or Chatbot to get FFO
Intent intent = RequestToSimpleParserOrChatbot(request.Text);
//RequestToExecutionEngine(intents, request.Metadata.RequestUserInfo);
ICommand command = ConvertIntentToCommand(intent);
_executionService.Execute(command, request.Metadata);
}
public IActionResult Run(Guid id)
{
using (_databaseContextFactory.Create())
{
var test = _testRepository.Get(id);
var executionContext = _executionService.Execute(test.FormulaId, test.ArgumentValues(), new ContextLogger(ContextLogLevel.Verbose));
var result = executionContext.GetResult();
return(Ok(new
{
Passed = _valueComparer.IsSatisfiedBy(test.ExpectedResultDataTypeName, test.ExpectedResult, "==", result.ToString(CultureInfo.InvariantCulture)),
Exception = executionContext.Exception.AllMessages(),
Result = result,
LogLines = executionContext.Logger.Lines,
Results = executionContext.GetResults()
}));
}
}
public void ProcessMessage(IHandlerContext <ExecuteTestCommand> context)
{
if (string.IsNullOrEmpty(context.TransportMessage.SenderInboxWorkQueueUri))
{
return;
}
var message = context.Message;
if (!Enum.TryParse(message.LogLevel, true, out ContextLogLevel logLevel))
{
logLevel = ContextLogLevel.None;
}
using (_databaseContextFactory.Create())
{
var test = _testRepository.Get(message.Id);
var executionContext = _executionService
.Execute(message.Id, test.ArgumentValues(), new ContextLogger(logLevel));
var response = new TestExecutedEvent
{
Id = test.Id,
FormulaId = test.FormulaId,
Log = executionContext.Logger.ToString()
};
if (!executionContext.HasException)
{
response.Exception = executionContext.Exception.Message;
response.FormulaContext = new Messages.v1.TransferObjects.FormulaContext();
response.FormulaContext = GetFormulaContext(executionContext.RootFormulaContext);
}
else
{
response.Result = executionContext.GetResult();
}
context.Send(response, c => c.Reply());
}
}
protected override void Execute(
IExecutionService executionService
)
{
if (Status == Status.NotExecuted)
{
ChangeStatus(
executionService,
Status.Executing);
}
if (Status == Status.Executing)
{
if (Embedded != null &&
Embedded.Status == Status.Executed)
{
Embedded = null;
}
var definition = Definition.As <Definition.While>();
if (Embedded == null &&
definition.BooleanExpression(this))
{
Embedded = definition.Embedded.New(this);
executionService.Execute(Embedded);
}
if (Embedded == null)
{
ChangeStatus(
executionService,
Status.Executed);
}
}
}
public ActionResult <IEnumerable <string> > TestSyncWithoutContext()
{
executionService.Execute(ProcessExamplesEnum.Process1, () => TestMethod());
return(Ok());
}
