public async Task <ActionResult> Index()
{
List <AccountTransactionViewModel> viewModel = new List <AccountTransactionViewModel>();
int managerId = Int32.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
List <Team> teams;
AccountTransactionViewModel currentTransaction;
List <TransactionHistory> transactions = await TransactionRepository.All.Where(t => t.ManagerId == managerId).ToListAsync();
foreach (TransactionHistory transaction in transactions)
{
currentTransaction = new AccountTransactionViewModel();
currentTransaction.Details = new List <TransactionInformationViewModel>();
currentTransaction.TransactionId = transaction.TransactionId;
teams = await TeamRepository.All.Where(t => t.PaymentTransactionId == transaction.TransactionId).ToListAsync();
foreach (Team team in teams)
{
currentTransaction.Details.Add(new TransactionInformationViewModel()
{
Date = transaction.TransactionDate,
Id = team.Id,
Name = team.Name,
Type = "Team",
TypeDescription = "TEAM PAYMENT"
});
}
viewModel.Add(currentTransaction);
}
return(View(viewModel));
}
// GET: BankAccount/Edit/5
public async Task <IActionResult> Transact(Guid?id, TransactionType transactionTypeId)
{
ViewBag.TransactionType = transactionTypeId.ToString();
if (id == null)
{
return(NotFound());
}
var account = await _context.Accounts.SingleOrDefaultAsync(m => m.Id == id && m.UserId == UserId);
if (account == null)
{
return(NotFound());
}
AccountTransactionViewModel model = new AccountTransactionViewModel()
{
Id = account.Id,
TransactionTypeId = transactionTypeId
};
return(View(model));
}
public async Task <IActionResult> DebitAccount(string id)
{
//needs to implement update function
var decryptedId = GuidEncoder.Decode(id);
var account = await _accountRepository.FindAsync(decryptedId.ToString());
if (!account.IsBlocked)
{
ViewBag.AccountTypesLeftForfundTransfer = await _accountTypeRepository.FindAllAccountTypesByAccountTypeIdAsync(account.AccountTypeId);
ViewBag.OrderByTypes = await GetOrderByTypesAsync();
ViewBag.TransactionTypes = await GetTransactionTypeAsync();
var newTransaction = new AccountTransactionViewModel()
{
AccUriKey = GuidEncoder.Encode(account.AccountId),
AppUserUriKey = GuidEncoder.Encode(account.AppUserId),
IdUriKey = GuidEncoder.Encode(account.Id),
AccountTypeIdUriKey = GuidEncoder.Encode(account.AccountTypeId),
UiControl = "Debit"
};
return(View("TransferFund", newTransaction));
}
//Todo: more informative view
return(View());
}
public IActionResult MakeReadyTransfer(int accountId)
{
AccountTransactionViewModel model = new AccountTransactionViewModel(_context);
model.SetFromAccount(accountId);
return(View(model));
}
public IActionResult AccountDetails(int id, int page = 1)
{
var isAjax = Request.Headers["X-Requested-With"] == "XMLHttpRequest";
const int pageSize = 20;
var model = new AccountTransactionViewModel();
model.Account = _context.Accounts.SingleOrDefault(a => a.AccountId == id);
var firstTransactionList = _context.Transactions.Where(t => t.AccountId == id);
model.TransactionList = firstTransactionList.ToList();
var totalNumber = model.TransactionList.Count();
var transactions = GetTransactions(id, pageSize, (page - 1) * pageSize);
model.ListViewModel = new LongListViewModel
{
PageNumber = page,
PageSize = pageSize,
TotalNumberOfItems = totalNumber,
CanShowMore = page * pageSize < totalNumber,
Transactions = transactions
};
if (isAjax)
{
return(PartialView("_TransactionRows", model));
}
else
{
return(View(model));
};
}
public async Task <IActionResult> TransferFund(string Id)
{
string accTypeId;
//Check the number of userAccounts
var decryptedId = GuidEncoder.Decode(Id).ToString();
var userAccount = await _accountRepository.FindAccountIncludeAppUserAsync(decryptedId);
var userAccounts = await _accountRepository.FindAccountsByAppUserIdAsync(userAccount.AppUserId);
var accounts = userAccounts.ToList();
var numberOfAccounts = accounts.Count();
ViewBag.TransactionTypes = await GetTransactionTypeAsync();
ViewBag.OrderByTypes = await GetOrderByTypesAsync();
if (numberOfAccounts < 2)
{
ViewBag.AccountTypesLeftForfundTransfer = await GetAccountTypesAsync();
var newTransaction = new AccountTransactionViewModel()
{
NumberOfAccounts = numberOfAccounts,
};
newTransaction.AccUriKey = GuidEncoder.Encode(userAccount.AccountId);
return(View(newTransaction));
}
ViewBag.AccountTypesLeftForfundTransfer = await GetAccountTypesLeftForfundTransferAsync(userAccount.AccountTypeId);
if (!userAccount.IsBlocked)
{
var newTransaction = new AccountTransactionViewModel()
{
AccUriKey = GuidEncoder.Encode(userAccount.AccountId),
AppUserUriKey = GuidEncoder.Encode(userAccount.AppUserId),
IdUriKey = GuidEncoder.Encode(userAccount.Id),
UiControl = "Transfer"
};
return(View(newTransaction));
}
//Todo: more informative view
return(View());
}
public async Task <IActionResult> CreditAccount(AccountTransactionViewModel model)
{
var cancellationToken = new CancellationToken();
if (ModelState.IsValid)
{
var decryptedId = GuidEncoder.Decode(model.AccUriKey);
//var accountTypeId = GuidEncoder.Decode(model.AccountToCredit).ToString();
var account = await _accountRepository.FindAccountsIncludeRelatedClassesAsync(decryptedId.ToString(), model.AccountToCredit);
account.CurrentBalance += model.AmountToCredit;
//relect txn on debited acct
model.AccountId = account.AccountId;
model.AppUserId = account.AppUserId;
model.DateOfTransaction = DateTime.UtcNow;
model.AccountToCredit = account.AccountTypeId;
model.CurrentBalanceAccountToCredit = account.CurrentBalance;
account.AccountTransactions.Add(_mapper.Map <AccountTransaction>(model));
await _unitOfWorkAccount.UpdateAsync(cancellationToken, account);
//Todo: Update db
var identityUser = await _userManager.FindByIdAsync(model.Id);
if (await _userManager.IsInRoleAsync(identityUser, "Bank Admin") || await _userManager.IsInRoleAsync(identityUser, "Bank Manager"))
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("UserAccountsByAccountId", new { id = GuidEncoder.Encode(model.AccountId) }));
}
}
return(View("TransferFund", model));
}
public IActionResult Callback(string code)
{
var client = new RestClient("https://localhost:5001/api/Authentication/AccessToken?code=" + code);
var request = new RestRequest(Method.GET);
var response = client.Execute <AccessToken>(request);
var accessTokenResponse = JsonConvert.DeserializeObject <AccessToken>(response.Content);
//retrieve accounts
client = new RestClient("https://localhost:5001/api/Transactions?token=" + accessTokenResponse.access_token);
var accountRequest = new RestRequest(Method.GET);
var accountResponse = client.Execute <List <AccountTransaction> >(accountRequest);
client = new RestClient("https://localhost:5001/api/Transactions/UserMetrics?token=" + accessTokenResponse.access_token);
var metricRequest = new RestRequest(Method.GET);
var metricResponse = client.Execute <List <UserTransactionMetrics> >(request);
var viewModel = new AccountTransactionViewModel();
viewModel.AccountTransactions = accountResponse.Data;
viewModel.UserTransactionMetrics = metricResponse.Data;
return(View(viewModel));
}
public async Task <ElasticSearchResponse> UpdateAccountTransactionModel(string message)
{
const string index = "account";
Logger.Log("Updating document to ElasticSearch");
// Get the event name from the message
var eventName = Regex.Matches(message, @"EventName"":[\s]*""([a-zA-Z)]+)").First().Groups.Last().Value;
Logger.Log($"Event Name: {eventName}");
// Dynamically convert deserialized event to event type
dynamic request = JsonConvert.DeserializeObject(message, Type.GetType(eventName));
var accountId = request.Transaction.AccountId.ToString();
Logger.Log($"Event Id: {accountId}");
Logger.Log($"Event Index: {index}");
var data = new AccountTransactionViewModel
{
Doc = new AccountTransactionDocument
{
Transactions = new List <AccountTransaction>
{
new AccountTransaction
{
Transaction = request.Transaction.ToString()
}
}
}
};
Logger.Log($"Partial Document: {JsonConvert.SerializeObject(data)}");
Logger.Log($"Sending document {accountId} to ElasticSearch");
return(await _repository.UpdateAsync(index, accountId, JsonConvert.SerializeObject(data)));
}
public void PopulateTransactionHistory()
{
TransactionHistory.Clear();
// TODO: don't require every wallet transaction. Consider alternate source for these
// transactions.
var walletTxs = _wallet.RecentTransactions.MinedTransactions
.SelectMany(b => b.Transactions)
.Concat(_wallet.RecentTransactions.UnminedTransactions.Select(kvp => kvp.Value));
Amount runningBalance = 0;
foreach (var tx in walletTxs)
{
Amount debit, credit;
if (Accounting.RelevantTransaction(tx, _account, out debit, out credit))
{
Amount delta = debit + credit;
runningBalance += delta;
var accountTransaction = new AccountTransactionViewModel(tx, delta, runningBalance);
TransactionHistory.Add(accountTransaction);
}
}
}
public void PopulateTransactionHistory()
{
TransactionHistory.Clear();
// TODO: don't require every wallet transaction. Consider alternate source for these
// transactions.
var walletTxs = _wallet.RecentTransactions.MinedTransactions
.SelectMany(b => b.Transactions)
.Concat(_wallet.RecentTransactions.UnminedTransactions.Select(kvp => kvp.Value));
Amount runningBalance = 0;
foreach (var tx in walletTxs)
{
Amount debit, credit;
if (Accounting.RelevantTransaction(tx, _account, out debit, out credit))
{
Amount delta = debit + credit;
runningBalance += delta;
var accountTransaction = new AccountTransactionViewModel(tx, delta, runningBalance);
TransactionHistory.Add(accountTransaction);
}
}
}
public async Task <IActionResult> Transact(Guid id, [Bind("Id,Amount, TransactionTypeId")] AccountTransactionViewModel account)
{
if (ModelState.IsValid)
{
try
{
var record = _context.Accounts.FirstOrDefault(x => x.Id == id && x.UserId == UserId);
if (record == null)
{
ModelState.AddModelError("", "Depositor account not found.");
return(View(account));
}
if (account.TransactionTypeId == TransactionType.Deposit)
{
record.Deposit(account.Amount, "");
}
else if (account.TransactionTypeId == TransactionType.Withdraw)
{
if (record.Balance < account.Amount)
{
ModelState.AddModelError("", "Amount cannot exceed balance.");
return(View(account));
}
record.Withdraw(account.Amount);
}
_context.Update(record);
_context.AddRange(record.AccountTransactions);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
//this is how you get entries
foreach (var entry in ex.Entries)
{
if (entry.Entity is Account)
{
if (account.TransactionTypeId == TransactionType.Withdraw)
{
if (_context.Accounts.Find(id).Balance < account.Amount)
{
ModelState.AddModelError("Amount", "Another transaction completed while trying to complete current transsaction.");
return(View(account));
}
else
{
var retry = _context.Accounts.FirstOrDefault(x => x.Id == id && x.UserId == UserId);
retry.Withdraw(account.Amount);
_context.Update(retry);
_context.AddRange(retry.AccountTransactions);
_context.SaveChanges();
}
//var proposedValues = entry.CurrentValues;
//var databaseValues = entry.GetDatabaseValues();
//foreach (var property in proposedValues.Properties)
//{
// var proposedValue = proposedValues[property];
// var databaseValue = databaseValues[property];
// // TODO: decide which value should be written to database
// // proposedValues[property] = <value to be saved>;
//}
//// Refresh original values to bypass next concurrency check
//entry.OriginalValues.SetValues(databaseValues);
}
else if (account.TransactionTypeId == TransactionType.Deposit)
{
var retry = _context.Accounts.FirstOrDefault(x => x.Id == id && x.UserId == UserId);
retry.Deposit(account.Amount, "");
_context.Update(retry);
_context.AddRange(retry.AccountTransactions);
_context.SaveChanges();
}
}
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(account));
}
public async Task <IActionResult> TransferFund(AccountTransactionViewModel model)
{
if (ModelState.IsValid)
{
var cancellationToken = new CancellationToken();
var accountBalance = (await _accountRepository
.FindAsync(GuidEncoder.Decode(model.AccUriKey)
.ToString()))
.CurrentBalance;
var acctToCreditTypeId = model.AccountToCredit;
if (accountBalance - model.AmountToCredit >= 0)
{
var decryptedId = GuidEncoder.Decode(model.AccUriKey);
var account = await _accountRepository.FindAsync(decryptedId.ToString());
var acctViewModel = _mapper.Map <AccountViewModel>(account);
account.CurrentBalance -= model.AmountToCredit;
//account to credit
var acctToCredit = await _accountRepository.FindByAccountTypeAndAppUserIdAsync(account.AppUserId, acctToCreditTypeId);
if (acctToCredit.IsBlocked)
{
// Todo: appropraite view needed
return(View());
}
acctToCredit.CurrentBalance += model.AmountToCredit;
//reflect txn on debited acct
model.AccountId = account.AccountId;
model.AppUserId = account.AppUserId;
model.DateOfTransaction = DateTime.UtcNow;
model.AccountToCredit = (await _accountTypeRepository.FindAsync(acctToCreditTypeId)).Type;
model.AccountToDebit = (await _accountTypeRepository.FindAsync(account.AccountTypeId)).Type;
model.NewBalanceOfDebitedAccount = account.CurrentBalance;
model.CurrentBalanceAccountToCredit = acctToCredit.CurrentBalance;
account.AccountTransactions.Add(_mapper.Map <AccountTransaction>(model));
//Todo: Do i need to modify accToCrediTxn to reflect more?
var accToCreditTxn = _mapper.Map <AccountTransactionViewModel>(model);
accToCreditTxn.TransactionTypeId = (await _transactionTypeRepository.FindByType("Transfer Fund Received")).TransactionTypeId;
accToCreditTxn.AccountId = acctToCredit.AccountId;
var newTxn = _mapper.Map <AccountTransaction>(accToCreditTxn);
acctToCredit.AccountTransactions.Add(newTxn);
//Todo: Update db
await _unitOfWorkAccount.UpdateAsync(cancellationToken, account);
await _unitOfWorkAccount.UpdateAsync(cancellationToken, acctToCredit);
var identityUser = await _userManager.FindByIdAsync(acctToCredit.Id);
if (await _userManager.IsInRoleAsync(identityUser, "Bank Admin") || await _userManager.IsInRoleAsync(identityUser, "Bank Manager"))
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("UserAccountsByAccountId", new { id = GuidEncoder.Encode(acctToCredit.AccountId) }));
}
}
}
return(View(model));
}
public ActionResult SaveAccountTransaction(AccountTransactionViewModel model)
{
_invoiceService.SaveAccountTransaction(AutoMapper.Mapper.Map <AccountTransactionViewModel, AccountTransaction>(model), CurrentTenantId, CurrentUserId);
return(Json(model, JsonRequestBehavior.AllowGet));
}
