public MessageService(RabbitMqService rabbitMqService, IOptions <ExchangeSettings> exchangeSettings, IOptions <QueueSettings> queueSettings, ILogger <MessageService> logger) { _rabbitMqService = rabbitMqService; _logger = logger; _exchangeSettings = exchangeSettings.Value; _queueSettings = queueSettings.Value; }
public bool UpdateData(ExchangeSettings LocObject) { bool update = false; try { Object ReturnValue = ValidateUpdate(LocObject); DataTable value = VSWebDAL.ConfiguratorDAL.ExchangeDAL.Ins.GetDataForCredentialsById(LocObject); if (value.Rows.Count > 0) { if (ReturnValue.ToString() == "") { update = VSWebDAL.ConfiguratorDAL.ExchangeDAL.Ins.UpdateData(LocObject); } else { return(update); } } else { return(update); } } catch (Exception ex) { throw ex; } return(update); }
public SampleExchangeSettingsViewModel() : base(new MockExchangeSettingsView()) { Model = new ExchangeSettings() { ServerPath = "exchange.example.com", UserName = "******" }; }
protected MessageExchange() { _queues = new List <ExchangeQueue>(); _queueSettings = new QueueSettings(); Settings = new ExchangeSettings(); }
public void GdaxIntegrationBuyTest() { Bot bot = _dbContext .Bots .Include("BaseCoin") .Include("Coin") .Single(x => x.BotId == 1); ExchangeSettings exchangeSettings = _mapper.Map <ApiSetting, ExchangeSettings>( _user.ApiSettings.Single(x => x.Exchange.ExchangeId == bot.Exchange.ExchangeId), new ExchangeSettings()); exchangeSettings.Simulate = false; _exchangeApi = ExchangeEngine.ExchangeFactory.GetExchangeApi( (Enumerations.ExchangesEnum)bot.Exchange.ExchangeId, exchangeSettings); Ticker ticker = _exchangeApi.GetTicker(bot.BaseCoin, bot.Coin); bot.Amount = 10m; // 3 euros OrderManager orderManager = new OrderManager(bot, new Trader(_logger), _dbContext, _logger, _mapper, _messagingApp); orderManager.Buy(new Candle() { ClosePrice = ticker.Ask, Timestamp = DateTime.Now }); }
public ExchangeSettings GetDataForServerType(ExchangeSettings STypebject) { DataTable ServerTypesDataTable = new DataTable(); ExchangeSettings ReturnSTypeobject = new ExchangeSettings(); try { string SqlQuery = "Select TestId from ExchangeTestNames where TestName='" + STypebject.TestName + "'"; ServerTypesDataTable = objAdaptor.FetchData(SqlQuery); //populate & return data object if (ServerTypesDataTable.Rows.Count > 0) { if (ServerTypesDataTable.Rows[0]["TestId"].ToString() != "") { ReturnSTypeobject.id = int.Parse(ServerTypesDataTable.Rows[0]["TestId"].ToString()); } } else { ReturnSTypeobject.TestId = 0; } } catch { } finally { } return(ReturnSTypeobject); }
public bool UpdateData(ExchangeSettings LOCbject) { string SqlQuery = ""; bool Update; try { //7/10/2015 NS modified for VSPLUS-1985 //if (LOCbject.Password == " ") SqlQuery = "UPDATE CASServerTests SET ServerId= @ServerId,TestId= @TestId, URLs= @URLs, CredentialsId= @CredentialsId WHERE id = @id"; SqlCommand cmd = new SqlCommand(SqlQuery); cmd.Parameters.AddWithValue("@ServerId", (object)LOCbject.ServerId ?? DBNull.Value); cmd.Parameters.AddWithValue("@TestId", (object)LOCbject.TestId ?? DBNull.Value); cmd.Parameters.AddWithValue("@URLs", (object)LOCbject.URLs ?? DBNull.Value); cmd.Parameters.AddWithValue("@CredentialsId", (object)LOCbject.CredentialsId ?? DBNull.Value); cmd.Parameters.AddWithValue("@id", (object)LOCbject.id ?? DBNull.Value); Update = objAdaptor.ExecuteNonQuerywithcmd(cmd); //Update = objAdaptor.ExecuteNonQuery(SqlQuery); } catch { Update = false; } finally { } return(Update); }
public async Task UpdateAsync(string exchange, string assetPair, DateTime timestamp, IReadOnlyList <OrderBookLevel> sellLevels, IReadOnlyList <OrderBookLevel> buyLevels) { await _semaphore.WaitAsync(); try { ExchangeSettings exchangeSettings = await _exchangeSettingsService.GetByNameAsync(exchange); if (exchangeSettings == null || exchangeSettings.Status != ExchangeStatus.Active) { return; } if (!exchangeSettings.Instruments.Contains(assetPair)) { return; } await _externalOrderBookService.UpdateAsync(exchange, assetPair, timestamp, sellLevels, buyLevels); await Task.WhenAll( _aggregatedOrderBookService.UpdateAsync(assetPair), _internalOrderBookService.UpdateAsync(assetPair)); } catch (Exception exception) { _log.WarningWithDetails("An error occurred while calculating order books", exception, new { exchange, assetPair, timestamp, sellLevels, buyLevels }); } finally { _semaphore.Release(); } }
public async Task UpdateAsync(ExchangeSettings exchangeSettings, string userId) { await _exchangeSettingsRepository.UpdateAsync(exchangeSettings); _cache.Set(exchangeSettings); _log.InfoWithDetails("Exchange setting updated", new { exchangeSettings, userId }); }
public async Task UpdateAsync(ExchangeSettings exchangeSettings) { var entity = new ExchangeSettingsEntity(GetPartitionKey(), GetRowKey(exchangeSettings.Name)); Mapper.Map(exchangeSettings, entity); await _storage.InsertOrReplaceAsync(entity); }
public BaseSettingsController( ILogger logger, UserManager <ApplicationUser> userManager, ApplicationDbContext context, IOptions <ExchangeSettings> settings) : base(logger, userManager, context) { _settings = settings.Value; }
public void PropertiesTest() { var viewModel = Container.GetExportedValue <ExchangeSettingsViewModel>(); var exchangeSettings = new ExchangeSettings(); AssertHelper.PropertyChangedEvent(viewModel, x => x.Model, () => viewModel.Model = exchangeSettings); Assert.AreEqual(exchangeSettings, viewModel.Model); }
public InventorySnapshotSubscriber(ILogFactory logFactory, ExchangeSettings exchangeSettings, IInventorySnapshotService inventorySnapshotService) { _log = logFactory.CreateLog(this); _logFactory = logFactory; _settings = exchangeSettings; _inventorySnapshotService = inventorySnapshotService; }
public HealthIssueSubscriber(ILogFactory logFactory, ExchangeSettings exchangeSettings, IHealthMonitorService healthMonitorService) { _log = logFactory.CreateLog(this); _logFactory = logFactory; _settings = exchangeSettings; _healthMonitorService = healthMonitorService; }
private void ShowExchangeSettingsView() { ExchangeSettings exchangeSettings = EmailAccount.EmailAccountSettings is ExchangeSettings ? (ExchangeSettings)EmailAccount.EmailAccountSettings : new ExchangeSettings(); exchangeSettingsViewModel = exchangeSettingsViewModelFactory.CreateExport().Value; exchangeSettingsViewModel.Model = exchangeSettings; editEmailAccountViewModel.ContentView = exchangeSettingsViewModel.View; }
public void ValidationTest() { var exchangeSettings = new ExchangeSettings(); Assert.AreEqual("The Exchange Server field is required.", exchangeSettings.Validate("ServerPath")); exchangeSettings.ServerPath = "exchange.example.com"; Assert.AreEqual("", exchangeSettings.Validate("ServerPath")); }
public AuditMessageSubscriber(ILogFactory logFactory, ExchangeSettings exchangeSettings, IAuditMessageService auditMessageService) { _log = logFactory.CreateLog(this); _logFactory = logFactory; _settings = exchangeSettings; _auditMessageService = auditMessageService; }
private static void ValidationTestCore(ExchangeSettings exchangeSettings) { Assert.AreEqual("The Exchange Server field is required.", exchangeSettings.GetErrors(nameof(ExchangeSettings.ServerPath)).Single().ErrorMessage); Assert.AreEqual("The User Name field is required.", exchangeSettings.GetErrors(nameof(ExchangeSettings.UserName)).Single().ErrorMessage); exchangeSettings.ServerPath = "exchange.example.com"; exchangeSettings.UserName = "******"; Assert.IsFalse(exchangeSettings.HasErrors); }
public BittrexExchange(ExchangeSettings settings) { _settings = settings; _marketName = settings.Bittrex.Market; RiskManager = new RiskManagerService(this, settings.Bittrex.Market, settings.Bittrex.RiskManager.BalanceMinLimit); PlaceOrderController = new PlaceOrderControlService(this); _placeOrderWorker = new PlaceOrderWorker(PlaceOrderController); // _placeOrderWorker.RefreshOnBuy += PlaceOrderWorkerOnRefreshOnBuy; // _placeOrderWorker.RefreshOnSell += PlaceOrderWorkerOnRefreshOnSell; }
public void ValidationTest() { var exchangeSettings = new ExchangeSettings(); exchangeSettings.Validate(); var clone = (ExchangeSettings)exchangeSettings.Clone(); ValidationTestCore(exchangeSettings); ValidationTestCore(clone); }
public ExchangeGdaxAPI(ExchangeSettings exchangeSettings) { Logger = LogManager.GetCurrentClassLogger(); RequestContentType = "application/json"; _exchangeSettings = exchangeSettings; LoadSettings(); RateLimit = new RateGate(2, TimeSpan.FromSeconds(1)); }
public void PropertiesTest() { var exchangeSettings = new ExchangeSettings(); AssertHelper.PropertyChangedEvent(exchangeSettings, x => x.ServerPath, () => exchangeSettings.ServerPath = "exchange.example.com"); Assert.AreEqual("exchange.example.com", exchangeSettings.ServerPath); AssertHelper.PropertyChangedEvent(exchangeSettings, x => x.UserName, () => exchangeSettings.UserName = "******"); Assert.AreEqual("bill", exchangeSettings.UserName); }
public LykkeTradeSubscriber(ILogFactory logFactory, ExchangeSettings exchangeSettings, ILykkeTradeService lykkeTradeService, IRealisedPnLService realisedPnLService) { _log = logFactory.CreateLog(this); _logFactory = logFactory; _settings = exchangeSettings; _lykkeTradeService = lykkeTradeService; _realisedPnLService = realisedPnLService; }
public ExchangeSettings GetDataForServerType(ExchangeSettings STypeObject) { try { return(VSWebDAL.ConfiguratorDAL.ExchangeDAL.Ins.GetDataForServerType(STypeObject)); } catch (Exception ex) { throw ex; } }
public DataTable GetExchangeSettings(ExchangeSettings Mobj) { try { return(VSWebDAL.ConfiguratorDAL.ExchangeDAL.Ins.GetExchangeSettings(Mobj)); } catch (Exception ex) { throw ex; } }
public static void ExchangeDeclare(this IModel channel, ExchangeSettings settings) { Check.NotNull(channel, nameof(channel)); Check.NotNull(settings, nameof(settings)); channel.ExchangeDeclare(settings.ExchangeName, settings.ExchangeType, settings.IsDurable, settings.IsAutoDelete, settings.Arguments); }
public async Task UpdateAsync(string exchange, string assetPair, DateTime timestamp, IReadOnlyList <OrderBookLevel> sellLevels, IReadOnlyList <OrderBookLevel> buyLevels) { ExchangeSettings exchangeSettings = await _exchangeSettingsService.GetByNameAsync(exchange); if (exchangeSettings == null) { throw new FailedOperationException("Exchange setting not found"); } AssetPairModel assetPairSettings = _marketInstrumentService.GetAssetPair(assetPair, exchange); if (assetPairSettings == null) { throw new FailedOperationException("Asset pair not found"); } var externalOrderBook = new ExternalOrderBook { Exchange = exchange, AssetPair = assetPair, Timestamp = timestamp, SellLevels = sellLevels.Select(o => new ExternalOrderBookLevel { Price = (o.Price * (1 + exchangeSettings.MarketFee + exchangeSettings.TransactionFee)) .TruncateDecimalPlaces(assetPairSettings.PriceAccuracy, true), Volume = o.Volume, Markup = exchangeSettings.MarketFee + exchangeSettings.TransactionFee, OriginalPrice = o.Price }) .OrderBy(o => o.Price) .ToList(), BuyLevels = buyLevels.Select(o => new ExternalOrderBookLevel { Price = (o.Price * (1 - exchangeSettings.MarketFee - exchangeSettings.TransactionFee)) .TruncateDecimalPlaces(assetPairSettings.PriceAccuracy), Volume = o.Volume, Markup = exchangeSettings.MarketFee + exchangeSettings.TransactionFee, OriginalPrice = o.Price }) .OrderByDescending(o => o.Price) .ToList() }; lock (_sync) { if (!_orderBooks.ContainsKey(exchange)) { _orderBooks[exchange] = new Dictionary <string, ExternalOrderBook>(); } _orderBooks[exchange][assetPair] = externalOrderBook; } }
private void ExchangeDeclare(IModel model, ExchangeSettings settings) { this.logger.LogInformation($"Declaring exchange {settings.ExchangeName}"); model.ExchangeDeclare( exchange: settings.ExchangeName, type: settings.Type, durable: settings.Durable, autoDelete: settings.AutoDelete, arguments: settings.Arguments ); }
public Object UpdateExchangeSettingsData(ExchangeSettings Mobj) { try { return(VSWebDAL.ConfiguratorDAL.ExchangeDAL.Ins.UpdateExchangeSettingsData(Mobj)); } catch (Exception ex) { throw ex; } }
public ExternalTradeSubscriber(ILogFactory logFactory, ExchangeSettings exchangeSettings, IExternalTradeService externalTradeService, IRealisedPnLService realisedPnLService) { _log = logFactory.CreateLog(this); _logFactory = logFactory; _settings = exchangeSettings; _externalTradeService = externalTradeService; _realisedPnLService = realisedPnLService; }
public ExchangeBinding(ExchangeSettings exchange, string routingKey = "") { RoutingKey = routingKey; Exchange = exchange; Arguments = new Dictionary<string, object>(); }