protected override async Task DoTimer()
{
_log.Info("DwhStoreProcedureChannel.DoTimer() - started...");
ResponceDataSet response = await ExecuteProcedure();
_log.Info("DwhStoreProcedureChannel.DoTimer() - executed procedure.", response);
var report = response.Data.Tables
.Cast <DataTable>()
.ToArray();
foreach (var table in report)
{
foreach (DataRow row in table.Rows)
{
var str = new StringBuilder();
foreach (DataColumn column in table.Columns)
{
str.AppendLine($"{column.ColumnName}: {row[column.ColumnName]}");
}
_log.Info("DwhStoreProcedureChannel.DoTimer() - sending a message...", str);
await SendMessage(str.ToString());
_log.Info("DwhStoreProcedureChannel.DoTimer() - finished sending a message.", str);
}
}
_log.Info("DwhStoreProcedureChannel.DoTimer() - finished.");
}
private Task <ResponceDataSet> Process(Dictionary <string, StringValues> parameters)
{
try
{
if (!parameters.ContainsKey(_sqlAdapter.StoredProcedureParamName) ||
string.IsNullOrEmpty(parameters[_sqlAdapter.StoredProcedureParamName]))
{
throw new ArgumentException("spname parameter is missing or empty");
}
ResponceDataSet responce = new ResponceDataSet
{
Data = new DataSet(),
};
var sw = new Stopwatch();
sw.Start();
_sqlAdapter.CallStoredProcedureAndFillDataSet(parameters, responce.Data);
sw.Stop();
var message = $"============\nResult of {parameters[SqlAdapter.SpNameParam]} ({sw.ElapsedMilliseconds} ms): ";
var index = 0;
foreach (DataTable table in responce.Data.Tables)
{
message += $"Table {index} count={table.Rows.Count}; ";
}
message += "\nParams: ";
foreach (var parameter in parameters)
{
message += $"{parameter.Key}={parameter.Value}; ";
}
Console.WriteLine(message);
return(Task.FromResult(responce));
}
catch (Exception ex)
{
_log.Info(nameof(Process), "Exception on execute request", exception: ex, context: $"params: {parameters.ToJson()}");
throw new ValidationApiException(HttpStatusCode.BadRequest, ex.Message);
}
}
private async Task <ResponceDataSet> ExecuteProcedure()
{
int countTry = 3;
while (countTry > 0)
{
countTry--;
try
{
_log.Info("DwhStoreProcedureChannel.ExecuteProcedure() - calling DWH client...", Metainfo);
ResponceDataSet response =
await _dwhClient.Call(new Dictionary <string, string>(), Metainfo, "report");
_log.Info("DwhStoreProcedureChannel.ExecuteProcedure() - successfully received response.", new
{
Procedure = Metainfo,
Response = response
});
return(response);
}
catch (Exception ex)
{
Log.Error(ex, context: $"Procedure: {Metainfo}");
if (countTry <= 0)
{
throw;
}
}
await Task.Delay(5000);
}
throw new Exception("Cannot execute store procedure");
}
protected override async Task DoTimer()
{
ResponceDataSet response = await _dwhClient.Call(new Dictionary <string, string>(), Metainfo, "report");
var report = response.Data.Tables
.Cast <DataTable>()
.ToArray();
var table = report.FirstOrDefault();
if (table == null || table.Rows.Count <= 0)
{
return;
}
var str = new StringBuilder();
str.AppendLine($"please do these actions at cryptofacilities.com");
str.AppendLine();
foreach (DataRow row in table.Rows)
{
if (row[table.Columns[0].ColumnName].ToString() == "Adjustment_Required_($)")
{
var value = decimal.Parse(row[table.Columns[2].ColumnName].ToString());
str.AppendLine($"* Position Adjustment Required at {Math.Round(value, 2)} $, asset: {row[table.Columns[1].ColumnName]}. ");
}
if (row[table.Columns[0].ColumnName].ToString() == "Margin_Adjustment_Required_($)")
{
var value = decimal.Parse(row[table.Columns[2].ColumnName].ToString());
str.AppendLine($"* Margin Adjustment Required at {Math.Round(value, 2)}, asset: {row[table.Columns[1].ColumnName]}. ");
}
}
await SendMessage(str.ToString());
}
private async Task <IReadOnlyCollection <SettlementTrade> > GetTradesAsync()
{
ResponceDataSet response = await RetriesWrapper.RunWithRetriesAsync(() =>
_dwhClient.Call(new Dictionary <string, string>
{
["fromTime"] = "2018-01-01"
},
_tradesSpName, _database));
var settlementTrades = new List <SettlementTrade>();
if (response.Data == null)
{
return(settlementTrades);
}
List <Trade> trades;
List <Transaction> transactions;
using (DataTableReader reader = response.Data.Tables[0].CreateDataReader())
trades = Mapper.Map <List <Trade> >(reader);
using (DataTableReader reader = response.Data.Tables[1].CreateDataReader())
transactions = Mapper.Map <List <Transaction> >(reader);
foreach (Trade trade in trades)
{
TradeType tradeType;
if (trade.Direction == "sell")
{
tradeType = TradeType.Sell;
}
else if (trade.Direction == "buy")
{
tradeType = TradeType.Buy;
}
else
{
continue;
}
Transaction[] tradeTransactions = transactions.Where(o => o.TradeId == trade.TradeId).ToArray();
if (tradeTransactions.Length != 2)
{
continue;
}
if (tradeTransactions.All(o => !trade.AssetPair.StartsWith(o.Asset)) &&
tradeTransactions.All(o => !trade.AssetPair.EndsWith(o.Asset)))
{
continue;
}
var settlementTrade = new SettlementTrade
{
Id = trade.TradeId,
Type = tradeType,
AssetPair = trade.AssetPair,
Price = (decimal)trade.Price,
Timestamp = trade.Timestamp,
IsCompleted = false
};
foreach (Transaction transaction in tradeTransactions)
{
if (settlementTrade.AssetPair.StartsWith(transaction.Asset))
{
settlementTrade.BaseAsset = transaction.Asset;
settlementTrade.Volume = (decimal)Math.Abs(transaction.Amount);
}
else if (settlementTrade.AssetPair.EndsWith(transaction.Asset))
{
settlementTrade.QuoteAsset = transaction.Asset;
settlementTrade.OppositeVolume = (decimal)Math.Abs(transaction.Amount);
}
}
settlementTrades.Add(settlementTrade);
}
return(settlementTrades);
}
