public HttpResponseMessage Login(HttpRequestMessage request, [FromBody] LoginUserDTO loginUserDTO)
{
AccountsApiModel accountsWebApiModel = new AccountsApiModel();
TransactionalInformation transaction = new TransactionalInformation();
AccountsBusinessService accountsBusinessService;
if (loginUserDTO.UserName == null)
{
loginUserDTO.UserName = "";
}
if (loginUserDTO.Password == null)
{
loginUserDTO.Password = "";
}
accountsBusinessService = new AccountsBusinessService(accountsDataService);
User user = accountsBusinessService.Login(
loginUserDTO.UserName,
loginUserDTO.Password,
out transaction);
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return(badResponse);
}
ApplicationInitializationBusinessService initializationBusinessService;
initializationBusinessService = new ApplicationInitializationBusinessService(applicationDataService);
List <ApplicationMenu> menuItems = initializationBusinessService.GetMenuItems(true, out transaction);
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
var badResponse = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return(badResponse);
}
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.IsAuthenicated = true;
accountsWebApiModel.ReturnMessage.Add("Login successful.");
accountsWebApiModel.MenuItems = menuItems;
accountsWebApiModel.User = user;
FormsAuthentication.SetAuthCookie(user.UserId.ToString(), createPersistentCookie: false);
var response = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.OK, accountsWebApiModel);
return(response);
}
public async Task <RegisterUserDTO> ValidateLogin(LoginUserDTO model)
{
var user = await DbContext.UserDatas.Where(u => u.Email == model.Email && u.Password == model.Password)
.FirstOrDefaultAsync();
if (user != null)
{
return(Mapper.Map <RegisterUserDTO>(user));
}
return(null);
}
public async Task <IActionResult> Login(LoginUserDTO request)
{
ServiceResponse <string> response = await _authRepo.Login(
request.Username, request.Password);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public bool Insert(LoginUserDTO value)
{
User val = new User();
val = mapper.LoginUserDTOToUser(value);
val.CreatedOn = DateTime.Now;
val.ModifiedOn = DateTime.Now;
house.Insert(val);
return(true);
}
public async Task <bool> ValidateUser(LoginUserDTO userDTO)
{
//_user = await _userManager.FindByNameAsync(userDTO.Email);
//return (_user != null && await _userManager.CheckPasswordAsync(_user, userDTO.Password));
_user = await _userManager.FindByNameAsync(userDTO.Email);
var validPassword = await _userManager.CheckPasswordAsync(_user, userDTO.Password);
return(_user != null && validPassword);
}
public LoginUserDTO GetUserLoginCredentials(string userName, string password)
{
LoginUserDTO user = new LoginUserDTO();
if (userName != null && password != null)
{
user.UserName = userName;
user.Password = password;
}
return(user);
}
public async Task LoginFailUserTest()
{
var request = new LoginUserDTO()
{
Login = "******", Password = "******"
};
var response = await _client.GetAsync($"account/{request.Login}/{request.Password}");
var responseString = await response.Content.ReadAsStringAsync();
responseString.Should().BeEquivalentTo("INVALID_USER");
}
public async Task <ActionResult <SuccessfulLoginResult> > Login([FromBody] LoginUserDTO login)
{
Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(login.Email, login.Password, isPersistent : false, lockoutOnFailure : false);
User user = await _userManager.FindByEmailAsync(login.Email);
JwtSecurityToken token = await GenerateTokenAsync(user); // defined
string serializedToken = new JwtSecurityTokenHandler().WriteToken(token); // serilize the token
return(Ok(serializedToken));
}
public async Task <IActionResult> Login([FromBody] LoginUserDTO login)
{
if (ModelState.IsValid)
{
var res = await userService.LoginUser(login);
switch (res)
{
case LoginUserResult.IncorrectData:
return(JsonResponseStatus.NotFound(new { message = "حسابی با این مشخصات وجود ندارد" }));
case LoginUserResult.NotActivated:
return(JsonResponseStatus.Error(new { message = "حساب کاربری شما فعال نشده است" }));
case LoginUserResult.Success:
var user = await userService.GetUserByEmail(login.Email);
var userRole = await userService.GetUserRoleById(user.Id);
var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("JupiterJwtBearer"));
var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);
var tokenOptions = new JwtSecurityToken(
issuer: "https://localhost:5001",
claims: new List <Claim>
{
new Claim(ClaimTypes.Name, user.Email),
new Claim(ClaimTypes.Role, userRole),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
},
expires: DateTime.Now.AddDays(30),
signingCredentials: signinCredentials
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(tokenOptions);
return(JsonResponseStatus.Success(new
{
token = tokenString,
expireTime = 30,
firstName = user.FirstName,
lastName = user.LastName,
userId = user.Id,
avatar = user.Avatar,
role = userRole,
email = user.Email,
gender = user.Gender,
}));
}
}
return(JsonResponseStatus.Error());
}
public async Task <IActionResult> Login(LoginUserDTO user)
{
if (ModelState.IsValid)
{
var result = await _signManager.PasswordSignInAsync(user.UserName, user.Password, false, false);
if (!result.Succeeded)
{
return(Login());
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> UserLogin([FromBody] LoginUserDTO login)
{
try
{
var result = await _userService.Login(login);
return(result is null || !result.Authenticated ? (IActionResult)NotFound() : Ok(result));
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <AuthResponce> LoginUserDTO_LogInAsync_Return_AuthResponce()
{
CreateDefaultApplicationUserServiceInstance();
var _fake = _fakeUsers[0];
var fakeLoginModel = new LoginUserDTO();
fakeLoginModel.Email = _fake.Email;
fakeLoginModel.Password = RandomString(5);
var authResponce = await _userService.LogInAsync(fakeLoginModel, RandomString(9));
Assert.NotNull(authResponce);
return(authResponce);
}
[Route("Authenticate")] //
public IActionResult Authenticate([FromBody] LoginUserDTO registerUser)
{
var authenticatedUser = _userService.Authenticate(ref registerUser);
if (authenticatedUser == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(GenerateUserWithToken(new UserDTO {
Id = authenticatedUser.Id, UserName = authenticatedUser.UserName
})));
}
//[ValidateAntiForgeryToken]
public ActionResult RegisterUser([Bind(Include = "ID,Email,Password,FullName")] LoginUserDTO user)
{
if (ModelState.IsValid)
{
TempData["SuccessMessage"] = "Registration Successful";
_busiuser.Insert(user);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View("Create"));
}
}
public async Task <ActionResult> Login(LoginUserDTO dto)
{
var login = await userService.Login(dto, AuthenticationManager);
if (login)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
public async Task <ServiceResult> Login(LoginUserDTO model)
{
ServiceResult result = new ServiceResult();
var logResult = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
if (logResult.Succeeded)
{
result.Status = ServiceResultStatus.Success;
}
return(result);
}
public async Task <IActionResult> Login([FromBody] LoginUserDTO userDTO)
{
_logger.LogInformation($"Login Attempt for {userDTO.Email} ");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!await _authManager.ValidateUser(userDTO))
{
return(Unauthorized());
}
return(Accepted(new { Token = await _authManager.CreateToken() }));
}
public async Task <IActionResult> SignIn(LoginUserDTO userData)
{
if (ModelState.IsValid)
{
string accessToken = await authenticationService.Authenticate(userData);
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid username or password"));
}
return(Ok(accessToken));
}
return(Conflict(ModelState));
}
/// <summary>
/// Crea nuevo SessionToken y lo registra en la base de datos, si ya existía anteriormente actualiza su fecha de expiración.
/// </summary>
/// <param name="user">EL User al que corresponde el token</param>
/// <param name="deviceIdentifier">Identificador del dispositivo que esta utilizando el usuario</param>
/// <param name="expireHours">La cantidad de horas hasta que expira el token. Si es null no expirará.</param>
/// <returns>El token creado</returns>
public static SessionTokenDTO Create(LoginUserDTO user, string tokenKey, int?expireHours)
{
SessionTokenDTO sessionTokenDto = new SessionTokenDTO
{
/* Para mayor seguridad, se repite el totenKey dos veces al armar el token */
Token = AesEncryption.GetInstance().Encrypt(user.UserName + tokenKey + tokenKey),
IdUser = user.UserName
};
/* Genera el token en la BDD */
//sessionTokenDto = Create(sessionTokenDto);
return(sessionTokenDto);
}
public LoginUserDTO Get_LoginUser_Data(LoginUserSearchDTO searchModel)
{
log.MethodStart();
LoginUserDTO objReturn = new LoginUserDTO();
using (var trans = _db.Database.BeginTransaction())
{
try
{
var objResult = _db.LoginUserDTOs.FromSqlRaw <LoginUserDTO>("sp_Check_UserLogin {0}, {1}", searchModel.usr_username, searchModel.usr_password).ToList();
if (objResult.Count > 0)
{
objReturn = objResult.FirstOrDefault();
_db.LogUserLogins.Add(new LogUserLogin()
{
log_usr_id = objReturn.usr_username,
log_access_ip = searchModel.usr_clientIp,
log_session_id = searchModel.usr_sessionId,
log_login_timestamp = DateTime.Now,
log_status = "Login"
});
var objUserLogin = _db.TCUserLogins.FirstOrDefault(x => x.usr_username == searchModel.usr_username);
if (objUserLogin != null)
{
objUserLogin.usr_accessFailedCount = 0;
}
_db.SaveChanges();
}
trans.Commit();
}
catch (Exception ex)
{
// TODO: Handle failure
trans.Rollback();
}
finally
{
trans.Dispose();
}
}
log.MethodFinish();
return(objReturn);
}
public LoginedUserDTO LoginUser(LoginUserDTO loginUserDTO)
{
var list = UserRepository.Find(tempuser => (tempuser.Email == loginUserDTO.Email && tempuser.Password == loginUserDTO.Password)).ToList();
if (list.Count != 0)
{
User user = list.First();
var config = new MapperConfiguration(cfg => cfg.CreateMap <User, LoginedUserDTO>());
var mapper = config.CreateMapper();
LoginedUserDTO logineduser = mapper.Map <User, LoginedUserDTO>(user);
return(logineduser);
}
return(null);
}
public UserDTO Authenticate(ref LoginUserDTO registeredUser)
{
string userName = registeredUser.UserName, password = registeredUser.Password;
var user = dbContext.Users.FirstOrDefault(x => x.UserName == userName && x.Password == password);
if (user == null)
{
return(null);
}
return(new UserDTO {
Id = user.Id, UserName = user.UserName
});
}
public LoginUserDTO GetUserCredentials()
{
if (Preferences.Get("stored_user", string.Empty) != true.ToString())
{
return(null);
}
var loginUser = new LoginUserDTO()
{
Username = Preferences.Get("username", string.Empty),
Password = Preferences.Get("password", string.Empty)
};
return(loginUser);
}
public async Task <LoginResult> LoginAsync(LoginUserDTO loginUser)
{
using (var httpClient = new HttpClient())
{
var response = await httpClient.PostAsync(_apiURL,
new StringContent(
JsonConvert.SerializeObject(loginUser),
Encoding.UTF8, "application/json"
));
var jsonResponse = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <LoginResult>(jsonResponse));
}
}
public bool PasswordValidation(LoginUserDTO credentials)
{
string name = credentials.UserName;
string password = credentials.Password;
User user = GetUserByUserName(name);
if (user != null)
{
if (user.UserName == name && PasswordHashTool.VerifyHashedPassword(password, user.Password))
{
return(true);
}
}
return(false);
}
public async Task <Tuple <LoginUserDTO, ExamCreate.ExamData, ExamDTO> > CreateExam(
bool includeTags = true, bool isPrivate = false, string[] extraTags = null,
LoginUserDTO loggedUser = null)
{
loggedUser = loggedUser ?? (await CreateUserAndLogin()).Item4;
var examData = TestData.Exam.Create.NewExamData(includeTags, isPrivate, extraTags);
client.Authorize(loggedUser.Token);
var responseExam = await client.PostExamSuccesfully("/exams", new ExamCreate.Request()
{
Exam = examData
});
client.Unauthorize();
return(Tuple.Create(loggedUser, examData, responseExam));
}
//POST : /api/ApplicationUser/Login
public async Task <IActionResult> Login(LoginUserDTO model)
{
_logger.LogInfo($"Logging account with username {model.UserName}...");
var user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
_logger.LogError($"Username or password is incorrect.");
return(BadRequest(new { message = "Username or password is incorrect." }));
}
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
if (user.LockoutEnd >= DateTime.UtcNow)
{
_logger.LogError($"User have entered 3 invalid attempts");
user.AccessFailedCount = 0;
return(Forbid());
}
user.AccessFailedCount = 0;
//Get role assigned to the user
var role = await _userManager.GetRolesAsync(user);
var options = new IdentityOptions();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim("UserID", user.Id),
new Claim(options.ClaimsIdentity.RoleClaimType, role.FirstOrDefault())
}),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.JWT_Secret)), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var securityToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(securityToken);
return(Ok(new { token }));
}
await _userManager.AccessFailedAsync(user); // Register failed access
return(BadRequest(new { message = "Incorrect password." }));
}
public async Task <IActionResult> Login([FromBody] LoginUserDTO loginUser)
{
var user = await _dbContext.AuthenticateAsync(loginUser.Email, loginUser.Password);
if (user != null)
{
return(Ok(new
{
token = _authProvider.GenerateNewToken(user), expiry = "30 minutes",
userId = user.Id.ToString()
}));
}
else
{
return(Unauthorized());
}
}
public async Task <ActionResult <TokenDTO> > GetTokenAsync(string userId, LoginUserDTO loginUserDto)
{
try
{
var jwt = await _tokenService.GetTokenAsync(loginUserDto, userId);
if (jwt.Token == null)
{
return(Unauthorized());
}
return(jwt);
}
catch
{
return(Unauthorized());
}
}
public async Task <ActionResult <ValidationResponseDTO> > SignInUser(LoginUserDTO loginUserDTO)
{
EntityUser user = await _userManager.FindByNameAsync(loginUserDTO.Username);
if (user == null)
{
return(BadRequest("Invalid Username"));
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginUserDTO.Password, lockoutOnFailure : false);
if (result.Succeeded)
{
return(ReturnValidation(user));
}
return(BadRequest("Invalid Password"));
}
//관리그룹,선생님,정회원,준회원
public LoginUserDTO GetLoginUserInfo(string user_id)
{
LoginUserDTO dto = null;
try
{
StringBuilder query = new StringBuilder();
query.Append("select a.[user_id] as [UserID], a.[user_name] as [UserName], a.[nick_name] as [NickName], c.[title] as [Group] ");
query.Append("from [xe_member] as a ");
query.Append(" join [xe_member_group_member] as b ");
query.Append(" on a.[member_srl]=b.[member_srl] ");
query.Append(" join [xe_member_group] as c ");
query.Append(" on b.[group_srl]=c.[group_srl] ");
query.Append("where a.[user_id]=N'%USER_ID%' ");
query.Replace("%USER_ID%", user_id);
DataSet ds = null;
SqlParameter[] param = null;
ds = db.GetDataSet(query.ToString(), CommandType.Text, param);
if (ds != null)
{
if (ds.Tables.Count > 0)
{
if (ds.Tables[0].Rows.Count > 0)
{
dto = new LoginUserDTO();
dto.UserID = ds.Tables[0].Rows[0]["UserID"].ToString();
dto.UserName = ds.Tables[0].Rows[0]["UserName"].ToString();
dto.NickName = ds.Tables[0].Rows[0]["NickName"].ToString();
dto.Group = ds.Tables[0].Rows[0]["Group"].ToString().ToUpper();
}
}
}
}
catch (Exception ex)
{
dto = null;
}
return dto;
}
