public IEnumerable <Transaction> GetTransactions(DateTime dateFrom, DateTime dateTo, ETransactionType transactionType, Guid accountId)
{
return(_context.Transactions
.AsNoTracking()
.Where(TransactionQueries.GetTransactions(dateFrom, dateTo, transactionType, accountId))
.OrderBy(x => x.CreateDate));
}
public List <AppViewModel> GetAllApps()
{
var appQuery = new AppQueries(_context);
var txQuery = new TransactionQueries(_context);
List <AppViewModel> appsList = new List <AppViewModel>();
var apps = appQuery.QueryApps();
foreach (var appInfo in apps)
{
var txCount = txQuery.QueryTotalChainTransactionCount(appInfo.Id);
var vm = AppViewModel.FromApp(appInfo);
vm.TxCount = txCount;
appsList.Add(vm);
}
appsList = appsList.OrderByDescending(x => x.TxCount).ToList();
for (int i = 0; i < appsList.Count; i++)
{
appsList[i].Rank = i + 1;
}
return(appsList);
}
public List <TransactionViewModel> GetTransactions(int currentPage, int pageSize = AppSettings.PageSize, string chain = null)
{
var txQuery = new TransactionQueries(_context);
var query = txQuery.QueryTransactions(chain).Skip((currentPage - 1) * pageSize).Take(pageSize);
return(query.AsEnumerable().Select(TransactionViewModel.FromTransaction).ToList());
}
public List <TransactionViewModel> GetTransfers(string symbol, int amount = AppSettings.PageSize)
{
var txsQuery = new TransactionQueries(_context);
var transfers = txsQuery.QueryLastTokenTransactions(symbol, amount);
var temp = transfers.Select(TransactionViewModel.FromTransaction).ToList();
return(new List <TransactionViewModel>(temp.Where(p => p.AmountTransfer > 0).Take(amount)));
}
public void WhenAAccountIdAndAPeriodAndATypeOfTansactionShouldReturnCorrectTransactions()
{
//When
var transactions = _transactions.AsQueryable().Where(
TransactionQueries.GetTransactions(DateTime.Now.Date, DateTime.Now.AddDays(1).Date, ETransactionType.Credit, _account1.Id));
//Then
Assert.Equal(1, transactions.Count());
}
public string SearchCommand(string input)
{
try
{
if (Address.IsValidAddress(input)) //maybe is address
{
return($"address/{input}");
}
//token
var token = new TokenQueries(_context).QueryToken(input.ToUpperInvariant());
if (token != null)// token
{
return($"token/{token.Symbol}");
}
//app
var app = new AppQueries(_context).QueryApp(input);
if (app != null)
{
return($"app/{app.Id}");
}
//chain
var chain = new ChainQueries(_context).QueryChain(input);
if (chain != null)
{
return($"chain/{chain.Address}");
}
//hash
if (Hash.TryParse(input, out var hash))
{
var tx = new TransactionQueries(_context).QueryTransaction(input);
if (tx != null)
{
return($"tx/{tx.Hash}");
}
var block = new BlockQueries(_context).QueryBlock(input);
if (block != null)
{
return($"block/{block.Hash}");
}
}
return(null);
}
catch (Exception e)
{
Console.WriteLine(e);
return("/home");
}
}
public TransactionViewModel GetTransaction(string txHash)
{
var txQuery = new TransactionQueries(_context);
var transaction = txQuery.QueryTransaction(txHash);
if (transaction == null)
{
return(null);
}
return(TransactionViewModel.FromTransaction(transaction));
}
public TransactionTests()
{
LoggedInAccountId = 1;
var testTransactionOptions = new DbContextOptionsBuilder <TransactionDbContext>()
.UseInMemoryDatabase("TestTransactionsDatabase")
.Options;
_testTransactionDbContext = new TransactionDbContext(testTransactionOptions);
_testTransactionQueries = new TransactionQueries(_testTransactionDbContext, LoggedInAccountId);
_testDepositService = new DepositService(_testTransactionQueries);
_testWithdrawalService = new WithdrawalService(_testTransactionQueries);
_testAccountHistoryService = new AccountHistoryService(_testTransactionQueries);
}
public HomeViewModel GetLastestInfo()
{
var blockQuery = new BlockQueries(_context);
var txsQuery = new TransactionQueries(_context);
var chainQuery = new ChainQueries(_context);
var blocks = blockQuery.QueryLastBlocks(14);
var transactions = txsQuery.QueryLastTransactions(15);
var blocksVm = blocks.Select(BlockHomeViewModel.FromBlock).ToList();
var txsVm = transactions.Select(TransactionHomeViewModel.FromTransaction).ToList();
// tx history chart calculation
var repTxs = txsQuery.QueryLastTransactions(1000, null);
var chart = new Dictionary <string, uint>();
foreach (var transaction in repTxs)
{
var block = transaction.Block;
DateTime chartTime = new Timestamp(block.Timestamp);
var chartKey = $"{chartTime.Day}/{chartTime.Month}";
if (chart.ContainsKey(chartKey))
{
chart[chartKey] += 200;
}
else
{
chart[chartKey] = 1;
}
}
int totalChains = chainQuery.QueryChainCount;
uint height = chainQuery.QueryChain("main").Height;
int totalTransactions = txsQuery.QueryTotalChainTransactionCount();
var vm = new HomeViewModel
{
Blocks = blocksVm,
Transactions = txsVm,
Chart = chart,
TotalTransactions = totalTransactions,
TotalChains = totalChains,
BlockHeight = height,
};
return(vm);
}
public void Test1()
{
var result = _transactions.AsQueryable().Where(TransactionQueries.GetActiveTransactions());
Assert.AreEqual(result.Count(), 1);
}
public DepositService(TransactionQueries transactionQueries)
{
_transactionQueries = transactionQueries;
}
public int GetTransactionsCount(string chain = null)
{
var txQuery = new TransactionQueries(_context);
return(txQuery.QueryTotalChainTransactionCount(chain));
}
public static void LoggedInMenuOptions(int accountId, ref bool loggedIn)
{
//instanticate dependencies for depositService, withdrawalService and transactionService
var loggedinAccountId = accountId;
var transactionOptions = new DbContextOptionsBuilder <TransactionDbContext>()
.UseInMemoryDatabase("BankingAppDatabase")
.Options;
var transactionDbContext = new TransactionDbContext(transactionOptions);
var transactionQueries = new TransactionQueries(transactionDbContext, loggedinAccountId);
var accountHistoryService = new AccountHistoryService(transactionQueries);
while (loggedIn)
{
Console.WriteLine("Please choose from the following menu options:\n");
Console.WriteLine("a) Make a deposit");
Console.WriteLine("b) Make a withdrawal");
Console.WriteLine("c) Check your balance");
Console.WriteLine("d) See your transaction history");
Console.WriteLine("e) Log out");
Console.WriteLine("f) Quit");
var menuChoice = Console.ReadLine();
switch (menuChoice)
{
case "a":
var depositService = new DepositService(transactionQueries);
var depositAmount = ValidateTransactionEntry("Deposit");
var depositMessage = depositService.SubmitTransaction(depositAmount);
Console.WriteLine(depositMessage);
break;
case "b":
var withdrawalService = new WithdrawalService(transactionQueries);
var withdrawalAmount = ValidateTransactionEntry("Withdrawal");
var withdrawalMessage = withdrawalService.SubmitTransaction(withdrawalAmount);
Console.WriteLine(withdrawalMessage);
break;
case "c":
Console.WriteLine($"Your account balance is: ${accountHistoryService.GetAccountBalance()}");
break;
case "d":
var transactionHistory = accountHistoryService.GetransactionHistory();
Console.WriteLine("Transaction History:\n");
foreach (var transaction in transactionHistory)
{
Console.WriteLine($"${transaction.Amount}");
Console.WriteLine(transaction.Timestamp);
Console.WriteLine("--------------------------------------------------");
}
break;
case "e":
loggedIn = false;
break;
case "f":
Quit();
break;
default:
Console.WriteLine("Invalid selection, please choose again.\n");
break;
}
}
}
public WithdrawalService(TransactionQueries transactionQueries)
{
_transactionQueries = transactionQueries;
}
public Task <IEnumerable <TransactionOutput> > GetTransactionOutput(CancellationToken cancellationToken, string transactionId)
{
return(TransactionQueries.GetTransactionOutputs(this.GetConnection(), cancellationToken, transactionId));
}
public CurrentBalanceRetriever(TransactionQueries transactionQueries)
{
_transactionQueries = transactionQueries;
}
public AddCreditTransactionCommandHandler(AccountHistoryContext context,
TransactionQueries transactionQueries)
{
_context = context;
_transactionQueries = transactionQueries;
}
public AccountHistoryService(TransactionQueries transactionQueries)
{
_transactionQueries = transactionQueries;
}
public TransactionsRetriever(TransactionQueries transactionQueries)
{
_transactionQueries = transactionQueries;
}
