public async Task <IActionResult> Login([FromBody] Login.Request req, [FromServices] AuthDBContext authDB)
{
// la: LocalAccount
var account = await authDB.Accounts.FindAsync(req.account);
if (account == null)
{ // Not find account
return(Ok(new Login.Response
{
resultCode = ProtocolModels.Auth.Login.Response.ResultCode.Ng
}));
}
if (account.hashedPassword != evolib.Util.Hasher.ToPbkdf2(req.password, account.salt))
{ // Mismatch password
return(Ok(new Login.Response
{
resultCode = ProtocolModels.Auth.Login.Response.ResultCode.Ng
}));
}
return(Ok(new Login.Response
{
resultCode = ProtocolModels.Auth.Login.Response.ResultCode.Ok,
account = account.account,
permission = account.permission,
nickname = account.nickname,
hostType = account.hostType,
}));
}
public async Task <IActionResult> Login([FromBody] Login.Request req)
{
var requester = new AuthenticationServer.ProtocolModels.Auth.Login();
requester.request.account = req.account;
requester.request.password = req.password;
var response = await requester.PostAsync(AuthenticationServerInfo.Uri);
if (response == null)
{
return(BuildErrorResponse("SeverInternalError"));
}
if (response.resultCode == AuthenticationServer.ProtocolModels.Auth.Login.Response.ResultCode.Ng)
{
return(BuildErrorResponse("NgAuth"));
}
var toolAccount = new KvsModels.ToolAccount(response.account);
toolAccount.Model.signingKey = evolib.Util.KeyGen.Get(32);
toolAccount.Model.lastAuthDate = DateTime.UtcNow;
await toolAccount.SaveAsync();
var payload = new EvoToolJwt.Payload();
payload.accountId = response.account;
var token = EvoToolJwt.Build(payload, toolAccount.Model.signingKey);
return(Ok(new Login.Response
{
token = token,
}));
}
public async Task <ActionResult <AuthData> > Login(Login.Request request)
{
var result = await _mediator.Send(request);
if (result != null)
{
return(result);
}
return(Unauthorized("Unable to authorize user"));
}
public async Task CanGetToken()
{
var loginRequest = new Login.Request()
{
Email = UserEmail, Password = Password
};
var response = await client.PostAsync("/api/auth/login", HttpClientUtils.CreateContent(loginRequest));
var data = await response.Content.ReadFromJsonAsync <AuthData>();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsNotNull(data);
Assert.IsTrue(!string.IsNullOrEmpty(data.Token));
}
public async Task <Result <string, Error> > Login(Login.Request request)
{
var user = await _userManager.FindByEmailAsync(request.Email.ToString());
if (user == null)
{
return(Result.Failure <string, Error>(new Error.BadRequest("Invalid login attempt")));
}
var result = await _signInManager.PasswordSignInAsync(user, request.Password, isPersistent : false, lockoutOnFailure : false);
if (result.Succeeded == false)
{
return(Result.Failure <string, Error>(new Error.BadRequest("Invalid login attempt")));
}
return(Result.Success <string, Error>(await GenerateSerializedSecurityTokenForUserWithEmail(request.Email)));
}
public async Task Initialize()
{
factory = new CustomWebApplicationFactory <Startup>();
client = factory.CreateClient(new WebApplicationFactoryClientOptions
{
BaseAddress = new Uri(BaseURL)
});
var loginRequest = new Login.Request()
{
Email = UserEmail, Password = Password
};
var response = await client.PostAsync("/api/auth/login", HttpClientUtils.CreateContent(loginRequest));
var data = await response.Content.ReadFromJsonAsync <AuthData>();
clientUser = factory.CreateClient(new WebApplicationFactoryClientOptions
{
BaseAddress = new Uri(BaseURL)
});
clientUser.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", data.Token);
}
public async Task <Login.Response> Login(Login.Request loginRequest, CancellationToken cancellationToken)
{
var user = await _repository.FindWhere(u => u.Name == loginRequest.Name, cancellationToken);
if (user == null)
{
throw new UserNotFoundException(loginRequest.Name);
}
if (!user.Password.Equals(loginRequest.Password))
{
throw new NoRightsException("Нет прав");
}
var claims = new List <Claim>
{
new(ClaimTypes.Name, loginRequest.Name),
new(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var token = new JwtSecurityToken
(
claims: claims,
expires: DateTime.UtcNow.AddDays(60),
notBefore: DateTime.UtcNow,
signingCredentials: new SigningCredentials(
new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Token:Key"])),
SecurityAlgorithms.HmacSha256
)
);
return(new Login.Response
{
Token = new JwtSecurityTokenHandler().WriteToken(token)
});
}
public async Task <string> Login(Login.Request request)
{
return(await _mediator.Send(request));
}
public Task <Login.Response> Login([FromBody] Login.Request request) => _mediator.Send(request);
public async Task <IActionResult> Login([FromBody] Login.Request req)
{
var accountType = evolib.Account.Type.Unknown;
var account = "";
var hostType = evolib.HostType.Unknown;
var accountAccessToken = "";
var countryCode = "";
if (req.password == SystemInfo.BattleServerPassword)
{
account = "ba8b168a-71f2-4fd4-82e3-e427b5714899";
hostType = HostType.BattleServer;
}
else if (req.accountType == evolib.Account.Type.Inky)
{
{ // POST login
var requester = new evolib.Multiplatform.Inky.Login1();
requester.request.temporary_token = req.authToken;
var response = await requester.PostAsync(req.authToken);
if (response.StatusCode == System.Net.HttpStatusCode.OK && response.Payload.status == "success")
{
accountAccessToken = response.Payload.data.access_token;
}
else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
return(BuildErrorResponse(Error.LowCode.NgAuth));
}
else
{
return(BuildErrorResponse(Error.LowCode.ServerInternalError));
}
}
{ // GET accounts/me
var requester = new evolib.Multiplatform.Inky.AccountsMe();
var response = await requester.GetAsync(accountAccessToken);
if (response.StatusCode == System.Net.HttpStatusCode.OK && response.Payload.status == "success")
{
account = response.Payload.data.uid.ToString();
countryCode = response.Payload.data.country_code;
}
else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
return(BuildErrorResponse(Error.LowCode.NgAuth));
}
else
{
return(BuildErrorResponse(Error.LowCode.ServerInternalError));
}
}
accountType = req.accountType;
hostType = evolib.HostType.Player;
}
#if DEBUG
else if (System.Text.RegularExpressions.Regex.IsMatch(req.account, @"^LoadTester([0-9]|[1-9][0-9]{1,5})@BNO$"))
{
await Task.Delay(500);
account = req.account;
hostType = HostType.Player;
accountType = evolib.Account.Type.LoadTest;
countryCode = "JP";
}
else
{
var requester = new AuthenticationServer.ProtocolModels.Auth.Login();
requester.request.account = req.account;
requester.request.password = req.password;
var response = await requester.PostAsyncXXX(AuthenticationServerInfo.Uri);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(BuildErrorResponse(Error.LowCode.ServerInternalError));
}
if (response.Payload.resultCode == AuthenticationServer.ProtocolModels.Auth.Login.Response.ResultCode.Ng)
{
return(BuildErrorResponse(Error.LowCode.NgAuth));
}
account = response.Payload.account;
hostType = response.Payload.hostType;
accountType = evolib.Account.Type.Dev1;
countryCode = "JP";
}
public async Task <IActionResult> Login(Login.Request request)
{
var result = await _identityService.Login(request);
return(result.MatchToActionResult(v => Ok(v)));
}
