public async Task<ObjectResource<LoginResource>> LoginAsync(LoginPayload payload)
{
if (payload == null) {
return new ObjectResource<LoginResource> { Code = ResourceCodes.NullPayload, Data = null, Message = "Payload cannot be null" }; }
string tokenString = string.Empty;
bool validUser = Authenticate(payload);
if (validUser)
{
tokenString = tokenGenerator.BuildJWTToken();
if(tokenGenerator == null)
{
logger.LogError($"unable to generate token for user {payload.Username}");
return new ObjectResource<LoginResource> { Code = ResourceCodes.InvalidToken, Message = "unable to generate Token" };
}
logger.LogInformation($"Successfully generated token for {tokenString}");
return new ObjectResource<LoginResource> { Code = ResourceCodes.Success, Data = new LoginResource { Token = tokenString, UserName = payload.Username }, Message = "Login Successful" };
}
else
{
logger.LogError($"Invalid Login payload: {payload} at {DateTime.Now}");
return new ObjectResource<LoginResource> { Code = ResourceCodes.InvalidLoginDetails, Data = null, Message = "password or username is incorrect" };
}
}
public void ConnectToServer()
{
startMenu.SetActive(false);
LoginPayload payload = new LoginPayload
{
login = username.text,
password = password.text
};
Packet pck = new Packet
{
Opcode = (int)Opcode.Opcode.CMSG_AUTH.LOGON_CHALLENGE,
Payload = payload
};
Client authClient = ClientManager.instance.authClient;
authClient.SetAuthenticationPacket(pck);
authClient.ConnectToServer();
/*
* Network.Packet packet = new Network.Packet
* {
* Opcode = 0,
* Payload = payload
* };
* Debug.Log(packet.ToString());
*/
}
public static void LoginUser(LoginPayload payload, ResponseCallback callback, ResponseFallback fallback)
{
HttpClient httpClient = new HttpClient();
Request request = new Request(HttpClient.Method.POST, Route.LOGIN_ROUTE, payload);
httpClient.Request(
request,
(statusCode, response) => {
LoginResponse loginResponse = Deserialize(response);
callback(loginResponse);
},
(statusCode, error) => {
if (statusCode == StatusCodes.CODE_VALIDATION_ERROR)
{
ValidationError validationError = ErrorDeserilizer.DeserializeValidationErrorData(error);
fallback(statusCode, validationError);
}
else
{
GenericError genericError = ErrorDeserilizer.DeserializeGenericErrorData(error);
fallback(statusCode, genericError);
}
}
);
}
public override ActionResult HandleRequest()
{
string __body = _contextWrapper.GetBody();
LoginPayload __paydload = __body.FromJsonTo <LoginPayload>();
if (__paydload.Password == "xx")
{
return(new ActionResult()
{
StatusCode = 401,
Content = "Username or password is incorrect"
});
}
// ==========================================================
// User autentication
// ==========================================================
//var user = new Core.Authentication.User();
//if (user == null) return null;
// ==========================================================
// Create token
// ==========================================================
return(new ActionResult()
{
StatusCode = 200,
Content = CreateJwtToken(__paydload.Username)
});
}
public async Task <ActionResult> Login([FromBody] LoginPayload loginPayload)
{
try
{
var m = new MailAddress(loginPayload.Email);
}
catch (FormatException)
{
Response.StatusCode = 400;
return(new JsonResult(new { status = "false", message = "email format" }));
}
var foundUser = _db.Users
.SingleOrDefault(u => u.Email == loginPayload.Email);
if (foundUser != null)
{
if (BCrypt.Net.BCrypt.Verify(loginPayload.Password, foundUser.Password))
{
var tokenString = GenerateJsonWebToken(foundUser);
return(new JsonResult(new
{
foundUser.Email,
foundUser.Id,
foundUser.Nume,
token = tokenString
}));
}
return(BadRequest(new { status = false, message = "Wrong password or email " }));
}
return(BadRequest(new { status = false, message = "No user with this email found" }));
}
public async Task <bool> LoginAsync(LoginPayload payload)
{
using var http = _httpFactory.CreateClient(Constants.AUTH_CLIENT_NAME);
try
{
var res = await http.PostAsJsonAsync($"{http.BaseAddress}/login", payload);
if (res.IsSuccessStatusCode)
{
var auth = await res.Content.ReadFromJsonAsync <AuthResponse>();
_localstorage.SetItem(Constants.ACCESS_TOKEN_NAME, auth.Token);
_localstorage.SetItem(Constants.USER_DATA_NAME, auth.User);
}
else
{
var content = await res.Content.ReadFromJsonAsync <ErrorResponse>();
Console.Error.WriteLine($"Failed to Login: {content?.Message}");
return(false);
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
return(false);
}
return(true);
}
public async Task <IActionResult> Login([FromBody] LoginPayload loginPayload)
{
try
{
MailAddress m = new MailAddress(loginPayload.Email);
}
catch (FormatException)
{
return(new JsonResult(new { status = "false", message = "email format" }));
}
var foundUser = _db.Users
.SingleOrDefault(u => u.Email == loginPayload.Email);
if (foundUser != null)
{
if (BCrypt.Net.BCrypt.Verify(loginPayload.Password, foundUser.PasswordHash))
{
var tokenString = GenerateJSONWebToken(foundUser);
return(new JsonResult(new
{
status = "true",
firstName = foundUser.UserName,
Id = foundUser.Id,
token = tokenString
}));
}
return(BadRequest(new { status = false, message = "Wrong password or email " }));
}
else
{
return(BadRequest(new { status = false, message = "No user with this email found" }));
}
}
public async Task <IActionResult> Register([FromBody] LoginPayload registerPayload)
{
try
{
var existUser = _db.Users
.Any(u => u.Email == registerPayload.Email);
if (existUser)
{
//return JS
}
var userToCreate = new User
{
FirstName = registerPayload.FirstName,
LastName = registerPayload.LastName,
Email = registerPayload.Email,
PasswordHash = BC.HashPassword(registerPayload.Password),
Role = "Default"
};
_db.Users.Add(userToCreate);
_db.SaveChanges();
return(Ok(new { status = true }));
}
catch (Exception)
{
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> Auth([FromBody] LoginPayload payload)
{
return(await RunDefaultAsync(async() =>
{
var user = await _userBusiness.Login(payload);
return Ok(user);
}));
}
public async Task <ActionResult <TokenProxy> > Authenticate(
[FromBody] LoginPayload loginPayload,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations
)
{
var user = await _context.Set <User>().FirstOrDefaultAsync(u => u.Email == loginPayload.Email);
if (user == null)
{
return(StatusCode(404, new
{
Message = "O usuário com esse e-mail não foi encontrado",
Status = 404
}));
}
if (user.Password != loginPayload.Password.HashMD5())
{
return(BadRequest(new
{
Message = "A senha está incorreta.",
Status = 400
}));
}
var identity = new ClaimsIdentity(
new[]
{
new Claim(ClaimTypes.Name, user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Roles)
}
);
var dataCriacao = DateTime.Now;
var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(StatusCode(200, new TokenProxy
{
Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
Token = $"Bearer {token}"
}));
}
private bool Authenticate(LoginPayload login)
{
bool validUser = false;
if (login.Username == "Smartace" && login.Password == "Smartace1$")
{
validUser = true;
}
return validUser;
}
private async Task <IResult> OnLogin(LoginPayload login, IAuthService auth)
{
var(canLogin, user) = await auth.VerifyUserLoginAsync(login);
if (!canLogin || user is null)
{
return(Results.BadRequest(new ErrorResponse("Credentials Not Valid")));
}
var token = auth.SignJwtToken(user);
return(Results.Ok(new AuthResponse(token, user)));
}
public async Task <ActionResult <string> > LoginAsync([FromBody] LoginPayload loginPayload)
{
try
{
var res = await auth.LoginAsync(loginPayload);
return(Ok(res));
}
catch (AuthException ex)
{
return(BadRequest(ex.Message));
}
}
public HttpResponse <string> Login(LoginPayload payload)
{
var results = from u in this._dbContext.Users where u.Email == payload.Email && u.Password == payload.Password select u;
var result = results.ToList();
if (result.Count() == 0)
{
return(new BadRequest <string>("Invalid email or password."));
}
var user = result[0];
var token = generateToken(user);
return(new Ok <string>(token.ToString()));
}
public async Task PasswordLogin(IHttpContext context)
{
var user = await Authenticator.Authenticate(context, AuthenticationMethod.Password);
if (user == null)
{
// Authenticate is responsible for sending the response.
return;
}
var token = Authenticator.GenerateToken(user);
context.Response.Headers.Add("Authorization", string.Format("Bearer {0}", token));
await context.SendResponse(HttpStatusCode.OK, LoginPayload.FromToken(token));
}
public void OnLogin(string senderId, LoginPayload loginPayload)
{
Console.WriteLine(">> Login");
var player = new Player(uidCounter++, loginPayload.Name, new Position(0f, 0f, 0f));
players[player.Uid] = player;
var loginResponseRpc = new LoginResponse(new LoginResponsePayload(player.Uid));
var loginResponseJson = JsonConvert.SerializeObject(loginResponseRpc);
sendTo(loginResponseJson, senderId);
Console.WriteLine(player.ToString() + " login.");
}
public async Task LoginAsync_PassValidCredentials_ReturnSuccess()
{
var collection = GetCollection().BuildServiceProvider();
var authLogin = collection.GetService <IAuthenticationService>();
var tokengenerator = collection.GetService <ITokenGenerator>();
var payload = new LoginPayload
{
Username = "******",
Password = "******"
};
var tokenResult = await authLogin.LoginAsync(payload);
Assert.Equals(ResourceCodes.Success, tokenResult.Code);
}
public async Task <UserProxy> Login(LoginPayload payload)
{
var user = await _userRepository.GetByUsarname(payload.Username);
if (user == null)
{
throw new InvalidProgramException("Usuário não encontrado.");
}
if (user.Password != payload.Password.CalculateMd5Hash())
{
throw new InvalidProgramException("Senha inválida.");
}
return(new UserProxy().EntityToProxy(user));
}
/// <summary>
/// Converts an audit event to a device event
/// </summary>
/// <param name="auditEvent">The audit event to be converted</param>
/// <returns>Device event based on the input</returns>
private IEvent AuditEventToDeviceEvent(AuditEvent auditEvent)
{
string remoteAddress = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Address, throwIfNotExist: false);
LoginPayload payload = new LoginPayload
{
Executable = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Executable),
ProcessId = Convert.ToUInt32(auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.ProcessId)),
UserId = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.LoginUserId, throwIfNotExist: false),
UserName = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Account, throwIfNotExist: false),
Result = GetAuditEventLoginResult(auditEvent),
RemoteAddress = remoteAddress == "?" ? null : remoteAddress,
Operation = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Operation, throwIfNotExist: false)
};
return(new Login(Priority, payload, auditEvent.TimeUTC));
}
public async Task <string> LoginAsync(LoginPayload payload)
{
var login = await userManager.FindByEmailAsync(payload.Email);
if (login is null)
{
throw new AuthException("Email Or Password Is Incorrect");
}
var result = await signInManager.CheckPasswordSignInAsync(login, payload.Password, false);
if (result.Succeeded)
{
return(tokenizer.GenerateToken(("ID", login.UserID), ("Email", login.Email)));
}
throw new AuthException("Email Or Password Is Incorrect");
}
public LoginResponsePayload Login(LoginPayload payload)
{
User user = _usersRep.FindOneAsync(x => x.Login == payload.Login).Result;
if (user == null)
{
return(new LoginResponsePayload("error", "Login does not exist!"));
}
if (!VerifyUserPassword(user, payload.Password))
{
return(new LoginResponsePayload("error", "Password is invalid!"));
}
_currentUser = user;
UserInfo currentUserInfo = new UserInfo(_currentUser.Id.ToString(), _currentUser.Login, _currentUser.FirstName, _currentUser.LastName, _currentUser.AssistantChatId, _currentUser.BirthDate);
return(new LoginResponsePayload("success", "logged in successfully", Guid.NewGuid().ToString(), currentUserInfo));
}
public ActionResult <User> Login([FromBody] LoginPayload loginPayload)
{
var foundUser = _db.Users.SingleOrDefault(u => u.Email == loginPayload.Email);
if (foundUser != null)
{
if (BC.Verify(loginPayload.Password, foundUser.PasswordHash))
{
var tokenString = GenerateJSONWebToken(foundUser);
return(new JsonResult(new { status = true, foundUser.FirstName, foundUser.Id }));
}
return(new JsonResult(new { status = false, message = "Wrong password or email" }));
}
else
{
return(new JsonResult(new { status = false, message = "User does not exist" }));
}
}
public async Task <IActionResult> Login([FromBody] LoginPayload loginPayload)
{
var foundUser = _db.Users
.SingleOrDefault(u => u.Email == loginPayload.Email);
if (foundUser != null)
{
if (BC.Verify(loginPayload.Password, foundUser.PasswordHash))
{
var tokenString = GenerateJSONWebToken(foundUser);
return(Ok(new { status = true, token = tokenString }));
}
return(BadRequest(new { status = false, message = "wrond email or password" }));
}
else
{
return(BadRequest(new { status = false, message = "no user with this email found" }));
}
}
public IActionResult Login(LoginPayload payload)
{
if (!_db.StudentExists(payload.IndexNumber))
{
return(Unauthorized("User not found"));
}
var SecurityData = _db.GetStudentSecurityData(payload.IndexNumber);
Console.WriteLine(SecurityData.PasswordHash);
if (String.IsNullOrEmpty(SecurityData.PasswordHash))
{
var Salt = HashingService.GenerateSalt();
_db.UpdatePassword(
payload.IndexNumber,
Salt,
HashingService.Hash(payload.PlainPassword, Salt)
);
}
else if (!HashingService.Check(
payload.PlainPassword,
SecurityData.Salt,
SecurityData.PasswordHash
))
{
return(Unauthorized("Wrong password"));
}
var RefreshToken = Guid.NewGuid();
_db.UpdateRefreshToken(payload.IndexNumber, RefreshToken.ToString());
return(Ok(new
{
AccessToken = new JwtSecurityTokenHandler().WriteToken(_security.GenerateToken(
payload.IndexNumber,
SecurityData.Role
)),
RefreshToken = RefreshToken
}));
}
public async Task <(bool, UserDTO?)> VerifyUserLoginAsync(LoginPayload payload, CancellationToken ct = default)
{
var result = await _users.FindAsync(user => user.Email !.Equals(payload.Email), null, ct);
var user = result.FirstOrDefault(ct);
if (user is null)
{
return(false, null);
}
return(
BCryptNet.EnhancedVerify(payload.Password, user.Password),
new UserDTO
{
Email = user.Email,
LastName = user.LastName,
Name = user.Name,
Id = user.Id
}
);
}
public static RegisterPersonRequest FromVisitor(Visitor visitor, LoginPayload loginPayload)
{
return(new RegisterPersonRequest()
{
vFirst_name = visitor.FirstName,
vLast_name = visitor.LastName,
vBirth_number = visitor.RC,
vEmail = visitor.Email,
vPhone_number = visitor.Phone,
vMunicipality = visitor.City,
vStreet = visitor.Street,
vStreet_number = visitor.StreetNo,
vPostal_code = visitor.ZIP,
vHealth_insurance_company = visitor.Insurance,
dBirth_date = $"{visitor.BirthDayYear}-{visitor.BirthDayMonth:D2}-{visitor.BirthDayDay:D2}",
vEntered_by_first_name = loginPayload.User.FirstName,
vEntered_by_last_name = loginPayload.User.LastName,
vEntered_by_email = loginPayload.User.PrimaryEmail,
nIs_mom_user = "******",
});
}
public async Task <ActionResult> Register([FromBody] LoginPayload payload)
{
try
{
var m = new MailAddress(payload.Email);
}
catch (Exception)
{
return(new JsonResult(new { status = false, message = "email format " + payload.Email }));
}
try
{
var existingUserWithMail = _db.Users
.Any(u => u.Email == payload.Email);
if (existingUserWithMail)
{
return(new JsonResult(new { status = false, message = "An account with this email already exists " }));
}
var userToCreate = new User
{
Email = payload.Email,
Password = BCrypt.Net.BCrypt.HashPassword(payload.Password),
Nume = payload.Nume
};
await _db.Users.AddAsync(userToCreate);
await _db.SaveChangesAsync();
return(Ok());
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(new JsonResult(new { error = ex.Message }));
}
}
public async Task <TokenProxy> Login(LoginPayload payload)
{
var userEntity = await _usersRepository.GetByLogin(payload.Username);
if (userEntity == null)
{
throw new InvalidArgumentException("Usuário ou senha inválidos!",
(int)ExceptionEnum.NotFound);
}
if (userEntity.Password != payload.Password.CalculateMd5Hash())
{
throw new InvalidArgumentException("Usuário ou senha inválidos!",
(int)ExceptionEnum.NotFound);
}
var jwtToken = JwtSecurityToken(userEntity);
var tokenProxy = CreateTokenProxy(jwtToken);
return(tokenProxy);
}
public void Login()
{
var payload = new LoginPayload
{
Executable = "app.exe",
UserName = "******",
UserId = "500",
LocalPort = "900",
Operation = "opX",
ProcessId = 3,
RemoteAddress = "10.0.0.1",
RemotePort = "70",
Result = LoginPayload.LoginResult.Fail
};
foreach (LoginPayload.LoginResult value in Enum.GetValues(typeof(LoginPayload.LoginResult)))
{
payload.Result = value;
var obj = new Login(EventPriority.Low, payload, DateTime.UtcNow);
obj.ValidateSchema();
}
}
public IHttpActionResult Login(LoginPayload bodyPayload)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var adminUser = _userRepository.getAdminUser();
if (bodyPayload.email != adminUser.email)
{
return(Unauthorized());
}
var cookie = new HttpCookie("user-token", new JWTServices().generateJWTToken(adminUser));
cookie.Expires = DateTime.Now.AddHours(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
cookie.HttpOnly = true;
HttpContext.Current.Response.SetCookie(cookie);
return(Json(adminUser));
}
