public async Task <IActionResult> Login(LoginDTO model)
{
if (!IsValidApiRequest())
{
return(ApiBadRequest("Invalid Headers!"));
}
var user = await UserManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(ApiBadRequest("User does not exist."));
}
if (await UserManager.CheckPasswordAsync(user, model.Password))
{
return(Ok(new
{
token = _jwt.GenerateSecurityToken(new JwtUser()
{
Email = user.Email,
roleId = user.Department
})
}));
}
return(ApiBadRequest("Bad password"));
}
public string Get()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(token);
}
public string GetRandomToken(string userName)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(userName);
return(token);
}
public IActionResult Post([FromBody] Login login)
{
try
{
var userGot = _userRepository.GetUserByEmail(login.email);
if (userGot != null)
{
if (_userRepository.CheckMatch(userGot.passhash_user, login.password))
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(userGot);
return(Ok(token));
}
else
{
return(Content("Invalid Password"));
}
}
else
{
return(Content("User not found!"));
}
}
catch (Exception)
{
return(new StatusCodeResult(500));
}
}
public string GetRandomToken()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(token);
}
[HttpGet(nameof(FetchToken))] // Get TOKEN - MARK VANZ
public async Task <IActionResult> FetchToken(string email)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(email);
return(Ok(token)); // Return Token
}
public string GetToken()
{
var jwtService = new JwtService(_config);
var token = jwtService.GenerateSecurityToken("*****@*****.**");
return(token);
}
public string GetRandomToken()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(token);
}
public async Task <IActionResult> CheckCustomerToken()
{
var customer = await _workContext.GetCurrentCustomerAsync();
if (customer == null)
{
return(Ok(new { success = false, message = await _localizationService.GetResourceAsync("Customer.Not.Found") }));
}
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(customer.Email, customer.Id);
var shippingAddress = customer.ShippingAddressId.HasValue ? await _addressService.GetAddressByIdAsync(customer.ShippingAddressId.Value) : null;
var firstName = await _genericAttributeService.GetAttributeAsync <string>(customer, NopCustomerDefaults.FirstNameAttribute);
var lastName = await _genericAttributeService.GetAttributeAsync <string>(customer, NopCustomerDefaults.LastNameAttribute);
return(Ok(new
{
success = true,
token,
pushToken = customer.PushToken,
shippingAddress,
firstName,
lastName,
RemindMeNotification = customer.RemindMeNotification,
RateReminderNotification = customer.RateReminderNotification,
OrderStatusNotification = customer.OrderStatusNotification,
avatar = await _pictureService.GetPictureUrlAsync(await _genericAttributeService.GetAttributeAsync <int>(customer, NopCustomerDefaults.AvatarPictureIdAttribute), _mediaSettings.AvatarPictureSize, true)
}));
}
public string GetRandomToken()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(token);
}
public static string GetToken(IConfiguration config, string email)
{
var jwt = new JwtService(config);
var token = jwt.GenerateSecurityToken(email);
return(token);
}
public async Task <ActionResult <string> > Login()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(token);
}
public async Task <ActionResult> GetRandomToken(string username, string password)
{
var person = await _personRepository.GetPersonAsync(username);
if (person == null || string.IsNullOrEmpty(person.HashedPassword))
{
return(Ok());
}
if (person.EmailConfirmed.ToLower() == "false")
{
return(Ok("Confirm Email Address"));
}
if (person.ChangePassword.ToLower() == "true")
{
// 60 min time limit from when the email was sent
return(Ok("User must change password"));
}
if (person.HashedPassword.Equals(password))
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(username);
return(Ok(token));
}
return(Ok());
}
public IActionResult GetRandomToken()
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken("*****@*****.**");
return(Ok(new { Token = token }));
}
public IActionResult Login(LoginVM loginVM)
{
Account account = myContext.Accounts.Where(acc => acc.Employee.Email == loginVM.Email).FirstOrDefault();
try
{
bool isValidPassword = BCrypt.Net.BCrypt.Verify(loginVM.Password, account.Password);
if (isValidPassword)
{
var result = accountRepository.Login(loginVM);
if (result == null)
{
return(NotFound(new { status = HttpStatusCode.NotFound, result, message = "Login Unsuccessful", Token = "" }));
}
var jwt = new JwtService(configuration);
var token = jwt.GenerateSecurityToken(result);
return(Ok(new { status = HttpStatusCode.OK, message = "Login Success", result, Token = token }));
}
return(BadRequest(new { status = HttpStatusCode.BadRequest, result = "", message = "Login Unsuccessful" }));
}
catch (Exception)
{
return(BadRequest(new { status = HttpStatusCode.BadRequest, result = "", message = "Login Unsuccessful" }));
}
}
public User Register([FromBody] User model)
{
try
{
// create user
model.Password = HashPassword(model.Password);
model.JWT = _authService.GenerateSecurityToken(model);
_context.Add(model);
_context.SaveChanges();
model.Password = null;
return(model);
}
catch (Exception)
{
return(null);
}
}
public ActionResult GetToken([FromHeader] string Authorization = null)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(Authorization);
Response.Headers.Add("Authorization", token);
return(Ok());
}
public ActionResult <string> Login([FromBody] LoginDTO value)
{
EmployeeDetails obj = _employeeService.ValidateLoginCredentials(value.orcId, value.password);
if (obj != null)
{
return(_jwtService.GenerateSecurityToken(obj.AccessToken, obj.OrcId));
}
return(BadRequest("Invalid Username or Password"));
}
private string GetRandomToken(string email)
{
if (string.IsNullOrEmpty(email))
{
throw new ArgumentNullException();
}
var token = _jwtService.GenerateSecurityToken(email);
return(token);
}
public void GenerateSecurityToken_Test()
{
// Arrange
var rand = new Random();
var emailId = rand.Next();
var newEmail = $"randomemail{emailId}@google.com";
// Act
var token = _jwtService.GenerateSecurityToken(newEmail);
// Assert
Assert.True(token != null);
}
/// <summary>
/// Generate Token according to User information
/// </summary>
/// <param name="u">User Object, to user ID,EMail,Status </param>
/// <returns>New Token</returns>
private JWT_Bearer GenToken(SM.User u)
{
JWT_Bearer JWTB = new JWT_Bearer();
if (u != null)
{
JwtService jwt = new JwtService(_config);
JWTB.id = u.Id;
JWTB.ExpirationDateTime = DateTime.Now.AddMinutes(double.Parse(_config.GetSection("JwtConfig").GetSection("expirationInMinutes").Value));
JWTB.BearerJWT = jwt.GenerateSecurityToken(u.Email, u.Status.ToString(), u.Id.
ToString());;
}
return(JWTB);
}
public ActionResult GetRandomToken([FromBody] LoginRequest login)
{
var user = GetUserFromEmail(login.Email);
if (user == null || !user.CheckPassword(login.Password))
{
return(Unauthorized());
}
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(user);
return(new JsonResult(new { token }));
}
public void GenerateSecurityToken_InputEmailUsername_EqualsClaim()
{
var jwt = new JwtService(Configuration);
var token = jwt.GenerateSecurityToken(new User {
Email = "*****@*****.**", Username = "******"
});
var handler = new JwtSecurityTokenHandler();
var jsonToken = handler.ReadToken(token);
var tokenS = handler.ReadToken(token) as JwtSecurityToken;
Assert.Equal("*****@*****.**", tokenS.Claims.First(claim => claim.Type == "email").Value);
Assert.Equal("foo", tokenS.Claims.First(claim => claim.Type == "unique_name").Value);
}
public ActionResult <string> GetRandomToken([FromBody] UserDTO content)
{
content.Password = SecurityUtils.HashFunction(content.Password);
if (_context.User.Any(u => u.Email == content.Email && u.Password == content.Password))
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(content.Email);
return(token);
}
return(StatusCode(401));
}
public async Task <IActionResult> Signup(AuthDTO model)
{
if (!IsValidApiRequest())
{
return(ApiBadRequest("Invalid headers!"));
}
var user = new UserDTO {
UserName = model.Username ?? model.Email, Email = model.Email
};
foreach (var validator in _userManager.PasswordValidators)
{
var res = await validator.ValidateAsync(_userManager, null, model.Password);
if (!res.Succeeded)
{
return(ApiBadRequest(res.Errors.First().Description));
}
}
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(ApiBadRequest(result.Errors.First().Description));
}
return(Created("", new
{
token = _jwt.GenerateSecurityToken(new User()
{
Username = user.UserName,
Email = user.Email
})
}));
}
public IActionResult Login(LoginDataIn data)
{
(RetornoDataOut retorno, LoginOut loginOut) = _userData.Login(data);
if (retorno.Result == Retorno.Error)
{
return(StatusCode(200, retorno));
}
RetornoDataOut DataRetorno = new RetornoDataOut
{
Data = new { Token = _jwtServices.GenerateSecurityToken(loginOut.Email, loginOut.Username, loginOut.Id.ToString()) }
};
return(StatusCode(200, DataRetorno));
}
public static void LoginTokenAutoridad(IConfiguration _config, Models.Autoridad autoridad, ResultResponse <LoginAutoridadResponse> response)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(autoridad.Email);
LoginAutoridadResponse loginResponse = new LoginAutoridadResponse {
Token = token,
Id = autoridad.Id,
Name = autoridad.Name,
LastName = autoridad.Lastname
};
response.Data = loginResponse;
response.Error = false;
response.Message = "Inicio de Sesion Satisfactorio";
}
public static void LoginTokenCustomer(IConfiguration _config, Models.Customer customer, ResultResponse <LoginCustomerResponse> response)
{
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(customer.Email);
LoginCustomerResponse loginResponse = new LoginCustomerResponse {
Token = token,
CustomerId = customer.CustomerId,
Names = customer.Names,
LastNames = customer.LastNames
};
response.Data = loginResponse;
response.Error = false;
response.Message = "Inicio de sesión satisfactorio";
}
public async Task <ActionResult <User> > LoginPostUser(UserLoginInfo user)
{
var tUser = _context.User
.Where(x => x.Email == user.UsernameEmail || x.Username == user.UsernameEmail)
.Where(x => x.Token
==
BCrypt.Net.BCrypt.HashPassword(user.Password, _configuration["salt"])).FirstOrDefault();
if (tUser == null)
{
return(NotFound(tUser));
}
var Jwt = new JwtService(_configuration);
var token = Jwt.GenerateSecurityToken(tUser.Email);
return(CreatedAtAction("Login", new { Token = token }, "new token"));
}
public IActionResult GetUtilisateurs(string Login, string MotDePasse)
{
try
{
Utilisateur utilisateurATrouver = _context.Utilisateurs.Where(c => (c.Login.Equals(Login) && c.MotDePasse.Equals(Utilitaire.HashPassword(MotDePasse)))).FirstOrDefault();
if (utilisateurATrouver == null)
{
return(NoContent());
}
string type;
switch (utilisateurATrouver.GetType().ToString())
{
case "GestionClientAPI.Models.Client":
type = "Client";
break;
case "GestionClientAPI.Models.Gestionnaire":
type = "Gestionnaire";
break;
case "GestionClientAPI.Models.Administrateur":
type = "Administrateur";
break;
default:
type = "Utilisateur";
break;
}
var jwt = new JwtService(_config);
var token = jwt.GenerateSecurityToken(utilisateurATrouver.Login);
ResultConnexion resultConnexion = new ResultConnexion()
{
Token = token, Type = type, Id = utilisateurATrouver.UtilisateurId
};
return(Ok(resultConnexion));
} catch (Exception) { }
return(BadRequest());
}