public async Task <NexusUser> LoginAsync(NexusUserCredential userCredential, CancellationToken token = default)
{
token.ThrowIfCancellationRequested();
userCredential.Validate();
var param = new Dictionary <string, string>
{
{ "username", userCredential.Username },
{ "password", userCredential.Password }
};
if (userCredential.Pin.HasValue)
{
param.Add("pin", userCredential.Pin.Value.ToString());
}
var genesisId = await PostAsync <GenesisId>("accounts/login", new NexusRequest(param), token);
if (string.IsNullOrWhiteSpace(genesisId?.Session))
{
throw new InvalidOperationException($"{userCredential.Username} login failed");
}
return(new NexusUser
{
GenesisId = genesisId,
Pin = userCredential.Pin
});
}
public async Task <IActionResult> Create(CreateAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var cred = new NexusUserCredential
{
Username = model.Username,
Password = model.Password,
Pin = model.Pin
};
await _userManager.CreateAccount(HttpContext, cred, model.AutoLogin);
return(RedirectToAction("index", "node"));
}
catch (Exception e)
{
ModelState.AddModelError("summary", e.Message);
return(View(model));
}
}
public async Task LoginAsync(HttpContext httpContext, NexusUserCredential user, bool isPersistent = false, CancellationToken token = default)
{
var accountService = await _serviceFactory.GetAsync <AccountService>(httpContext);
var nexusUser = await accountService.LoginAsync(user, token);
if (nexusUser == null)
{
return;
}
nexusUser.Username = user.Username;
httpContext.Session.SetString(_cookieConstants.GenesisIdKey, nexusUser.GenesisId.Genesis);
httpContext.Session.SetString(_cookieConstants.SessionIdKey, nexusUser.GenesisId.Session);
httpContext.Session.SetString(_cookieConstants.UsernameKey, nexusUser.Username);
if (httpContext.User.Identity.IsAuthenticated)
{
((ClaimsIdentity)httpContext.User.Identity).AddClaims(AddUserClaims(nexusUser));
await httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, httpContext.User);
}
else
{
var identity = new ClaimsIdentity(AddUserClaims(nexusUser), CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
}
}
public async Task CreateAccount(HttpContext httpContext, NexusUserCredential user, bool login = false, CancellationToken token = default)
{
var accountService = await _serviceFactory.GetAsync <AccountService>(httpContext);
var genesisId = await accountService.CreateAccountAsync(user, token);
if (genesisId != null && login)
{
await LoginAsync(httpContext, user, false, token);
}
}
public static void Validate(this NexusUserCredential userCredential)
{
if (userCredential == null)
{
throw new ArgumentException("User credential is required");
}
if (string.IsNullOrWhiteSpace(userCredential.Username))
{
throw new ArgumentException("Username is required");
}
if (string.IsNullOrWhiteSpace(userCredential.Password))
{
throw new ArgumentException("Password is required");
}
if (!userCredential.Pin.HasValue)
{
throw new ArgumentException("PIN is required");
}
}
public async Task <GenesisId> CreateAccountAsync(NexusUserCredential userCredential, CancellationToken token = default)
{
token.ThrowIfCancellationRequested();
userCredential.Validate();
var request = new NexusRequest(new Dictionary <string, string>
{
{ "username", userCredential.Username },
{ "password", userCredential.Password },
{ "pin", userCredential.Pin.ToString() }
});
var tx = await PostAsync <Transaction>("accounts/create", request, token);
if (string.IsNullOrWhiteSpace(tx?.Genesis))
{
throw new InvalidOperationException($"Create account {userCredential.Username} failed");
}
return(new GenesisId {
Genesis = tx.Genesis
});
}
