public PriceCalculationUoW()
{
_businessEntityRepository = RepositoryFactory.Create <IBusinessEntityRepository>(_dbContext);
_businessItemRepository = RepositoryFactory.Create <IBusinessItemRepository>(_dbContext);
_catalogueRepository = RepositoryFactory.Create <ICatalogueRepository>(_dbContext);
_groupRepository = RepositoryFactory.Create <IGroupRepository>(_dbContext);
_ruleRepository = RepositoryFactory.Create <IRuleRepository>(_dbContext);
_strategyRepository = RepositoryFactory.Create <IStrategyRepository>(_dbContext);
}
public Strategy[] GetStrategies()
{
return(ExecuteFaultHandledOperation(() =>
{
IStrategyRepository strategyRepository = _DataRepositoryFactory.GetDataRepository <IStrategyRepository>();
IEnumerable <Strategy> strategies = strategyRepository.Get();
return strategies.ToArray();
}));
}
public BetStrategyService(IGameRepository gameRepository, IBetRepository betRepository, IStrategyRepository strategyRepository,
IStrategyFactory strategyFactory,IRankingRepository rankingRepository, IScorer scorer)
{
this._gameRepository = gameRepository;
this._betRepository = betRepository;
this._strategyRepository = strategyRepository;
this._strategyFactory = strategyFactory;
this._rankingRepository = rankingRepository;
this._scorer = scorer;
}
public BetStrategyService(IGameRepository gameRepository, IBetRepository betRepository, IStrategyRepository strategyRepository,
IStrategyFactory strategyFactory, IRankingRepository rankingRepository, IScorer scorer)
{
this._gameRepository = gameRepository;
this._betRepository = betRepository;
this._strategyRepository = strategyRepository;
this._strategyFactory = strategyFactory;
this._rankingRepository = rankingRepository;
this._scorer = scorer;
}
public OverviewController(
IStrategyRepository strategyRepository,
IAssetRepository assetRepository,
IMarketDataService marketDataService,
IMapper mapper)
{
_strategyRepository = strategyRepository;
_assetRepository = assetRepository;
_marketDataService = marketDataService;
_mapper = mapper;
}
public bool CanStrategyAcceptFunds(int strategyId, decimal amount)
{
bool canAcceptFunds = false;
IStrategyRepository strategyRepository = _DataRepositoryFactory.GetDataRepository <IStrategyRepository>();
Strategy strategy = strategyRepository.GetStrategy(strategyId);
canAcceptFunds = amount <= (strategy.MaximumAUM - strategy.CurrentAUM);
return(canAcceptFunds);
}
public TradingController(
ITradeRepository tradeRepository,
ITradeExecutionService tradeExecutionService,
IMarketDataService marketDataService,
IStrategyRepository strategyRepository,
IMapper mapper)
{
_tradeRepository = tradeRepository;
_tradeService = tradeExecutionService;
_marketDataService = marketDataService;
_strategyRepository = strategyRepository;
_mapper = mapper;
}
public TradeExecutionService(
IStrategyRepository strategyRepository,
IAssetRepository assetRepository,
ITradeRepository tradeRepository,
IMarketDataService marketDataService,
ITradeFinalizationService tradeFinalizationService,
IExchangeObjectFactory exchangeObjectFactory)
{
_strategyRepository = strategyRepository;
_assetRepository = assetRepository;
_tradeRepository = tradeRepository;
_marketDataService = marketDataService;
_tradeFinalizationService = tradeFinalizationService;
_exchangeFactory = exchangeObjectFactory;
}
public StrategyController(
IStrategyRepository strategyRepository,
IAssetRepository assetRepository,
IEvaluationRepository evaluationRepository,
ITradeRepository tradeRepository,
IMarketDataService marketDataService,
IMapper mapper)
{
_strategyRepository = strategyRepository;
_assetRepository = assetRepository;
_evaluationRepository = evaluationRepository;
_tradeRepository = tradeRepository;
_marketDataService = marketDataService;
_mapper = mapper;
}
public TaskEngine(IStrategyRepository strategyRespository, IStageResolver stageResolver)
{
if (strategyRespository == null)
{
throw new ArgumentNullException("strategyRespository");
}
m_stategyRespository = strategyRespository;
if (stageResolver == null)
{
throw new ArgumentNullException("stageResolver");
}
m_stageResolver = stageResolver;
}
public Strategy UpdateStrategy(Strategy strategy)
{
return(ExecuteFaultHandledOperation(() =>
{
IStrategyRepository strategyRepository = _DataRepositoryFactory.GetDataRepository <IStrategyRepository>();
Strategy updatedEntity = null;
if (strategy.StrategyID == 0)
{
updatedEntity = strategyRepository.Add(strategy);
}
else
{
updatedEntity = strategyRepository.Update(strategy);
}
return updatedEntity;
}));
}
public CreateStrategyCommandHandler(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public RepositoryFactory(IDeploymentRepository deploymentRepository, ISchemesRepository schemesRepository, IStrategyRepository strategyRepository)
{
DeploymentRepository = deploymentRepository ?? new DeploymentRepository();
SchemesRepository = schemesRepository ?? new SchemesRepository();
StrategyRepository = strategyRepository ?? new StrategyRepository();
}
public StrategyController(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public StrategyService(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public StrategyService(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public GetAllStrategiesQueryHandler(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public GetStrategyByIdQueryHandler(IStrategyRepository strategyRepository)
{
_strategyRepository = strategyRepository;
}
public UpdateStrategyCommandHandler(IApplicationDbContext context, IStrategyRepository strategyRepository)
{
_context = context;
_strategyRepository = strategyRepository;
}
public StrategyController(IStrategyRepository items)
{
Items = items;
}
