public async Task <IActionResult> Index(string searchString)
{
var response = await BankApi.InitializeClient().GetAsync("api/Customers");
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
//Storing the response details recieved from web api.
var result = response.Content.ReadAsStringAsync().Result;
//Deserializing the response recieved from web api and storing into a list.
var customers = JsonConvert.DeserializeObject <List <Customer> >(result);
var customers1 = from m in customers
select m;
if (!String.IsNullOrEmpty(searchString))
{
customers1 = customers1.Where(s => s.CustomerName.Contains(searchString));
}
return(View(customers1.ToList()));
}
public void SendMoneyTransfer_ReturnsFalse_WhenTransferCannotBeCreated()
{
// ARRANGE
var userMock = new Mock <IUser>();
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock
.Setup(x => x.IsAuthenticated())
.Returns(true);
authServiceMock
.Setup(x => x.SignedUser)
.Returns(userMock.Object);
var userStoreMock = new Mock <IUserStore>();
userStoreMock
.Setup(x => x.GetUserByLogin(It.IsAny <string>()))
.Returns(userMock.Object);
var accountServiceMock = new Mock <IAccountService>();
accountServiceMock
.Setup(x => x.CreateMoneyTransfer(It.IsAny <IUser>(), It.IsAny <IUser>(), It.IsAny <decimal>()))
.Throws(new AccountOperationException(It.IsAny <string>()));
var bank = new BankApi(authServiceMock.Object, accountServiceMock.Object, userStoreMock.Object);
// ACT
var result = bank.SendMoneyTransfer("RecipientLogin", 100.0M);
// ASSERT
Assert.IsFalse(result);
}
public IActionResult DeleteConfirmed(int id)
{
var response = BankApi.InitializeClient().DeleteAsync($"api/Customers/{id}").Result;
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
return(NotFound());
}
public void SignIn_ReturnsFalse_WhenUserSigns_WithIncorrectCredentials()
{
// ARRANGE
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock.Setup(x => x.Authenticate("testlogin", "testpassword")).Returns(true);
var bank = new BankApi(authServiceMock.Object, _accountServiceDouble, _userStoreDouble);
// ACT
var result = bank.SignIn("wronglogin", "wrongpassword");
// ASSERT
Assert.IsFalse(result);
}
public IActionResult Create(Customer customer)
{
if (ModelState.IsValid)
{
var content = new StringContent(JsonConvert.SerializeObject(customer), Encoding.UTF8, "application/json");
var response = BankApi.InitializeClient().PostAsync("api/Customers", content).Result;
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
}
return(View(customer));
}
public static async Task <bool> CheckBlockAsync(int id)
{
var response = await BankApi.InitializeClient().GetAsync($"api/Logins/{id}");
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
var result = response.Content.ReadAsStringAsync().Result;
var login = JsonConvert.DeserializeObject <Login>(result);
return(login.Block);
}
internal static async Task UpdateCurrentUserFromServer(string eMail = "")
{
try
{
if (String.IsNullOrEmpty(eMail) && CurrentUser?.EMail != null)
{
eMail = CurrentUser.EMail;
}
var user = await BankApi.GetCurrentUser();
user.Cards = new List <CardInfo>(await BankApi.GetCards());
user.Pays = new List <PayInfo>(await BankApi.GetPays());
CurrentUser = new BankUserDb(user, eMail);
var allCards = Repository.GetItems <CardInfoDb>().Where(c => c.UserId == user.Id).ToList();
foreach (var cardInfo in allCards)
{
Repository.DeleteItem <CardInfoDb>(cardInfo.Id);
}
var allPays = Repository.GetItems <PayInfoDb>().Where(c => c.UserId == user.Id).ToList();
foreach (var payInfo in allPays)
{
Repository.DeleteItem <CardInfoDb>(payInfo.Id);
}
if (user.Cards != null)
{
foreach (var userCard in user.Cards)
{
Repository.SaveItem <CardInfoDb>(new CardInfoDb(userCard, user.Id));
}
}
if (user.Pays != null)
{
foreach (var userPay in user.Pays)
{
Repository.SaveItem <PayInfoDb>(new PayInfoDb(userPay, user.Id));
}
}
Repository.SaveItem(CurrentUser);
}
catch (Exception ex)
{
CurrentUser = null;
//
}
}
public void SignOut_ReturnsTrue_WhenDeauthenticationSucceeds()
{
// ARRANGE
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock.Setup(x => x.Deauthenticate()).Returns(true);
var bank = new BankApi(authServiceMock.Object, _accountServiceDouble, _userStoreDouble);
// ACT
var result = bank.SignOut();
// ASSERT
Assert.IsTrue(result);
}
public AccountService(
WiseContext db,
BankApi bankApi,
AvatarsService avatarsService,
UserManager <User> userManager,
EmailService emailService,
IConfiguration config)
{
_db = db;
_bankApi = bankApi;
_avatarsService = avatarsService;
_userManager = userManager;
_emailService = emailService;
_config = config;
}
public void GetMyAccountBalance_Throws_WhenUserIsNotAuthenticated()
{
// ARRANGE
const decimal expectedBalance = 1000.0M;
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock.Setup(x => x.IsAuthenticated()).Returns(false);
var bank = new BankApi(authServiceMock.Object, _accountServiceDouble, _userStoreDouble);
// ACT
var balance = bank.GetMyAccountBalance();
// ASSERT
Assert.AreEqual(expectedBalance, balance);
}
public void SendMoneyTransfer_ReturnsFalse_WhenRecipientDoesNotExist()
{
// ARRANGE
const string invalidRecipientLogin = "******";
const decimal exampleAmount = 100.0M;
var authServiceMock = new Mock <IAuthenticationService>();
var accountServiceMock = new Mock <IAccountService>();
var bank = new BankApi(authServiceMock.Object, accountServiceMock.Object, _userStoreDouble);
// ACT
bool result = bank.SendMoneyTransfer(invalidRecipientLogin, exampleAmount);
// ASSERT
Assert.IsFalse(result);
}
public async Task <IActionResult> Index(string searchString)
{
var response = await BankApi.InitializeClient().GetAsync("api/BillPays");
/* if (!response.IsSuccessStatusCode)
* throw new Exception();*/
//Storing the response details recieved from web api.
var result = response.Content.ReadAsStringAsync().Result;
//Deserializing the response recieved from web api and storing into a list.
var BillPays = JsonConvert.DeserializeObject <List <BillPay> >(result);
return(View(BillPays.ToList()));
}
public void GetMyAccountBalance_ReturnsPredefinedAmount()
{
// ARRANGE
const decimal expectedBalance = 1000.0M;
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock.Setup(x => x.IsAuthenticated()).Returns(true);
var accountServiceMock = new Mock <IAccountService>();
accountServiceMock.Setup(x => x.GetBalance(It.IsAny <IUser>())).Returns(expectedBalance);
var bank = new BankApi(authServiceMock.Object, accountServiceMock.Object, _userStoreDouble);
// ACT
var balance = bank.GetMyAccountBalance();
// ASSERT
Assert.AreEqual(expectedBalance, balance);
}
public async Task <IActionResult> Reverse(int id)
{
var response = await BankApi.InitializeClient().GetAsync($"api/BillPays/{id}");
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
var result = response.Content.ReadAsStringAsync().Result;
var billPay = JsonConvert.DeserializeObject <BillPay>(result);
billPay.Block = !billPay.Block;
var content = new StringContent(JsonConvert.SerializeObject(billPay), Encoding.UTF8, "application/json");
response = BankApi.InitializeClient().PutAsync("api/BillPays", content).Result;
return(RedirectToAction(nameof(Index)));
}
public IActionResult Edit(int id, Customer customer)
{
if (id != customer.CustomerID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var content = new StringContent(JsonConvert.SerializeObject(customer), Encoding.UTF8, "application/json");
var response = BankApi.InitializeClient().PutAsync("api/Customers", content).Result;
if (response.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(Profile), new { id = customer.CustomerID }));
}
}
return(View(customer));
}
public async Task <IActionResult> Block(int id)
{
var response = await BankApi.InitializeClient().GetAsync($"api/Logins/{id}");
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
var result = response.Content.ReadAsStringAsync().Result;
var login = JsonConvert.DeserializeObject <Login>(result);
login.Block = true;
login.ModifyDate = DateTime.UtcNow;
var content = new StringContent(JsonConvert.SerializeObject(login), Encoding.UTF8, "application/json");
response = BankApi.InitializeClient().PutAsync("api/Logins", content).Result;
return(RedirectToAction(nameof(Index)));
}
// GET: Customers/Edit/1
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var response = await BankApi.InitializeClient().GetAsync($"api/Customers/{id}");
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
var result = response.Content.ReadAsStringAsync().Result;
var customer = JsonConvert.DeserializeObject <Customer>(result);
return(View(customer));
}
public void SignUp_ReturnTrue_WhenSignUpSucceeds()
{
// ARRANGE
var login = "******";
var password = "******";
var authServiceMock = new Mock <IAuthenticationService>();
authServiceMock.Setup(x => x.SignUp(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
var accountServiceMock = new Mock <IAccountService>();
var userStoreMock = new Mock <IUserStore>();
var bank = new BankApi(authServiceMock.Object, accountServiceMock.Object, userStoreMock.Object);
// ACT
var result = bank.SignUp(login, password);
// ASSERT
Assert.IsTrue(result);
}
public void SendMoneyTransfer_ReturnsFalse_WhenUserIsNotAuthenticated()
{
// ARRANGE
const string recipientLogin = "******";
const decimal exampleAmount = 100.0M;
var authServiceMock = new Mock <IAuthenticationService>();
var accountServiceMock = new Mock <IAccountService>();
var recipientMock = new Mock <IUser>();
var userStoreMock = new Mock <IUserStore>();
userStoreMock.Setup(x => x.GetUserByLogin(recipientLogin)).Returns(recipientMock.Object);
var bank = new BankApi(authServiceMock.Object, accountServiceMock.Object, userStoreMock.Object);
// ACT
var result = bank.SendMoneyTransfer(recipientLogin, exampleAmount);
// ASSERT
Assert.IsFalse(result);
}
// GET: Transactions/ViewTransaction
public async Task <IActionResult> ViewTransaction()
{
var id = TempData["customerId"];
DateTime date1 = DateTime.Parse(HttpContext.Session.GetString("Date1"));
DateTime date2 = DateTime.Parse(HttpContext.Session.GetString("Date2"));
string s = string.Format("api/Transactions/{0}", id);
var response = await BankApi.InitializeClient().GetAsync(s);
if (!response.IsSuccessStatusCode)
{
throw new Exception();
}
// Storing the response details recieved from web api.
var result = response.Content.ReadAsStringAsync().Result;
// Deserializing the response recieved from web api and storing into a list.
var transactions = JsonConvert.DeserializeObject <List <Transaction> >(result);
TimeZoneInfo cstZone = TimeZoneInfo.FindSystemTimeZoneById("AUS Eastern Standard Time");
foreach (Transaction transaction in transactions)
{
transaction.TransactionTimeUtc = TimeZoneInfo.ConvertTimeFromUtc(transaction.TransactionTimeUtc, cstZone);
}
var selectedTransactions = from transaction in transactions
where transaction.TransactionTimeUtc.CompareTo(date1) >= 0 && transaction.TransactionTimeUtc.CompareTo(date2) <= 0
select transaction;
String jsonString = JsonConvert.SerializeObject(selectedTransactions);
HttpContext.Session.SetString(sessionKey, jsonString);
return(View(selectedTransactions));
}
public PurchasesService(WiseContext db, BankApi bankApi)
{
_db = db;
_bankApi = bankApi;
}
// POST: Make a payment
public async Task <HttpResponseMessage> Post([FromBody] PaymentBindingModels Payment)
{
try
{
//In case POST send with no data
if (Payment == null)
{
throw new Exception("No data provided");
}
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
using (ApplicationDbContext entities = new ApplicationDbContext())
{
//Retrieve Authenticated User
var AuthenticatedUser = entities.Users.FirstOrDefault(x => x.Email == User.Identity.Name);
if (AuthenticatedUser == null)
{
throw new Exception("Unable to retrieve authenticated user");
}
//Request Bank Payment
BankApi objBank = new BankApi();
BankResponseModel objresponse = await objBank.MakeBankPayment(Payment);
PaymentModel PayModel = new PaymentModel()
{
CardHolderName = Payment.CardHolderName,
CardNumber = Payment.GetMaskCardNumber(),
Amount = Payment.Amount,
Currency = Payment.Currency.ToUpper(),
AuthUser = AuthenticatedUser,
CardExpDate = Payment.CardExpDate,
Cvv = Payment.Cvv,
RequestDate = DateTime.Now,
BankIdentifer = objresponse.Identifier,
BankStatus = objresponse.Status
};
//Save Payment
entities.Payments.Add(PayModel);
entities.SaveChanges();
if (objresponse.Status != "OK")
{
throw new Exception("Error processing payment with bank");
}
var objPayResponse = new
{
status = "OK",
PaymentBankIdentifer = PayModel.BankIdentifer,
GetPayment = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority) + "/api/Payment/" + PayModel.Id
};
var messsage = Request.CreateResponse(HttpStatusCode.Created, objPayResponse);
return(messsage);
}
}
catch (Exception ex)
{
using (var scope = DI.DI.Container.BeginLifetimeScope())
{
var obj = scope.Resolve <ILoggerInterface>();
//Logger error Message
obj.LogMessage("PaymentsController.Post", ex.Message);
}
ErrorResponseModel objResponse = new ErrorResponseModel()
{
Status = "ERROR", Message = ex.Message
};
return(Request.CreateResponse(HttpStatusCode.BadRequest, objResponse));
}
}
//[Test]
public void TestOperations()
{
var accounts = new List <BankAccount>();
decimal totalSum = 0;
for (int i = 0; i < 5; i++)
{
accounts.Add(
new BankAccount
{
Id = i,
CardNumber = $"408.17.810.0.9991.{i.ToString("D6")}",
Amount = Convert.ToDecimal(i * 1000),
VisaNumber = i.ToString("D16"),
VisaName = $"Test User{i}",
VisaCcv = i.ToString("D3"),
VisaDate = "01/18"
});
totalSum += Convert.ToDecimal(i * 1000);
}
BankDataHelper.SaveAccounts(accounts);
var result = BankDataHelper.GetAccounts();
Assert.IsNotNull(result);
Assert.AreEqual(result.Count, 5);
CheckTotalSum(totalSum, result);
var bankVisaTransaction1 = new BankVisaTransaction
{
Amount = 1000,
RecipientAccountNumber = accounts[0].CardNumber,
SenderCardNumber = accounts[1].VisaNumber,
SenderCcvCode = accounts[1].VisaCcv,
SenderName = accounts[1].VisaName,
SenderValidBefore = accounts[1].VisaDate
};
var bankApi = new BankApi();
var res1 = bankApi.DoWithVisa(bankVisaTransaction1);
Assert.NotNull(res1);
result = BankDataHelper.GetAccounts();
Assert.AreEqual(res1, BankResponse.Success);
CheckTotalSum(totalSum, result);
Assert.AreEqual(1000, result[0].Amount);
Assert.AreEqual(0, result[1].Amount);
var res2 = bankApi.DoWithVisa(bankVisaTransaction1);
Assert.NotNull(res2);
result = BankDataHelper.GetAccounts();
Assert.AreEqual(res2, BankResponse.NotEnoughtMoney);
CheckTotalSum(totalSum, result);
Assert.AreEqual(1000, result[0].Amount);
Assert.AreEqual(0, result[1].Amount);
var bankVisaTransaction2 = new BankVisaTransaction
{
Amount = 3050,
RecipientAccountNumber = accounts[0].CardNumber,
SenderCardNumber = accounts[4].VisaNumber,
SenderCcvCode = accounts[4].VisaCcv,
SenderName = accounts[4].VisaName,
SenderValidBefore = accounts[4].VisaDate
};
var res3 = bankApi.DoWithVisa(bankVisaTransaction2);
Assert.NotNull(res3);
result = BankDataHelper.GetAccounts();
Assert.AreEqual(res3, BankResponse.Success);
CheckTotalSum(totalSum, result);
Assert.AreEqual(4050, result[0].Amount);
Assert.AreEqual(950, result[4].Amount);
var bankVisaTransaction3 = new BankVisaTransaction
{
Amount = 3050,
RecipientAccountNumber = accounts[0].CardNumber,
SenderCardNumber = accounts[4].VisaNumber,
SenderCcvCode = accounts[2].VisaCcv,
SenderName = accounts[3].VisaName,
SenderValidBefore = accounts[4].VisaDate
};
var res4 = bankApi.DoWithVisa(bankVisaTransaction3);
Assert.NotNull(res4);
result = BankDataHelper.GetAccounts();
Assert.AreEqual(res4, BankResponse.Error);
CheckTotalSum(totalSum, result);
}
