protected async override void OnPublished(object data)
{
IsBusy = true;
base.OnPublished(data);
try
{
IsLoading = true;
var strategies = await strategyService.GetStrategies().ConfigureAwait(true);
Strategies.Clear();
strategies.ForEach(s => Strategies.Add(s));
}
catch (Exception ex)
{
ShowMessage(new Message {
MessageType = MessageType.Error, Text = ex.Message
});
}
finally
{
IsLoading = false;
IsBusy = false;
}
}
private async void AddStrategy(object param)
{
if (param == null ||
string.IsNullOrEmpty(param.ToString()))
{
return;
}
var strategyName = param.ToString();
if (Strategies.Any(s => s.Name.Equals(strategyName)))
{
ShowMessage(new Message {
MessageType = MessageType.Info, Text = $"A strategy with the name {strategyName} already exists."
});
return;
}
try
{
var strategy = new Strategy {
Name = strategyName
};
await strategyService.SaveStrategy(strategy);
Strategies.Add(strategy);
Module.AddStrategy(strategy.Name);
}
catch (Exception ex)
{
ShowMessage(new Message {
MessageType = MessageType.Error, Text = ex.Message
});
}
}
public RacePreviewModel(Race race, Track track, List <Trait> traits, List <Strategy> strategies, List <SeasonTeam> favourites)
{
Race = race;
Track = track;
if (traits != null)
{
foreach (var trait in traits)
{
TrackTraits.Add(trait);
}
}
if (strategies != null)
{
foreach (var strat in strategies)
{
Strategies.Add(strat);
}
}
if (favourites != null)
{
foreach (var team in favourites)
{
Favourites.Add(team);
}
}
}
public override void AddedToFieldHook()
{
base.AddedToFieldHook();
//Strategies used within the Spawner
Strategies.Add(new EveryNActs(this, SpawnCallback, interval: 150));
//Strategies.Add(new EveryNPercent(this, SpawnCallback, percent: 1));
}
public void Add(StrategyBase strategy)
{
if (Strategies.Contains(strategy))
{
return;
}
strategy.Manager = this;
Strategies.Add(strategy);
}
public TGCObjLoader()
{
Strategies.Add(new AddShadowStrategy());
Strategies.Add(new AddUsemtlStrategy());
Strategies.Add(new CreateNewMeshStrategy());
Strategies.Add(new CreateNormalStrategy());
Strategies.Add(new CreateFaceStrategy());
Strategies.Add(new CreateTextCoordStrategy());
Strategies.Add(new CreateVertexStrategy());
Strategies.Add(new NoOperationStrategy());
}
public InstrumentStrategyHelper GetInstrumentStrategyHelper(Instrument instrument, SmartQuant.Strategy strategy)
{
InstrumentStrategyHelper value;
if (!Strategies.TryGetValue(instrument.Id, out value))
{
value = new InstrumentStrategyHelper(framework, strategy, instrument);
value.OpenCloseHelper = OpenCloseHelper;
Strategies.Add(instrument.Id, value);
}
return(value);
}
public MainWindowContext()
{
var serializer = new XmlSerializer(typeof(Event));
foreach (var file in Directory.EnumerateFiles("Events", "*.xml"))
{
using (var reader = new StreamReader(file))
{
var e = (Event)serializer.Deserialize(reader);
Events.Add(e);
}
}
Strategies.Add(new OptimalStrategy());
}
public void Add(Strategy strategy)
{
if (strategy == null)
{
return;
}
lock (locker)
{
if (Strategies.ContainsKey(strategy.Key))
{
Strategies.Remove(strategy.Key);
}
Strategies.Add(strategy.Key, strategy);
}
}
public override void Refresh()
{
Context.Trades
.Include(x => x.Strategy)
.OrderByDescending(x => x.DateOpened)
.Load();
//populate Strategies, used in combobox strategy selector
Strategies.Clear();
var strats = Context.Strategies.OrderBy(x => x.Name).ToList();
foreach (Strategy s in strats)
{
Strategies.Add(s);
}
TradesSource.View.Refresh();
}
public override void Refresh()
{
//tags
var selectedTags = Tags
.Where(x => x.IsChecked)
.Select(x => x.Item)
.ToList();
Tags.Clear();
foreach (var checkItem in Context
.Tags
.OrderBy(x => x.Name)
.ToList()
.Select(x => new CheckListItem <Tag>(x, selectedTags.Contains(x))))
{
Tags.Add(checkItem);
}
//strategies
var selectedStrats = Strategies
.Where(x => x.IsChecked)
.Select(x => x.Item)
.ToList();
Strategies.Clear();
foreach (var checkItem in Context
.Strategies
.OrderBy(x => x.Name)
.ToList()
.Select(x => new CheckListItem <Strategy>(x, selectedStrats.Contains(x))))
{
Strategies.Add(checkItem);
}
//benchmarks
Benchmarks.Clear();
foreach (Benchmark b in Context.Benchmarks.OrderBy(x => x.Name))
{
Benchmarks.Add(b);
}
}
public void Add <T1, T2>(Strategy strategy)
{
if (strategy == null)
{
return;
}
lock (locker)
{
var pair = GetPairKey <T1, T2>();
if (pair != null)
{
var kkey = pair.Value.Key;
var vkey = pair.Value.Value;
Strategies.Remove(vkey);
Keys.Remove(kkey);
}
Strategies.Add(strategy.Key, strategy);
Keys.Add(TypePair.Create <T1, T2>(), strategy.Key);
}
}
private async void AddStrategy(object param)
{
if (param == null ||
string.IsNullOrEmpty(param.ToString()))
{
return;
}
var strategyName = param.ToString();
if (Strategies.Any(s => s.Name.Equals(strategyName, StringComparison.Ordinal)))
{
ShowMessage(new Message {
MessageType = MessageType.Info, Text = $"A strategy with the name {strategyName} already exists."
});
return;
}
try
{
IsLoading = true;
var strategy = new Strategy {
Name = strategyName
};
await strategyService.SaveStrategy(strategy).ConfigureAwait(true);
Strategies.Add(strategy);
ConfigurationModule.AddStrategy(strategy.Name);
}
catch (Exception ex)
{
ShowMessage(new Message {
MessageType = MessageType.Error, Text = ex.Message
});
}
finally
{
IsLoading = false;
}
}
public ObjMaterialsLoader()
{
Strategies.Add(new CreateNewMaterialStrategy());
Strategies.Add(new ParseMaterialAndColorStrategy());
Strategies.Add(new NoOperationStrategyForMaterial());
}
public SearchBehavior()
{
Strategies.Add(new FullScanRadar());
Strategies.Add(new SearchMovement());
}
public override void Refresh()
{
//tags
var selectedTags = Tags
.Where(x => x.IsChecked)
.Select(x => x.Item)
.ToList();
Tags.Clear();
foreach (var checkItem in Context
.Tags
.OrderBy(x => x.Name)
.ToList()
.Select(x => new CheckListItem <Tag>(x, selectedTags.Contains(x))))
{
Tags.Add(checkItem);
}
//strategies
var selectedStrats = Strategies
.Where(x => x.IsChecked)
.Select(x => x.Item)
.ToList();
Strategies.Clear();
foreach (var checkItem in Context
.Strategies
.OrderBy(x => x.Name)
.ToList()
.Select(x => new CheckListItem <Strategy>(x, selectedStrats.Contains(x))))
{
Strategies.Add(checkItem);
}
//Instruments
if (Instruments.Count == 0)
{
//on first load we want all instruments selected, otherwise remember previous selection
foreach (var checkItem in Context
.Instruments
.OrderBy(x => x.Symbol)
.ToList()
.Select(x => new CheckListItem <Instrument>(x, true)))
{
Instruments.Add(checkItem);
}
}
else
{
var selectedInstruments = Instruments
.Where(x => x.IsChecked)
.Select(x => x.Item)
.ToList();
Instruments.Clear();
foreach (var checkItem in Context
.Instruments
.OrderBy(x => x.Symbol)
.ToList()
.Select(x => new CheckListItem <Instrument>(x, selectedInstruments.Contains(x))))
{
Instruments.Add(checkItem);
}
}
//benchmarks
Benchmarks.Clear();
foreach (Benchmark b in Context.Benchmarks.OrderBy(x => x.Name))
{
Benchmarks.Add(b);
}
//backtest results from the external data source
BacktestSeries.Clear();
if (Datasourcer.ExternalDataSource.Connected)
{
BacktestSeries.AddRange(
Datasourcer
.ExternalDataSource
.GetBacktestSeries());
}
}
/// <summary>
/// Add a trading strategy to a specified symbol.
/// </summary>
/// <param name="strategy">the strategy to apply on the selected symbol. <see cref="IStrategy"/> </param>
/// <param name="symbol">Symbol ex: "XRPEUR" </param>
/// <param name="percent">Percentage of the portfolio to allocate to this strategy</param>
public void AddStrategy(IStrategy strategy, string symbol, double percent = 100.0)
{
var assetName = MarketExchange.NormalizeSymbolName(symbol);
Strategies.Add(new StrategyObject(strategy, assetName, percent));
}
public void AddStrategy(IIndexUpdateStrategy strategy)
{
strategy.Initialize(this);
Strategies.Add(strategy);
}
public void RegisterPersisterStrategy(IHalPersisterStrategy strategy)
{
strategy.HalClient = this;
strategy.HttpClient = HttpClient;
Strategies.Add(strategy);
}
static CookingStrategies()
{
Strategies.Add(0, new OvenBacking());
Strategies.Add(1, new Grilling());
Strategies.Add(2, new DeepFrying());
}
public VictoryBehavior()
{
Strategies.Add(new NoTarget());
}
