public async Task <BalanceProviderModel> Send(decimal value, WalletTableModel walletSender, WalletTableModel walletReceiver)
{
var currency = await _walletsRepository.GetCurrencyByAcronimAsync(walletSender.CurrencyAcronim);
BalanceProviderModel balanceProviderModel = new();
balanceProviderModel.PercentCommission = currency.PercentCommissionForTransfer;
balanceProviderModel.StartBalanceSender = walletSender.Value;
balanceProviderModel.StartBalanceReceiver = walletReceiver.Value;
if (currency.PercentCommissionForTransfer != null)
{
balanceProviderModel.Commission = value * currency.PercentCommissionForTransfer.Value;
balanceProviderModel.ResultBalanceSender = walletSender.Value - value;
balanceProviderModel.ResultBalanceReceiver = walletReceiver.Value + (value - balanceProviderModel.Commission.Value);
}
else
{
balanceProviderModel.ResultBalanceSender = walletSender.Value - value;
balanceProviderModel.ResultBalanceReceiver = walletReceiver.Value + value;
}
return(balanceProviderModel);
}
public async Task UpdateWalletBalanceAsync(WalletTableModel wallet)
{
try
{
await _db.ExecuteAsync("UpdateWalletBalance",
new
{
walletId = wallet.Id,
newWalletBalance = wallet.Value
},
commandType : CommandType.StoredProcedure);
}
catch (Exception ex) { return; }
}
public async Task <WalletTableModel> GetUserWalletAsync(string userId, string acronim)
{
try
{
WalletTableModel result = ((List <WalletTableModel>) await _db.QueryAsync <WalletTableModel>("GetUserWalletByAcronim",
new
{
userId = userId,
acronim = acronim
},
commandType: CommandType.StoredProcedure
)).FirstOrDefault();
return(result);
}
catch (Exception ex) { return(null); }
}
public async Task <BalanceProviderModel> Withdraw(decimal value, WalletTableModel wallet)
{
var currency = await _walletsRepository.GetCurrencyByAcronimAsync(wallet.CurrencyAcronim);
BalanceProviderModel balanceProviderModel = new();
balanceProviderModel.PercentCommission = currency.PercentCommissionForOutcomeTransaction;
balanceProviderModel.StartBalanceSender = wallet.Value;
if (currency.PercentCommissionForOutcomeTransaction != null)
{
balanceProviderModel.Commission = value * currency.PercentCommissionForOutcomeTransaction.Value;
}
balanceProviderModel.ResultBalanceSender = wallet.Value - value;
return(balanceProviderModel);
}
public async Task <WalletTableModel> CreateUserWalletAsync(WalletTableModel wallet)
{
try
{
var p = new DynamicParameters();
p.Add("userId", wallet.UserId);
p.Add("address", wallet.Address);
p.Add("currencyAcronim", wallet.CurrencyAcronim);
p.Add("value", wallet.Value);
p.Add("new_identity", dbType: DbType.Int32, direction: ParameterDirection.Output);
await _db.QueryAsync <int>("CreateUserWallet", p, commandType : CommandType.StoredProcedure);
wallet.Id = p.Get <int>("new_identity");
return(wallet);
}
catch (Exception ex) { return(null); }
}
public async Task <BalanceProviderModel> Income(WalletTableModel walletTableModel,
IncomeTransactionTableModel incomeTransaction)
{
var currency = await _walletsRepository.GetCurrencyByAcronimAsync(incomeTransaction.CurrencyAcronim);
var balanceProviderModel = new BalanceProviderModel();
balanceProviderModel.PercentCommission = currency.PercentCommissionForIncomeTransaction;
balanceProviderModel.StartBalanceReceiver = walletTableModel.Value;
if (currency.PercentCommissionForIncomeTransaction != null)
{
balanceProviderModel.Commission = incomeTransaction.Amount * currency.PercentCommissionForIncomeTransaction.Value;
balanceProviderModel.ResultBalanceReceiver = walletTableModel.Value + (incomeTransaction.Amount - balanceProviderModel.Commission.Value);
}
else
{
balanceProviderModel.ResultBalanceReceiver = walletTableModel.Value + incomeTransaction.Amount;
}
return(balanceProviderModel);
}
public async Task <ActionResult> Crypto(string firstCurrency, string secondCurrency)
{
CryptoModel model = new CryptoModel();
List <PairsTableModel> pairs = await _pairsRepository.GetAllPairsAsync();
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (!string.IsNullOrEmpty(userId))
{
model.UserId = userId;
var userWallets = await _walletsRepository.GetUserWalletsAsync(userId);
model.UserWallets = userWallets;
WalletTableModel firstWallet = userWallets.FirstOrDefault(x => x.CurrencyAcronim == firstCurrency.ToUpper());
if (firstWallet == null)
{
var newWallet = new WalletTableModel
{
UserId = userId,
CurrencyAcronim = firstCurrency.ToUpper(),
Address = System.Guid.NewGuid().ToString().Replace("-", ""),
Value = 0
};
firstWallet = await _walletsRepository.CreateUserWalletAsync(newWallet);
}
model.UserWallets.Add(firstWallet);
model.FirstWallet = firstWallet;
WalletTableModel secondWallet = userWallets.FirstOrDefault(x => x.CurrencyAcronim == secondCurrency.ToUpper());
if (secondWallet == null)
{
var newWallet = new WalletTableModel
{
UserId = userId,
CurrencyAcronim = secondCurrency.ToUpper(),
Address = System.Guid.NewGuid().ToString().Replace("-", ""),
Value = 0
};
secondWallet = await _walletsRepository.CreateUserWalletAsync(newWallet);
}
model.UserWallets.Add(secondWallet);
model.SecondWallet = secondWallet;
model.UserOpenOrders = await _tradeRepository.GetOpenOrders_ByCreateUserIdWithOrderByDescCreateDate(userId, firstCurrency, secondCurrency);
}
firstCurrency = firstCurrency.ToUpper();
secondCurrency = secondCurrency.ToUpper();
model.BuyOrderBook = await _tradeRepository.GetBuyOrderBookAsync(firstCurrency, secondCurrency);
model.SellOrderBook = await _tradeRepository.GetSellOrderBookAsync(firstCurrency, secondCurrency);
model.MarketTrades = await _tradeRepository.GetClosedOrders_Top100(firstCurrency, secondCurrency);
return(View(model));
}
public async Task <ActionResult> BTCUSDT()
{
List <WalletTableModel> userWallets = new List <WalletTableModel>();
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
BTC_USDTViewModel model = new BTC_USDTViewModel();
if (!string.IsNullOrEmpty(userId))
{
model.UserId = userId;
userWallets = await _walletsRepository.GetUserWalletsAsync(userId);
model.UserWallets = userWallets;
WalletTableModel btcWallet = userWallets.FirstOrDefault(x => x.CurrencyAcronim == "BTC");
if (btcWallet == null)
{
var newbtcWallet = new WalletTableModel
{
UserId = userId,
CurrencyAcronim = "BTC",
Address = System.Guid.NewGuid().ToString().Replace("-", ""),
Value = 0
};
btcWallet = await _walletsRepository.CreateUserWalletAsync(newbtcWallet);
}
model.UserWallets.Add(btcWallet);
model.BtcWallet = btcWallet;
WalletTableModel usdtWallet = userWallets.FirstOrDefault(x => x.CurrencyAcronim == "USDT");
if (usdtWallet == null)
{
usdtWallet = new WalletTableModel
{
UserId = userId,
CurrencyAcronim = "USDT",
Address = System.Guid.NewGuid().ToString().Replace("-", ""),
Value = 0
};
usdtWallet = await _walletsRepository.CreateUserWalletAsync(usdtWallet);
}
model.UserWallets.Add(usdtWallet);
model.UsdtWallet = usdtWallet;
model.UserOpenOrders = await _tradeRepository.spGet_BTC_USDT_OpenOrders_ByCreateUserIdWithOrderByDescCreateDate(userId);
}
model.BuyOrderBook = await _tradeRepository.Get_BTC_USDT_BuyOrderBookAsync();
model.SellOrderBook = await _tradeRepository.Get_BTC_USDT_SellOrderBookAsync();
model.MarketTrades = await _tradeRepository.spGet_BTC_USDT_ClosedOrders_Top100();
return(View(model));
}
public async Task <WalletTableModel> GetUpdatedWalletAsync(string userId)
{
WalletTableModel wallet = await _walletsRepository.GetUserWalletAsync(userId, "ZEC");
if (wallet == null)
{
return(null);
}
List <IncomeWalletTableModel> incomeZecWallets = await _walletsRepository.GetUserIncomeWalletsByAcronimAsync(userId, "ZEC");
List <IncomeTransactionTableModel> transactionModels = await _transactionsRepository.GetIncomeTransactions(userId, "ZEC");
List <string> savedTransactions = transactionModels.Select(x => x.TransactionId).ToList();
foreach (var incomeZecWallet in incomeZecWallets)
{
List <ZecDeltas> addressIncomeTransactions = GetAddressIncomingTransactions(incomeZecWallet.Address);
foreach (var tx in addressIncomeTransactions)
{
if (!savedTransactions.Contains(tx.TxId))
{
var transaction = await _transactionsRepository.CreateIncomeTransactionAsync(new IncomeTransactionTableModel()
{
CurrencyAcronim = "ZEC",
TransactionId = tx.TxId,
Amount = tx.Satoshis / 100000000,
UserId = userId,
FromAddress = null,
ToAddress = tx.Address,
TransactionFee = 0,
});
var result = await _balanceProvider.Income(wallet, transaction);
await _eventsRepository.CreateEventAsync(new EventTableModel()
{
UserId = userId,
Type = (int)EventTypeEnum.Income,
Comment = $"Income transaction {transaction.CurrencyAcronim}",
WhenDate = DateTime.Now,
CurrencyAcronim = transaction.CurrencyAcronim,
StartBalance = result.StartBalanceReceiver,
ResultBalance = result.ResultBalanceReceiver,
PlatformCommission = result.Commission,
Value = transaction.Amount
});
transaction.PlatformCommission = result.Commission;
wallet.Value = result.ResultBalanceReceiver.Value;
transaction.PlatformCommission = result.Commission;
await _transactionsRepository.CreateIncomeTransactionAsync(transaction);
}
}
}
await _walletsRepository.UpdateWalletBalanceAsync(wallet);
return(wallet);
}
