/// <summary>
/// This method 'LoginAuthentication' will check the login authentication
/// </summary>
/// <param name=" data"></param>
/// <returns>Returns 1 if Success, 0 for failure</returns>
public DataTable LoginAuthentication(LoginInputDTO loginInput)
{
DataTable sendResponse = new DataTable();
try
{
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
using (SqlCommand cmd = new SqlCommand("spLoginAuthentication", con))
{
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter tvpParam = cmd.Parameters.AddWithValue("@EMAIL_ID", loginInput.emailid);
tvpParam.SqlDbType = SqlDbType.Text;
SqlParameter tvparam1 = cmd.Parameters.AddWithValue("@PASSWORD", loginInput.password);
tvparam1.SqlDbType = SqlDbType.Text;
SqlParameter tvparam2 = cmd.Parameters.AddWithValue("@UserType", loginInput.usertype);
tvparam2.SqlDbType = SqlDbType.Text;
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
da.Fill(sendResponse);
}
}
}
}
catch (Exception ex)
{
ExceptionLogger.WriteToErrorLogFile(ex);
}
return(sendResponse);
}
public async Task <ResponseEntity <CustomerOutputDTO> > Login(LoginInputDTO input)
{
var response = new ResponseEntity <CustomerOutputDTO>();
try
{
var customer = await _customerRepository.FirstAsync(a => a.IsActive && a.Email == input.Email && a.Password == input.Password);
if (customer == null)
{
response.HttpCode = HttpStatusCode.Unauthorized;
return(response);
}
response.Result = new CustomerOutputDTO
{
CustomerId = customer.Id,
Name = customer.Name,
Surname = customer.Surname,
Address = customer.Address,
Email = customer.Email,
PhoneNumber = customer.PhoneNumber
};
}
catch (Exception ex)
{
response.Exception = ex;
response.ErrorMessage = ex.Message;
response.HttpCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public string GenerateToken([FromBody] LoginInputDTO data)
{
var user = _userRepository.GetByUserName(data.UserName);
var hash = PasswordHasherHelper.HashString($"{data.Password}{user.Salt}");
if (hash != user.HashPassword)
{
throw new UnauthorizedException(user);
}
return($"{user.GenerationToken()}.{user.Id}");
}
public IActionResult Login([FromBody] LoginInputDTO login)
{
User user = AuthenticateUser(login);
if (user == null)
{
return(Unauthorized());
}
return(Ok(new LoginOutputDTO
{
Token = GenerateJWTToken(user)
}));
}
public UserProfileDTO Login([FromBody] LoginInputDTO loginInputDTO)
{
var result = _loginService.Login(loginInputDTO);
if (result?.tokenResponse != null)
{
this.HttpContext.Response.StatusCode = (int)HttpStatusCode.OK;
return(result);
}
else
{
this.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(new UserProfileDTO());
}
}
public object LoginAuthentication(LoginInputDTO loginInput)
{
DataTable res = new DataTable();
res = _hostessBL.LoginAuthentication(loginInput);
try
{
return(Json(new JsonResponseResult {
_ErrorCode = TruflConstants._ErrorCodeSuccess, _Data = res, _StatusCode = TruflConstants._StatusCodeOK, _StatusMessage = TruflConstants._StatusMessageSuccess
}));
}
catch (Exception ex)
{
return(Json(new JsonResponseResult {
_ErrorCode = TruflConstants._ErrorCodeFailed, _Data = ex.ToString(), _StatusCode = TruflConstants._StatusCodeFailed, _StatusMessage = TruflConstants._StatusMessageFailed
}));
}
}
public async Task <ActionResult <LoginOutputDTO> > Login(LoginInputDTO loginDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(loginDTO));
}
var login = await _mediator.Send(new GetUserByLoginQuery
{
User = _mapper.Map <Users>(loginDTO)
});
if (login == null)
{
return(Unauthorized("Usuário e/ou senha inválidos"));
}
return(Ok(_mapper.Map <LoginOutputDTO>(login)));
}
public async Task <string> SubmitLogin(LoginInputDTO input)
{
var userId = await _homeBus.SubmitLoginAsync(input);
var claims = new[]
{
new Claim("userId", userId)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtOptions.Secret));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var jwtToken = new JwtSecurityToken(
string.Empty,
string.Empty,
claims,
expires: DateTime.Now.AddHours(_jwtOptions.AccessExpireHours),
signingCredentials: credentials);
return(new JwtSecurityTokenHandler().WriteToken(jwtToken));
}
private async Task <TokenResponse> MainAsync(LoginInputDTO model)
{
// discover endpoints from metadata
var disco = await DiscoveryClient.GetAsync("http://localhost:5000");
// request token
var tokenClient = new TokenClient(disco.TokenEndpoint, model.ClientId, model.ClientSecret);
var tokenResponse =
await tokenClient.RequestResourceOwnerPasswordAsync(model.Email, model.Password, model.Scope);
if (tokenResponse.IsError)
{
return(new TokenResponse(HttpStatusCode.Unauthorized, "Unautorized"));
}
Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");
return(tokenResponse);
}
public UserProfileDTO Login(LoginInputDTO loginInputDTO)
{
if (loginInputDTO == null)
{
Console.WriteLine("loginInputDTO == null!!!!!!!!!!!!!!!!!!!");
return(null);
}
var loggedUserProfileDto = new UserProfileDTO();
var tokenResponse = MainAsync(loginInputDTO).GetAwaiter().GetResult();
if (tokenResponse.HttpStatusCode != HttpStatusCode.OK)
{
return(loggedUserProfileDto);
}
loggedUserProfileDto = _personService.GetLoggedUserProfileByToken(tokenResponse.AccessToken);
loggedUserProfileDto.tokenResponse = tokenResponse.AccessToken;
return(loggedUserProfileDto);
}
public async Task <string> SubmitLogin(LoginInputDTO input)
{
return(await _homeBus.SubmitLoginAsync(input));
}
public DataTable LoginAuthentication(LoginInputDTO loginInput)
{
return(_hostessDL.LoginAuthentication(loginInput));
}
User AuthenticateUser(LoginInputDTO loginCredentials)
{
User user = appUsers.SingleOrDefault(x => x.UserName == loginCredentials.UserName && x.Password == loginCredentials.Password);
return(user);
}
public async Task <IActionResult> Login(LoginInputDTO input)
{
return(HttpEntity(await _customerService.Login(input)));
}
