public AlgorithmMessage UpdateAlgorithmMessage(AlgorithmMessage message)
{
return(ExecuteFaultHandledOperation(() =>
{
IAlgorithmInstanceRepository algorithmInstanceRepository = _DataRepositoryFactory.GetDataRepository <IAlgorithmInstanceRepository>();
AlgorithmInstance instance = algorithmInstanceRepository.Get(message.AlgorithmInstanceID);
if (instance == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No algorithm instance found for instanceId '{0}'.", message.AlgorithmInstanceID));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
IAlgorithmMessageRepository messageRepository = _DataRepositoryFactory.GetDataRepository <IAlgorithmMessageRepository>();
AlgorithmMessage updatedEntity = null;
if (message.AlgorithmMessageID == 0)
{
updatedEntity = messageRepository.Add(message);
}
else
{
updatedEntity = messageRepository.Update(message);
}
return updatedEntity;
}));
}
public AlgorithmInstance UpdateAlgorithmInstance(AlgorithmInstance instance)
{
WithStrategyClient(strategyClient =>
{
_algorithmInstanceResult = strategyClient.UpdateAlgorithmInstance(instance);
});
return(_algorithmInstanceResult);
}
public async Task <AlgorithmInstance> UpdateAlgorithmInstanceAsync(AlgorithmInstance instance)
{
await WithStrategyClientAsync(async strategyClient =>
{
_algorithmInstanceResult = await strategyClient.UpdateAlgorithmInstanceAsync(instance);
});
return(_algorithmInstanceResult);
}
public virtual async Task <bool> Initialize(int strategyId)
{
try
{
AddAlgorithmMessage(string.Format("{0} is starting ...", _shortClassName), true, TraceEventType.Start);
if (strategyId <= 0)
{
throw new ArgumentException("StrategyId may not be less than or equal to 0.");
}
if (_logger == null)
{
_logger = ObjectBase.Container.GetExportedValue <IEventLogger>();
}
MetadataCaller.Instance().ClearCache();
Strategy strategy = StrategyCaller.Instance().GetStrategy(strategyId);
if (strategy == null)
{
throw new ArgumentException(string.Format("Strategy not found for strategyId {0}.", strategyId));
}
_strategy = strategy;
_shortClassName = _strategy.Name.Split('.').ToList().Last();
Parameters = new AlgorithmParameters(await StrategyCaller.Instance().GetAlgorithmParametersAsync(_strategy.StrategyID));
// create and save instance
_instance = new AlgorithmInstance()
{
StrategyID = strategyId, Status = (short?)AlgorithmStatus.NotRunning
};
await UpdateAlgorithmInstance();
_messages = new ObservableCollection <AlgorithmMessage>();
// hook up event handlers
Messages.CollectionChanged += OnAlgorithmMessageChanged;
_suspended = () => { return(_instance.Status == (short?)AlgorithmStatus.RunningSuspended); };
AddAlgorithmMessage(string.Format("{0} is initialized.", _shortClassName), true, TraceEventType.Start);
}
catch (Exception e)
{
Exception ex = new Exception(string.Format("Algorithm for strategyId: {0} failed to initialize.", strategyId), e);
AddAlgorithmException(ex).Wait();
return(false);
}
return(true);
}
public AlgorithmInstance UpdateAlgorithmInstance(AlgorithmInstance instance)
{
return(ExecuteFaultHandledOperation(() =>
{
AlgorithmInstance updatedEntity = null;
Strategy strategy = GetStrategy(instance.StrategyID);
if (strategy != null)
{
IAlgorithmInstanceRepository algorithmInstanceRepository = _DataRepositoryFactory.GetDataRepository <IAlgorithmInstanceRepository>();
if (instance.AlgorithmInstanceID == 0)
{
updatedEntity = algorithmInstanceRepository.Add(instance);
}
else
{
updatedEntity = algorithmInstanceRepository.Update(instance);
}
}
return updatedEntity;
}));
}
public AlgorithmInstance UpdateAlgorithmInstance(AlgorithmInstance instance)
{
return(Channel.UpdateAlgorithmInstance(instance));
}
public Task <AlgorithmInstance> UpdateAlgorithmInstanceAsync(AlgorithmInstance instance)
{
return(Channel.UpdateAlgorithmInstanceAsync(instance));
}
private async Task UpdateAlgorithmInstance()
{
_instance = await StrategyCaller.Instance().UpdateAlgorithmInstanceAsync(_instance);
}
