public async Task GetUser_UserIsLoggedIn()
{
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "*****@*****.**"),
new Claim("UserID", "16ce682d-2bd5-45df-bc08-1f21e12f68b0"),
}, "mock"));
_userController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
_mockUserManager.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
var result = await _userController.GetUser();
Assert.IsNotNull(((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value);
}
public static CBAUser GetMockObject()
{
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, objCBAUser.UserName),
new Claim(ClaimTypes.NameIdentifier, objCBAUser.Id),
new Claim("Email", objCBAUser.UserName),
};
var identity = new ClaimsIdentity(claims, "Test");
var claimsPrincipal = new ClaimsPrincipal(identity);
var mockPrincipal = new Mock <IPrincipal>();
mockPrincipal.Setup(x => x.Identity).Returns(identity);
mockPrincipal.Setup(x => x.IsInRole(It.IsAny <string>())).Returns(true);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext.Setup(m => m.User).Returns(claimsPrincipal);
return(objCBAUser);
}
public async Task PostChangePassword()
{
ResetPasswordDto objPasswordModel = new ResetPasswordDto()
{
Id = "*****@*****.**",
NewPassword = "******",
ConfirmPassword = "******",
Token = "CfDJ8I9H5drWaGxHgWTL%2BERlWjzlReKkIFkFAtEfKwyOEM11WgvvjONokXL9sLJPyNf7lzlki8CfutXU7c8dUx8bxRmj4JYbeOFQaY0uacxy6eHN%2B0AOhX%2FPhdliED3P5qaIiVwWyr1W05a%2BOjgPkRXSQj7Ku0kSVgF4PcdJpL1oB3p2vjql1tYqqfIE7I5rJP5GBC%2BvAM5SOfVGOFry%2BBfA5F%2B3zzcL82H1PneaR2IXq64H"
};
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
_mockUserManager.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
_mockUserManager.Setup(x => x.ResetPasswordAsync(It.IsAny <CBAUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
var result = await _resetPasswordController.PostChangePassword(objPasswordModel);
Assert.AreEqual(((Microsoft.AspNetCore.Mvc.StatusCodeResult)result).StatusCode, 200);
}
public static async Task SeedSuperUserAsync(UserManager <CBAUser> userManager, RoleManager <CBARole> roleManager)
{
var superUser = new CBAUser
{
Email = "*****@*****.**",
UserName = "******",
EmailConfirmed = true,
IsEnabled = true
};
if (!userManager.Users.Any(user => user.Id == superUser.Id))
{
var user = await userManager.FindByEmailAsync(superUser.Email);
if (user == null)
{
await userManager.CreateAsync(superUser, "Ade981_");
await userManager.AddToRolesAsync(superUser, new List <string>()
{
DefaultRole.SuperUser.ToString()
});
}
await roleManager.SeedClaimsForSuperAdmin();
}
}
public async Task PostForgotPassword()
{
EmailModel obj = new EmailModel()
{
Email = "*****@*****.**"
};
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
string token = "CfDJ8I9H5drWaGxHgWTL%2BERlWjzlReKkIFkFAtEfKwyOEM11WgvvjONokXL9sLJPyNf7lzlki8CfutXU7c8dUx8bxRmj4JYbeOFQaY0uacxy6eHN%2B0AOhX%2FPhdliED3P5qaIiVwWyr1W05a%2BOjgPkRXSQj7Ku0kSVgF4PcdJpL1oB3p2vjql1tYqqfIE7I5rJP5GBC%2BvAM5SOfVGOFry%2BBfA5F%2B3zzcL82H1PneaR2IXq64H";
_mockUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
_mockUserManager.Setup(x => x.GeneratePasswordResetTokenAsync(It.IsAny <CBAUser>())).ReturnsAsync(token);
//Mocking host address.
_forgetPasswordController.ControllerContext = new ControllerContext();
_forgetPasswordController.ControllerContext.HttpContext = new DefaultHttpContext();
_forgetPasswordController.ControllerContext.HttpContext.Request.Host = new HostString("localhost:62856");
_forgetPasswordController.ControllerContext.HttpContext.Request.Scheme = "https";
var result = await _forgetPasswordController.PostForgotPassword(obj);
Assert.AreEqual(((ObjectResult)result).Value, "An email has been sent with instruction to reset your password...!!");
}
public async Task AssignTill(int tillId, CBAUser user)
{
var till = await _context.InternalAccounts.FindAsync(tillId);
till.User = user;
_context.Update(till);
await _context.SaveChangesAsync();
}
public async Task UpdateUserRoleAsync(CBAUser user, string role)
{
user.CBARole = await _roleManager.FindByNameAsync(role);
_context.Update(user);
await _context.SaveChangesAsync();
await _userManager.AddToRoleAsync(user, role);
}
public void SendPasswordResetEmail(string pathToFile, string callbackUrl, CBAUser user)
{
var builder = new BodyBuilder();
using StreamReader SourceReader = File.OpenText(pathToFile);
builder.HtmlBody = SourceReader.ReadToEnd();
builder.HtmlBody = string.Format(builder.HtmlBody, callbackUrl, user.FirstName);
SendEmailFromTemplate(user, "Reset your Password", builder.ToMessageBody());
}
public async Task CheckUserExist_UserIsAvailable()
{
CBAUser objCBAUser = ClsCommon.GetMockObject();
_mockUserManager.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
var result = await _userController.CheckUserExist("*****@*****.**");
Assert.IsNotNull(((ObjectResult)result).Value, "Exist");
}
public async Task CheckUserExist_UserIsNotAvaialable()
{
CBAUser objCBAUser = ClsCommon.GetMockObject();
//IdentityError err = new IdentityError();
//err.Description = "Failed to create the user";
//_mockUserManager.Setup(x => x.FindByEmailAsync(It.IsAny<string>())).ReturnsAsync(IdentityResult.Failed(err));
var result = await _userController.CheckUserExist("*****@*****.**");
Assert.AreEqual(((ObjectResult)result).Value, "NotExist");
}
private async Task LoadAsync(CBAUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public async Task EditUserRoleAsync(UserRoleViewModel userRoleViewModel)
{
CBAUser user = await _userManager.FindByIdAsync(userRoleViewModel.User.Id);
CBARole role = await _roleManager.FindByIdAsync(userRoleViewModel.RoleId);
await _userManager.RemoveFromRolesAsync(user, await _userManager.GetRolesAsync(user));
await _userManager.AddToRoleAsync(user, role.Name);
user.CBARole = role;
_context.Update(user);
await _context.SaveChangesAsync();
}
public async Task ConfirmMail_InvalidToken()
{
CBAUser objCBAUser = ClsCommon.GetMockObject();
string mockToken = "CfDJ8I9H5drWaGxHgWTL + ERlWjwsoqt2f5ZNoc4xdQXmlFVvLV3crqNf8lyPN2 + 1i7zONZT + OR6gYFJZm6N3cjM2LnsnzobTpGLdznAhTQ3LEE / sW / F9b7AtIT2cvGDVFbsjSJN0GUTdXaJFiZR8yrBI2fggnAB5rDqGBnq3UOyJN0qa68Xwj6bsifkPFy25xRlOnNh83MPVFwzUuGwOpsWMsaUnaTb + XCWGQgBUzSISlKyv + wLS7mU1 + iOKqpWpI / HPSg == ";
_mockUserManager.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
_mockUserManager.Setup(x => x.ConfirmEmailAsync(It.IsAny <CBAUser>(), mockToken + "1234")).ReturnsAsync(IdentityResult.Success);
_mockUserManager.Setup(x => x.UpdateAsync(It.IsAny <CBAUser>())).ReturnsAsync(IdentityResult.Success);
var result = await _userController.ConfirmEmail(objCBAUser.Id, mockToken);
Assert.AreEqual(((ObjectResult)result).StatusCode, 500);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
MailAddress address = new MailAddress(Input.Email);
string UserName = address.User;
var user = new CBAUser {
UserName = UserName, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <CBAUser> CreateUserAsync(CBAUser modelUser, string password)
{
MailAddress address = new MailAddress(modelUser.Email);
string userName = address.User;
var user = new CBAUser
{
UserName = userName,
Email = modelUser.Email,
FirstName = modelUser.FirstName,
LastName = modelUser.LastName
};
await _userManager.CreateAsync(user, password);
return(await _userManager.FindByIdAsync(user.Id));
}
public async Task PostUser_Failed()
{
//Mocking host address.
_userController.ControllerContext = new ControllerContext();
_userController.ControllerContext.HttpContext = new DefaultHttpContext();
_userController.ControllerContext.HttpContext.Request.Host = new HostString("https://*****:*****@guest.com",
Password = "******",
FirstName = "Guest",
LastName = "Test",
PhoneNumber = "0225689994",
OrgName = "Christchurch",
OrgCode = "CHRCH",
StreetAddrL1 = "1/32 catelina drive",
StreetAddrL2 = "",
City = "Auckland",
Country = "Newzealand",
OrgPhoneNumber = "0203388485",
LogoURL = "",
CharitiesNumber = "",
GSTNumber = ""
};
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
IdentityError err = new IdentityError();
err.Description = "Failed to create the user";
//Mocking methods.
_mockUserManager.Setup(x => x.CreateAsync(It.IsAny <CBAUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed(err));
_mockUserManager.Setup(x => x.GenerateEmailConfirmationTokenAsync(It.IsAny <CBAUser>())).ReturnsAsync("CfDJ8I9H5drWaGxHgWTL+ERlWjwsoqt2f5ZNoc4xdQXmlFVvLV3crqNf8lyPN2+1i7zONZT+OR6gYFJZm6N3cjM2LnsnzobTpGLdznAhTQ3LEE/sW/F9b7AtIT2cvGDVFbsjSJN0GUTdXaJFiZR8yrBI2fggnAB5rDqGBnq3UOyJN0qa68Xwj6bsifkPFy25xRlOnNh83MPVFwzUuGwOpsWMsaUnaTb+XCWGQgBUzSISlKyv+wLS7mU1+iOKqpWpI/HPSg==");
var result = await _userController.PostUser(cbaUserRegDto);
Assert.AreEqual(((ObjectResult)result).Value, "Failed to create the user");
}
public async Task Login()
{
CBAUser objCBAUser = ClsCommon.GetMockObject();
_mockUserManager.Setup(x => x.FindByNameAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
_mockSignInManager.Setup(x => x.PasswordSignInAsync(It.IsAny <CBAUser>(), It.IsAny <string>(), false, false)).ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Success);
Login objLogin = new Login()
{
Username = "******",
Password = "******"
};
var result = await _accountController.Login(objLogin);
Assert.IsNotNull(((ObjectResult)result).Value);
}
public void SendEmailFromTemplate(CBAUser user, string subject, MimeEntity content)
{
EmailMessage message = new EmailMessage
{
Sender = new MailboxAddress("CBA Admin", _emailMetadata.Sender),
Reciever = new MailboxAddress($"{user.FirstName} {user.LastName}", user.Email),
Subject = subject,
Content = content
};
var mimeMessage = EmailMessage.CreateEmailMessage(message);
SmtpClient smtpClient = new SmtpClient();
smtpClient.Connect(_emailMetadata.SmtpServer, _emailMetadata.Port, true);
smtpClient.Authenticate(_emailMetadata.UserName, _emailMetadata.Password);
smtpClient.Send(mimeMessage);
smtpClient.Disconnect(true);
}
private async Task LoadSharedKeyAndQrCodeUriAsync(CBAUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public async Task ConfirmMail_ValidToken()
{
CBAUser objCBAUser = ClsCommon.GetMockObject();
string mockToken = "CfDJ8I9H5drWaGxHgWTL + ERlWjwsoqt2f5ZNoc4xdQXmlFVvLV3crqNf8lyPN2 + 1i7zONZT + OR6gYFJZm6N3cjM2LnsnzobTpGLdznAhTQ3LEE / sW / F9b7AtIT2cvGDVFbsjSJN0GUTdXaJFiZR8yrBI2fggnAB5rDqGBnq3UOyJN0qa68Xwj6bsifkPFy25xRlOnNh83MPVFwzUuGwOpsWMsaUnaTb + XCWGQgBUzSISlKyv + wLS7mU1 + iOKqpWpI / HPSg == ";
_mockUserManager.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(objCBAUser);
_mockUserManager.Setup(x => x.ConfirmEmailAsync(It.IsAny <CBAUser>(), mockToken)).ReturnsAsync(IdentityResult.Success);
_mockUserManager.Setup(x => x.UpdateAsync(It.IsAny <CBAUser>())).ReturnsAsync(IdentityResult.Success);
//Mocking host address.
_userController.ControllerContext = new ControllerContext();
_userController.ControllerContext.HttpContext = new DefaultHttpContext();
_userController.ControllerContext.HttpContext.Request.Host = new HostString("https://localhost:62856");
var result = await _userController.ConfirmEmail(objCBAUser.Id, mockToken);
//Assert.AreEqual(((ObjectResult)result).Value, "succeed");
}
private async Task LoadAsync(CBAUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
var firstName = user.FirstName;
var lastName = user.LastName;
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber,
UserName = userName,
FirstName = firstName,
LastName = lastName
};
}
public async Task PostVerifyToken_InvalidUser()
{
VerifyTokenDto obj = new VerifyTokenDto()
{
Id = "cee2f64c-fe87-40ca-ac8b-",
Token = "CfDJ8I9H5drWaGxHgWTL%2BERlWjzlReKkIFkFAtEfKwyOEM11WgvvjONokXL9sLJPyNf7lzlki8CfutXU7c8dUx8bxRmj4JYbeOFQaY0uacxy6eHN%2B0AOhX%2FPhdliED3P5qaIiVwWyr1W05a%2BOjgPkRXSQj7Ku0kSVgF4PcdJpL1oB3p2vjql1tYqqfIE7I5rJP5GBC%2BvAM5SOfVGOFry%2BBfA5F%2B3zzcL82H1PneaR2IXq64H"
};
CBAUser objCBAUser = new CBAUser()
{
Email = "*****@*****.**",
FirstName = "Guest",
LastName = "Test",
UserName = "******"
};
//_mockUserManager.Setup(x => x.FindByIdAsync(It.IsAny<string>())).ReturnsAsync();
_mockUserManager.Setup(x => x.VerifyUserTokenAsync(It.IsAny <CBAUser>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(false);
var result = await _resetPasswordController.PostVerifyToken(obj);
Assert.AreEqual(((ObjectResult)result).Value, "Invalid User..!!");
}
public async Task <IActionResult> PostUser([FromBody] UserRegDto regUser)
{
var cbaUser = new CBAUser()
{
Email = regUser.Email,
FirstName = regUser.FirstName,
LastName = regUser.LastName,
PhoneNumber = regUser.PhoneNumber,
UserName = regUser.Email,
Organisation = new Organisation
{
Name = regUser.OrgName,
Code = regUser.OrgCode,
StreetAddressOne = regUser.StreetAddrL1,
StreetAddressTwo = regUser.StreetAddrL2,
City = regUser.City,
Country = regUser.Country,
PhoneNumber = regUser.OrgPhoneNumber,
Logo = regUser.LogoURL,
CharitiesNumber = regUser.CharitiesNumber,
GSTNumber = regUser.GSTNumber,
CreatedAt = DateTime.Now,
}
};
try
{
var result = await _userManager.CreateAsync(cbaUser, regUser.Password);
if (result != null && result.Succeeded)
{
//_logger.LogInformation("User created a new account with password");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(cbaUser);
var hostAddress = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}";
var queryPrarms = new Dictionary <string, string>()
{
{ "userId", cbaUser.Id + "" },
{ "token", code + "" }
};
string callbackUrl = QueryHelpers.AddQueryString($"{hostAddress}/api/user/confirmEmail", queryPrarms);
var pathToFile = Directory.GetCurrentDirectory()
+ Path.DirectorySeparatorChar.ToString()
+ "EmailTemplates"
+ Path.DirectorySeparatorChar.ToString()
+ "ConfirmRegEmailTemplate.html";
string htmlBody = "";
using (StreamReader SourceReader = System.IO.File.OpenText(pathToFile))
{
htmlBody = await SourceReader.ReadToEndAsync();
};
Email emailContent = new Email()
{
To = cbaUser.Email,
Subject = $"CBA user validation email for {cbaUser.FirstName} {cbaUser.LastName}",
Body = string.Format(htmlBody, cbaUser.FirstName, callbackUrl)
};
var sentEmailRes = await _emailService.SendEmail(_emailConfig, emailContent);
return(sentEmailRes? Ok("succeed") : StatusCode(500, "Failed to send confirmation email, please contact CBA"));
}
else
{
foreach (var error in result.Errors)
{
//_logger.LogError(error.ToString());
Console.WriteLine(error.ToString());
}
return(StatusCode(500, "Failed to create the user"));
}
}
catch (Exception ex)
{
throw ex;
}
#region Old code
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
//if (LoginExists(user.Email))
//{
// return BadRequest("Login Invalid");
//}
//user.Password = _crypto.HashMD5(user.Password);
//_context.User.Add(user);
//await _context.SaveChangesAsync();
//return CreatedAtAction("GetUsers", new { id = user.Id }, user);
#endregion
}
public void SendAccountConfirmationEmail(string pathToFile, string callbackUrl, CBAUser user, string password)
{
var builder = new BodyBuilder();
using StreamReader SourceReader = File.OpenText(pathToFile);
builder.HtmlBody = SourceReader.ReadToEnd();
builder.HtmlBody = string.Format(builder.HtmlBody, callbackUrl, user.UserName, user.Email, password, user.FirstName, user.LastName);
SendEmailFromTemplate(user, "Confirm your Email", builder.ToMessageBody());
}
public async Task EditRoleClaimsAsync(CBARole role, IEnumerable <RoleClaimsViewModel> roleClaims, CBAUser user)
{
var claims = await _roleManager.GetClaimsAsync(role);
foreach (var claim in claims)
{
await _roleManager.RemoveClaimAsync(role, claim);
}
var selectedClaims = roleClaims.Where(a => a.IsSelected).ToList();
foreach (var claim in selectedClaims)
{
MemberInfo member = typeof(Permission).GetMember(claim.Type)[0];
var name = ((DisplayAttribute)member.GetCustomAttributes(typeof(DisplayAttribute), false)[0]).Name;
await _roleManager.AddClaimAsync(role, new Claim(claim.Type, name));
await _signInManager.RefreshSignInAsync(user);
}
}
public async Task CreateTellerPosting(string userId, TellerPostingViewModel viewModel)
{
float creditBalance = 0;
float debitBalance = 0;
CBAUser user = await _context.Users.Include(u => u.Till).FirstOrDefaultAsync(u => u.Id == userId);
InternalAccount tellerAccount = user.Till;
if ((viewModel.TransactionSlipNo == null) || (await _context.Postings.AnyAsync(p => p.TransactionSlipNo == viewModel.TransactionSlipNo)))
{
throw new Exception("Duplicate Transaction. A transaction with this Slip Number has already been posted.");
}
InternalAccount vault = await _context.InternalAccounts.SingleOrDefaultAsync(i => i.AccountCode == "10000000000000");
AccountConfiguration settings = _context.AccountConfigurations.First();
CustomerAccount customerAccount;
var creditPosting = new Posting
{
TransactionDate = viewModel.TransactionDate,
TransactionSlipNo = viewModel.TransactionSlipNo,
Credit = viewModel.Amount,
Notes = viewModel.Notes,
Balance = creditBalance,
PostingDate = DateTime.Now,
CBAUserId = userId,
};
var debitPosting = new Posting
{
TransactionDate = viewModel.TransactionDate,
TransactionSlipNo = viewModel.TransactionSlipNo,
Debit = viewModel.Amount,
Notes = viewModel.Notes,
Balance = debitBalance,
PostingDate = DateTime.Now,
CBAUserId = userId,
};
switch (viewModel.TransactionType)
{
case TransactionType.Withdrawal:
if (tellerAccount == null)
{
throw new Exception("You cannot post a customer transaction. There is no Till associated with this account.");
}
customerAccount = await _context.CustomerAccounts
.Where(i => i.AccountNumber == viewModel.AccountNumber)
.FirstOrDefaultAsync();
if (!customerAccount.IsActivated)
{
throw new Exception("Unable to post transaction. Customer Account is deactivated.");
}
if (tellerAccount.AccountBalance < viewModel.Amount)
{
throw new Exception("Unable to post transaction. Insufficient funds in Till.");
}
switch (customerAccount.AccountClass)
{
case AccountClass.Savings:
if (customerAccount.AccountBalance <= settings.SavingsMinBalance)
{
throw new Exception("Account has reached Minimum Balance limit. Cannot post withdrawal.");
}
break;
case AccountClass.Current:
if (customerAccount.AccountBalance <= settings.CurrentMinBalance)
{
throw new Exception("Account has reached Minimum Balance limit. Cannot post withdrawal.");
}
break;
case AccountClass.Loan:
break;
default:
break;
}
creditBalance = tellerAccount.AccountBalance - viewModel.Amount;
debitBalance = customerAccount.AccountBalance - viewModel.Amount;
creditPosting.AccountCode = tellerAccount.AccountCode;
debitPosting.AccountNumber = customerAccount.AccountNumber;
creditPosting.GLAccount = tellerAccount;
debitPosting.GLAccount = customerAccount;
tellerAccount.AccountBalance = creditBalance;
customerAccount.AccountBalance = debitBalance;
_context.Update(customerAccount);
break;
case TransactionType.Deposit:
if (tellerAccount == null)
{
throw new Exception("You cannot post a customer transaction. There is no Till associated with this account.");
}
customerAccount = await _context.CustomerAccounts
.Where(i => i.AccountNumber == viewModel.AccountNumber)
.FirstOrDefaultAsync();
if (!customerAccount.IsActivated)
{
throw new Exception("Unable to post transaction. Customer Account is deactivated.");
}
creditBalance = customerAccount.AccountBalance + viewModel.Amount;
debitBalance = tellerAccount.AccountBalance + viewModel.Amount;
creditPosting.AccountNumber = customerAccount.AccountNumber;
debitPosting.AccountCode = tellerAccount.AccountCode;
creditPosting.GLAccount = customerAccount;
debitPosting.GLAccount = tellerAccount;
tellerAccount.AccountBalance = debitBalance;
customerAccount.AccountBalance = creditBalance;
_context.Update(customerAccount);
break;
case TransactionType.VaultIn:
tellerAccount = await _context.InternalAccounts.FirstOrDefaultAsync(a => a.AccountCode == viewModel.AccountCode);
if (tellerAccount.AccountBalance < viewModel.Amount)
{
throw new Exception("Unable to post transaction. Insufficient funds in Till.");
}
creditBalance = tellerAccount.AccountBalance - viewModel.Amount;
debitBalance = vault.AccountBalance + viewModel.Amount;
creditPosting.AccountCode = tellerAccount.AccountCode;
debitPosting.AccountCode = vault.AccountCode;
creditPosting.GLAccount = tellerAccount;
debitPosting.GLAccount = vault;
creditPosting.TransactionDate = debitPosting.TransactionDate = DateTime.Now;
creditPosting.Notes = debitPosting.Notes = "VaultIn";
tellerAccount.AccountBalance = creditBalance;
vault.AccountBalance = debitBalance;
_context.Update(vault);
break;
case TransactionType.VaultOut:
tellerAccount = await _context.InternalAccounts.FirstOrDefaultAsync(a => a.AccountCode == viewModel.AccountCode);
if (vault.AccountBalance < viewModel.Amount)
{
throw new Exception("Unable to post transaction. Insufficient funds in Vault.");
}
creditBalance = vault.AccountBalance - viewModel.Amount;
debitBalance = tellerAccount.AccountBalance + viewModel.Amount;
creditPosting.AccountCode = vault.AccountCode;
debitPosting.AccountCode = tellerAccount.AccountCode;
creditPosting.GLAccount = vault;
debitPosting.GLAccount = tellerAccount;
creditPosting.TransactionDate = debitPosting.TransactionDate = DateTime.Now;
creditPosting.Notes = debitPosting.Notes = "VaultIn";
tellerAccount.AccountBalance = debitBalance;
vault.AccountBalance = creditBalance;
_context.Update(vault);
break;
default:
break;
}
_context.Update(tellerAccount);
await _context.SaveChangesAsync();
creditPosting.TransactionDate = DateTime.Now;
debitPosting.TransactionDate = DateTime.Now;
creditPosting.Balance = creditBalance;
debitPosting.Balance = debitBalance;
_context.Add(creditPosting);
_context.Add(debitPosting);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new CBAUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
