private Transaction CreateTransaction(Match match, Stock userStock, Stock externalStock,
TransactionType defaultOutcome, TransactionType defaultIncome)
{
int day = int.Parse(match.Groups["Day"].Value);
int month = int.Parse(match.Groups["Month"].Value);
int year = int.Parse(match.Groups["Year"].Value);
int id = int.Parse(match.Groups["Id"].Value);
string operationType = match.Groups["OperationType"].Value.Trim();
var noteLines = match.Groups["Note"].Value.Split('\n');
string title = match.Groups["Title"].Value.Trim();
string currency = match.Groups["Currency"].Value.Trim();
bool negativeSign = match.Groups["Sign"].Value.Equals("-");
int bigValue = int.Parse(match.Groups["ValueWithSpaces"].Value.Replace(" ", string.Empty));
int smallValue = int.Parse(match.Groups["ValueAfterComma"].Value);
decimal value = bigValue + smallValue / 100m;
var date = new DateTime(year, month, day);
string note =
$"{id} - {string.Join(" ", noteLines.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x.Trim()))} {operationType}";
bool isBalanceNote = match.Groups["BalanceValueWithSpaces"].Success;
if (isBalanceNote)
{
int bigValueBalance = int.Parse(match.Groups["BalanceValueWithSpaces"].Value.Replace(" ", string.Empty));
int smallValueBalance = int.Parse(match.Groups["BalanceValueAfterComma"].Value);
decimal balance = bigValueBalance + smallValueBalance / 100m;
note = $"{note} saldo: {balance:#,##0.00} ({currency})";
if (!Balances.ContainsKey(userStock))
{
Balances[userStock] = new Dictionary <DateTime, decimal>();
}
if (!Balances[userStock].ContainsKey(date))
{
Balances[userStock][date] = balance;
}
}
var transactionType = negativeSign ? defaultOutcome : defaultIncome;
var position = new Position(title, value);
return(new Transaction(transactionType, date, title, note, new List <Position> {
position
}, userStock, externalStock));
}
/// <summary>
///
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/v2/account/balance", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <Dictionary <string, JToken> >(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances.ContainsKey(_currency_id.Key) == false)
{
continue;
}
var _balance = privateClient.DeserializeObject <CBalanceItem>(_balances[_currency_id.Key].ToString());
if (_balance != null)
{
_balance.currency = _currency_id.Value;
_balance.used = _balance.total - _balance.free;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// ACCOUNT BALANCES
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/v2/balance/", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <JToken>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
if (_balances.SelectToken($"{_currency_id.Key}_available") != null)
{
var _balance = new BBalanceItem
{
free = _balances[$"{_currency_id.Key}_available"].Value <decimal>(),
used = _balances[$"{_currency_id.Key}_reserved"].Value <decimal>()
};
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
protected override bool Execute(CodeActivityContext context)
{
if (string.IsNullOrEmpty(ObjectIds))
{
Errors.Set(context, "Не определены объекты для которых будет сформирован баланс");
return(false);
}
MultiPsSelectedArgs args;
try
{
args = ObjectIds.DeserializeFromString <MultiPsSelectedArgs>();
}
catch (Exception ex)
{
Errors.Set(context, "Ошибка преобразования параметров " + ex.Message);
return(false);
}
try
{
var res = ARM_Service.BL_GetFreeHierarchyBalanceByObjects(args.PSList,
StartDateTime.Get(context),
EndDateTime.Get(context), TimeZoneId,
DiscreteType, UnitDigit);
if (res != null && res.CalculatedValues != null)
{
Balances.Set(context, res.CalculatedValues.Values.ToList());
if (res.Errors != null && res.Errors.Length > 0)
{
Errors.Set(context, res.Errors.ToString());
}
}
}
catch (Exception ex)
{
Errors.Set(context, ex.Message);
if (!HideException.Get(context))
{
throw ex;
}
}
return(string.IsNullOrEmpty(Errors.Get(context)));
}
private void Initial()
{
bool isStop = false;
while (!isStop)
{
Teachers.Add(TeacherGenerator());
if (Teachers.Count > 4)
{
isStop = true;
}
}
Balances.Add(BalanceGenerator());
StockGenerator();
}
private async void Intialize()
{
AddBalanceCommand = new Command(AddBalance);
PlusPage = new Command(OpenPlusPage);
MinusPage = new Command(OpenMinusPage);
EditBalanceCommand = new Command(EditBalance);
Balances = JsonConvert.DeserializeObject <ObservableCollection <Balance> >(await DependencyService.Get <IFileWorker>().LoadTextAsync(BalanceFile));
Categories = JsonConvert.DeserializeObject <ObservableCollection <Category> >(await DependencyService.Get <IFileWorker>().LoadTextAsync(CategoriesFile));
Balances.CollectionChanged += Balances_CollectionChanged;
Categories.CollectionChanged += Categories_CollectionChanged;
LastBalance = Balances.Sum(x => x.Count);
}
public bool grabarMovimiento(Balances balance)
{
SqlCommand Comando = new SqlCommand();
String nombreSp = "spGrabarBalance";
ArmarParametrosBalance(ref Comando, balance);
if (EjecutarProcedimientoAlmacenado(Comando, nombreSp) >= 1)
{
return(true);
}
else
{
return(false);
}
}
public void ArmarParametrosBalance(ref SqlCommand Comando, Balances balance)
{
SqlParameter parametros = new SqlParameter();
parametros = Comando.Parameters.Add("@MONTO", SqlDbType.Float);
parametros.Value = balance.Monto;
parametros = Comando.Parameters.Add("@DIA", SqlDbType.Int);
parametros.Value = balance.Dia;
parametros = Comando.Parameters.Add("@MES", SqlDbType.Int);
parametros.Value = balance.Mes;
parametros = Comando.Parameters.Add("@AÑO", SqlDbType.Int);
parametros.Value = balance.Año;
parametros = Comando.Parameters.Add("@TIPO", SqlDbType.Int);
parametros.Value = balance.Tipo;
}
///<summary>
/// Example of how we can build a json using class Object.
/// Balances bal = new Balances{
///cashBalance=1.0,
///heldCashBalance=1.0};
/// </summary>
void buildJson()
{
Debug.Log("we are building a json from object");
Balances bal = new Balances
{
cashBalance = 1.0,
heldCashBalance = 1.0,
availableCashBalance = 1.0,
availableGameplayBalance = 1.0,
pendingGameplayBalance = 1.0
};
string json = JsonConvert.SerializeObject(bal, Formatting.Indented);
Debug.Log(json);
}
private void RemoveSelectedItems()
{
List <ObjectListViewItem> selectedItems = new List <ObjectListViewItem>();
foreach (var item in BalancesListView.SelectedItems)
{
selectedItems.Add(item as ObjectListViewItem);
}
foreach (ObjectListViewItem item in selectedItems)
{
BalancesListView.Items.Remove(item);
Balances.Remove(item.UnderlyingObject as BalanceInformation);
}
}
public double GetBalance(string currency)
{
try {
if (Exchange.GetBalance(this, currency))
{
BalanceBase res = Balances.FirstOrDefault(b => b.Currency == currency);
return(res == null? 0: res.Available);
}
return(-1);
}
catch (Exception e) {
Telemetry.Default.TrackException(e);
return(-1);
}
}
/// <summary>
/// Get current account information.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiGet1Async("/account", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = privateClient.DeserializeObject <JObject>(_json_value.Content);
{
var _json_balances = privateClient.DeserializeObject <List <BBalanceItem> >(_json_data["balances"].ToString());
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balances = _json_balances.Where(b => b.currency == _currency_id.Key);
foreach (var _balance in _balances)
{
_balance.currency = _currency_id.Value;
_balance.total = _balance.free + _balance.used;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
private void UpdateBalances()
{
Balances.Clear();
foreach (var ticketEntity in SelectedTicket.TicketEntities)
{
if (ticketEntity.AccountId > 0)
{
var entityType = _cacheService.GetEntityTypeById(ticketEntity.EntityTypeId);
if (_applicationState.GetPaymentScreenPaymentTypes().Any(x => x.AccountTransactionType.TargetAccountTypeId == entityType.AccountTypeId))
{
var balance = _accountService.GetAccountBalance(ticketEntity.AccountId);
Balances.Add(ticketEntity.AccountId, balance);
}
}
}
}
public Transaction[] Parse(string input, Stock userStock, Stock externalStock, TransactionType defaultOutcome,
TransactionType defaultIncome, bool generateMissingStocks = false)
{
Balances.Clear();
if (userStock != null)
{
Balances[userStock] = new Dictionary <DateTime, decimal>();
}
var output = new List <Transaction>();
var lines = input.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
var elements = ColumnSplitter == null
? line.Count(x => x == ';') >= (Rules.Any() ? Rules.Max(x => x.Index) : 0)
? line.Split(';')
: line.Split(new[] { line.Contains("\",\"") ? "\",\"" : "," }, StringSplitOptions.None)
: line.Split(new[] { ColumnSplitter }, StringSplitOptions.None);
elements = elements.Select(x => x.Replace("\"", string.Empty)).ToArray();
var transaction = new Transaction
{
ExternalStock = externalStock,
UserStock = userStock
};
transaction.Positions.Add(new Position());
bool match = Rules.Any();
foreach (var rule in Rules)
{
if (!MatchRule(rule, elements, transaction, defaultIncome, defaultOutcome, userStock, generateMissingStocks))
{
match = false;
break;
}
}
transaction.RecalculateId();
if (match)
{
output.Add(transaction);
}
}
return(output.ToArray());
}
public Transaction[] Parse(string input, Stock userStock, Stock externalStock,
TransactionType defaultOutcome, TransactionType defaultIncome, bool generateMissingStocks = false)
{
Balances.Clear();
var output = new List <Transaction>();
var regex = new Regex(RegexValue);
foreach (Match match in regex.Matches(input))
{
output.Add(CreateTransaction(match, userStock, externalStock, defaultOutcome, defaultIncome));
}
ParseBalanceHelper.AdjustMissingBalances(output, Balances);
return(output.ToArray());
}
public async Task <Exception> TryUpdateAccountInfo(UserInfo userInfo)
{
if (!ConnectedUsers.ContainsKey(userInfo.Id))
{
return(new ValidationException(string.Empty));
}
var response = await TryRunTask <string, AccountInfoResponse>(GetAccountInfo, OnDisposeCts.Token, userInfo.Login);
if (response.IsSuccess)
{
ConnectedUsers[userInfo.Id].AccountInfo = response.Result;
var responseBalances = response.Result.Balances;
responseBalances.ForEach(x => x.UserInfo = ConnectedUsers[userInfo.Id]);
lock (Balances)
{
responseBalances.ForEach(x =>
{
var balanceInd = Balances.FindIndex(y => y.UserInfo.Id == x.UserInfo.Id && y.CurrencyType == x.CurrencyType);
if (balanceInd >= 0)
{
Balances[balanceInd] = x;
}
else
{
Balances.Add(x);
}
});
}
}
else
{
return(response.Exception);
}
var historyResp = await TryRunTask <string, AccountHistoryResponse[]>(GetAccountHistory, OnDisposeCts.Token, userInfo.Login);
if (historyResp.IsSuccess)
{
ConnectedUsers[userInfo.Id].AccountHistory = historyResp.Result;
return(null);
}
return(historyResp.Exception);
}
/// <summary>
/// Used to retrieve all balances from your account.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalancesAsync(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarketsAsync();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiPost1Async("/api/v1/fund/allAccount", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <BBalances>(_json_value.Content);
{
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _balances.result.Where(b => b.currency == _currency_id.Key).SingleOrDefault();
if (_balance != null)
{
//_balance.total = _balance.free + _balance.used;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
/// <summary>
/// Check ETH, ETC, and KRW and BTC balances. Request or cancel BTC withdrawals.
/// </summary>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <Balances> FetchBalances(Dictionary <string, object> args = null)
{
var _result = new Balances();
var _markets = await publicApi.LoadMarkets();
if (_markets.success == true)
{
privateClient.ExchangeInfo.ApiCallWait(TradeType.Private);
var _params = privateClient.MergeParamsAndArgs(args);
var _json_value = await privateClient.CallApiGet1Async("/user/balances", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = privateClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _balances = privateClient.DeserializeObject <Dictionary <string, KBalanceItem> >(_json_value.Content);
foreach (var _currency_id in _markets.CurrencyNames)
{
var _balance = _balances.Where(b => b.Key == _currency_id.Key).SingleOrDefault().Value;
if (_balance != null)
{
_balance.used = _balance.trade_in_use + _balance.withdrawal_in_use;
_balance.total = _balance.used + _balance.free;
_balance.currency = _currency_id.Value;
_result.result.Add(_balance);
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_markets);
}
return(_result);
}
private void SetExchangeChart(string exchange)
{
List <ExchangeBalance> list = Balances.Where(item => item.Balance > 0 && item.Exchange == exchange).ToList();
List <ExchangeBalance> wallets = WalletManager.GetWalletBalances();
list.AddRange(wallets.Where(balance => balance.Exchange == exchange));
List <string> symbols = new List <string>();
List <decimal> totals = new List <decimal>();
foreach (ExchangeBalance balance in list.OrderByDescending(item => item.TotalInBTC))
{
symbols.Add(balance.Symbol);
totals.Add(balance.TotalInUSD);
}
decimal[] yValues = totals.ToArray();
string[] xValues = symbols.ToArray();
Series series1 = chart.Series[0];
series1["CollectedThreshold"] = "1";
series1["CollectedThresholdUsePercent"] = "true";
series1["CollectedLabel"] = "Below 1%";
series1["CollectedLegendText"] = "Below 1%";
series1["CollectedColor"] = "Red";
series1["CollectedToolTip"] = "Below 1%";
chart.Series["Default"].Font = PreferenceManager.GetFormFont(ParentForm);
chart.Titles[0].Font = chart.Series["Default"].Font;
chart.Titles[0].Text = symbols.Count + " " + exchange + " BALANCES BY PERCENTAGE (" + list.Sum(balance => balance.TotalInUSD).ToString("C") + ")";
chart.Series["Default"].Points.DataBindXY(xValues, yValues);
chart.Series["Default"].ChartType = SeriesChartType.Pie;
chart.Series["Default"]["PieLabelStyle"] = "Outside";
chart.Series["Default"]["PieDrawingStyle"] = "SoftEdge";
chart.Series[0].ToolTip = "Percent: #PERCENT";
chart.Series[0].ToolTip = "#VALX" + " : " + "#PERCENT" + " (" + "#VALY{$#,##0.00}" + ")";
chart.Series[0].LabelToolTip = "#VALY{$#,##0.00}";
chart.Series[0].Label = "#VALX" + " (" + "#PERCENT" + ")";
chart.ChartAreas[0].Area3DStyle.Enable3D = true;
chart.ChartAreas[0].Area3DStyle.Inclination = 0;
}
public decimal GetBalanceForDate(DateTime date)
{
var lastBalanceBeforeDate = Balances.Where(x => x.Date <= date).OrderByDescending(x => x.Date).FirstOrDefault();
if (lastBalanceBeforeDate != null)
{
var sumExpences = Expences.Where(x => x.Date > lastBalanceBeforeDate.Date && x.Date <= date).Sum(x => x.Amount);
var sumIncome = Income.Where(x => x.Date > lastBalanceBeforeDate.Date && x.Date <= date).Sum(x => x.Amount);
var sum = sumIncome - sumExpences;
return(lastBalanceBeforeDate.Amount + sum);
}
else
{
var sumExpences = Expences.Where(x => x.Date <= date).Sum(x => x.Amount);
var sumIncome = Income.Where(x => x.Date <= date).Sum(x => x.Amount);
return(sumIncome - sumExpences);
}
}
public async Task <IActionResult> UpdateOpeningBalance([FromBody] Balances balances)
{
if (balances == null)
{
return(BadRequest("Updation Failed"));
}
try
{
_unitOfWork.Balances.Update(balances);
_unitOfWork.SaveChanges();
return(Ok(balances));
}
catch
{
return(BadRequest("Updation Failed"));
}
}
public async Task <Exception> TryClaimRewards(BalanceModel balance)
{
var claimRewardsModel = new ClaimRewardsModel(balance.UserInfo, balance.RewardSteem, balance.RewardSp, balance.RewardSbd);
var response = await TryRunTask <ClaimRewardsModel, VoidResponse>(ClaimRewards, CancellationToken.None, claimRewardsModel);
if (response.IsSuccess)
{
Balances.ForEach(x =>
{
if (x.UserInfo.Chain == balance.UserInfo.Chain &&
x.UserInfo.Login.Equals(balance.UserInfo.Login, StringComparison.OrdinalIgnoreCase))
{
x.RewardSteem = x.RewardSbd = x.RewardSp = 0;
}
});
await TryUpdateAccountInfo(balance.UserInfo);
}
return(response.Exception);
}
private void SetBalance()
{
List <ExchangeBalance> balances = Balances.Where(item => item.Symbol == symbol).ToList();
List <ExchangeBalance> wallets = WalletManager.GetWalletBalancesBySymbol(symbol);
balances.AddRange(wallets);
Decimal balance = balances.Sum(item => item.Balance);
Decimal usd = balances.Sum(item => item.TotalInUSD);
if (balance > 0)
{
balanceLabel.Text = balance.ToString("N8") + " (" + usd.ToString("C") + ")";
balanceLabel.Visible = true;
}
else
{
balanceLabel.Visible = false;
}
}
public void UpdateUI(bool resize = false)
{
if (InvokeRequired)
{
UpdateUICallback d = new UpdateUICallback(UpdateUI);
Invoke(d, new object[] { resize });
}
else
{
try
{
List <ExchangeBalance> list = Balances.Where(item => item.Balance > 0).ToList();
List <ExchangeBalance> wallets = GetWalletBalances();
list.AddRange(wallets);
var roots = list.Select(b => b.Symbol).Distinct();
toolStripLabel_count.Text = roots.Count() + " Coins";
toolStripLabel_btc.Text = list.Sum(b => b.TotalInBTC).ToString("N8");
toolStripLabel_usd.Text = list.Sum(b => b.TotalInUSD).ToString("C");
//AddLogMessage(Name, "UpdateUI", PreferenceManager.preferences.BalanceView.GetHashCode().ToString() + " | " + tabControl.TabPages.Count, LogMessageType.DEBUG);
//if (tabControl.TabPages.Count > 0)
//{
tabControl.SelectedIndex = PreferenceManager.preferences.BalanceView.GetHashCode();
//tabControl.SelectedIndex = 1;
//}
//tabControl.SelectedIndex = PreferenceManager.preferences.BalanceView.GetHashCode();
//tabControl.SelectedIndex = 0;
SetView(resize);
if (resize)
{
ResizeUI();
}
}
catch (Exception ex)
{
AddLogMessage(Name, "UpdateUI", "EXCEPTION : " + ex.Message, LogMessageType.EXCEPTION);
}
}
}
public async Task <ActionResult <Balances> > PostBalances([FromForm] Balances balances)
{
ActionResponses actionResponses;
if (User.IsInRole("Admin"))
{
_context.tBalance.Add(balances);
await _context.SaveChangesAsync();
InsertLog("Topup", "Execution Success", "0");
InsertUserLog(balances.fUsername, "Topup", "eWallet Created");
actionResponses = _actionResponse.tActionResponses.FirstOrDefault(x => x.fErrorCode == "0");
return(CreatedAtAction("GetBalance", actionResponses));
}
else
{
InsertLog("Create eWallet", "Execution Failed", "4");
actionResponses = _actionResponse.tActionResponses.FirstOrDefault(x => x.fErrorCode == "4");
return(CreatedAtAction("GetBalance", actionResponses));
}
}
public async Task <IActionResult> Index()
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
DashboardViewModel dashboard = new DashboardViewModel();
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
API api = db.Customers.Include(c => c.API).Where(c => c.UserId == userId).Select(a => a.API).Single();
Balances balances = new Balances(api);
dashboard.Balances = await balances.GetBalanceValues();
stopwatch.Stop();
TimeSpan ts = stopwatch.Elapsed;
List <string> Symbols = new List <string> {
"ZILBTC", "TRXBTC", "BNBBTC", "BTCUSDT", "XZCXRP", "XRPUSDT", "WAVESETH", "ADABNB", "KMDBTC", "VIBEBTC", "REPBTC", "BTTBTC", "MTLBTC", "WINGSBTC", "STEEMBTC"
};
ViewBag.Markets = new SelectList(Symbols);
return(View(dashboard));
}
/// <summary>
/// Get your account's margin status.
/// </summary>
/// <returns></returns>
public async ValueTask <Balances> GetUserMargins()
{
var _result = new Balances();
var _params = new Dictionary <string, object>();
{
_params.Add("currency", "all");
}
var _response = await privateClient.CallApiGet2Async("/api/v1/user/margin", _params);
if (_response != null)
{
#if RAWJSON
_result.rawJson = _response.Content;
#endif
if (_response.IsSuccessful == true)
{
var _balances = privateClient.DeserializeObject <List <BBalanceItem> >(_response.Content);
if (_balances != null)
{
foreach (var _balance in _balances)
{
_balance.used = _balance.total - _balance.free;
}
_result.result = _balances.ToList <IBalanceItem>();
_result.SetSuccess();
}
}
else
{
var _message = privateClient.GetResponseMessage(_response);
_result.SetFailure(_message.message);
}
}
return(_result);
}
public async Task RefreshBalances(Storage.WalletType originalCurrency, CancellationToken cancellationToken)
{
var originalBalanceModel = Balances.FirstOrDefault(b => b.WalletType == originalCurrency);
if (originalBalanceModel == null)
{
throw new ArgumentException($"Balance item model for '{originalCurrency}' not found");
}
BalanceConverter converter = new BalanceConverter();
foreach (var balanceItemModel in Balances)
{
if (balanceItemModel.WalletType != originalCurrency)
{
var balance = await converter.GetBalance(originalCurrency, originalBalanceModel.Value,
balanceItemModel.WalletType, cancellationToken);
balanceItemModel.Value = balance;
}
}
}
private void SetExchangesChart()
{
List <ExchangeBalance> list = Balances.Where(item => item.Balance > 0).ToList();
List <ExchangeBalance> wallets = WalletManager.GetWalletBalances();
list.AddRange(wallets);
var roots = list.Select(b => b.Exchange).Distinct();
List <string> exchanges = new List <string>();
List <decimal> totals = new List <decimal>();
foreach (string exchange in roots)
{
//LogManager.AddLogMessage(Name, "InitializeChart", exchange, LogManager.LogMessageType.DEBUG);
exchanges.Add(exchange);
totals.Add(list.Where(balance => balance.Exchange == exchange).Sum(balance => balance.TotalInUSD));
}
decimal[] yValues = totals.ToArray();
string[] xValues = exchanges.ToArray();
chart.Series["Default"].Font = PreferenceManager.GetFormFont(ParentForm);
chart.Titles[0].Font = chart.Series["Default"].Font;
chart.Titles[0].Text = exchanges.Count + " EXCHANGES BY PERCENTAGE (" + list.Sum(balance => balance.TotalInUSD).ToString("C") + ")";
chart.Series["Default"].Points.DataBindXY(xValues, yValues);
chart.Series["Default"].ChartType = SeriesChartType.Pie;
chart.Series["Default"]["PieLabelStyle"] = "Outside";
chart.Series["Default"]["PieDrawingStyle"] = "SoftEdge";
chart.Series[0].ToolTip = "Percent: #PERCENT";
chart.Series[0].ToolTip = "#VALX" + " : " + "#PERCENT" + " (" + "#VALY{$#,##0.00}" + ")";
chart.Series[0].LabelToolTip = "#VALY{$#,##0.00}";
chart.Series[0].Label = "#VALX" + " (" + "#PERCENT" + ")";
chart.ChartAreas[0].Area3DStyle.Enable3D = true;
chart.ChartAreas[0].Area3DStyle.Inclination = 0;
}
public async Task <Balances> GetByIdAsync(string brokerId, long accountId, long walletId, string asset)
{
using (var context = _connectionFactory.CreateDataContext())
{
IQueryable <BalanceEntity> query = context.Balances;
query = query.Where(x => x.AccountId == accountId);
if (walletId != 0)
{
query = query.Where(x => x.WalletId == walletId);
}
query = query.Where(x => x.BrokerId == brokerId);
query = query.Where(x => x.Asset.ToUpper() == asset.ToUpper());
var balances = await query.ToListAsync();
balances = MergeBalances(balances);
var result = new Balances();
result.Timestamp = DateTime.UtcNow;
result.AccountId = accountId;
result.WalletId = walletId;
balances.ForEach(x => result.List.Add(new Balance
{
Amount = decimal.Parse(x.Balance),
Asset = x.Asset,
Reserved = decimal.Parse(x.Reserved),
Timestamp = x.Timestamp
}));
return(result);
}
}
