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);
        }
    }
Exemple #2
0
        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);
        }
Exemple #3
0
        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();
        }
Exemple #4
0
 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);
        }
Exemple #7
0
    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;
     }
 }
Exemple #11
0
        /// <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);
            }
        }
Exemple #12
0
        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);
        }
Exemple #13
0
 private void SaveUser(BinaryWriter writer, BankUser bankUser)
 {
     writer.Write(bankUser.UserId);
     writer.Write(bankUser.FirstName);
     writer.Write(bankUser.LastName);
     writer.Flush();
 }
Exemple #14
0
        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);
        }
Exemple #15
0
        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));
        }
Exemple #16
0
        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);
    }
Exemple #18
0
    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);
        }
    }
Exemple #19
0
 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);
        }
Exemple #22
0
    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"));
        }
Exemple #25
0
    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;
 }
Exemple #29
0
        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);
        }
Exemple #30
0
        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);
        }
Exemple #31
0
    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;
 }