public void should_succeed_if_registered()
{
AuthService auth = new AuthService();
var acontroller = new AccountController(auth);
acontroller.Request = new HttpRequestMessage();
acontroller.Configuration = new HttpConfiguration();
var p = new UserModel
{
Name = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var res = acontroller.Register(p);
}
public async Task AccountController_RegisterTest_InvalidEmailFormat()
{
//Arrange
AccountController controller = IoCFactory.Instance.CurrentContainer.Resolve <AccountController>();
RegisterViewModel model = new RegisterViewModel()
{
Email = "test.test",
Password = "******",
ConfirmPassword = "******"
};
//Act
ViewResult result = await controller.Register(model) as ViewResult;
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(controller.ModelState.Count == 1);
string errors = string.Join("; ", controller.ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage));
Assert.IsFalse(string.IsNullOrEmpty(errors));
}
public void Register_ShouldReturnRegisterViewModel_WhenModelStateIsNotValid()
{
// Arrange
var mockedStore = new Mock <IUserStore <ApplicationUser> >();
var mockedUserManager = new Mock <ApplicationUserManager>(mockedStore.Object);
var mockedAuthenticationManager = new Mock <IAuthenticationManager>();
var mockedSignInManager = new Mock <ApplicationSignInManager>(mockedUserManager.Object, mockedAuthenticationManager.Object);
var mockedViewModel = new Mock <RegisterViewModel>();
var accController = new AccountController(mockedUserManager.Object, mockedSignInManager.Object);
accController.ModelState.AddModelError("invalid", "invalid");
// Act
var actionResultTask = accController.Register(mockedViewModel.Object);
actionResultTask.Wait();
var viewResult = actionResultTask.Result as ViewResult;
// Assert
Assert.IsInstanceOf <RegisterViewModel>(viewResult.Model);
}
public async Task RegisterHttpPostEmailIsNullTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
_accountController.ModelState.AddModelError("key", "error message");
var viewModel = new AccountRegisterViewModel()
{
Email = null,
Password = "******",
ConfirmPassword = "******"
};
var result = await _accountController.Register(viewModel);
Assert.IsInstanceOf <ViewResult>(result);
}
public async void SuccessUserRegister()
{
var controller = new AccountController(userManager.Object, signInManager.Object);
RegisterUserViewModel vm = new RegisterUserViewModel()
{
Email = "*****@*****.**",
Password = "******",
PasswordConfirm = "pass123QWE",
DateBirth = DateTime.Now
};
// Действие - выполняем регистрацию
var res = await controller.Register(vm) as RedirectToActionResult;
Assert.Equal("Index", res.ActionName);
Assert.Equal("Home", res.ControllerName);
// Проверяем на предмет добавления пользователя в бд
Assert.Equal(vm.Email, _users.FirstOrDefault(i => i.Email == vm.Email).Email);
}
public void Register_Post_ReturnsViewIfModelStateIsInvalid()
{
// Arrange
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
controller.ModelState.AddModelError("", "Dummy error message.");
// Act
ActionResult result = controller.Register(model);
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
}
public void Register_Post_ReturnsViewIfRegistrationFails()
{
// Arrange
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
// Act
ActionResult result = controller.Register(model);
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
Assert.AreEqual("Username already exists. Please enter a different user name.", controller.ModelState[""].Errors[0].ErrorMessage);
Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
}
public void Register_Post_ReturnsViewIfRegistrationFails()
{
// 排列
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
// 操作
ActionResult result = controller.Register(model);
// 断言
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
Assert.AreEqual("用户名已存在。请另输入一个用户名。", controller.ModelState[""].Errors[0].ErrorMessage);
Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
}
public async Task Register_ShouldReturnRegisterViewWithModel_IfCreateAsyncIdentityResultReturnFailed()
{
//Arrange
var userManager = new UserManagerFake(isUserConfirmed: true, identityResult: IdentityResult.Failed());
var signInManager = new SignInManagerFake(_httpContextAccessor.Object, signInResult: Microsoft.AspNetCore.Identity.SignInResult.Failed);
var captchaResponse = new CaptchaResponse {
Success = "true"
};
_mediatorMock.Setup(m => m.Send(It.IsAny <ValidateCaptchaQuery>(), It.IsAny <CancellationToken>())).ReturnsAsync(captchaResponse);
var sut = new AccountController(userManager, signInManager, _emailSender.Object, _loggerFactoryWrapper.Object, _razorViewToString.Object, _mediatorMock.Object);
//Act
var result = (ViewResult)await sut.Register(A.New <RegisterViewModel>());
result.Should().NotBeNull();
result.Should().BeOfType <ViewResult>();
result.Model.Should().NotBeNull();
result.Model.Should().BeOfType <RegisterViewModel>();
}
public async Task GivenAccountToRegister_WhenAccountDoesNotPreviouslyExistInTheDatabase_ThenUserIsStoredInDatabase()
{
// Arrange
var dbSetMock = new List <AppUser>().AsQueryable().BuildMockDbSet();
var dataContextOptions = new DbContextOptionsBuilder <DataContext>().Options;
var dataContextMock = new Mock <DataContext>(dataContextOptions);
dataContextMock.Setup(x => x.Users).Returns(dbSetMock.Object);
var request = new RegisterUserRequest {
UserName = "******", Password = "******"
};
var tokenServiceMock = new Mock <ITokenService>();
tokenServiceMock.Setup(ts => ts.CreateToken(It.Is <AppUser>(user => user.UserName == "username1"))).Returns("Here is the token");
var testee = new AccountController(dataContextMock.Object, tokenServiceMock.Object);
// Act
await testee.Register(request).ConfigureAwait(false);
// Assert
dbSetMock.Verify(dbs => dbs.AddAsync(It.Is <AppUser>(user => user.UserName == "username1"), It.IsAny <CancellationToken>()), Times.Once);
dataContextMock.Verify(dc => dc.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public void Register_Post_ReturnsRedirectOnSuccess()
{
// Arrange
var memberService = MockRepository.GenerateStub <IMembershipService>();
memberService.Stub(x => x.MinPasswordLength).Return(10);
memberService.Stub(x => x.CreateUser("abc", "def", "ijk")).Return(
MembershipCreateStatus.Success);
var formService = MockRepository.GenerateMock <IFormsAuthenticationService>();
formService.Expect(x => x.SignIn("someUser", false));
var controller = new AccountController {
FormsService = formService, MembershipService = memberService
};
//AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
// Act
ActionResult result = controller.Register(model);
// Assert
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
RedirectToRouteResult redirectResult = (RedirectToRouteResult)result;
Assert.AreEqual("Home", redirectResult.RouteValues["controller"]);
Assert.AreEqual("Index", redirectResult.RouteValues["action"]);
//formService.AssertWasCalled(x => x.SignIn("someUser", false));
formService.VerifyAllExpectations();
}
public void ShouldReturnBadRequestWhenRegisteringWithInvalidAddresses()
{
// Arrange
var person = new Person();
var personRepository = new StubIPersonRepository()
{
GetPersonByEmailString = emailAddress => person
};
var controller = new AccountController(personRepository, null, null, null);
SetupControllerForTests(controller);
// Act
var result = controller.Register(new RegistrationInfo
{
FirstName = "John",
LastName = "Doe",
Password = "******",
EmailAddresses = new List <string> {
"*****@*****.**"
},
Addresses = new List <AddressInfo> {
new AddressInfo()
},
CreditCards = new List <CreditCardInfo> {
new CreditCardInfo()
}
});
// Assert
var error = JsonConvert.DeserializeAnonymousType(
result.Content.ReadAsStringAsync().Result,
new { Message = string.Empty });
Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest);
}
public void Register_Post_ReturnsViewIfModelStateIsInvalid()
{
// 準備
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
controller.ModelState.AddModelError("", "ダミー エラー メッセージ。");
// 実行
ActionResult result = controller.Register(model);
// アサート
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
}
public void Register_Post_ReturnsViewIfModelStateIsInvalid()
{
// Упорядочение
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
controller.ModelState.AddModelError("", "Заглушка сообщения об ошибке.");
// Действие
ActionResult result = controller.Register(model);
// Утверждение
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
}
public async Task Register_InvalidState_BadRequest()
{
// Arrange
const string field = "dog-error";
const string errorMessage = "The hair of the dog that bit you";
var service = new MockAccountService {
MRegister = (model) => "Doesn't really matter a fourth time"
};
var controller = new AccountController(service);
controller.ModelState.AddModelError(field, errorMessage);
// Act
var result = await controller.Register(MockRegisterViewModel.Get(0)) as BadRequestObjectResult;
var error = result?.Value as SerializableError;
// Assert
Assert.NotNull(error);
Assert.Equal(400, result.StatusCode);
Assert.Single(error.Keys);
Assert.True(error.ContainsKey(field));
Assert.Equal(new[] { errorMessage }, error.GetValueOrDefault(field));
}
public void Register_Test()
{
// Arrange
IList <UserRoles> rolelist = null;
_mockRoleRepository.Setup(x => x.GetRoles())
.Returns(rolelist = new List <UserRoles> {
new UserRoles {
RoleId = 1, RoleName = "Admin"
}, new UserRoles {
RoleId = 2, RoleName = "Doctor"
}, new UserRoles {
RoleId = 3, RoleName = "Patient"
}
});
// Act
var roleresult = _accountcontroller.Register();
//Assert
Assert.IsInstanceOfType(roleresult, typeof(ActionResult));
Assert.IsInstanceOfType(roleresult.Model, typeof(UserRegisters));
Assert.AreEqual(rolelist.Count, ((UserRegisters)roleresult.Model).RoleList.Count);
}
public void SuccessfullyRegisterShouldReturnCreated()
{
// ARRANGE
var fakeUserRequest = new SignUpRequest
{
Email = @"*****@*****.**",
FullName = "Carlos Perez",
Gender = 0,
Phone = "+53 12345678",
Birthday = DateTime.Now,
Password = @"S3cretP@$$",
ConfirmationPassword = @"S3cretP@$$"
};
using var context = new CoreDbContext(ContextOptions);
var accountService = new AccountService(new Mock <IConfiguration>().Object, new UnitOfWork(context), new Mock <IStringLocalizer <IAccountService> >().Object, new Mock <IDetectionService>().Object, storageService);
var accountController = new AccountController(accountService, new Mock <AutoMapper.IMapper>().Object, new Mock <IEmailService>().Object, new Mock <IWebHostEnvironment>().Object);
// ACT
var taskResult = (ObjectResult)accountController.Register(fakeUserRequest).Result;
// ASSERT
Assert.Equal(201, taskResult.StatusCode);
}
public async Task RegisterFailedTest()
{
var userValidators = new List <IUserValidator <ChatLeUser> >();
var validator = new Mock <IUserValidator <ChatLeUser> >();
userValidators.Add(validator.Object);
var userManagerMock = MockUserManager(userValidators);
userManagerMock.Setup(u => u.CreateAsync(It.IsAny <ChatLeUser>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityError()
{
Code = "test",
Description = "test"
}));
var userManager = userManagerMock.Object;;
var signinManager = MockSigninManager <ChatLeUser>(userManager);
var metaDataProvider = new Mock <IModelMetadataProvider>().Object;
var chatManager = new Mock <IChatManager <string, ChatLeUser, Conversation, Attendee, Message, NotificationConnection> >().Object;
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary());
using (var controller = new AccountController(userManager, signinManager.Object, chatManager)
{
ViewData = viewData
})
{
var result = await controller.Register(new RegisterViewModel()
{
ConfirmPassword = "******",
Password = "******",
UserName = "******"
});
Assert.IsType <ViewResult>(result);
}
}
public static void GenerateGeneralMenu()
{
while (true)
{
Console.WriteLine("---------WELCOME TO SPRING HERO BANK---------");
Console.WriteLine("1. Register for free.");
Console.WriteLine("2. Login.");
Console.WriteLine("3. Exit.");
Console.WriteLine("---------------------------------------------");
Console.WriteLine("Please enter your choice (1|2|3): ");
var choice = Utility.GetInt32Number();
switch (choice)
{
case 1:
accController.Register();
break;
case 2:
if (accController.DoLogin())
{
Console.WriteLine("Login success.");
}
break;
case 3:
Console.WriteLine("See you later.");
Environment.Exit(1);
break;
default:
Console.WriteLine("Invalid choice.");
break;
}
}
}
public async Task Register_Fail()
{
var accountService = new Mock <IAccountService>();
accountService.Setup(x => x.FindUserAsync(It.IsAny <string>()))
.ReturnsAsync(new User {
Email = "*****@*****.**"
});
var controller = new AccountController(null, accountService.Object, _mapper, _notificationServiceMock.Object);
var output = await controller.Register(new RegisterModelDto());
accountService.Verify(m => m.RegisterUserAsync(It.IsAny <User>()), Times.Never());
Assert.AreEqual(output.GetType(), typeof(OkObjectResult));
dynamic dto = ((OkObjectResult)output).Value;
Assert.AreEqual(dto.GetType(), typeof(SimpleResponseDto));
var res = (SimpleResponseDto)dto;
Assert.IsFalse(res.Success);
}
public void RegisterPOST_ShouldRegister_NewUser()
{
// Arrange
var mockedVerification = new Mock <IVerificationProvider>();
var mockedUser = new Mock <User>();
mockedVerification.Setup(v => v.RegisterAndLoginUser(It.IsAny <User>(), It.IsAny <string>(),
It.IsAny <bool>(), It.IsAny <bool>())).Returns(IdentityResult.Success);
var controller = new AccountController(mockedVerification.Object);
var viewModel = new RegisterViewModel()
{
Password = "******",
Email = "*****@*****.**"
};
controller.Register(viewModel);
// Act and Assert
controller
.WithCallTo(c => c.Register(viewModel))
.ShouldRedirectTo((StoreController c) => c.Index());
}
public void Register_Post_ReturnsViewIfModelStateIsInvalid()
{
// Disponer
AccountController controller = GetAccountController();
RegisterModel model = new RegisterModel()
{
UserName = "******",
Email = "goodEmail",
Password = "******",
ConfirmPassword = "******"
};
controller.ModelState.AddModelError("", "Mensaje de error ficticio.");
// Actuar
ActionResult result = controller.Register(model);
// Declarar
Assert.IsInstanceOfType(result, typeof(ViewResult));
ViewResult viewResult = (ViewResult)result;
Assert.AreEqual(model, viewResult.ViewData.Model);
Assert.AreEqual(10, viewResult.ViewData["PasswordLength"]);
}
public async Task Register_Method_Test_CreateUserAsync_Call_Once_Return_Not_Null_Result()
{
// Arrange
var request = new RegisterUserDto();
var model = new RegisterUserViewModel()
{
Request = request
};
var returnModel = new AuthorizationResultDto()
{
IsSuccessful = true
};
_userService.Setup(f => f.CreateUserAsync(model.Request)).ReturnsAsync(returnModel);
var controller = new AccountController(_userService.Object);
// Act
var result = await controller.Register(model);
// Assert
Assert.IsNotNull(result);
_userService.Verify(f => f.CreateUserAsync(request), Times.Once);
}
public async Task RegisterPost_ReturnsContentWithSuccessMsg_WhenPassMatchAndCreateUsrSuccess()
{
// Arrange
var model = new RegistrationModel
{
Email = string.Empty,
PasswordConfirmation = string.Empty,
Password = string.Empty,
};
_mockFacade.Setup(facade => facade.CreateUserAsync(It.IsNotNull <User>(), It.Is <string>(fn => fn.Equals(model.Password))))
.Returns(Task.FromResult(IdentityResult.Success));
_mockFacade.Setup(facade => facade.GenerateEmailConfirmationTokenAsync(It.IsAny <User>()))
.Returns(Task.FromResult(string.Empty));
_mockFacade.Setup(facade => facade.SendConfirmationEmailAsync(It.Is <string>(fn => fn.Equals(model.Email)), It.IsAny <string>()))
.Returns(Task.FromResult(string.Empty));
var controller = new AccountController(_mockFacade.Object)
{
Url = _mockUrlHelper.Object,
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
controller.ControllerContext.HttpContext.Request.Scheme = "";
// Act
var result = await controller.Register(model);
// Assert
var contentResult = Assert.IsType <ContentResult>(result);
_mockFacade.VerifyAll();
Assert.Equal("Check your email for a verification link", contentResult.Content);
}
public async Task Register_WhenAddPasswordFails_ExpectUpdateToNotBeCalledAndModelStateToHaveErrors()
{
//arrange
var controller = new AccountController(mockInteraction.Object, mockClientStore.Object, mockAccessor.Object, mockUserManager.Object, mockSchemeProvider.Object, mockEvents.Object, mockUrlHelper.Object);
mockUserManager.Setup(x => x.FindByNameAsync(It.IsAny <string>())).ReturnsAsync(new IdentityExpressUser());
mockUserManager.Setup(x => x.AddPasswordAsync(It.IsAny <IdentityExpressUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed(new IdentityError {
Description = "Error"
}));
var model = new RegisterInputModel
{
Username = "******"
};
//act
var result = await controller.Register(model);
//assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.False(viewResult.ViewData.ModelState.IsValid);
mockUserManager.Verify(x => x.UpdateAsync(It.IsAny <IdentityExpressUser>()), Times.Never);
}
public void AnUserCanBeRegisteredWithAnUserNameAndAPasswordIfThereIsNotAnotherUserWithThatUserName()
{
var response = controller.Register(RegistrationFormForPepe(), "");
response.AssertActionRedirect().ToAction("Login");
}
public async Task<ActionResult> Import()
{
ArrayList newUsers = new ArrayList();
//newUsers.Add("hello");
// Filter Regex
string regex = "^[a-z,A-Z,0-9]*@uwec.edu$";
Regex r = new Regex(regex);
if (Request.Files.Count > 0)
{
var file = Request.Files[0];
if (file != null && file.ContentLength > 0)
{
var fileName = Path.GetFileName(file.FileName);
var path = Path.GetFullPath(Server.MapPath("~"));
path = Path.Combine(path , fileName); //H:\tfkt5\Mélodie\excel\
file.SaveAs(path);
foreach (var worksheet in Workbook.Worksheets(path))
{
foreach (var row in worksheet.Rows)
{
foreach (var cell in row.Cells)
{
if (cell != null)
{
Match m = r.Match(cell.Text);
if (m.Success)
{
newUsers.Add(cell.Text);
}
}
}
}
}
}
}
for (int x = 0; x < newUsers.Count; x++)
{
Users user = new Users();
user.email = (String)newUsers[x];
user.role_id = "Student";
// generate a random password for the user
AccountController ac = new AccountController();
string password = GenerateRandomPassword(8);
RegisterViewModel model = new RegisterViewModel();
model.UserName = user.email.Substring(0, user.email.IndexOf('@'));
model.Email = user.email;
model.role_id = user.role_id;
// notify the user that an account has been created in their name
await ac.Register(model);
}
//stuff to make the computer stop yelling at me
return RedirectToAction("Index");
}
public void GenerateMainMenu()
{
Console.Clear();
while (true)
{
Console.Clear();
Console.WriteLine("-------------------------- Ngân Hàng Spring Hero Bank --------------------------");
Console.WriteLine("1. Đăng ký tài khoản.");
Console.WriteLine("2. Đăng nhập hệ thống.");
Console.WriteLine("3. Thoát");
Console.WriteLine("---------------------------------------------------------------------------------");
Console.WriteLine("Nhập lựa chọn của bạn (1, 2, 3)");
var choice = PromptHelper.GetUserChoice(1, 3);
switch (choice)
{
case 1:
Console.Clear();
Console.WriteLine("Đăng ký tài khoản");
Console.WriteLine(
"---------------------------------------------------------------------------------");
Account newAccount = _accountController.Register();
if (newAccount == null)
{
Console.WriteLine("Đăng ký tài khoản không thành công");
PromptHelper.StopConsole("Nhấn phím bất kỳ để quay lại menu chính...");
break;
}
Console.WriteLine("Bạn đã đăng ký thành công tài khoản với thông tin: ");
Console.WriteLine($"Họ và tên: {newAccount.FullName}\n" +
$"Số tài khoản: {newAccount.AccountNumber}\n" +
$"Sô dư hiện tại: {newAccount.Balance}\n" +
$"Số điện thoại: {newAccount.PhoneNumber}\n" +
$"Email: {newAccount.Email}\n" +
$"Tên đăng nhập: {newAccount.Username}");
PromptHelper.StopConsole("Ấn phím bất kỳ để tiếp tục....");
break;
case 2:
Console.Clear();
Console.WriteLine("Đăng nhập hệ thống");
Console.WriteLine(
"---------------------------------------------------------------------------------");
var currentAccount = _accountController.Login();
if (currentAccount == null)
{
Console.WriteLine("Đăng nhập không thành công");
Console.WriteLine("Đăng nhập không thành công. Vui lòng thử lại!. ");
PromptHelper.StopConsole("Nhấn phím bất kỳ để quay lại menu chính...");
break;
}
CurrentLogin = currentAccount;
if (CurrentLogin.Role == AccountRole.ADMIN)
{
GenerateAdminMenu();
}
if (CurrentLogin.Role == AccountRole.GUEST)
{
GenerateCustomMenu();
}
break;
case 3:
Console.WriteLine("Thoát");
Console.WriteLine("Cảm ơn quý khách đã sử dụng dịch vụ của ngân hàng SHB");
break;
default:
Console.WriteLine("Không hợp lệ");
break;
}
if (choice == 3)
{
break;
}
}
}
public void RegisterTest()
{
var result = _accountController.Register() as ViewResult;
Assert.AreEqual("Register", result.ViewName);
}
public static void GenerateAdminMenu()
{
var generateMenu = new GenerateMenu();
var accountController = new AccountController();
var transactionController = new TransactionController();
while (true)
{
try
{
Console.Clear();
Console.WriteLine("—— Ngân hàng Spring Hero Bank ——");
Console.WriteLine(
$"Chào mừng Admin {AccountController.currentAccount.Fullname} quay trở lại. Vui lòng chọn thao tác:");
Console.WriteLine("1. Danh sách người dùng.");
Console.WriteLine("2. Danh sách lịch sử giao dịch.");
Console.WriteLine("3. Tìm kiếm người dùng theo tên.");
Console.WriteLine("4. Tìm kiếm người dùng theo số tài khoản.");
Console.WriteLine("5. Tìm kiếm người dùng theo số điện thoại.");
Console.WriteLine("6. Thêm người dùng mới.");
Console.WriteLine("7. Khoá và mở tài khoản người dùng.");
Console.WriteLine("8. Tìm kiếm lịch sử giao dịch theo số tài khoản.");
Console.WriteLine("9. Thay đổi thông tin tài khoản.");
Console.WriteLine("10. Thay đổi thông tin mật khẩu.");
Console.WriteLine("11. Đăng xuất.");
Console.WriteLine("12. Thoát.");
Console.WriteLine("--------------------------------");
Console.WriteLine("Nhập lựa chọn của bạn (1-12): ");
var choice = int.Parse(Console.ReadLine());
switch (choice)
{
case 1:
accountController.ListUser();
break;
case 2:
transactionController.PrintlistTransactionHistory();
break;
case 3:
accountController.FindUserByUsername();
break;
case 4:
accountController.FindUserByAccountNumber();
break;
case 5:
accountController.FindUserByPhone();
break;
case 6:
accountController.Register();
break;
case 7:
accountController.UpdateAccountStatus();
break;
case 8:
transactionController.PrintListTransaction();
break;
case 9:
accountController.UpdateAccountInfor();
break;
case 10:
accountController.UpdateAccountPassword();
break;
case 11:
Console.WriteLine("Đăng xuất");
break;
case 12:
Console.WriteLine("Goodbye!");
Environment.Exit(0);
break;
default:
Console.WriteLine("Hãy nhập từ 1 đến 12");
break;
}
if (choice == 11)
{
AccountController.currentAccount = null;
generateMenu.GetMenu(AccountController.currentAccount);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
}
public async Task <ActionResult> AddEmployee([Bind(Include = "EmployeeId,FirstName," +
"LastName, MiddleName,SIN,StreetAddress,City,PostalCode," +
"HomePhone,CellPhone,OfficePhone,OfficeEmail,DOB,AddedBy," +
"HireDate, ProvincesList, ProvinceEmployee, EmployeeProvinceId")]
Employee employee)
{
if (ModelState.IsValid)
{
int provId = Convert.ToInt32(Request.Form["ProvincesList"]);
employee.EmployeeProvinceId = provId;
//get currently logged user from Identity
string currentUser = User.Identity.GetUserName();
var addedBy = db.Employees.Where(e => e.OfficeEmail.Contains(currentUser)).FirstOrDefault();
if (addedBy == null)
{
//Need this for the 1st user.
employee.AddedBy = 1;
}
else
{
employee.AddedBy = addedBy.EmployeeId;
}
employee.Password = GeneratePassword(8, 1);
db.Employees.Add(employee);
db.SaveChanges();
//save province info
int empId = employee.EmployeeId;
ProvinceEmployee pe = new ProvinceEmployee();
pe.EmployeeId = empId;
pe.ProvinceId = provId;
db.ProvincesEmployees.Add(pe);
db.SaveChanges();
AccountController accountController = new AccountController();
accountController.ControllerContext = this.ControllerContext;
RegisterViewModel registerModel = new RegisterViewModel();
registerModel.Email = employee.OfficeEmail;
registerModel.Password = employee.Password;
registerModel.ConfirmPassword = employee.Password;
return(await accountController.Register(registerModel, new string[] { RoleName.AGENT, RoleName.EMPLOYEE }, new { controller = "Employee", action = "Index" }));
//create new employee auth record
// await CreateAuthRecordAsync(employee);
//return RedirectToAction("Register");
}
ViewBag.CountryList = new SelectList(db.Countries, "CountryId", "Name");
ViewBag.ProvincesList = new SelectList(db.Provinces, "ProvinceId", "Name");
return(View());
}
public void Register_ReturnsViewResult_WhenSucceeded()
{
var result = _accountController.Register();
Assert.IsType <ViewResult>(result);
}
