public void LogInSuccessfullyTest()
{
LoginDTO loginUser = new LoginDTO();
loginUser.UserName = "******";
loginUser.Password = "******";
UserDTO userDTO = new UserDTO();
userDTO.Name = "Pepe";
userDTO.LastName = "Perez";
userDTO.UserName = "******";
userDTO.Phone = 091234567;
userDTO.Password = "******";
userDTO.Role = "Administrador";
var mockUserDAO = new Mock <UserDAO>();
mockUserDAO.Setup(us => us.LogIn(loginUser)).Returns(userDTO);
var userService = new UserServiceImpl(mockUserDAO.Object);
UserLoggedDTO result = userService.LogIn(loginUser);
userService.LogOut(result.Token);
}
private void btnLogin_Click(object sender, EventArgs e)
{
LoginDTO userToLogIn = this.createLogInDTO();
try
{
UserLoggedDTO userLogged = this.userService.LogIn(userToLogIn);
if (userLogged.Role == "Administrador")
{
Main main = new Main(userLogged);
this.Hide();
main.ShowDialog();
}
else
{
MessageBox.Show(
"El usuario no tiene suficientes permisos.",
"Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
} catch (UserOrPasswordNotFoundException)
{
MessageBox.Show(
"El nombre de usuario o contraseña no son correctos.",
"Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async Task <IActionResult> Login([FromBody] UserLoginDTO model)
{
var resultLogin = await SignInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (resultLogin.Succeeded)
{
var user = UserManager.Users.SingleOrDefault(r => r.UserName == model.UserName);
var token = GenerateJwtToken(user.Email, user);
var result = new UserLoggedDTO
{
User = new UserDTO
{
Id = user.Id,
Name = user.Name,
UserName = user.UserName
},
Token = token
};
return(Ok(result));
}
else
{
var rule = new BrokenRule("Invalid username or password.");
rule.Add("UserName", "Invalid username or password");
throw new RuleException(rule);
}
}
private UserLoggedDTO createUserLoggedDTO()
{
UserLoggedDTO userLoggedDTO = new UserLoggedDTO();
userLoggedDTO.FullName = "Pepe Perez";
userLoggedDTO.Role = "Administrador";
userLoggedDTO.Token = Guid.NewGuid();
return(userLoggedDTO);
}
public async Task <IActionResult> Post([FromBody] UserRegisterDTO model)
{
var user = new User
{
UserName = model.UserName,
Email = model.Email,
Name = model.Name
};
var resultCreate = await UserManager.CreateAsync(user, model.Password);
if (resultCreate.Succeeded)
{
await SignInManager.SignInAsync(user, false);
var token = GenerateJwtToken(model.Email, user);
user = await UserManager.FindByEmailAsync(model.Email);
var result = new UserLoggedDTO
{
User = new UserDTO
{
Id = user.Id,
Name = user.Name,
UserName = user.UserName
},
Token = token
};
return(Ok(result));
}
else
{
if (resultCreate.Errors.Count() > 0)
{
var rule = new BrokenRule("Error!");
foreach (var item in resultCreate.Errors)
{
rule.Add("UserName", item.Description);
}
throw new RuleException(rule);
}
else
{
var rule = new BrokenRule("Error!");
rule.Add("UserName", "Register failed");
throw new RuleException(rule);
}
}
}
public IHttpActionResult LogIn([FromBody] LoginDTO user)
{
HttpResponseMessage response = new HttpResponseMessage();
try
{
UserLoggedDTO userDTO = this.userService.LogIn(user);
response = this.Request.CreateResponse(HttpStatusCode.OK, userDTO);
} catch (UserOrPasswordNotFoundException e)
{
response = this.Request.CreateResponse(HttpStatusCode.BadRequest, e.Message);
}
return(ResponseMessage(response));
}
public HttpResponseMessage Login(UserDTO user)
{
User dbUser = map.ToSingleUser(user);
User existingUser = this.data.Users.WithUsernameAndAuthCode(dbUser.Username, dbUser.AuthCode);
if (existingUser == null)
{
throw new FamilyValidationException("Invalid username or password.");
}
UserLoggedDTO result = this.map.ToSingleUserLoggedDTO(existingUser);
HttpResponseMessage response = this.Request.CreateResponse(HttpStatusCode.OK, result);
return(response);
}
public void LogInErrorTest()
{
LoginDTO loginUser = new LoginDTO();
loginUser.UserName = "******";
loginUser.Password = "******";
var mockUserDAO = new Mock <UserDAO>();
UserDTO userDTO = null;
mockUserDAO.Setup(us => us.LogIn(loginUser)).Returns(userDTO);
var userService = new UserServiceImpl(mockUserDAO.Object);
UserLoggedDTO result = userService.LogIn(loginUser);
}
public VehicleManagement(UserLoggedDTO user, Logs logs)
{
InitializeComponent();
this.vehicleService = new VehicleServiceImpl(new VehicleDAOImpl(), new FlowDAOImp(), new ZoneDAOImp());
this.userLogged = user;
this.logs = logs;
addVehiclesWindow = new AddVehicles(this, vehicleService);
this.addBtn.FlatStyle = FlatStyle.Flat;
this.addBtn.FlatAppearance.BorderSize = 0;
this.delBtn.FlatStyle = FlatStyle.Flat;
this.delBtn.FlatAppearance.BorderSize = 0;
this.modifyBtn.FlatStyle = FlatStyle.Flat;
this.modifyBtn.FlatAppearance.BorderSize = 0;
importerService = new Services.ImporterOffline.ImporterOffline("Importers");
LoadVehiclesImportsBtns();
this.init();
}
public UserLoggedDTO LogIn(LoginDTO loginUser)
{
UserLoggedDTO userLoggedDTO = new UserLoggedDTO();
bool userLoggedIn = false;
foreach (UserDTO user in TokenContainer.GetContext().LoggedUsers.Values)
{
if (user.UserName.Equals(loginUser.UserName))
{
KeyValuePair <Guid, UserDTO> valuePair = TokenContainer.GetContext().LoggedUsers.FirstOrDefault(u => u.Value.Equals(user));
UserDTO userDTO = valuePair.Value;
userLoggedDTO.FullName = userDTO.Name + " " + userDTO.LastName;
userLoggedDTO.Role = userDTO.Role;
userLoggedDTO.Token = valuePair.Key;
userLoggedIn = true;
LogEvent log = new LoginEvent(user);
VehicleTrackingLog.GetInstance().WriteEvent(log);
}
}
if (!userLoggedIn)
{
UserDTO userDTO = this.userDAO.LogIn(loginUser);
if (userDTO == null)
{
throw new UserOrPasswordNotFoundException("El nombre de usuario o password no son correctos");
}
else
{
Guid token = Guid.NewGuid();
TokenContainer.GetContext().LoggedUsers.Add(token, userDTO);
userLoggedDTO.Token = token;
userLoggedDTO.FullName = userDTO.Name + " " + userDTO.LastName;
userLoggedDTO.Role = userDTO.Role;
LogEvent log = new LoginEvent(userDTO);
VehicleTrackingLog.GetInstance().WriteEvent(log);
}
}
return(userLoggedDTO);
}
public void LoginSuccessfullyTest()
{
LoginDTO loginUser = createLoginDTO();
UserDTO userDTO = createUserDTO();
UserLoggedDTO userLoggedDTO = createUserLoggedDTO();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.LogIn(loginUser)).Returns(userLoggedDTO);
mockUserService.Setup(us => us.GetUserLoggedIn(userLoggedDTO.Token)).Returns(userDTO);
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)userController.LogIn(loginUser);
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public Main(UserLoggedDTO user)
{
InitializeComponent();
this.userLogged = user;
this.init();
}
