public async Task create([QueryField] string username, [QueryField] string password)
{
if (username == null || password == null)
{
throw HttpException.BadRequest();
}
if (!validated)
{
throw HttpException.Forbidden();
}
// If a user already exists, it is not possible to create a new user
if (await getUser(username) != null)
{
throw HttpException.NotAcceptable();
}
var model = new AccountModel {
username = username.ToLower(), // :to_lower_thinking: - Taylor
permissions = new List <string> {
"Admin"
}
};
model.setPassword(password);
await accountCollection.InsertOneAsync(model);
}
public async Task delete([QueryField] string username)
{
if (username == null)
{
throw HttpException.BadRequest();
}
if (!validated)
{
throw HttpException.Forbidden();
}
var user = await getUser(username);
if (user == null)
{
throw HttpException.NotFound();
}
var result = await accountCollection.DeleteOneAsync(
Builders <AccountModel> .Filter.Eq(x => x.id, user.id));
if (result.DeletedCount != 1)
{
throw HttpException.InternalServerError();
}
}
/// <summary>
/// Checks the client.
/// </summary>
/// <param name="clientAddress">The client address.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task CheckClient(IPAddress clientAddress)
{
if (_whiteListBag.Contains(clientAddress))
{
return;
}
foreach (var criterion in _criterions)
{
var result = await criterion.ValidateIPAddress(clientAddress).ConfigureAwait(false);
if (!result)
{
continue;
}
TryBanIP(clientAddress, false);
break;
}
if (_blacklistDictionary.ContainsKey(clientAddress))
{
throw HttpException.Forbidden();
}
}
public async Task GetState([QueryField] bool?json, string tokenArg)
{
(ChatId, UserId)? token = ApiMessenger.ParseToken(tokenArg);
if (token == null)
{
throw HttpException.Forbidden();
}
var(_, user) = ((ChatId, UserId))token;
using var context = new UserContext(user);
var publicUser = new PublicUser(context.User);
var bytes = MessagePackSerializer.Serialize(publicUser);
if (json ?? false)
{
var response = MessagePackSerializer.ConvertToJson(bytes);
HttpContext.Response.ContentType = "application/json";
bytes = Encoding.UTF8.GetBytes(response);
}
else
{
HttpContext.Response.ContentType = "application/x-msgpack";
}
using (var stream = HttpContext.OpenResponseStream())
{
await stream.WriteAsync(bytes, 0, bytes.Length);
}
}
/// <inheritdoc />
protected override Task OnRequestAsync(IHttpContext context)
{
ClientAddress = context.Request.RemoteEndPoint.Address;
if (!Blacklist.ContainsKey(ClientAddress))
{
return(Task.CompletedTask);
}
context.SetHandled();
throw HttpException.Forbidden();
}
protected override async Task OnRequestAsync(IHttpContext context)
{
if (_restrictedPaths.Any(o => context.RequestedPath.StartsWith(o)))
{
throw HttpException.Forbidden();
}
else
{
await base.OnRequestAsync(context);
}
}
public string Register([QueryField] string secret, [QueryField] long?id)
{
if (secret != ApiMessenger._secret)
{
throw HttpException.Forbidden();
}
var userId = id ?? ApiMessenger.LongRandom();
using var context = new UserContext(new UserId(ApiMessenger.MessengerId, userId));
return($"{userId}:{context.User.Token}");
}
private async Task <object> Precheck(Func <Task <object> > function)
{
if (!Passcode.IsEmptyOrNull())
{
if (!HttpContext.HasRequestHeader("passcode"))
{
throw HttpException.Forbidden();
}
else
{
string matchcode = HttpContext.RequestHeader("Passcode");
if (matchcode != Passcode)
{
throw HttpException.Forbidden();
}
}
}
return(await function());
}
public async Task PostMessage(string tokenArg)
{
(ChatId, UserId)? token = ApiMessenger.ParseToken(tokenArg);
if (token == null)
{
throw HttpException.Forbidden();
}
var(chat, user) = ((ChatId, UserId))token;
var text = await HttpContext.GetRequestDataAsync <string>();
var message = new ReceivedMessage
{
ChatId = chat,
Text = text,
UserId = user
};
ApiMessenger.InvokeOnMessageReceived(message);
}
