/// <summary>
/// Register interface:
/// * IFeesSettingsClient
/// </summary>
public static void RegisterFeesClients(this ContainerBuilder builder,
IMyNoSqlSubscriber myNoSqlSubscriber)
{
var feesSettings = new MyNoSqlReadRepository <FeesSettingsNoSqlEntity>(myNoSqlSubscriber,
FeesSettingsNoSqlEntity.TableName);
var assetFees = new MyNoSqlReadRepository <AssetFeesNoSqlEntity>(myNoSqlSubscriber,
AssetFeesNoSqlEntity.TableName);
var depositFees = new MyNoSqlReadRepository <DepositFeesNoSqlEntity>(myNoSqlSubscriber,
DepositFeesNoSqlEntity.TableName);
var instrumentFees = new MyNoSqlReadRepository <SpotInstrumentFeesNoSqlEntity>(myNoSqlSubscriber,
SpotInstrumentFeesNoSqlEntity.TableName);
builder
.RegisterInstance(new DepositFeesClient(depositFees))
.As <IDepositFeesClient>()
.AutoActivate()
.SingleInstance();
builder
.RegisterInstance(new AssetFeesClient(assetFees, feesSettings))
.As <IAssetFeesClient>()
.AutoActivate()
.SingleInstance();
builder
.RegisterInstance(new SpotInstrumentFeesClient(instrumentFees, feesSettings))
.As <ISpotInstrumentFeesClient>()
.AutoActivate()
.SingleInstance();
}
public KycStatusClient(MyNoSqlReadRepository <KycProfileNoSqlEntity> readerKycStatuses, IKycStatusService kycStatusService)
{
_readerKycStatuses = readerKycStatuses;
_kycStatusService = kycStatusService;
_readerKycStatuses.SubscribeToUpdateEvents(list => Changed(), list => Changed());
}
public async static Task ReadInstrumentsFees()
{
//http://192.168.1.80:5123
// var writer = new MyNoSqlServerDataWriter<SpotInstrumentFeesNoSqlEntity>(GetUrl, SpotInstrumentFeesNoSqlEntity.TableName, false);
// var entities = await writer.GetAsync();
// Console.WriteLine(JsonConvert.SerializeObject(entities));
//192.168.1.80:5125
var myNoSqlClient = new MyNoSqlTcpClient(GetUrl, "local");
var subs = new MyNoSqlReadRepository <SpotInstrumentFeesNoSqlEntity>(myNoSqlClient,
SpotInstrumentFeesNoSqlEntity.TableName);
myNoSqlClient.Start();
Thread.Sleep(10000);
var entities = subs.Get();
Console.WriteLine(JsonConvert.SerializeObject(entities));
//
// var entity = subs.Get(SpotInstrumentFeesNoSqlEntity.GeneratePartitionKey("jetwallet"),
// SpotInstrumentFeesNoSqlEntity.GenerateRowKey("ALGOUSD"));
//
// Console.WriteLine(JsonConvert.SerializeObject(entity));
//
// var entities = subs.Get(SpotInstrumentFeesNoSqlEntity.GeneratePartitionKey("jetwallet"));
//
// Console.WriteLine(JsonConvert.SerializeObject(entities));
//
// var entities1 = subs.Get();
//
// Console.WriteLine(JsonConvert.SerializeObject(entities1));
}
public KYCClientFactory(string kycServiceGrpcServiceUrl)
{
_reader = null;
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var channel = GrpcChannel.ForAddress(kycServiceGrpcServiceUrl);
_channel = channel.Intercept(new PrometheusMetricsInterceptor());
}
public KYCClientFactory(string kycServiceGrpcServiceUrl, MyNoSqlReadRepository <KycCountryNoSqlEntity> reader)
{
_reader = reader;
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var channel = GrpcChannel.ForAddress(kycServiceGrpcServiceUrl);
_channel = channel.Intercept(new PrometheusMetricsInterceptor());
}
/// <summary>
/// Register interfaces:
/// * ICurrentPricesCache
/// </summary>
public static void RegisterMatchingEnginePriceSourceClient(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber)
{
var subs = new MyNoSqlReadRepository <BidAskNoSql>(myNoSqlSubscriber, BidAskNoSql.TableName);
builder
.RegisterInstance(new CurrentPricesCache(subs))
.As <ICurrentPricesCache>()
.AutoActivate()
.SingleInstance();
}
public static void RegisterMatchingEngineOrderBookClient(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber)
{
var subs = new MyNoSqlReadRepository <OrderBookNoSql>(myNoSqlSubscriber, OrderBookNoSql.TableName);
builder
.RegisterInstance(new OrderBookCache(subs))
.As <IOrderBookService>()
.AutoActivate()
.SingleInstance();
}
public static void RegisterApiKeyVolumesClient(
this ContainerBuilder builder,
IMyNoSqlSubscriber myNoSqlSubscriber)
{
MyNoSqlReadRepository <ApiKeyVolumeNoSqlEntity> readRepository =
new MyNoSqlReadRepository <ApiKeyVolumeNoSqlEntity>(myNoSqlSubscriber,
ApiKeyVolumeNoSqlEntity.TableName);
builder.RegisterInstance(readRepository).As <IMyNoSqlServerDataReader <ApiKeyVolumeNoSqlEntity> >()
.SingleInstance();
}
public static void RegisterSnapshotClient(this ContainerBuilder builder, string avgPriceGrpcServiceUrl, IMyNoSqlSubscriber myNoSqlSubscriber)
{
var factory = new BalanceHistoryClientFactory(avgPriceGrpcServiceUrl);
var snapshotService = factory.GetSnapshotService();
var subs = new MyNoSqlReadRepository <SnapshotNoSqlEntity>(myNoSqlSubscriber, SnapshotNoSqlEntity.TableName);
builder
.RegisterInstance(new SnapshotClient(subs, snapshotService))
.As <ISnapshotClient>()
.SingleInstance();
}
public AssetsServiceUserDataClient(string myNoSqlServerReaderHostPort, string assetServiceHttpApiUrl, ILogFactory logFactory)
{
_log = logFactory.CreateLog(this);
var host = Environment.GetEnvironmentVariable("HOST") ?? Environment.MachineName;
_httpClient = new AssetsServiceHttp(new Uri(assetServiceHttpApiUrl));
_myNoSqlClient = new MyNoSqlTcpClient(() => myNoSqlServerReaderHostPort, host);
_readerAssetConditionNoSql = new MyNoSqlReadRepository <AssetConditionNoSql>(_myNoSqlClient, AssetConditionNoSql.TableName);
_readerWatchListCustomNoSql = new MyNoSqlReadRepository <WatchListCustomNoSql>(_myNoSqlClient, WatchListCustomNoSql.TableNameCustomWatchList);
_readerWatchListPredefinedNoSql = new MyNoSqlReadRepository <WatchListPredefinedNoSql>(_myNoSqlClient, WatchListPredefinedNoSql.TableNamePredefinedWatchList);
}
/// <summary>
/// Register interface:
/// * IFeesSettingsClient
/// </summary>
public static void RegisterFeesSettingsClients(this ContainerBuilder builder,
IMyNoSqlSubscriber myNoSqlSubscriber)
{
var subs = new MyNoSqlReadRepository <FeesSettingsNoSqlEntity>(myNoSqlSubscriber,
FeesSettingsNoSqlEntity.TableName);
builder
.RegisterInstance(new FeesSettingsClient(subs))
.As <IFeesSettingsClient>()
.AutoActivate()
.SingleInstance();
}
private static void GetData(MyNoSqlReadRepository <ReplaceEntity> dataReader)
{
Console.WriteLine("--------");
var data = dataReader.Get();
var i = 0;
foreach (ReplaceEntity item in data)
{
Console.WriteLine($"{++i} :{item.Value}");
}
Console.WriteLine("========");
}
public static void RegisterOperationHistoryClient(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber, string operationHistoryGrpcServiceUrl, int maxCachedEntities)
{
var factory = new BalanceHistoryClientFactory(operationHistoryGrpcServiceUrl);
var operationHistoryService = factory.GetOperationHistoryService();
var subs = new MyNoSqlReadRepository <OperationHistoryNoSqlEntity>(myNoSqlSubscriber, OperationHistoryNoSqlEntity.TableName);
builder.RegisterInstance(operationHistoryService).As <IOperationHistoryService>().SingleInstance();
builder
.RegisterInstance(new OperationsHistoryHistoryClient(operationHistoryService, subs, maxCachedEntities))
.As <IOperationsHistoryClient>()
.SingleInstance();
}
private void RegisterNoSqlClient(string brokerId)
{
MyNoSqlTcpClient client;
lock (_gate)
{
if (_myNoSqlSubscriberByBroker.TryGetValue(brokerId, out client))
{
return;
}
client = new MyNoSqlTcpClient(_getMyNoSqlHostPort, $"{_appName}-{brokerId}");
_minuteBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameMinute(brokerId));
_hourBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameHour(brokerId));
_dayBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameDay(brokerId));
_monthBidAskReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleBidAskNoSql>(client, CandleBidAskNoSql.TableNameMonth(brokerId));
_minuteTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameMinute(brokerId));
_hourTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameHour(brokerId));
_dayTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameDay(brokerId));
_monthTradeReaderByBroker[brokerId] = new MyNoSqlReadRepository <CandleTradeNoSql>(client, CandleTradeNoSql.TableNameMonth(brokerId));
_myNoSqlSubscriberByBroker[brokerId] = client;
}
client.Start();
//todo: use wait initialization
var index = 0;
while (index < 50)
{
if (_minuteBidAskReaderByBroker[brokerId].Count() > 0 &&
_hourBidAskReaderByBroker[brokerId].Count() > 0 &&
_dayBidAskReaderByBroker[brokerId].Count() > 0 &&
_monthBidAskReaderByBroker[brokerId].Count() > 0 &&
_minuteTradeReaderByBroker[brokerId].Count() > 0 &&
_hourTradeReaderByBroker[brokerId].Count() > 0 &&
_dayTradeReaderByBroker[brokerId].Count() > 0 &&
_monthTradeReaderByBroker[brokerId].Count() > 0)
{
break;
}
Thread.Sleep(100);
index++;
}
}
public static void RegisterKycCountriesClient(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber, string grpcServiceUrl)
{
var subs = new MyNoSqlReadRepository <KycCountryNoSqlEntity>(myNoSqlSubscriber, KycCountryNoSqlEntity.TableName);
var factory = new KYCClientFactory(grpcServiceUrl, subs);
builder
.RegisterInstance(subs)
.As <IMyNoSqlServerDataReader <KycCountryNoSqlEntity> >()
.SingleInstance();
builder
.RegisterInstance(factory.GetKycCountriesService())
.As <IKycCountriesService>()
.AutoActivate()
.SingleInstance();
}
private static void CheckNoSql()
{
var myNoSqlClient = new MyNoSqlTcpClient(() => "192.168.10.80:5125", "TestApp");
var subs = new MyNoSqlReadRepository <OrderBookNoSql>(myNoSqlClient, OrderBookNoSql.TableName);
myNoSqlClient.Start();
IOrderBookService client = new OrderBookCache(subs);
Console.Write("Symbol: ");
var cmd = Console.ReadLine();
var symbol = "";
while (cmd != "exit")
{
Console.Clear();
if (!string.IsNullOrEmpty(cmd))
{
symbol = cmd;
}
Console.WriteLine($"Symbol: {symbol}");
var book = client.GetOrderBook("jetwallet", symbol);
if (book != null)
{
foreach (var level in book.Where(e => e.Volume < 0).OrderByDescending(e => e.Price))
{
Console.WriteLine($"\t{level.Price}\t{level.Volume}");
}
Console.WriteLine();
foreach (var level in book.Where(e => e.Volume > 0).OrderByDescending(e => e.Price))
{
Console.WriteLine($"{level.Volume}\t{level.Price}");
}
}
Console.WriteLine();
Console.WriteLine();
Console.Write("Symbol: ");
cmd = Console.ReadLine();
}
}
/// <summary>
/// Register interfaces:
/// * IClientWalletService
/// </summary>
public static void RegisterClientWalletsClients(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber, string clientWalletsGrpcServiceUrl)
{
var subs = new MyNoSqlReadRepository <ClientWalletNoSqlEntity>(myNoSqlSubscriber, ClientWalletNoSqlEntity.TableName);
var factory = new ClientWalletsClientFactory(clientWalletsGrpcServiceUrl, subs);
builder
.RegisterInstance(subs)
.As <IMyNoSqlServerDataReader <ClientWalletNoSqlEntity> >()
.SingleInstance();
builder
.RegisterInstance(factory.ClientWalletService())
.As <IClientWalletService>()
.AutoActivate()
.SingleInstance();
}
/// <summary>
/// Register interfaces:
/// * IKycStatusClient
/// </summary>
public static void RegisterKycStatusClients(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber,
string kycStatusServiceUrl)
{
var kycStatusMyNoSqlReadRepository =
new MyNoSqlReadRepository <KycProfileNoSqlEntity>(myNoSqlSubscriber, KycProfileNoSqlEntity.TableName);
var kycClientFactory = new KYCClientFactory(kycStatusServiceUrl);
builder.RegisterInstance(kycStatusMyNoSqlReadRepository)
.As <IMyNoSqlServerDataReader <KycProfileNoSqlEntity> >()
.AutoActivate()
.SingleInstance();
builder
.RegisterInstance(new KycStatusClient(kycStatusMyNoSqlReadRepository,
kycClientFactory.GetKycStatusService()))
.As <IKycStatusClient>()
.AutoActivate()
.SingleInstance();
}
public static void RegisterBitgoDepositAddressClient(this ContainerBuilder builder,
string bitgoDepositDetectorGrpcServiceUrl, IMyNoSqlSubscriber myNoSqlClient)
{
var reader = new MyNoSqlReadRepository <DepositAddressEntity>(myNoSqlClient, DepositAddressEntity.TableName);
var blockchainReader =
new MyNoSqlReadRepository <BlockchainDepositAddressEntity>(myNoSqlClient,
BlockchainDepositAddressEntity.TableName);
builder
.RegisterInstance(reader)
.As <IMyNoSqlServerDataReader <DepositAddressEntity> >()
.SingleInstance();
var factory = new DepositDetectorClientFactory(bitgoDepositDetectorGrpcServiceUrl);
builder
.RegisterInstance(
new DepositAddressServiceCachedClient(factory.GetDepositAddressService(), reader, blockchainReader))
.As <IDepositAddressService>()
.SingleInstance();
}
public static async Task TestReplaceAsync(string hostPort, string serverUrl)
{
var dataWriter = new MyNoSqlServerDataWriter <ReplaceEntity>(() => serverUrl, "test", false);
var client = new MyNoSqlTcpClient(() => hostPort, "test-app");
client.Start();
var dataReader = new MyNoSqlReadRepository <ReplaceEntity>(client, "test");
await Task.Delay(3000);
GetData(dataReader);
await UpdateData(dataWriter);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
GetData(dataReader);
await Task.Delay(3000);
//client.Stop();
}
public void TestInitTableWithMixedNewData()
{
var entity1 = new TestEntity
{
PartitionKey = "PK",
RowKey = "RK",
TimeStamp = "0"
};
var entity2 = new TestEntity
{
PartitionKey = "PK2",
RowKey = "RK2",
TimeStamp = "2"
};
var subscriberMock = new MyNoSqlSubscriberMock();
var dataReader = new MyNoSqlReadRepository <TestEntity>(subscriberMock, "test");
var updates = new List <TestEntity>();
var deletes = new List <TestEntity>();
dataReader.SubscribeToUpdateEvents(updates.AddRange, deletes.AddRange);
subscriberMock.InitAction(new[] { entity1 });
subscriberMock.UpdateAction(new[] { entity2 });
Assert.AreEqual(2, updates.Count);
Assert.AreEqual(0, deletes.Count);
updates.Clear();
subscriberMock.InitAction(new[] { entity2 });
Assert.AreEqual(0, updates.Count);
Assert.AreEqual(1, deletes.Count);
}
public NoSqlClientWalletService(IClientWalletService grpcService, MyNoSqlReadRepository <ClientWalletNoSqlEntity> reader)
{
_grpcService = grpcService;
_reader = reader;
}
public AssetFeesClient(MyNoSqlReadRepository <AssetFeesNoSqlEntity> assetFeesReader,
MyNoSqlReadRepository <FeesSettingsNoSqlEntity> feesSettingsReader)
{
_assetFeesReader = assetFeesReader;
_feesSettingsReader = feesSettingsReader;
}
public SpotInstrumentFeesClient(MyNoSqlReadRepository <SpotInstrumentFeesNoSqlEntity> spotInstrumentsReader,
MyNoSqlReadRepository <FeesSettingsNoSqlEntity> feesSettingsReader)
{
_spotInstrumentsReader = spotInstrumentsReader;
_feesSettingsReader = feesSettingsReader;
}
public SnapshotClient(MyNoSqlReadRepository <SnapshotNoSqlEntity> snapshotReader, ISnapshotService snapshotGrpcService)
{
_snapshotReader = snapshotReader;
_snapshotGrpcService = snapshotGrpcService;
}
public DepositFeesClient(MyNoSqlReadRepository <DepositFeesNoSqlEntity> depositFeesReader)
{
_depositFeesReader = depositFeesReader;
}
public FeesSettingsClient(MyNoSqlReadRepository <FeesSettingsNoSqlEntity> reader)
{
_reader = reader;
}
public static void RegisterAuthorizationSessionCache(this ContainerBuilder builder, IMyNoSqlSubscriber myNoSqlSubscriber)
{
var reader = new MyNoSqlReadRepository <SpotSessionNoSql>(myNoSqlSubscriber, SpotSessionNoSql.TableName);
builder.RegisterInstance(reader).As <IMyNoSqlServerDataReader <SpotSessionNoSql> >().SingleInstance();
}
public CurrentPricesCache(MyNoSqlReadRepository <BidAskNoSql> reader)
{
_reader = reader;
}
public KycCountriesClient(IKycCountriesService grpcService, MyNoSqlReadRepository <KycCountryNoSqlEntity> reader)
{
_grpcService = grpcService;
_reader = reader;
}
