// Todo Fix
public async Task <EkycTxModel> GetAccessToken()
{
EkycTxModel ekycTxModel = new EkycTxModel();
var authen = new AuthenticateRequestModel()
{
Username = "******", Password = "******"
}; // Todo Fix
try
{
var client = clientFactory.CreateClient();
StringContent content = new StringContent(JsonConvert.SerializeObject(authen), Encoding.UTF8, "application/json");
using var response = await client.PostAsync("http://w2wasdho126:8094/api/user/authen", content);
string apiResponse = await response.Content.ReadAsStringAsync();
ekycTxModel = JsonConvert.DeserializeObject <EkycTxModel>(apiResponse);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(ekycTxModel);
}
public Task <Result <AuthenticateResponseModel> > Authenticate(AuthenticateRequestModel model, string ipAddress)
{
try
{
var user = _userLoginService.Authenticate(model);
if (user == null)
{
return(Task.FromResult(ResultMessage <AuthenticateResponseModel> .Error(Constants.NotFoundUserLogin)));
}
var employee = _employeeService.GetEmployee(user.FkEmpId ?? 0);
var jwtToken = GenerateJwtToken(user);
var refreshToken = GenerateRefreshToken(ipAddress, model.Username);
_refreshTokenService.CreateRefreshToken(refreshToken);
var resultAuthentication = new AuthenticateResponseModel(employee, jwtToken, refreshToken.Token, user.Role);
return(Task.FromResult(ResultMessage <AuthenticateResponseModel> .Success(resultAuthentication)));
}
catch (Exception ex)
{
return(Task.FromResult(ResultMessage <AuthenticateResponseModel> .ExceptionError(ex)));
}
}
public UserLoginModel Authenticate(AuthenticateRequestModel model)
{
var entity = _apiTestContext.UserLogin.FirstOrDefault(f => f.Username == model.Username && f.Password == model.Password);
if (entity == null)
{
return(new UserLoginModel());
}
return(_mapper.Map <UserLoginModel>(entity));
}
public async Task <ApiResponse> Authenticate(AuthenticateRequestModel model)
{
var result = await _authenticateUserCommand.Execute(new AuthenticateUserCommandArgs
{
Email = model.Email,
Password = model.Password
});
return(ApiResponse.Success(result));
}
public async Task <SessionResponseModel> Authenticate([FromBody] AuthenticateRequestModel requestModel)
{
var(token, refreshToken) = await _mediator.Send(new AuthenticateCmd(requestModel.Email, requestModel.PwdHash));
return(new SessionResponseModel
{
Token = token,
RefreshToken = refreshToken
});
}
public IActionResult Authenticate(AuthenticateRequestModel model)
{
var response = _memberService.Authenticate(model.Email, model.Password);
if (response == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(response));
}
public async Task <AuthenticateResponseModel> AuthenticateAsync(AuthenticateRequestModel model)
{
var user = _userReadRepository.GetAll().SingleOrDefault(x => x.Username == model.Username);
if (user == null || user.Password != HashPassword(model.Password, user.Salt))
{
return(null);
}
var token = GenerateToken(user, model.Secret);
return(await Task.FromResult(new AuthenticateResponseModel(user.Id, user.Username, token)));
}
public IActionResult Authenticate([FromBody] AuthenticateRequestModel model)
{
var response = _userService.Authenticate(_mapper.Map <AuthenticateRequest>(model), ipAddress());
if (response == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
setTokenCookie(response.RefreshToken);
return(Ok(response));
}
public async Task <AuthenticateResponseModel> AuthenticateAsync(AuthenticateRequestModel model)
{
var user = await _userObjectService.GetUserByUserNameAsync(model.Username);
if (user == null || user.Password != HashPassword(model.Password, user.Salt))
{
return(null);
}
var token = GenerateToken(user, model.Secret);
return(await Task.FromResult(new AuthenticateResponseModel(user.Id, user.Username, token)));
}
public IActionResult Authenticate(AuthenticateRequestModel model)
{
try
{
var user = _serviceAuth.Authenticate(model.Email, model.Password);
var response = GiveJWTToken(user.Email, user.Role.ToString());
return(Ok(response));
}
catch (Exception ee)
{
return(BadRequest(ee.Message));
}
}
public AuthenticateResponseModel Authenticate(AuthenticateRequestModel model)
{
var user = _userRepository.Authenticate(model.Email, model.Password);
// return null if user not found
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = GenerateJwtToken(user);
return(new AuthenticateResponseModel(user, token));
}
public AuthResponseModel Authenticate(AuthenticateRequestModel <SiteAuthModel> auth)
{
var user = UserRepository.GetByEmail(auth.Data.Email.ToLowerInvariant());
if (user == null)
{
throw new CredentialWrong();
}
if (!ValidateCredentials(auth))
{
throw new CredentialWrong();
}
if (!user.IsActive)
{
throw new AcccountDeactivatedException();
}
return(Authenticate(user, auth.Offset));
}
public async Task <AuthenticateResponseModel> AuthenticateAsync([FromBody] AuthenticateRequestModel request)
{
AuthResultModel authModel = null;
switch (request.LoginProvider)
{
case LoginProvider.Standard:
authModel = await _authService.AuthAsync(request.Email, request.Password);
break;
case LoginProvider.Google:
authModel = await _authService.SocialAuthAsync(request.Email, Domain.Enums.LoginProvider.Google);
break;
}
return(_mapper.Map <AuthenticateResponseModel>(authModel));
}
public UserLoginModel Authenticate(AuthenticateRequestModel model)
{
return(_userLoginRepository.Authenticate(model));
}
public HttpResponseMessage Authenticate(AuthenticateRequestModel request)
{
return(Request.CreateResponse(HttpStatusCode.OK, new AuthenticateResponseModel()));
}
public async Task <ActionResult <AuthenticateResponseModel> > Authenticate([FromBody] AuthenticateRequestModel model)
{
var authToken = await adminService.AuthenticateAsync(model.UserName, model.Password);
return(Ok(new AuthenticateResponseModel(model.UserName, authToken)));
}
public async Task <AuthenticationResponse> Post(AuthenticateRequestModel model)
{
var response = await authService.Authenticate(AgentName.Minecraft, model.Username, model.Password);
return(response);
}
public bool ValidateCredentials(AuthenticateRequestModel <SiteAuthModel> auth)
{
var user = UserRepository.GetByEmail(auth.Data.Email);
return(ValidateCredentials(auth.Data.Password, user.Id));
}
public async Task <AuthenticateResponseModel> AuthenticateAsync([FromBody] AuthenticateRequestModel request)
{
var authModel = await _authService.AuthAsync(request.ClientId, request.ClientSecret, request.UserInfo);
return(_mapper.Map <AuthenticateResponseModel>(authModel));
}
public async Task <AuthenticateResponseModel> AuthenticateAsync([FromBody] AuthenticateRequestModel request)
{
var authModel = await _authService.AuthAsync(request.Email, request.Password);
return(_mapper.Map <AuthenticateResponseModel>(authModel));
}
