private void btnEntrar_Click(object sender, EventArgs e)
{
if (rbAluno.Checked)
{
MatriculaForm mf = new MatriculaForm();
this.Hide();
mf.ShowDialog();
return;
}
try
{
int retorno;
LoginModel login = new LoginModel();
LoginController lg = new LoginController();
login.Login = txtLogin.Text;
login.Senha = txtSenha.Text;
retorno = lg.logar(login);
if (retorno.Equals(1))
{
MainForm adm = new MainForm();
this.Hide();
adm.ShowDialog();
}
else
{
MessageBoxAdv.Show("Login ou senha inválido");
}
}
catch (Exception ex)
{
MessageBox.Show("Error:" + ex);
}
}
/// <summary>
/// Erzeugt eine Instanz der Klasse LoginViewModel.
/// </summary>
/// <param name="navService">Referenz auf den Navigationsdienst der Anwendung.</param>
/// <param name="errorMapper">Referenz auf den Fehlerdienst der Anwendung.</param>
public LoginViewModel(INavigationService navService, IErrorMapper errorMapper)
: base(navService, errorMapper)
{
loginController = new LoginController(this);
LoginCommand = new AsyncRelayCommand(param => executeLoginCommand());
}
public void TestUserFooCannotLogin()
{
var controller = new LoginController();
var response = controller.Login("Foo", "Admin");
Assert.IsFalse(GetSuccessValueFromActionResult(response));
}
public LoginModel(LoginController loginController)
{
SessionData sessionData = SessionData.GetInstance();
m_loginController = loginController;
LoginRequestPending = false;
sessionData.Reset();
}
// Use this for initialization
void Start()
{
_Controller = new LoginController(this);
PhotonEngine.UseExistingOrCreateNewPhotonEngine(ServerAddress, ApplicationName);
}
public LoginControllerTest()
{
ba1 = new BankAccount { id = 1, Username = "******", password = "******", AccountBalance = 25000 };
ba2 = new BankAccount { id = 2, Username = "******", password = "******", AccountBalance = 20000 };
loginlist = new List<BankAccount> { ba1, ba2 };
dummyrepo = new LoginDummyRepository(loginlist);
uow = new unitofworkclass(dummyrepo);
controller = new LoginController(uow);
}
public void When_user_forgot_password_should_save_user()
{
var stubUserRepository = MockRepository.GenerateStub<IUserRepository>();
var stubbedSmsSender = MockRepository.GenerateStub<ISmsSender>();
var theUser = new User { HashedPassword = "******" };
stubUserRepository.Stub(_ => _.GetUserByName("ayende")).Return(theUser);
var controllerUnderTest = new LoginController(stubUserRepository, stubbedSmsSender);
controllerUnderTest.ForgotMyPassword("ayende");
stubUserRepository.AssertWasCalled(_ => _.Save(theUser));
}
private void Awake()
{
_instance = this;
loginController = this.GetComponent<LoginController>();
registerController = this.GetComponent<RegisterController>();
roleController = this.GetComponent<RoleController>();
roleController.OnAddRole += OnAddRole;
roleController.OnGetRole += OnGetRole;
roleController.OnSelectRole += OnSelectRole;
}
public void SetUp()
{
_flash = MockRepository.GenerateStub<IFlash>();
_auth = MockRepository.GenerateStub<IAuthenticationContext>();
_locator = MockRepository.GenerateStub<IServiceLocator>();
ServiceLocator.SetLocatorProvider(()=> _locator);
_resolver = MockRepository.GenerateStub<IUrlResolver>();
_locator.Stub(l => l.GetInstance<IUrlResolver>()).Return(_resolver);
_controller = new LoginController(_flash, _auth, _resolver);
beforeEach();
}
public LoginControllerTests()
{
_userService = A.Fake<IUserService>();
_resetPasswordService = A.Fake<IResetPasswordService>();
_authorisationService = A.Fake<IAuthorisationService>();
_loginService = A.Fake<ILoginService>();
_uniquePageService = A.Fake<IUniquePageService>();
_loginController = new LoginController(_userService, _resetPasswordService, _authorisationService, _uniquePageService, _loginService, A.Fake<IStringResourceProvider>());
// initial setup as this is reused
A.CallTo(() => _uniquePageService.RedirectTo<LoginPage>(null)).Returns(new RedirectResult("~/login-page"));
A.CallTo(() => _uniquePageService.RedirectTo<ForgottenPasswordPage>(null))
.Returns(new RedirectResult("~/forgotten-password"));
}
public void TestUserLoginGetResponse()
{
// Setup
var services = GenFormServiceProvider.Instance.Resolve<ILoginServices>();
Isolate.WhenCalled(() => services.Login(LoginUser.NewLoginUser("Admin", "Admin"))).CallOriginal();
var controller = new LoginController();
// controller receives login request from GUI
var response = controller.Login("Admin", "Admin");
// LoginController delegates request to ServiceLayer
Isolate.Verify.WasCalledWithExactArguments(() => services.Login(LoginUser.NewLoginUser("Admin", "Admin")));
// Assert result
var result =GetSuccessValueFromActionResult(response);
Assert.IsTrue(result);
}
protected void Sign_in_Button_Click(object sender, EventArgs e)
{
Login lg = new Login();
lg.Email= login_email.Text;
lg.Password= login_password.Text;
LoginController lc = new LoginController();
if(lc.checkLogin(lg)==1){
warning.Text = "sucess";
}
if(lc.checkLogin(lg)>1){
warning.Text = "multiple User Accounts from one email";
}
if(lc.checkLogin(lg)<1){
warning.Text = "Username or Password doesn't match";
}
}
//Setup
public unit_test_logincontroller()
{
//Adding config to tests.
var confbuilder = new ConfigurationBuilder();
confbuilder.AddJsonFile("appsettings.json");
_configuraion = confbuilder.Build();
//Setting up In memory dbs.
userdb = new SqliteConnection("DataSource=:memory:");
passdb = new SqliteConnection("DataSource=:memory:");
walletdb = new SqliteConnection("DataSource=:memory:");
userdb.Open();
passdb.Open();
walletdb.Open();
//Setting up contexts.
var userbuild = new DbContextOptionsBuilder <UserModelContext>()
.UseSqlite(userdb).Options;
var passbuild = new DbContextOptionsBuilder <PassModelContext>()
.UseSqlite(passdb).Options;
var walletbuild = new DbContextOptionsBuilder <WalletContext>()
.UseSqlite(walletdb).Options;
var userContext = new UserModelContext(userbuild);
var passContext = new PassModelContext(passbuild);
var walletContext = new WalletContext(walletbuild);
//Drop and create
userContext.Database.EnsureDeleted();
userContext.Database.EnsureCreated();
passContext.Database.EnsureDeleted();
passContext.Database.EnsureCreated();
walletContext.Database.EnsureDeleted();
walletContext.Database.EnsureCreated();
//Seeding data to test on
SeedUsers.seedUsers(userContext, passContext, walletContext);
//Setting uut
_uut = new LoginController(_configuraion, passContext, userContext);
}
public void Setup()
{
// Arrange START
_loginForm = new LoginForm()
{
Login = "******", Password = "******"
};
_user = new User("Andrzej", "Kowalski", "ankow", "somehash123123!@#!@#", "*****@*****.**")
{
Token = "somejettoken123!"
};
_userDto = new UserDTO(_user);
_userServiceMock = new Mock <IUserService>();
_userServiceMock.Setup(
s => s.LoginUser(
It.Is <LoginForm>(
lf => lf.Login == _loginForm.Login &&
lf.Password == _loginForm.Password
)
)
).Returns(
Task.FromResult(_user)
);
_userServiceMock.Setup(
s => s.LoginUser(
It.Is <LoginForm>(
lf => lf.Login != _loginForm.Login ||
lf.Password != _loginForm.Password
)
)
).Returns(
Task.FromResult <User>(null)
);
_loginController = new LoginController(_userServiceMock.Object);
// Arrange STOP
}
public void ActivateAccount_IfAccountIsActivatedSuccessfully_TheTier0LevelWillGetVerified()
{
RegistrationController registrationController =
_applicationContext["RegistrationController"] as RegistrationController;
IHttpActionResult httpActionResult = registrationController.Register(new SignUpParam("*****@*****.**", "user", "123", "Pakistan",
TimeZone.CurrentTimeZone, ""));
OkNegotiatedContentResult <string> okResponseMessage =
(OkNegotiatedContentResult <string>)httpActionResult;
string activationKey = okResponseMessage.Content;
Assert.IsNotNullOrEmpty(activationKey);
UserController userController = _applicationContext["UserController"] as UserController;
httpActionResult = userController.ActivateUser(new UserActivationParam("user", "123", activationKey));
OkNegotiatedContentResult <string> okResponseMessage1 =
(OkNegotiatedContentResult <string>)httpActionResult;
Assert.AreEqual(okResponseMessage1.Content, "activated");
LoginController loginController = _applicationContext["LoginController"] as LoginController;
httpActionResult = loginController.Login(new LoginParams("user", "123"));
OkNegotiatedContentResult <UserValidationEssentials> keys =
(OkNegotiatedContentResult <UserValidationEssentials>)httpActionResult;
Assert.IsNotNullOrEmpty(keys.Content.ApiKey);
Assert.IsNotNullOrEmpty(keys.Content.SecretKey);
Assert.IsNotNullOrEmpty(keys.Content.SessionLogoutTime.ToString());
TierController tierController = _applicationContext["TierController"] as TierController;
tierController.Request = new HttpRequestMessage(HttpMethod.Get, "");
tierController.Request.Headers.Add("Auth", keys.Content.ApiKey);
httpActionResult = tierController.GetTierStatuses();
OkNegotiatedContentResult <UserTierStatusRepresentation[]> statuses = (OkNegotiatedContentResult <UserTierStatusRepresentation[]>)httpActionResult;
Assert.AreEqual(statuses.Content.Length, 5);
Assert.AreEqual(statuses.Content[0].Status, Status.Verified.ToString());
}
public void ReturnsOk()
{
// Arrange
// Mock the Repository we will use in our Controller... Example:
//var mockRepository = new Mock<IProductRepository>();
//mockRepository.Setup(x => x.GetById(42))
// .Returns(new Product { Id = 42 });
// Pass the repository into the controller to initialize it.
var controller = new LoginController
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
// Act
// Assert
// Assert.IsType<OkResult>();
}
protected void AtualizarSenha(object sender, EventArgs e)
{
if (Password1.Value.Length < 6)
{
Response.Write("<script>alert('A senha deve possuir no mínimo 6 caracteres.')</script>");
}
else if (Password1.Value != Password2.Value)
{
Response.Write("<script>alert('Senhas digitadas não conferem. As senhas devem ser iguais.')</script>");
}
else
{
LoginController loginController = new LoginController();
LoginModel pModel = new LoginModel();
pModel.Password = Password1.Value;
pModel.idUser = iduser.Value;
loginController.AlterarSenha(pModel);
Response.Write("<script>alert('Senha alterada')</script>");
}
}
public static void CreateNewLogin(LoginController controller)
{
var login = new Login();
Console.WriteLine("What's the name of the connection ?");
login.ConnectionName = Console.ReadLine();
Console.WriteLine("What's the url of the site you want to connect?");
login.Url = Console.ReadLine();
Console.WriteLine("What's your username?");
login.UserName = Console.ReadLine();
Console.WriteLine("What's the length of your password?");
var passwordLength = Console.ReadLine();
login.GeneratePassword(int.Parse(passwordLength));
controller.AddNewLogin(login);
ShowLogin(login);
}
public void SetUp()
{
_returnUrl = Convert.ToBase64String(_clientId.ToByteArray()); // a fake returnUrl which is actually an encrypted string containing the client id
_mediator = Substitute.For <IMediator>();
_mediator.Send(Arg.Any <BuildLoginViewModelRequest>(), CancellationToken.None).Returns(new LoginViewModel()
{
Username = "",
Password = "",
RememberLogin = false,
ReturnUrl = _returnUrl,
AllowRememberLogin = false,
EnableLocalLogin = true
});
_mediator.Send(Arg.Any <GetClientByReturnUrlRequest>(), CancellationToken.None).Returns(new Client()
{
Id = _clientId
});
_controller = new LoginController(_mediator);
_controller.ViewData.ModelState.AddModelError("Password", "Password should be supplied");
_controller.ViewData.ModelState.AddModelError("Username", "Username should be supplied");
}
public void LoginPost_SuccessfullLoginReturnsCorrectView_ViewNameEqualIndex()
{
var userManager = new UserManagerFake {
ValidPassword = "******"
};
var model = new LoginModel
{
Username = "******",
Password = "******"
};
using (var controller = new LoginController(userManager, new SessionHelperFake()))
{
var result = controller.Login(model) as RedirectToRouteResult;
string expectedAction = "Index";
string expectedController = "Home";
Assert.AreEqual(expectedAction, result.RouteValues["Action"]);
Assert.AreEqual(expectedController, result.RouteValues["Controller"]);
}
}
public void Can_Login_With_Valid_Credentials()
{
// Организация
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate("admin", "12345")).Returns(true);
LoginViewModel model = new LoginViewModel
{
Login = "******",
PasswordHash = "12345"
};
LoginController target = new LoginController(mock.Object);
// Действие
ActionResult result = target.SignIn(model, "/SignInSuccessURL");
// Утверждение
Assert.IsInstanceOfType(result, typeof(RedirectResult));
Assert.AreEqual("/SignInSuccessURL", ((RedirectResult)result).Url);
}
public async Task LoginControllerAuth()
{
var data = new LoginDataHandler();
var logic = new CoreApiLogicHandler();
data.ResultConfig = new UserConfig();
var login = LoginData.GetLogin();
var auth = LoginData.GetAuth();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(StandardUser);
logic.Result.Setup(m => m.Execute(It.IsAny <SigninAuth>())).Returns(auth);
var controller = new LoginController(data, Cloud, logic);
var result = await controller.Auth(login) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SigninAuth>()), Times.Once);
auth.Id.Should().NotBeEmpty();
auth.IsTwoFactor.Should().BeFalse();
auth.User.ClientHasProfile.Should().BeFalse();
auth.User.ClientProfileThumbUrl.Should().BeEmpty();
auth.User.ProfileThumbUrl.Should().BeEmpty();
auth.User.Email.Should().BeEmpty();
auth.User.HasPhone.Should().BeFalse();
auth.User.HasProfile.Should().BeFalse();
auth.User.Name.Should().BeEmpty();
auth.User.TenantId.Should().BeEmpty();
auth.User.TenantName.Should().BeEmpty();
auth.Right.Should().NotBeNull();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public async Task LoginControllerAuthFail()
{
var data = new LoginDataHandler();
var logic = new CoreApiLogicHandler();
var login = LoginData.GetLogin();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(null);
var controller = new LoginController(data, Cloud, logic);
var result = await controller.Auth(login) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeFalse();
logic.Result.Verify(s => s.Execute(It.IsAny <SigninAuth>()), Times.Never);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public void Login_Should_redirect_last_request_when_login_is_ok()
{
var loginData = new LoginData()
{
UserName = USER_NAME,
Password = USER_PSW,
ReturnPage = RETURN_PAGE
};
var expectedResult = RETURN_PAGE;
_mockUserManager.Setup(f => f.Get(It.IsAny <string>())).Returns(USER).Verifiable();
_mockSessionManager.Setup(f => f.AddUserToSession(It.IsAny <User>())).Verifiable();
var loginController = new LoginController(_mockUserManager.Object, _mockSessionManager.Object);
var result = loginController.Login(loginData) as RedirectResult;
Assert.AreEqual(result.Url, expectedResult);
_mockUserManager.Verify();
_mockSessionManager.Verify();
}
public void Login_Should_redirect_to_welcome_page_when_login_is_ok_but_returnPage_is_empty()
{
var loginData = new LoginData()
{
UserName = USER_NAME,
Password = USER_PSW,
ReturnPage = string.Empty
};
var expectedResult = "/Welcome.html";
_mockUserManager.Setup(f => f.Get(It.IsAny <string>())).Returns(USER).Verifiable();
_mockSessionManager.Setup(f => f.AddUserToSession(It.IsAny <User>())).Verifiable();
var loginController = new LoginController(_mockUserManager.Object, _mockSessionManager.Object);
var result = loginController.Login(loginData) as RedirectResult;
Assert.AreEqual(result.Url, expectedResult);
_mockUserManager.Verify();
_mockSessionManager.Verify();
}
public void PostInvalidParameter_ReturnBadRequestResult_WhenLoginIsNotSuccess()
{
var mockDac = new Mock <IAccountDAC>();
mockDac.Setup(dac => dac.GetUser(It.IsAny <string>(), It.IsAny <string>())).Returns(
new User()
{
Id = 1,
Username = "******",
Password = "******"
}
);
var loginController = new LoginController(mockDac.Object);
var result = loginController.Post(
new User()
{
Username = "******"
}
);
Assert.IsType <BadRequestResult>(result);
}
public void _1_ShareMovie()
{
try
{
var loginController = new LoginController();
var httpResponseMessage = loginController.Post(new Models.MyString(LoginControllerTest.UserTest));
var token = (JObject)JsonConvert.DeserializeObject(httpResponseMessage.Content.ReadAsStringAsync().Result);
var httpResponseMessage2 = loginController.Get(token["token"].ToString());
var userInfo = (JObject)JsonConvert.DeserializeObject(httpResponseMessage2.Content.ReadAsStringAsync().Result);
var movieController = new MovieController();
movieController.Post(new Models.Movie()
{
Url = TestUrl,
SharedBy = Int64.Parse(userInfo["Id"].ToString())
});
Assert.IsTrue(true);
}
catch (Exception)
{
Assert.Fail();
}
}
public void LoginController_IsAuthorized()
{
//Arrange
var mockService = new Mock <ILoginService>();
var controller = new LoginController(mockService.Object);
var vm = new AuthRequestViewModel
{
EmailAddress = "",
Password = ""
};
var response = new LoginDataViewModel("aaaaaa", "aaaaaaaaaaa");
mockService.Setup(serv => serv.Login(vm))
.Returns(response);
//Act
var result = controller.Authenticate(aAuthRequest: vm);
//Assert
Assert.IsType <OkObjectResult>(result);
}
public void Logout_Success()
{
var mockIAccountDataStore = new Mock <IAccountDataStore>();
var authenticationServiceMock = new Mock <IAuthenticationService>();
authenticationServiceMock
.Setup(a => a.SignOutAsync(It.IsAny <HttpContext>(), It.IsAny <string>(), It.IsAny <AuthenticationProperties>()))
.Returns(Task.CompletedTask);
var serviceProviderMock = new Mock <IServiceProvider>();
serviceProviderMock
.Setup(s => s.GetService(typeof(IAuthenticationService)))
.Returns(authenticationServiceMock.Object);
var controller = new LoginController(mockIAccountDataStore.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
{
RequestServices = serviceProviderMock.Object
}
}
};
var urlHelperFactory = new Mock <IUrlHelperFactory>();
serviceProviderMock
.Setup(s => s.GetService(typeof(IUrlHelperFactory)))
.Returns(urlHelperFactory.Object);
var result = controller.Logout();
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Login", viewResult.ControllerName);
}
private void continua_Click(object sender, EventArgs e)
{
emailAdress = email.Text;
if (LoginController.IsValidEmail(emailAdress) == true)
{
if (LoginController.Login(emailAdress) == true)
{
Log log = new Log(emailAdress);
log.Show();
}
else
{
Register register = new Register(emailAdress);
register.Show();
}
}
else
{
MessageBox.Show("Adresa de email este invalida", "Eroare", MessageBoxButtons.OK, MessageBoxIcon.Error);
email.Clear();
}
}
public void LoginReturnsOkWithUserIfCredentialsMatch()
{
// Arrange
const string expectedEmail = "*****@*****.**";
const string expectedPassword = "******";
var request = new LoginRequest()
{
EmailAddress = expectedEmail, Password = expectedPassword
};
var existingUser = new User()
{
EmailAddress = expectedEmail, Id = new MongoDB.Bson.ObjectId()
};
var credentials = new Auth()
{
UserId = existingUser.Id, HashedPassword = expectedPassword
};
var repository = new Mock <IGenericRepository>();
repository.Setup(u => u.SingleOrDefault(It.IsAny <Expression <Func <User, bool> > >())).Returns(existingUser);
repository.Setup(a => a.SingleOrDefault(It.IsAny <Expression <Func <Auth, bool> > >())).Returns(credentials);
var configuration = new Mock <IConfiguration>();
configuration.Setup(c => c["Jwt:Key"]).Returns(Guid.NewGuid().ToString());
var controller = new LoginController(new Mock <ILogger <LoginController> >().Object, configuration.Object, repository.Object);
// Act
var response = controller.Login(request).Result;
// Assert
Assert.That(response, Is.TypeOf(typeof(OkObjectResult)));
var obj = ((OkObjectResult)response).Value;
Assert.That(obj.GetType().GetProperty("token").GetValue(obj), Is.Not.Null);
}
private bool IsLogin()
{
if (string.IsNullOrWhiteSpace(UserId_TextBox.Text) || string.IsNullOrWhiteSpace(Pass_PasswordBox.Password))
{
MessageBox.Show("User or Pass is not empty!");
return(false);
}
LoginController login = new LoginController();
UserInfo user = login.GetUserInfo(UserId_TextBox.Text);
if (user != null && user.Password == Pass_PasswordBox.Password)
{
CommonInfo.UserInfo = user;
return(true);
}
else
{
MessageBox.Show("User or Pass is invalid!");
return(false);
}
}
public async Task TestBaseMock_Ok()
{
var mockLogger = new Mock <ILogger <UserService> >();
var dbcontext = TestHelpers.DbContext();
var context = TestHelpers.Context(Guid.NewGuid(), "Admin", new string[] { UserRol.AdminRol });
var userManager = new FakeUserManager(new UserStore <UserApp, UserRol, ApiDbContext, Guid>(dbcontext));
var roleManager = new FakeRoleManager(new RoleStore <UserRol, ApiDbContext, Guid>(dbcontext));
var signManager = new FakeSignInManager(userManager, roleManager, TestHelpers.Options(), context.Object);
ApiDbContext.SeedData(userManager, roleManager);
var userservice = new UserService(GetIConfigurationRoot(), userManager, signManager, _mockRepo.Object, context.Object, mockLogger.Object);
LoginController login = new LoginController(userservice);
// Probamos a loguearnos, que como tenemos generado el falso usuario dara el Ok
var loginResult = await login.Authenticate(new LoginRequest
{
Username = "******",
Password = "******"
});
// Assert
Assert.IsType <OkObjectResult>(loginResult);
UserController controller = new UserController(userservice);
// Probamos a añadir el usuario, que como esta moqueado dará el Ok tambien
var result = await controller.Post(new UserAPI
{
Username = "******",
Password = "******"
});
Assert.IsAssignableFrom <ObjectResult>(result);
var objectResponse = result as ObjectResult;
Assert.Equal(200, objectResponse.StatusCode);
}
public void Cannot_Login_With_Wrong_Credentials()
{
// Организация
Mock <IAuthProvider> mock = new Mock <IAuthProvider>();
mock.Setup(m => m.Authenticate("wrongLogin", "wrongPassword")).Returns(false);
LoginViewModel model = new LoginViewModel
{
Login = "******",
PasswordHash = "wrongPassword"
};
LoginController target = new LoginController(mock.Object);
// Действие
ActionResult result = target.SignIn(model, "/SignInFailureURL");
// Утверждение
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsFalse(((ViewResult)result).ViewData.ModelState.IsValid);
}
public void LoginUserSuccsess()
{
// Arrange
IRepositoryUser fakeRepositoryUser = new FakeUserRepository();
IEmailManger fakeEmailManger = new FakeEMailManger();
IReadFromBrowser fakeReadCookie = new FakeReadCookie();
IWriteToBrowser fakeWriteCookie = new FakeWriteCookie();
IEmptyCart fakeEmptyCart = new FakeEmptyCart();
ILogger fakeLogger = new FakeLogger();
Login login1 = new Login()
{
Username = "******", Email = "*****@*****.**", Password = "******"
};
LoginController loginController = new LoginController(fakeEmptyCart, fakeRepositoryUser,
fakeReadCookie, fakeWriteCookie, fakeEmailManger, fakeLogger);
// Act
ViewResult viewResult = loginController.Login(login1) as ViewResult;
var rez = viewResult.Model;
rez.Equals(new Login());
}
private void Login_Button_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(UserId_TextBox.Text) || string.IsNullOrWhiteSpace(Pass_PasswordBox.Password))
{
MessageBox.Show("User or Pass is not empty!");
return;
}
LoginController login = new LoginController();
Users user = login.GetUserInfo(UserId_TextBox.Text);
if (user.Password == Pass_PasswordBox.Password)
{
Window window = new Main();
window.Show();
this.Close();
}
else
{
MessageBox.Show("User or Pass is invalid!");
}
}
public void Registrate_Returns_ActionResults()
{
// Arrange
LoginController controller = new LoginController();
// Act
var result = controller.Registrate() as ViewResult;
// Assert
try
{
Assert.IsInstanceOf <ActionResult>(result);
}
catch
{
tdal.reports.Add(new reportFail
{
testType = "Login Controller",
errorMessage = "Action Registrate failed :",
timeLog = DateTime.UtcNow.Date
});
}
}
public async void ShouldReturnLoginViewWhenUncorrectLogin()
{
LoginModel model = new LoginModel();
model.ReturnUrl = "a";
model.Login = "******";
model.Password = "******";
IAuthenticator authenticator = MockRepository.GenerateStub <IAuthenticator>();
authenticator.Stub(s => s.Login(model)).Return(Task <bool> .FromResult(false));
LoginController controller = new LoginController(authenticator);
ActionResult result = await controller.Login(model);
authenticator.AssertWasCalled(s => s.Login(model));
ViewResult view = result as ViewResult;
Assert.IsNullOrEmpty(view.ViewName);
Assert.IsNullOrEmpty(model.Password);
Assert.IsFalse(controller.ModelState.IsValid);
}
// Use this for initialization
void Start()
{
//Debug.Log ("---------------------------------------------");
//Debug.Log ("MainPageController.Start() called");
//Player.Me = LoginController.CreateMockPlayer ();
if (!LoginController.isFromLogin)
{
Player.Me = LoginController.CreateMockPlayer();
}
nickNameLabel.text = Player.Me.nickname;
idLabel.text = "ID: " + Player.Me.userId;
coinLabel.text = "1000";
ImageLoader.Instance.Load(Player.Me.headimgurl, (Sprite sprite) => {
if (sprite != null && userImage != null)
{
userImage.sprite = sprite;
Player.Me.userHeadImage = userImage.sprite;
}
});
ResetNumberLabels();
ShowMessageIfNeed();
Sprite[] sprites = Resources.LoadAll <Sprite>("sprites/mainpage/createroom");
foreach (Sprite sprite in sprites)
{
gamePropertiesImageDict [sprite.name] = sprite;
}
audioSettingsImageDict[Music_On_Key] = Resources.Load <Sprite> ("sprites/mainpage/settings/btn_open");
audioSettingsImageDict[Audio_On_Key] = Resources.Load <Sprite> ("sprites/mainpage/settings/btn_open");
audioSettingsImageDict[Music_Off_Key] = Resources.Load <Sprite> ("sprites/mainpage/settings/btn_close");
audioSettingsImageDict[Audio_Off_Key] = Resources.Load <Sprite> ("sprites/mainpage/settings/btn_close");
CheckPlayerInGame();
}
private void buttonLogin_Click(object sender, EventArgs e)
{
if (textBoxPassword.Text == "" && textBoxUsername.Text == "")
{
MessageBox.Show("fields cannot be empty");
}
else
{
email = textBoxUsername.Text;
password = textBoxPassword.Text;
if (LoginController.loginControl(email, password))
{
userId = LoginController.getUserIdByMail(email);
role = LoginController.getRoleByUserId(userId);
if (LoginController.checkFirstLogin(email, password))
{
MessageBox.Show("First Login");
MessageBox.Show("Redirecting to password change");
Hide();
using (var cp = new PasswordChange(password, userId))
cp.ShowDialog();
cleartextBox();
Show();
}
else
{
Hide();
using (var mf = new mainForm(role, userId, this))
mf.ShowDialog();
cleartextBox();
Show();
}
}
else
{
MessageBox.Show("Access failed");
}
}
}
public void Login_SuccessfulReturnUrlNotNull()
{
User user = new User
{
ID = 1,
Email = "my@email",
Password = "******"
};
UserViewModel userViewModel = new UserViewModel
{
ID = 1,
Email = "my@email",
Password = "******"
};
mockUserService.Setup(m => m.AuthenticateUser(It.IsAny <String>(), It.IsAny <String>()))
.Returns(user);
var mockUrlHelper = new Mock <IUrlHelper>(MockBehavior.Strict);
mockUrlHelper.Setup(m => m.IsLocalUrl(It.IsAny <string>()))
.Returns(true);
var controller = new LoginController(mockUserService.Object, mapper);
controller.Url = mockUrlHelper.Object;
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext()
{
RequestServices = ServiceProviderMock()
};
string returnUrl = "/Classifieds/Create";
var result = controller.Login(userViewModel, returnUrl).Result;
var redirect = (RedirectResult)result;
Assert.Equal("/Classifieds/Create", redirect.Url);
}
private void realizarLogin()
{
string loginInserido = this.metroTextBoxUser.Text.ToLower();
string passwordInserido = this.metroTextBoxSenha.Text;
LoginController loginController = new LoginController();
loginController.verificaUsuarioSenha(loginInserido, passwordInserido);
if (Globals.tipoDeUsuario.Equals("user-comum") || Globals.tipoDeUsuario.Equals("administrador-comum") || Globals.tipoDeUsuario.Equals("administrador-geral"))
{
TelaInicial telaInicial = new TelaInicial();
telaInicial.Show();
this.Hide();
}
else
{
MessageBox.Show("Senha ou usuários incorretos, por favor, tente novamente.", "Login falhou", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.metroTextBoxUser.Text = "";
this.metroTextBoxSenha.Text = "";
this.ActiveControl = this.metroTextBoxUser;
}
}
private void btnCadastrar_Click(object sender, EventArgs e)
{
if (txtSenha.Text != txtCSenha.Text)
{
MessageBoxAdv.Show(this, "A senha não está igual a confirmação!", "Erro");
return;
}
try
{
LoginModel loginModel = new LoginModel();
loginModel.Login = txtLogin.Text;
loginModel.Senha = txtSenha.Text;
LoginController loginController = new LoginController();
loginController.cadastrarLogin(loginModel);
MessageBoxAdv.Show(this, "Login cadastrado com sucesso!", "Aviso");
this.Close();
}
catch(Exception ex)
{
MessageBoxAdv.Show(this, "Erro: " + ex, "Erro");
}
}
public LoginView()
{
// Create the controller
controller = new LoginController();
// Handlers for external events
controller.ConnectAccept += new LoginController.ExternalEventHandler(OnConnectAccept);
controller.ConnectDeny += new LoginController.ExternalEventHandler(OnConnectDeny);
controller.ConnectTimeOut += new LoginController.ExternalEventHandler(OnConnectTimeOut);
// Register the controller handlers to the service
controller.RegisterHandlers();
// Initialize Component
InitializeComponent();
// Handlers for internal events
this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(OnFormClosing);
ConnectButton.Click += new System.EventHandler(ConnectButton_Click);
password.KeyDown += new System.Windows.Forms.KeyEventHandler(password_KeyDown);
username.KeyDown += new System.Windows.Forms.KeyEventHandler(username_KeyDown);
CreateAccountButton.Click += new System.EventHandler(CreateAccountButton_Click);
}
public void When_user_forgot_password_should_save_user()
{
var userRepository = Mock.Create<IUserRepository>();
var smsSender = Mock.Create<ISmsSender>();
var theUser = new User { HashedPassword = "******" };
userRepository.Setup(x => x.GetUserByName("ayende")).Returns(theUser);
var controllerUnderTest = new LoginController(userRepository.Object, smsSender.Object);
controllerUnderTest.ForgotMyPassword("ayende");
userRepository.Verify(x => x.Save(theUser));
}
public void SetController(LoginController controller)
{
this.controller = controller;
}
void Start()
{
EventDelegate.Set(btn_start_user.onClick, () => { On_Start_Username_Click();});
EventDelegate.Set(btn_start_server.onClick, () => { On_Start_Server_Click();});
EventDelegate.Set(btn_start_enter.onClick, () => { On_Start_Enter_Click();});
EventDelegate.Set(btn_login_login.onClick, () => { On_Login_login_Click(); });
EventDelegate.Set(btn_login_reg.onClick, () => { On_Login_reg_Click(); });
EventDelegate.Set(btn_login_close.onClick, () => { On_Login_close_Click();});
EventDelegate.Set(btn_reg_cancel.onClick, () => { On_Reg_cancel_Click(); });
EventDelegate.Set(btn_reg_reg.onClick, () => { On_Reg_reg_Click(); });
EventDelegate.Set(btn_reg_close.onClick, () => { On_Reg_close_Click(); });
EventDelegate.Set(btn_server_selected.onClick, () => {On_server_selected_Click(); });
EventDelegate.Set(btn_select_return.onClick, () => { On_select_return_Click(); });
EventDelegate.Set(btn_select_change.onClick, () => { On_select_change_Click(); });
EventDelegate.Set(btn_selectshow_sure.onClick, () => { On_selectedshow_sure_click(); });
EventDelegate.Set(btn_selectshow_back.onClick, () => { On_selectedshow_back_Clik(); });
if(instance==null)
{
instance = this;
}
login = this.GetComponent<LoginController>();
register = this.GetComponent<RegisterController>();
roleControll = this.GetComponent<RoleController>();
roleControll.OnGetRole += this.OnGetRole;
roleControll.OnGetEmptyRole += this.OnGetEmptyRole;
roleControll.OnAddRole += this.OnAddRole;
roleControll.OnseletRole += this.OnSelectRole;
}
void Start()
{
controller=GameObject.Find("GameController").GetComponent<LoginController>();
}
public AssignConnectorHandler(LoginController controller)
: base(controller)
{
}
public LoginHandler(LoginController controller)
: base(controller)
{
}
void Start()
{
if (Application.isPlaying)
{
_connection = ConnectionController.Instance;
Servers = new List<ServerListItem>();
Servers.Add(SampleItem);
gameObject.SetActive(false);
LoginController = FindObjectOfType<LoginController>();
}
else
{
gameObject.SetActive(ShowInEditor);
}
}
void Awake()
{
loginController = GameObject.FindObjectOfType(typeof(LoginController)) as LoginController;
}
public CredentialsRequestHandler(LoginController controller)
: base(controller)
{
}
public void Init()
{
controller = new LoginController();
PrepareController(controller);
}
public LoginModel(LoginController loginController)
{
m_loginController = loginController;
LoginRequestPending = false;
}
private void loginsToolStripMenuItem_Click(object sender, EventArgs e)
{
LoginController pesLogin = new LoginController();
//bsLogins.DataSource = null;
bsLogins.DataSource = pesLogin.pesLogins().Tables[0];
dgConsultas.DataSource = bsLogins;
}
protected void Submit_Button_Click(object sender, EventArgs e)
{
Users s = new Users();
Login l = new Login();
l.Email = email.Text;
l.Password = password.Text;
LoginController lc = new LoginController();
lc.addLogin(l);
s.Login_idLogin1 = lc.getLoginId(l);
s.Fname = fname.Text;
s.Mname = mname.Text;
s.Lname = lname.Text;
s.Dob = this.SelectedDate;
s.Gender = int.Parse(DropDownList1.SelectedValue);
s.A_line_1 = aline1.Text;
s.A_line_2 = aline2.Text;
s.A_line_3 = aline3.Text;
s.Contact_no = Int32.Parse(contact.Text);
// s.Photo=FileUpload.
if (FileUpload.FileName != null)
{
HttpPostedFile myFile = FileUpload.PostedFile;
int nFileLen = myFile.ContentLength;
byte[] myData = new byte[nFileLen];
myFile.InputStream.Read(myData, 0, nFileLen);
Photo p = new Photo();
p.WriteToFile(@"D:\" + milliseconds + "_image.jpg", myData);
}
else
{
// No file
}
s.Photo = @"D:\" + milliseconds + "_image.jpg";
fname.Text = s.Photo;
UserController uc = new UserController();
fname.Text = uc.addUserdata(s);
}
public static LoginController Fixture()
{
LoginController controller = new LoginController(new LoginRepository(), "", new LoginView());
return controller;
}
public BaseLoginHandler(LoginController controller)
{
Controller = controller;
}
