/// <summary>
/// Adds a Discord user to the database.
/// </summary>
/// <param name="discordUser">The Discord user.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>The freshly created information about the user.</returns>
/// <exception cref="ArgumentException">Thrown if the user already exists in the database.</exception>
public async Task <RetrieveEntityResult <User> > AddUserAsync
(
IUser discordUser,
CancellationToken ct = default
)
{
if (discordUser.IsBot || discordUser.IsWebhook)
{
return(RetrieveEntityResult <User> .FromError
(
"Users cannot be viewed or created for bots or webhooks."
));
}
if (await IsUserKnownAsync(discordUser, ct))
{
return(RetrieveEntityResult <User> .FromError
(
$"A user with the ID {discordUser.Id} has already been added to the database."
));
}
var newUser = _database.CreateProxy <User>((long)discordUser.Id);
_database.Users.Update(newUser);
await _database.SaveChangesAsync(ct);
return(newUser);
}
/// <summary>
/// Grants consent to store user data for a given user.
/// </summary>
/// <param name="discordUser">The user that has granted consent.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>A task that must be awaited.</returns>
public async Task <Result <UserConsent> > GrantUserConsentAsync
(
Snowflake discordUser,
CancellationToken ct = default
)
{
var getConsent = await GetUserConsentAsync(discordUser, ct);
UserConsent userConsent;
if (!getConsent.IsSuccess)
{
userConsent = _database.CreateProxy <UserConsent>(discordUser);
_database.UserConsents.Update(userConsent);
userConsent.HasConsented = true;
}
else
{
userConsent = getConsent.Entity;
userConsent.HasConsented = true;
}
await _database.SaveChangesAsync(ct);
return(userConsent);
}
public async Task <RetrieveEntityResult <User> > AddUserAsync([NotNull] IUser discordUser)
{
if (discordUser.IsBot || discordUser.IsWebhook)
{
return(RetrieveEntityResult <User> .FromError
(
"Users cannot be viewed or created for bots or webhooks."
));
}
if (await IsUserKnownAsync(discordUser))
{
return(RetrieveEntityResult <User> .FromError
(
$"A user with the ID {discordUser.Id} has already been added to the database."
));
}
var newUser = new User((long)discordUser.Id);
_database.Users.Update(newUser);
await _database.SaveChangesAsync();
// Requery the database
return(await GetUserAsync(discordUser));
}
public async Task <IActionResult> PutQuestion([FromRoute] int id, [FromBody] Question question)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != question.QuestionId)
{
return(BadRequest());
}
_context.Entry(question).State = EntityState.Modified;
try
{
var stat = await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (!QuestionExists(id))
{
return(NotFound());
}
else
{
return(Forbid());
}
}
return(Ok());
}
public async Task <IActionResult> Create([Bind("QuizId,QuizName")] Quiz quiz)
{
if (ModelState.IsValid)
{
_context.Add(quiz);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(quiz));
}
/// <summary>
/// Adds a Discord server to the database.
/// </summary>
/// <param name="discordServer">The Discord server.</param>
/// <returns>The freshly created information about the server.</returns>
/// <exception cref="ArgumentException">Thrown if the server already exists in the database.</exception>
public async Task <RetrieveEntityResult <Server> > AddServerAsync(IGuild discordServer)
{
if (await IsServerKnownAsync(discordServer))
{
return(RetrieveEntityResult <Server> .FromError
(
$"A server with the ID {discordServer.Id} has already been added to the database."
));
}
var server = Server.CreateDefault(discordServer);
await _database.Servers.AddAsync(server);
await _database.SaveChangesAsync();
return(RetrieveEntityResult <Server> .FromSuccess(server));
}
/// <summary>
/// Grants consent to store user data for a given user.
/// </summary>
/// <param name="discordUser">The user that has granted consent.</param>
/// <returns>A task that must be awaited.</returns>
public async Task GrantUserConsentAsync(IUser discordUser)
{
var userConsent = await _database.UserConsents.FirstOrDefaultAsync(uc => uc.DiscordID == (long)discordUser.Id);
if (userConsent is null)
{
userConsent = new UserConsent((long)discordUser.Id)
{
HasConsented = true
};
await _database.UserConsents.AddAsync(userConsent);
}
else
{
userConsent.HasConsented = true;
}
await _database.SaveChangesAsync();
}
/// <summary>
/// Adds a Discord user to the database.
/// </summary>
/// <param name="discordUser">The Discord user.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>The freshly created information about the user.</returns>
/// <exception cref="ArgumentException">Thrown if the user already exists in the database.</exception>
public async Task <Result <User> > AddUserAsync
(
Snowflake discordUser,
CancellationToken ct = default
)
{
if (await IsUserKnownAsync(discordUser, ct))
{
return(new UserError
(
$"A user with the ID {discordUser} has already been added to the database."
));
}
var newUser = _database.CreateProxy <User>(discordUser);
_database.Users.Update(newUser);
await _database.SaveChangesAsync(ct);
return(newUser);
}
/// <summary>
/// Adds a Discord server to the database.
/// </summary>
/// <param name="discordServer">The Discord server.</param>
/// <param name="ct">The cancellation token in use.</param>
/// <returns>The freshly created information about the server.</returns>
/// <exception cref="ArgumentException">Thrown if the server already exists in the database.</exception>
public async Task <RetrieveEntityResult <Server> > AddServerAsync
(
IGuild discordServer,
CancellationToken ct = default
)
{
if (await IsServerKnownAsync(discordServer, ct))
{
return(RetrieveEntityResult <Server> .FromError
(
$"A server with the ID {discordServer.Id} has already been added to the database."
));
}
var server = _database.CreateProxy <Server>((long)discordServer.Id);
_database.Servers.Update(server);
server.IsNSFW = true;
await _database.SaveChangesAsync(ct);
return(RetrieveEntityResult <Server> .FromSuccess(server));
}