public void Initalize()
{
_brokers = new DigicoinBrokerSelector(new IDigicoinBroker[] { _broker1, _broker2 });
_trades = new TradeRepository();
_reports = new DigicoinReports(_trades);
_trader = new DigicoinTrader(_brokers, _trades);
}
public ExecutionService(IBlotterPublisher blotterPublisher, ITradeRepository tradeRepository, IAnalyticsService analyticsService)
{
_blotterPublisher = blotterPublisher;
_tradeRepository = tradeRepository;
_analyticsService = analyticsService;
_tradeId = 0;
}
public TraderInfoUnitOfWork(TraderInfoContext context)
{
_context = context;
TransferWindows = new TransferWindowRepository(_context);
Trades = new TradeRepository(_context);
}
public TradeController(IShareRepository shareRepository, ITradeRepository tradeRepository, IPortfolioRepository portfolioRepository, ITradeHandlerFactry tradeHandlerFactory)
{
_shareRepository = shareRepository;
_tradeRepository = tradeRepository;
_portfolioRepository = portfolioRepository;
_tradeHandlerFactory = tradeHandlerFactory;
}
public PhysicalContractCommandsHandler(
ILogger <PhysicalContractCommandsHandler> logger,
IUnitOfWork unitOfWork,
ITradeRepository tradeRepository,
ISectionRepository sectionRepository,
ICostRepository costRepository,
IIdentityService identityService,
IFreezeRepository freezeRepository,
ISystemDateTimeService systemDateTimeService,
IMapper mapper,
IAuthorizationService authorizationService,
IProcessMessageService processMessageService,
IMasterDataService masterDataService,
IUserService userService,
ISectionQueries sectionQueries)
{
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
_tradeRepository = tradeRepository ?? throw new ArgumentNullException(nameof(tradeRepository));
_sectionRepository = sectionRepository ?? throw new ArgumentNullException(nameof(sectionRepository));
_costRepository = costRepository ?? throw new ArgumentNullException(nameof(costRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
_systemDateTimeService = systemDateTimeService ?? throw new ArgumentNullException(nameof(systemDateTimeService));
_authorizationService = authorizationService ?? throw new ArgumentNullException(nameof(authorizationService));
_freezeRepository = freezeRepository ?? throw new ArgumentNullException(nameof(freezeRepository));
_processMessageService = processMessageService ?? throw new ArgumentNullException(nameof(processMessageService));
_masterDataService = masterDataService ?? throw new ArgumentNullException(nameof(masterDataService));
_userService = userService ?? throw new ArgumentNullException(nameof(userService));
_sectionQueries = sectionQueries ?? throw new ArgumentNullException(nameof(sectionQueries));
}
public TradeController(
ITradeRepository tradeRepository,
IMappingEngine mappingEngine)
{
_tradeRepository = tradeRepository;
_mappingEngine = mappingEngine;
}
public TradeFinalizationService(
IAssetRepository assetRepository,
ITradeRepository tradeRepository)
{
_assetRepository = assetRepository;
_tradeRepository = tradeRepository;
}
public ExecutionService(IBlotterPublisher blotterPublisher, ITradeRepository tradeRepository, IAnalyticsService analyticsService)
{
_blotterPublisher = blotterPublisher;
_tradeRepository = tradeRepository;
_analyticsService = analyticsService;
_tradeId = 0;
}
public BrokerController(ITraderRepository traderRepository, ISecurityRepository securityRepository,
ITradeRepository tradeRepository)
{
_traderRepository = traderRepository;
_securityRepository = securityRepository;
_tradeRepository = tradeRepository;
}
private MainViewModel GetVm()
{
MainViewModel.IsUnitTesting = true;
_ibClient = new IBClient(new EReaderMonitorSignal());
_connectionService = Substitute.For <IConnectionService>();
_orderManager = Substitute.For <IOrderManager>();
_accountManager = Substitute.For <IAccountManager>();
_contractManager = Substitute.For <IContractManager>();
_marketDataManager = Substitute.For <IMarketDataManager>();
_historicalDataManager = Substitute.For <IHistoricalDataManager>();
_orderCalculationService = Substitute.For <IOrderCalculationService>();
_exchangeRateService = Substitute.For <IExchangeRateService>();
_tradeRepository = Substitute.For <ITradeRepository>();
var orderManager = Substitute.For <IOrderManager>();
_ordersViewModel = new OrdersViewModel(_contractManager, _marketDataManager, _historicalDataManager, _orderCalculationService, orderManager, _tradeRepository);
_statusBarViewModel = Substitute.For <StatusBarViewModel>();
var positionsManager = Substitute.For <IPositionManager>();
var contractManager = Substitute.For <IContractManager>();
var positionsViewModel = new PositionsViewModel(_marketDataManager, _accountManager, positionsManager, contractManager);
var detailsViewModel = new DetailsViewModel();
_settingsViewModel = new SettingsViewModel();
return(new MainViewModel(_ibClient, _connectionService, _orderManager, _accountManager, _ordersViewModel, _statusBarViewModel, _historicalDataManager, _exchangeRateService, _orderCalculationService, positionsViewModel, detailsViewModel, _settingsViewModel));
}
public AccountRecharge(ITradeRepository tradeRepository, ITradeRecordRepository tradeRecordRepository,
ITransaction transaction, IServiceProxy serviceProxy, IIocContainer iocContainer) : base(iocContainer)
{
this.tradeRepository = tradeRepository;
this.tradeRecordRepository = tradeRecordRepository;
this.getUserState = serviceProxy.CreateProxy <IGetUserState>();
this.transaction = transaction;
}
public TradeTxService(ILogger logger,
ITradeRepository tradeRepository,
IMessageHandler <IMessage> messageHandler)
{
_logger = logger;
_tradeRepository = tradeRepository;
_messageHandler = messageHandler;
}
public TradeCalculator(ITradeRepository tradeRepository, IDateTimeProvider dateTimeProvider)
{
tradeRepository.CheckForNull("tradeRepository");
dateTimeProvider.CheckForNull("dateTimeProvider");
_tradeRepository = tradeRepository;
_dateTimeProvider = dateTimeProvider;
}
public PortfoliosController(IPortfolioRepository portfolioRepository, IAssetRepository assetRepository, ITradeRepository tradeRepository, IStockRepository stockRepository, ILogger <PortfoliosController> logger)
{
_portfolioRepository = portfolioRepository;
_assetRepository = assetRepository;
_tradeRepository = tradeRepository;
_stockRepository = stockRepository;
_logger = logger;
}
/// <summary>
/// Initialize <see cref="DigicoinReports"/> class.
/// </summary>
/// <param name="trades">Trades repository.</param>
public DigicoinReports(ITradeRepository trades)
{
if (trades == null)
{
throw new ArgumentNullException("trades");
}
_trades = trades;
}
public PhotosController(IHostingEnvironment host, ITradeRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IOptionsSnapshot <PhotoSettings> options)
{
this.photoSettings = options.Value;
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.repository = repository;
this.host = host;
}
public Handler(
ITradeRepository tradeRepository,
IDatabaseScopeFactory databaseScopeFactory,
ILogger <Handler> logger)
{
_tradeRepository = tradeRepository;
_databaseScopeFactory = databaseScopeFactory;
_logger = logger;
}
public LykkeTradeService(
ITradeRepository tradeRepository,
ILp3Service lp3Service,
ILogFactory logFactory)
{
_tradeRepository = tradeRepository;
_lp3Service = lp3Service;
_log = logFactory.CreateLog(this);
}
public void Setup()
{
var options = new DbContextOptionsBuilder <TraderDbContext>()
.UseSqlServer(Startup.ConnectionString)
.Options;
this.context = new TraderDbContext(options);
this.repository = new TradeRepository(this.context);
}
public TradeService(
ITradeRepository tradeRepository,
ISaveRepository unitOfWork,
ILogger <TradeService> logger)
{
_tradeRepository = tradeRepository;
_unitOfWork = unitOfWork;
_logger = logger;
}
public TradeService(ITradeRepository tradeRepository,
IMapper mapper)
{
_mapper = mapper ??
throw new ArgumentNullException(nameof(_mapper));
_tradeRepository = tradeRepository ??
throw new ArgumentNullException(nameof(_tradeRepository));
}
public TradeService(ITradeRepository tradeRepo)
{
if (tradeRepo == null)
{
throw new ArgumentNullException("tradeRepo");
}
this.tradeRepo = tradeRepo;
}
public TradeCommandHandler(IMediatorHandler mediator,
ITradeRepository tradeRepository,
ILogger <TradeCommandHandler> logger,
INotificationHandler <DomainNotification> notifications)
: base(mediator, (DomainNotificationHandler)notifications, logger)
{
_mediator = mediator;
_tradeRepository = tradeRepository;
}
public LoaderService(ITradeRepository tradeRepository, IExchangeClient[] clients,
IEventRepository eventRepository, ILogRepository logRepository, Config config, IFileService fileService)
{
_tradeRepository = tradeRepository;
_clients = clients;
_eventRepository = eventRepository;
_logRepository = logRepository;
_config = config;
_fileService = fileService;
}
public TradeController(IPopupService popupService, ITradeService tradeService, IEntityRepository entityRepository, ITradeRepository tradeRepository,
ITradeProductRepository tradeProductRepository, ITradeMoneyRepository tradeMoneyRepository, ITransactionScopeProvider transactionScopeProvider) : base(popupService)
{
this.tradeService = tradeService;
this.entityRepository = entityRepository;
this.tradeRepository = tradeRepository;
this.tradeProductRepository = tradeProductRepository;
this.tradeMoneyRepository = tradeMoneyRepository;
this.transactionScopeProvider = transactionScopeProvider;
}
/// <summary>
/// Constructor. Sets the Elapsed handler for the timer.
/// </summary>
public Simulator(ISecurityRepository securityRepository, ITradingDayRepository tradingDayRepository, ITradeRepository tradeRepository)
{
_tradeRepository = tradeRepository;
_securityRepository = securityRepository;
_securities = _securityRepository.GetAllAsync().Result;
_tradingDays = tradingDayRepository.GetAllAsync().Result;
_timer.Elapsed += UpdateAsync;
}
public HomeController(ITradeRepository tradeRepository,
ICurrencyRepository currencyRepository,
IParticipantRepository participantRepository,
IMapper mapper)
{
this._currencyRepository = currencyRepository;
this._participantRepository = participantRepository;
this._tradeRepository = tradeRepository;
this._mapper = mapper;
}
public TradeService(
IOptions <TradeServiceOptions> options,
ITradeRepository repo,
IGuidGeneratorService uids,
ILocalTimeService timestamps)
{
_options = options;
_repo = repo;
_uids = uids;
_timestamps = timestamps;
}
public ControllerTestBase()
{
var options = new DbContextOptionsBuilder <ExchangeContext>()
.UseInMemoryDatabase(databaseName: "TestDB")
.Options;
_exchangeContext = new ExchangeContext(options);
_shareRepository = new ShareRepository(_exchangeContext);
_tradeRepository = new TradeRepository(_exchangeContext);
_portfolioRepository = new PortfolioRepository(_exchangeContext);
}
public TradeController(IMediatorHandler mediator,
ITradeRepository tradeRepository,
UserManager <IdentityUser> userManager,
IUserAdapter userAdapter,
INotificationHandler <DomainNotification> notifications,
IStringLocalizer <TradeController> localizer,
ILogger <TradeController> logger)
: base(notifications, userManager, userAdapter, mediator, localizer, logger)
{
_tradeRepository = tradeRepository;
}
public BlotterViewModel(IReactiveTrader reactiveTrader,
Func<ITrade, bool, ITradeViewModel> tradeViewModelFactory,
IConcurrencyService concurrencyService)
{
_tradeRepository = reactiveTrader.TradeRepository;
_tradeViewModelFactory = tradeViewModelFactory;
_concurrencyService = concurrencyService;
Trades = new ObservableCollection<ITradeViewModel>();
LoadTrades();
}
public DraftPickController()
{
var context = new FantasyVBDEntities();
DraftPickRepo = new DraftPickRepository(context);
LeagueYearRepo = new LeagueYearRepository(context);
LeagueYearDraftOrderRepo = new LeagueYearDraftOrderRepository(context);
TradeRepo = new TradeRepository(context);
DraftPickkMapper = new AutoMapperHelper <List <Models.DraftPickModel>, IList <DataAccess.DraftPick> >();
numberOfRounds = 16;
}
public TradesController(ITradeRepository tradeRepository,
IMapper mapper,
ITradeService tradeService,
ICategoryRepository categoryRepository,
INotifier notificador) : base(notificador)
{
_tradeRepository = tradeRepository;
_mapper = mapper;
_tradeService = tradeService;
_categoryRepository = categoryRepository;
}
public TradeService(ITradeRepository tradeRepository, IDateTime dateTime, IEventRepository eventRepository, Config config,
IOrderService orderService, IExchangeClient[] exchangeClients, IFileService fileService, IStatusService statusService)
{
_tradeRepository = tradeRepository;
_dateTime = dateTime;
_eventRepository = eventRepository;
_config = config;
_orderService = orderService;
_exchangeClients = exchangeClients;
_fileService = fileService;
_statusService = statusService;
}
public TravelService(IRegionService regionService, IEquipmentService equipmentService, IEquipmentRepository equipmentRepository, IProductRepository productRepository,
ICitizenRepository citizenRepository, IWarRepository warRepository, ITradeRepository tradeRepository, ITradeService tradeService)
{
this.regionService = Attach(regionService);
this.equipmentService = Attach(equipmentService);
this.equipmentRepository = equipmentRepository;
this.citizenRepository = citizenRepository;
this.productRepository = productRepository;
this.warRepository = warRepository;
this.tradeRepository = tradeRepository;
this.tradeService = tradeService;
}
/// <summary>
/// Initialize <see cref="DigicoinTrader"/> class.
/// </summary>
/// <param name="brokers">Digicoin trading brokers.</param>
/// <param name="trades">Trades repository.</param>
public DigicoinTrader(IDigicoinBrokerSelector brokers, ITradeRepository trades)
{
if (brokers == null)
{
throw new ArgumentNullException("brokers");
}
if (trades == null)
{
throw new ArgumentNullException("trades");
}
_trades = trades;
_brokers = brokers;
}
public void SetUp()
{
_tradeRepo = Substitute.For<ITradeRepository>();
_analyticsService = Substitute.For<IAnalyticsService>();
_executionService = Substitute.For<IExecutionService>();
_lastValueCache = Substitute.For<IPriceLastValueCache>();
_scheduler = new HistoricalScheduler();
_scheduler.AdvanceTo(DateTimeOffset.Now);
_schedulerService = Substitute.For<ISchedulerService>();
_schedulerService.ThreadPool.Returns(_scheduler);
}
public BlotterViewModel(IReactiveTrader reactiveTrader,
Func<ITrade, bool, ITradeViewModel> tradeViewModelFactory,
IConcurrencyService concurrencyService,
ILoggerFactory loggerFactory)
{
_tradeRepository = reactiveTrader.TradeRepository;
_tradeViewModelFactory = tradeViewModelFactory;
_concurrencyService = concurrencyService;
Trades = new ObservableCollection<ITradeViewModel>();
_log = loggerFactory.Create(typeof (BlotterViewModel));
LoadTrades();
}
public TradeAppService(ITradeQuery queryTrade, ITradeRepository tradeRepository, IOrderQuery orderQuery,
IOrderRepository orderRepository, ISupplierRepository supplierRepository,
IMaterialRepository materialRepository, IActionCategoryRepository actionCategoryRepository,
IContractAircraftRepository contractAircraftRepository, IContractEngineRepository contractEngineRepository,
IRelatedDocRepository relatedDocRepository,IPnRegRepository pnregRepository)
{
_tradeQuery = queryTrade;
_tradeRepository = tradeRepository;
_orderQuery = orderQuery;
_orderRepository = orderRepository;
_supplierRepository = supplierRepository;
_materialRepository = materialRepository;
_actionCategoryRepository = actionCategoryRepository;
_contractAircraftRepository = contractAircraftRepository;
_contractEngineRepository = contractEngineRepository;
_relatedDocRepository = relatedDocRepository;
_pnRegRepository = pnregRepository;
}
public void Initialize(string username, string[] servers)
{
_connectionProvider = new ConnectionProvider(username, servers);
var referenceDataServiceClient = new ReferenceDataServiceClient(_connectionProvider);
var executionServiceClient = new ExecutionServiceClient(_connectionProvider);
var blotterServiceClient = new BlotterServiceClient(_connectionProvider);
var pricingServiceClient = new PricingServiceClient(_connectionProvider);
PriceLatencyRecorder = new PriceLatencyRecorder();
var concurrencyService = new ConcurrencyService();
var tradeFactory = new TradeFactory();
var executionRepository = new ExecutionRepository(executionServiceClient, tradeFactory, concurrencyService);
var priceFactory = new PriceFactory(executionRepository, PriceLatencyRecorder);
var priceRepository = new PriceRepository(pricingServiceClient, priceFactory);
var currencyPairUpdateFactory = new CurrencyPairUpdateFactory(priceRepository);
TradeRepository = new TradeRepository(blotterServiceClient, tradeFactory);
ReferenceData = new ReferenceDataRepository(referenceDataServiceClient, currencyPairUpdateFactory);
}
public void Initialize(string username, string[] servers, ILoggerFactory loggerFactory = null)
{
_loggerFactory = loggerFactory ?? new DebugLoggerFactory();
_log = _loggerFactory.Create(typeof(ReactiveTrader));
_connectionProvider = new ConnectionProvider(username, servers, _loggerFactory);
var referenceDataServiceClient = new ReferenceDataServiceClient(_connectionProvider, _loggerFactory);
var executionServiceClient = new ExecutionServiceClient(_connectionProvider);
var blotterServiceClient = new BlotterServiceClient(_connectionProvider, _loggerFactory);
var pricingServiceClient = new PricingServiceClient(_connectionProvider, _loggerFactory);
PriceLatencyRecorder = new PriceLatencyRecorder();
var concurrencyService = new ConcurrencyService();
var tradeFactory = new TradeFactory();
var executionRepository = new ExecutionRepository(executionServiceClient, tradeFactory, concurrencyService);
var priceFactory = new PriceFactory(executionRepository, PriceLatencyRecorder);
var priceRepository = new PriceRepository(pricingServiceClient, priceFactory, _loggerFactory);
var currencyPairUpdateFactory = new CurrencyPairUpdateFactory(priceRepository);
TradeRepository = new TradeRepository(blotterServiceClient, tradeFactory);
ReferenceData = new ReferenceDataRepository(referenceDataServiceClient, currencyPairUpdateFactory);
}
public void Initialize()
{
_brokers = Substitute.For<IDigicoinBrokerSelector>();
_repository = Substitute.For<ITradeRepository>();
_trader = new DigicoinTrader(_brokers, _repository);
}
public void Initialization()
{
_trades = Substitute.For<ITradeRepository>();
_reports = new DigicoinReports(_trades);
}
public BlotterHub(ITradeRepository tradeRepository, IContextHolder contextHolder)
{
_tradeRepository = tradeRepository;
_contextHolder = contextHolder;
}
public ExecutionService(IBlotterPublisher blotterPublisher, ITradeRepository tradeRepository)
{
_blotterPublisher = blotterPublisher;
_tradeRepository = tradeRepository;
_tradeId = 0;
}
public TradeController()
{
repository = new TradeRepository();
}
