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>();
}
