public void SendAuth(AuthQuery myauth)
{
string json = JsonConvert.SerializeObject(myauth);
Logger.Debug("Sent an API Auth message serialized as: " + json);
Ws.Send(json);
}
public void websocketClient_Opened(object sender, EventArgs e)
{
_failing = false;
Logger.Info("Websocket: Connection to API established.");
if (Properties.Settings.Default.OAuthToken == null)
{
Logger.Error("Oops! I am attempting to connect without an OAuth token. That's probably bad.");
}
else
{
AuthQuery auth = new AuthQuery()
{
action = "authorization",
bearer = Properties.Settings.Default.OAuthToken
};
SendAuth(auth);
SubscribeStream("0xDEADBEEF");
APIQuery login = new APIQuery
{
action = "rescues:read",
data = new Dictionary <string, string> {
{ "open", "true" }
}
};
SendQuery(login);
Logger.Info("Sent RescueGrid Update request.");
}
//TODO: Put stream subscription messages here when Mecha goes live. Do we want to listen to ourselves?
}
public async Task <ActionResult <string> > GetSessionId(
[FromBody] AuthQuery authObj
)
{
this.logger.LogInformation("POST request /account/auth");
var res = await useCase.GetSessionId(authObj.Login, authObj.Password, authObj.SessionId);
if (res.IsSuccess)
{
return(Ok(res.GetOrNull()));
}
else if (res.IsFailure)
{
return((res.ExceptionOrNull()) switch
{
UnauthorizedAccessException e => Unauthorized(),
_ => StatusCode(500),
});
public async Task <ActionResult> Post([FromBody] AuthQuery query, string returnUrl = null)
{
if (query != null)
{
var result = await Authenticate(query);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(result);
}
}
HttpContext.Response.StatusCode = 401;
HttpContext.Response.Headers["WWW-Authenticate"] = "Basic";
return(new EmptyResult());
}
private async Task <ActionResult> Authenticate(AuthQuery query)
{
var passwd = new PasswdResponse {
User = query.User
};
_logger.LogInformation("User: {0} logged", query.User);
//TODO: Crete user manager or use Microsoft identity
if (/*new UserManager().IsValid(username, password)*/ true)
{
var claims = new List <Claim> {
new Claim(ClaimTypes.NameIdentifier, query.User),
new Claim(ClaimTypes.Name, query.User),
// optionally you could add roles if any
//new Claim(ClaimTypes.Role, "RoleName"),
//new Claim(ClaimTypes.Role, "AnotherRole"),
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
passwd.Authenticated = true;
return(Ok(passwd));
}
// invalid username or password
ModelState.AddModelError("", "invalid username or password");
passwd.Authenticated = false;
return(new JsonResult(passwd)
{
StatusCode = 401
});
}
public async Task <ActionResult> Get(string returnUrl = null)
{
string authHeader = HttpContext.Request.Headers["Authorization"];
if (authHeader != null && authHeader.StartsWith("basic", StringComparison.OrdinalIgnoreCase))
{
var token = authHeader.Substring("Basic ".Length).Trim();
var credentialstring = Encoding.UTF8.GetString(Convert.FromBase64String(token));
int seperatorIndex = credentialstring.IndexOf(':');
var username = credentialstring.Substring(0, seperatorIndex);
var password = credentialstring.Substring(seperatorIndex + 1);
var query = new AuthQuery {
User = username, Password = password
};
var result = await Authenticate(query);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(result);
}
}
else
{
HttpContext.Response.StatusCode = 401;
HttpContext.Response.Headers["WWW-Authenticate"] = "Basic";
return(new EmptyResult());
}
}
public async Task <ActionResult> Login([FromBody] AuthQuery query) => Ok(await Handle(query));
protected async Task <Result> SendAuthQuery <Result>(AuthQuery <Result> query) where Result : new()
{
query.SetUserId(User.Identity.GetId());
return(await Mediator.Send(query));
}
