public User ValidateUserAsync(ValidateUserDto validateUser)
{
var hashPassword = _hashProvider.HashMd5(validateUser.Password);
var user = _userRepository.GetUserAsync(validateUser.Login, hashPassword);
var mappedUser = _mapperProvider.CreateMapByProfile <ScientificDatabase.Models.User, User, BaseProfile>(user);
return(mappedUser);
}
public async Task <IActionResult> ValidateFaceIdentity([FromBody] ValidateUserDto userDto)
{
var validation = await _faceService.ValidatePerson(userDto.Url);
if (validation)
{
return(Ok(validation));
}
else
{
return(Unauthorized("Usuario no autorizado"));
}
}
public ActionResult Sigin(ValidateUserDto data)
{
var bfUser = new BfUserManager();
LoginPageStage stage = new LoginPageStage
{
IsRemberLoginName = data.RemberUserName,
UserName = data.UserName
};
string enPswd = MB.Util.DESDataEncrypt.EncryptString(data.Password);
var loginValidate = bfUser.GetSysLoginUserData(data.UserName, enPswd);
if (loginValidate == null)
{
ViewBag.Message = "网络错误，请联系管理员！";
}
else
{
switch (loginValidate.Status)
{
case UserValidateStatus.UserNotExist:
ViewBag.Message = "账号不存在";
break;
case UserValidateStatus.PasswordError:
ViewBag.Message = "密码错误";
break;
default:
{
LoginSucceed(loginValidate.Result, data.RemberUserName);
if (!string.IsNullOrEmpty(data.RedirectUrl))
{
return(Redirect(data.RedirectUrl));
}
else
{
return(Redirect(FormsAuthenticationService.DefaultUrl));
}
}
}
}
return(View(stage));
}
public async Task Validate_Should_Validate_User()
{
var validationToken = "abc";
var validateUserName = "******";
var toValidateUser = new User()
{
BirthDate = DateTime.Now.AddYears(-30),
CreationDate = DateTime.Now,
EMail = "*****@*****.**",
FullName = "To Validate",
Id = 2000,
IsValid = false,
Password = new byte[] { 1, 1, 1 },
UserName = validateUserName,
ValidationToken = validationToken
};
using (var context = new DaOAuthContext(_dbContextOptions))
{
context.Users.Add(toValidateUser);
context.Commit();
}
var validateUserDto = new ValidateUserDto()
{
Token = validationToken,
UserName = validateUserName
};
var httpResponseMessage = await _client.PutAsJsonAsync("users/validate", validateUserDto);
Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode);
User validatedUser = null;
using (var context = new DaOAuthContext(_dbContextOptions))
{
validatedUser = context.Users.FirstOrDefault(u => u.Id.Equals(toValidateUser.Id));
}
Assert.IsNotNull(validatedUser);
Assert.IsTrue(validatedUser.IsValid);
}
/// <summary>
/// Получение Токена
/// </summary>
/// <returns></returns>
public async Task <ApplicationUser> GetApplicationUserAsync(string userName, string password)
{
try
{
var validateUser = new ValidateUserDto
{
Login = userName,
Password = password
};
var user = await _httpClientProvider.SendHttpPostWithResponse <User>(validateUser, "user/validate");
return(new ApplicationUser());
}
catch (Exception exception)
{
Logger.LogError(exception, "Ошибка при получении данных .");
return(null);
}
}
public UserDto ValidateUser(ValidateUserDto infos)
{
Logger.LogInformation($"Validate user {infos.UserName}");
Validate(infos);
using (var context = RepositoriesFactory.CreateContext())
{
var local = this.GetErrorStringLocalizer();
var userRepo = RepositoriesFactory.GetUserRepository(context);
var myUser = userRepo.GetByUserName(infos.UserName);
if (myUser == null)
{
throw new DaOAuthServiceException(local["ValidateUserNoUserFound"]);
}
if (!infos.Token.Equals(myUser.ValidationToken, StringComparison.Ordinal))
{
throw new DaOAuthServiceException(local["ValidateUserInvalidToken"]);
}
if (myUser.IsValid)
{
throw new DaOAuthServiceException(local["ValidateUserEverValidated"]);
}
myUser.IsValid = true;
userRepo.Update(myUser);
context.Commit();
return(myUser.ToDto());
}
}
public async Task <IActionResult> Validate([FromBody] ValidateUserDto user)
{
var result = await _service.Validate(_mapper.Map <UserDto>(user));
return(Ok(_mapper.Map <UserValidateResultDto>(result)));
}
public async Task <IActionResult> ValidateFaceIdentity([FromBody] ValidateUserDto userDto)
{
var validation = await _faceService.ValidatePerson(userDto.Url);
return(Ok(validation));
}
public IActionResult Validate(ValidateUserDto model)
{
return(Ok(_service.ValidateUser(model)));
}
public User ValidateUserAsync([FromBody] ValidateUserDto validateUser)
{
return(_userService.ValidateUserAsync(validateUser));
}
