private void SignInUser(string UserId, string Password) { BankUser user = bll.GetBankUser(UserId); if (user.StatusCode == "0") { string md5HashOfPassword = bll.GenerateMD5Hash(Password); if (user.Password == md5HashOfPassword) { AssignSessionVariables(user); } else { string msg = "INVALID PASSWORD SUPPLIED"; bll.InsertIntoAuditLog("Login", "", user.BankCode, user.Id, "Unsuccessfull login of User with ID :" + user.Id + " Error: " + msg); ShowMessage(msg, true); } } else { string msg = user.StatusDesc; bll.InsertIntoAuditLog("Login", "", user.BankCode, user.Id, "Unsuccessfull login of User with ID :" + user.Id + " Error: " + msg); ShowMessage(msg, true); } }
public TransactionResult Send(BankUser from, BankUser to, int amount) { if (from == null | to == null) { return(TransactionResult.UserNotExist); } else if (from.Amount < amount || amount == 0) { return(TransactionResult.NotValidAmount); } from.Amount -= amount; to.Amount += amount; this.db.Entry(from).State = EntityState.Modified; this.db.Entry(to).State = EntityState.Modified; this.db.BankUserTransactions.Add(new BankUserTransaction() { CreditorId = from.Id, DebitorId = to.Id, Amount = amount }); // must save all records or exception this.db.SaveChanges(); return(TransactionResult.Done); }
public static void Initialize(SimpleBankDbContext context) { context.Database.EnsureCreated(); // Look for any users. if (context.BankUsers.Any()) { return; // DB has been seeded } var users = new BankUser[] { new BankUser { AccountName = "edward", AccountNumber = "account1", Balance = 1000, Password = "******", CreatedDate = DateTime.Now }, new BankUser { AccountName = "will", AccountNumber = "account2", Balance = 50, Password = "******", CreatedDate = DateTime.Now }, }; foreach (BankUser s in users) { context.BankUsers.Add(s); } context.SaveChanges(); }
public void GenerateInternetBankingUser(BankUser user, out string login, out string password) { login = System.Web.Security.Membership.GeneratePassword(9, 0).ToUpper(); password = System.Web.Security.Membership.GeneratePassword(12, 2); InternetBankingUser internetUser = db.InternetBankingUsers.Where(u => u.BankUser.ID == user.ID).FirstOrDefault(); if (internetUser == null) { internetUser = new InternetBankingUser(); db.InternetBankingUsers.Add(internetUser); } else { LoginInfo info = authenticatedUsers.Values.Where(l => l.User == internetUser).FirstOrDefault(); if (info != null) { authenticatedUsers.Remove(info.UID); } } internetUser.Login = login; internetUser.Salt = Guid.NewGuid().ToString("N"); internetUser.PasswordHash = PasswordDistortion(password, internetUser.Salt); internetUser.BankUser = user; internetUser.Role = db.Roles.FirstOrDefault((r) => r.Name == "User"); db.SaveChanges(); }
/// <inheritdoc /> public void RegisterUser(BankUser bankUser, string password) { VerifyNull(bankUser, nameof(bankUser)); VerifyString(password, nameof(password)); try { var user = _userRepository.GetByEmail(bankUser.Email); if (!ReferenceEquals(user, null)) { throw new UserAlreadyRegisteredException(bankUser.Email); } string passwordHash = CryptographyHelper.GetSha256Hash(password); _userRepository.AddBankUser(bankUser.ToDalBankUser(passwordHash)); string subject = "Account registration"; string message = "You have successfully registered an account."; this.SendMail(bankUser.Email, subject, message); _unitOfWork.Commit(); } catch (Exception e) { if (e.GetType() == typeof(UserAlreadyRegisteredException)) { throw; } throw new BankServiceException("Registration error.", e); } }
private async Task <JwtSecurityToken> GenerateToken(BankUser user) { var userClaims = await _userManager.GetClaimsAsync(user); var roles = await _userManager.GetRolesAsync(user); var roleClaims = new List <Claim>(); for (int i = 0; i < roles.Count; i++) { roleClaims.Add(new Claim("roles", roles[i])); } var claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim("uid", user.Id) } .Union(userClaims) .Union(roleClaims); var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.Key)); var signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256); var jwtSecurityToken = new JwtSecurityToken( issuer: _jwtSettings.Issuer, audience: _jwtSettings.Audience, claims: claims, expires: DateTime.UtcNow.AddMinutes(_jwtSettings.DurationInMinutes), signingCredentials: signingCredentials); return(jwtSecurityToken); }
protected void Page_Load(object sender, EventArgs e) { try { user = Session["User"] as BankUser; Session["IsError"] = null; Approver = Request.QueryString["Approver"]; //Session is invalid if (user == null) { Response.Redirect("Default.aspx"); } else if (IsPostBack) { } else { LoadData(); MultiView1.ActiveViewIndex = 0; Multiview2.ActiveViewIndex = 1; } } catch (Exception ex) { bll.ShowMessage(lblmsg, ex.Message, true, Session); } }
public long AddBankUser(BankUserObject user) { try { if (user == null) { return(-2); } var bankUser = new BankUser { UserId = user.UserId }; using (var db = new ImportPermitEntities()) { var branches = db.BankBranches.Where(p => p.BranchCode.ToLower().Trim() == user.BranchCode.ToLower().Trim() && p.BankId == user.BankId).ToList(); if (!branches.Any()) { return(-2); } var branchId = branches[0].Id; bankUser.BranchId = branchId; var res = db.BankUsers.Add(bankUser); db.SaveChanges(); return(res.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
public long AddBankUserWithBranch(BankUserObject user) { try { if (user == null) { return(-2); } var bankUser = new BankUser { UserId = user.UserId, BranchId = user.BranchId }; if (bankUser.BranchId < 1 || bankUser.UserId < 1) { return(-2); } using (var db = new ImportPermitEntities()) { var res = db.BankUsers.Add(bankUser); db.SaveChanges(); return(res.Id); } } catch (Exception ex) { ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message); return(0); } }
internal string SaveUserDetails(BankUser user, string BankCode) { try { command = CbDatabase.GetStoredProcCommand("Users_Update", user.Id, user.Email, user.FullName, user.Usertype, user.Password, user.IsActive, user.BankCode, user.ModifiedBy, user.ModifiedBy, user.CanHaveAccount, user.PhoneNumber, user.BranchCode, user.DateOfBirth, user.Gender, user.TransactionLimit ); DataTable datatable = CbDatabase.ExecuteDataSet(command).Tables[0]; return(datatable.Rows[0][0].ToString()); } catch (Exception ex) { throw ex; } }
/// <inheritdoc /> public string OpenAccount(BankUser bankUser, decimal sum, AccountType accountType = AccountType.Base) { VerifyNull(bankUser, nameof(bankUser)); if (sum < 0) { throw new ArgumentException($"{nameof(sum)} must be not less than 0.", nameof(sum)); } try { string accountId = this.GetUniqueAccoutId(bankUser.Email, bankUser.SecondName); string cryptedAccountId = CryptographyHelper.Encrypt(accountId, bankUser.Email); int initialBonuses = GetInitialBonuses(accountType); var account = CreateAccount(accountType, cryptedAccountId, sum, initialBonuses, bankUser); _accountRepository.AddAccount(account.ToDalAccount()); return(accountId); } catch (Exception e) { throw new AccountServiceException("Open account error.", e); } }
public BankUser FindUserByName(string firstName, string lastName) { if (string.IsNullOrWhiteSpace(firstName)) { throw new ArgumentNullException(nameof(firstName)); } if (string.IsNullOrWhiteSpace(lastName)) { throw new ArgumentNullException(nameof(lastName)); } BankUser finedUser = null; foreach (var user in this._listUser) { if (user.FirstName.Equals(firstName) && user.LastName.Equals(lastName)) { finedUser = user; break; } } return(finedUser); }
private void SaveUser(BinaryWriter writer, BankUser bankUser) { writer.Write(bankUser.UserId); writer.Write(bankUser.FirstName); writer.Write(bankUser.LastName); writer.Flush(); }
public BankUser Add(BankUser model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } if (this.Get(model.UserId) != null) { throw new AddUserException(model.UserId); } var user = FindUserByName(model.FirstName, model.LastName); if (user != null) { throw new EqualsUserException(model.FirstName, model.LastName); } using (var fs = new FileStream(this._fileStorage, FileMode.Append, FileAccess.Write, FileShare.Read)) { using (BinaryWriter writer = new BinaryWriter(fs)) { SaveUser(writer, model); } } this._listUser = this._listUser.Concat(new[] { model }); return(model); }
public async Task <IActionResult> CreateUser(CreateUserViewModel model) { if (ModelState.IsValid) { var user = new BankUser { Email = model.Email, UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.Phone }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { _userManager.AddToRoleAsync(user, "Cashier").Wait(); return(RedirectToAction("ManageUsers")); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } } return(View(model)); }
public IHttpActionResult Post([FromBody] BankUser value) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { using (BankContext db = new BankContext()) { string userId = RequestContext.Principal.Identity.GetUserId(); value.UserIdentityId = userId; if (!db.BankUsers.Any(u => u.UserIdentityId == userId)) { db.BankUsers.Add(value); db.SaveChanges(); var createdUser = db.BankUsers.FirstOrDefault(u => u.UserIdentityId == userId); //send hellomail return(Ok(createdUser)); } } } catch (Exception e) { ExceptionProcessor.ProcessException(e); } return(BadRequest()); }
private BankTeller GetBankTeller(BankUser user) { BankTeller teller = new BankTeller(); teller.TellerAccountNumber = bll.GetAccountsByUserId(user.Id)[0]; teller.ApprovedBy = user.ApprovedBy; teller.BankCode = user.BankCode; teller.BranchCode = user.BranchCode; teller.DateOfBirth = user.DateOfBirth; teller.Email = user.Email; teller.FirstName = user.FirstName; teller.LastName = user.LastName; teller.OtherName = user.OtherName; teller.Gender = user.Gender; teller.Id = user.Id; teller.IsActive = user.IsActive; teller.ModifiedBy = user.ModifiedBy; teller.Password = user.Password; teller.PhoneNumber = user.PhoneNumber; teller.StatusCode = user.StatusCode; teller.StatusDesc = user.StatusDesc; teller.TransactionLimit = user.TransactionLimit; teller.Usertype = user.Usertype; return(teller); }
private void AssignSessionVariables(BankUser user) { Bank UsersBank = bll.GetBankById(user.BankCode); List <string> allowedAreas = bll.GetAllowedAreas(user.Usertype, user.BankCode); //Set Session Variables Specific to System Admin if (user.Usertype == "SYS_ADMIN") { SetSysAdminSession(ref UsersBank, ref allowedAreas, user); } else if (user.Usertype == "TELLER") { BankTeller teller = GetBankTeller(user); user = teller; } //we cant find the Users Bank if (UsersBank.StatusCode != "0") { throw new Exception("Unable To Determine Your Bank. Please contact System Administrator"); } //Get Areas the User is allowed to access else if (allowedAreas.Count == 0) { throw new Exception("Unable To Determine Your Access Rights. Please contact System Administrator"); } //Set Session Variables else { Session["User"] = user; Session["UsersBank"] = UsersBank; Session["AllowedAreas"] = allowedAreas; Response.Redirect("LoggedInStartPage.aspx", false); } }
private void UserLogedin(SignIn sender, BankUser args) { if (OnUserLogin != null) { OnUserLogin(this, args); } }
private static async Task SeedUser(UserManager <BankUser> userManager, BankSystemDbContext dbContext) { if (!dbContext.Users.Any()) { var user = new BankUser { Email = "*****@*****.**", FullName = "Test Testov", UserName = "******", EmailConfirmed = true, BankAccounts = new List <BankAccount> { new BankAccount { Balance = 10000, CreatedOn = DateTime.UtcNow, Name = "Main account", UniqueId = "ABCJ98131785" } } }; await userManager.CreateAsync(user, "Test123$"); } }
public async Task <int> CreateNewUser(BankUser user) { _context.Add(user); var result = await _context.SaveChangesAsync(); return(result); }
internal bool IsValidUser(string UserId, string BankCode, string UserType, out BaseObject obj) { List <string> allowedUserTypes = new List <string>(); allowedUserTypes.AddRange(UserType.Split('|')); obj = new BaseObject(); BankUser user = dh.GetUserById(UserId, BankCode); if (user.StatusCode == "0") { if (allowedUserTypes.Contains(UserType)) { obj = user; } else { obj.StatusCode = "100"; obj.StatusDesc = "ACCESS DENIED: BANK USER:"******" OF TYPE:" + UserType + " IS NOT PERMITTED TO PERFORM THIS OPERATION"; } } else { obj = user; } return(true); }
protected void Page_Load(object sender, EventArgs e) { try { user = Session["User"] as BankUser; usersBank = Session["UsersBank"] as Bank; fromDate = Session["fromDate"] as string; toDate = Session["toDate"] as string; DataTable dt = Session["StatementDataTable"] as DataTable; if (user == null) { Response.Redirect("Default.aspx"); } else if (IsPostBack) { } else { LoadData(dt); } } catch (Exception ex) { bll.ShowMessage(lblmsg, ex.Message, true, Session); } }
public IActionResult OrderSave(OrdersOrderSaveInputModel model) { Product saveFromDb = this.productsService.GetProductById(model.Id); BankUser userFromDb = this.usersService.GetCurrentUser(); if (userFromDb.Id == saveFromDb.Account.BankUserId) { return(this.Redirect("/")); } if (!userFromDb.Accounts.Any()) { return(this.Redirect("/Accounts/Activate")); } this.ViewData["Accounts"] = this.accountsService.GetUserAccounts(); OrderSave order = this.mapper.Map <OrderSave>(model); if (!ModelState.IsValid || saveFromDb.InterestRate != model.InterestRate || saveFromDb.Period != model.Period) { return(this.View(model)); } this.ordersService.AddOrderSave(order, saveFromDb); return(this.Redirect("/Users/OrderedSaves")); }
private void LoadData() { user = (BankUser)Session["User"]; usersBank = (Bank)Session["UsersBank"]; TitleLbl.InnerHtml = "<i class=\"fa fa-bank\"></i> BANK-OS : " + usersBank.BankName.ToUpper(); lblName.Text = user.FirstName + " " + user.LastName; lblUsersName.Text = user.FirstName + " " + user.LastName + " " + user.OtherName; lblUsersRole.Text = user.Usertype; lblCompnay.Text = usersBank.BankName; UserType type = bll.GetUserTypeById(user.Usertype, user.BankCode); if (type.StatusCode == "0") { lblUsersRole.Text = type.UserTypeName; } BankTeller teller = user as BankTeller; if (teller != null) { BankAccount account = bll.GetBankAccountById(teller.TellerAccountNumber, teller.BankCode); lblTellersBalance.Text = account.AccountBalance.Split('.')[0]; lblTellerAccount.Text = teller.TellerAccountNumber; TellersSection.Visible = true; } else { TellersSection.Visible = false; } }
protected void Page_Load(object sender, EventArgs e) { try { user = Session["User"] as BankUser; Session["IsError"] = null; //---------------------------------- //Check If this is an Edit Request Id = Request.QueryString["Id"]; BankCode = Request.QueryString["BankCode"]; //Session is invalid if (user == null) { Response.Redirect("Default.aspx"); } else if (IsPostBack) { } //this is a normal create account request else if (Id != null) { LoadData(); MultiView1.ActiveViewIndex = 0; } else { } } catch (Exception ex) { bll.ShowMessage(lblmsg, ex.Message, true, Session); } }
public void BankAccountsService_CreateAccount_ValidInputData_Test() { var user = new BankUser("User5", "User5"); var account = this._bankAccountService.CreateAccount(user, BankAccountType.Platinum); Assert.NotNull(this._bankAccountService.GetAccount(account.AccountId)); }
private static void UpdateBankUser(BankUser ormBankUser, DalBankUser dalBankUser) { ormBankUser.FirstName = dalBankUser.FirstName; ormBankUser.SecondName = dalBankUser.SecondName; ormBankUser.PasswordHash = dalBankUser.PasswordHash; ormBankUser.Role.RoleInfo = dalBankUser.Role; }
private BankAccount CreateAccounts(string accountId, string userId, string firstName, string lastName, BankAccountType typeAccount, uint amount, uint bonus, bool isClosed) { BankAccount newAccount; BankUser bankUser = new BankUser(userId, firstName, lastName); switch (typeAccount) { case BankAccountType.Base: newAccount = new BaseAccount(bankUser, accountId, typeAccount, amount, bonus, isClosed); break; case BankAccountType.Gold: newAccount = new GoldAccount(bankUser, accountId, typeAccount, amount, bonus, isClosed); break; case BankAccountType.Platinum: newAccount = new PlatinumAccount(bankUser, accountId, typeAccount, amount, bonus, isClosed); break; default: throw new InvalidEnumArgumentException(nameof(typeAccount)); } return(newAccount); }
private BankAccount CreateAccountByType(BankUser bankUser, BankAccountType typeAccount) { if (bankUser == null) { throw new ArgumentNullException(nameof(bankUser)); } BankAccount newAccount; switch (typeAccount) { case BankAccountType.Base: newAccount = new BaseAccount(bankUser); break; case BankAccountType.Gold: newAccount = new GoldAccount(bankUser); break; case BankAccountType.Platinum: newAccount = new PlatinumAccount(bankUser); break; default: throw new InvalidEnumArgumentException(nameof(typeAccount)); } return(newAccount); }
private void Upload(string base64, string PicName) { BankUser user = HttpContext.Current.Session["User"] as BankUser; if (user != null) { string[] parts = base64.Split(new char[] { ',' }, 2); Byte[] bytes = Convert.FromBase64String(parts[1]); string fileName = string.Format("{0}.jpg", DateTime.Now.Ticks); string path = HttpContext.Current.Server.MapPath("Images") + @"\" + user.BankCode + @"\" + fileName; if (PicName == "Profile") { ViewState["ProfilePic"] = fileName; UploadProfilePicSection.Visible = false; string msg = "Profile Picture Uploaded Successfully"; bll.ShowMessage(lblmsg, msg, false, Session); } else { ViewState["SignaturePic"] = fileName; string msg = "Customers Signature Uploaded Successfully"; bll.ShowMessage(lblmsg, msg, false, Session); UploadSignatureSection.Visible = false; } System.IO.File.WriteAllBytes(path, bytes); } }
public void ShouldIncreaseUserBalanceWhenDepositMoney() { var transactionService = new TransactionService(); var bankUser = new BankUser(); transactionService.Deposit(bankUser, 100); Assert.AreEqual(100,bankUser.Balance); }
public void ShouldDecreaseUserBalanceWhenWithdrawMoney() { var transactionService = new TransactionService(); var bankUser = new BankUser(){Balance = 500}; transactionService.Withdraw(bankUser, 100,0.02m); Assert.AreEqual(398, bankUser.Balance); }
public void ShouldUpdateLastTransactionTimeWhenDepositMoney() { var transactionService = new TransactionService(); var defaultTransactionTime = DateTime.MinValue; var bankUser = new BankUser(){LastTransactionTime =defaultTransactionTime}; transactionService.Deposit(bankUser, 100); Assert.IsTrue(bankUser.LastTransactionTime>defaultTransactionTime); }
public void ShouldUpdateLastTransactionTimeWhenWithdrawMoney() { var transactionService = new TransactionService(); var defaultTransactionTime = DateTime.MinValue; var bankUser = new BankUser() {Balance = 300, LastTransactionTime = defaultTransactionTime }; transactionService.Withdraw(bankUser, 100,0.02m); Assert.IsTrue(bankUser.LastTransactionTime > defaultTransactionTime); }
public Message CreateUser(Guid securityToken, BankUser user) { if (db.BankUsers.ToList().Any(u => u.PassportNumber.Equals(user.PassportNumber, StringComparison.InvariantCultureIgnoreCase))) { return Json(new { Status = "PassportAlreadyExist"}); } db.BankUsers.Add(user); db.SaveChanges(); return Json(new { Status = "OK", ID = user.ID }); }
public Message UpdateUser(Guid securityToken, BankUser user) { BankUser currentUser = db.BankUsers.Find(user.ID); //copy user info currentUser.FirstName = user.FirstName; currentUser.LastName = user.LastName; currentUser.PassportNumber = user.PassportNumber; currentUser.Address = user.Address; db.SaveChanges(); return Json("OK"); }
private object CreateUserResponse(BankUser user, bool joinCards) { var response = new { ID = user.ID, FirstName = user.FirstName, LastName = user.LastName, PassportNumber = user.PassportNumber, Address = user.Address, Cards = joinCards ? user.Cards.Select(c => CreateCardResponse(c, false)) : user.Cards.Select(c => (object)c.ID) }; return response; }