public ActionResult ChangePassword(UserChangePasswordViewModel objEntity)
        {
            int result = 0;
            UserRepository objUserRepository = new UserRepository();
            if (ModelState.IsValid)
            {

                objEntity.NewPassword = objEntity.NewPassword.Trim();
                objEntity.OldPassword = objEntity.OldPassword.Trim();
                objEntity.UserEmail = SessionWrapper.UserAccount.UserEmail;

                result = ValidateUserChangePassword(objEntity);

                if (result == ResultFlags.Success.GetHashCode())
                {
                    this.Flash("success", "Password updated successfully");

                    AccountRepository.Logout();
                    return RedirectToAction("Login", "Admin");

                }
                else if (result == ResultFlags.Failure.GetHashCode())
                {
                    this.Flash("Error", "Password failed to update");

                }
                else if (result == ResultFlags.OldPasswordMismatch.GetHashCode())
                {
                    this.Flash("Warning", "Old password and new password cannot be same");

                }

            }
            return View(objEntity);
        }
        public ActionResult ChangePassword(UserChangePasswordViewModel objEntity)
        {
            var objUserRepository = new UserRepository();
            if (ModelState.IsValid)
            {

                objEntity.NewPassword = objEntity.NewPassword.Trim();
                objEntity.OldPassword = objEntity.OldPassword.Trim();

                var objUserViewModel = objUserRepository.Update(UserFlags.UpdatePasswordByID.GetHashCode(),

                    new UserViewModel()
                    {
                        UserId = SessionWrapper.UserAccount.UserID,
                        UserEmail = SessionWrapper.UserAccount.UserEmail,
                        OldPassword = objEntity.OldPassword,
                        Password = objEntity.NewPassword
                    }
                    );
                if (objUserViewModel.Result == ResultFlags.Success.GetHashCode())
                {
                    this.Flash("success", "Password updated successfully ");

                    return RedirectToAction("Dashboard", "Admin");
                }
                else if (objUserViewModel.Result == ResultFlags.Failure.GetHashCode())
                {
                    this.Flash("error", "Password failed to update");

                }
                else if (objUserViewModel.Result == ResultFlags.OldPasswordMismatch.GetHashCode())
                {
                    this.Flash("warning", "Old Password mismatch");

                }

            }
            return View(objEntity);
        }
        public int ValidateUserChangePassword(UserChangePasswordViewModel objEntity)
        {
            int result = 0;
            AccountRepository objAccountRepository = new AccountRepository();
            var objUserRepository = new UserRepository();
            var objLoginUserViewModel = objAccountRepository.GetUserDetailsforLogin(UserFlags.UserSignIn.GetHashCode(), new UserLoginViewModel() { UserEmail = objEntity.UserEmail });

            if (objLoginUserViewModel != null)
            {
                if (PasswordHelpers.Validate(objLoginUserViewModel.Password, objLoginUserViewModel.PasswordSalt, objEntity.NewPassword))
                {
                    result = ResultFlags.OldPasswordMismatch.GetHashCode();

                }
                else
                {
                    PasswordHelpers.HashedPassword objHashedPassword = PasswordHelpers.Generate(objEntity.NewPassword);
                    var objNewUserViewModel = new UserViewModel()
                    {
                        UserId = SessionWrapper.UserAccount.UserId,
                        UserEmail = SessionWrapper.UserAccount.UserEmail,
                        PasswordSalt = objHashedPassword.Salt,
                        Password = objHashedPassword.Password
                    };

                    objNewUserViewModel = objUserRepository.Update(UserFlags.UpdatePasswordByID.GetHashCode(), objNewUserViewModel);
                    result = objNewUserViewModel.Result;

                }

            }

            return result;
        }
        public ActionResult ManageUsers()
        {
            var objUserRepository = new UserRepository();
            List<UserViewModel> objEntityList = objUserRepository.Select(UserFlags.SelectAll.GetHashCode(), new UserViewModel() { });
            if (objEntityList.Count == 0)
            {

                this.Flash("Info", "No Users");
            }

            return View(objEntityList);
        }
        public ActionResult ManageUserEdit(Int16 id, UserViewModel objEntity)
        {
            var objUserRepository = new UserRepository();

            if (ModelState.IsValid)
            {

                objEntity.UserId = id;

                objEntity = objUserRepository.Update(UserFlags.UpdateStatusByID.GetHashCode(), objEntity);
                if (objEntity.Result == ResultFlags.Success.GetHashCode())
                {
                    this.Flash("Success", "User details updated successfully");
                    return RedirectToAction("Index");
                }
                else if (objEntity.Result == ResultFlags.Failure.GetHashCode())
                {

                    this.Flash("Error", "User details failed to Update");
                }

            }

            return View(objEntity);
        }
        public ActionResult ManageUserEdit(int id)
        {
            UserRepository objUserRepository = new UserRepository();

            var objEntity = new UserViewModel();

            objEntity = objUserRepository.Select(UserFlags.SelectByID.GetHashCode(), new UserViewModel()
            {
                UserId = id
            }).FirstOrDefault();
            if (objEntity == null)
            {
                this.Flash("Error", "Failed to edit user details");

                return RedirectToAction("Index");
            }

            return View(objEntity);
        }
 public AccountRepository()
 {
     _userRepository = new UserRepository();
 }
 public AccountRepository()
 {
     _userRepository = new UserRepository();
     _roleRepository = new RoleRepository();
     _userAccessRepository = new UserAccessRepository();
 }