/// <summary> /// Creates the settings for the given Discord guild. /// </summary> /// <param name="guildID">The ID of the guild.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <Result <ServerModerationSettings> > CreateServerSettingsAsync ( Snowflake guildID, CancellationToken ct = default ) { var existingEntity = await GetServerSettingsAsync(guildID, ct); if (existingEntity.IsSuccess) { return(new UserError("That server already has settings.")); } var getServer = await _servers.GetOrRegisterServerAsync(guildID, ct); if (!getServer.IsSuccess) { return(Result <ServerModerationSettings> .FromError(getServer)); } var server = getServer.Entity; var settings = _database.CreateProxy <ServerModerationSettings>(server); _database.ServerSettings.Update(settings); await _database.SaveChangesAsync(ct); return(settings); }
/// <summary> /// Creates the settings for the given Discord guild. /// </summary> /// <param name="discordServer">The server.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <CreateEntityResult <ServerModerationSettings> > CreateServerSettingsAsync ( IGuild discordServer ) { var existingEntity = await GetServerSettingsAsync(discordServer); if (existingEntity.IsSuccess) { return(CreateEntityResult <ServerModerationSettings> .FromError("That server already has settings.")); } var getServer = await _servers.GetOrRegisterServerAsync(discordServer); if (!getServer.IsSuccess) { return(CreateEntityResult <ServerModerationSettings> .FromError(getServer)); } var server = getServer.Entity; var settings = new ServerModerationSettings(server); _database.ServerSettings.Update(settings); await _database.SaveChangesAsync(); return(settings); }
/// <summary> /// Creates a note for the given user. /// </summary> /// <param name="authorUser">The author of the note.</param> /// <param name="guildUser">The user.</param> /// <param name="content">The content of the note.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <CreateEntityResult <UserNote> > CreateNoteAsync ( IUser authorUser, IGuildUser guildUser, string content ) { var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild); if (!getServer.IsSuccess) { return(CreateEntityResult <UserNote> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(guildUser); if (!getUser.IsSuccess) { return(CreateEntityResult <UserNote> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorUser); if (!getAuthor.IsSuccess) { return(CreateEntityResult <UserNote> .FromError(getAuthor)); } var author = getAuthor.Entity; var note = new UserNote(server, user, author, string.Empty); var setContent = await SetNoteContentsAsync(note, content); if (!setContent.IsSuccess) { return(CreateEntityResult <UserNote> .FromError(setContent)); } _database.UserNotes.Update(note); await _database.SaveChangesAsync(); // Requery the database var getNote = await GetNoteAsync(guildUser.Guild, note.ID); if (!getNote.IsSuccess) { return(CreateEntityResult <UserNote> .FromError(getNote)); } return(CreateEntityResult <UserNote> .FromSuccess(getNote.Entity)); }
/// <summary> /// Creates a note for the given user. /// </summary> /// <param name="authorID">The ID of the author of the warning.</param> /// <param name="userID">The ID of the warned user.</param> /// <param name="guildID">The ID of the guild the user is on.</param> /// <param name="content">The content of the note.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <Result <UserNote> > CreateNoteAsync ( Snowflake authorID, Snowflake userID, Snowflake guildID, string content, CancellationToken ct = default ) { var getServer = await _servers.GetOrRegisterServerAsync(guildID, ct); if (!getServer.IsSuccess) { return(Result <UserNote> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(userID, ct); if (!getUser.IsSuccess) { return(Result <UserNote> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorID, ct); if (!getAuthor.IsSuccess) { return(Result <UserNote> .FromError(getAuthor)); } var author = getAuthor.Entity; var note = _database.CreateProxy <UserNote>(server, user, author, string.Empty); _database.UserNotes.Update(note); var setContent = await SetNoteContentsAsync(note, content, ct); if (!setContent.IsSuccess) { return(Result <UserNote> .FromError(setContent)); } await _database.SaveChangesAsync(ct); return(note); }
/// <summary> /// Creates a warning for the given user. /// </summary> /// <param name="authorUser">The author of the warning.</param> /// <param name="guildUser">The user.</param> /// <param name="reason">The reason of the warning.</param> /// <param name="messageID">The message that caused the warning, if any.</param> /// <param name="expiresOn">The expiry date for the warning, if any.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <CreateEntityResult <UserWarning> > CreateWarningAsync ( IUser authorUser, IGuildUser guildUser, string reason, long?messageID = null, DateTime?expiresOn = null, CancellationToken ct = default ) { var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild, ct); if (!getServer.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(guildUser, ct); if (!getUser.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorUser, ct); if (!getAuthor.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getAuthor)); } var author = getAuthor.Entity; var warning = _database.CreateProxy <UserWarning>(server, user, author, string.Empty, null, null); _database.UserWarnings.Update(warning); var setReason = await SetWarningReasonAsync(warning, reason, ct); if (!setReason.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setReason)); } if (!(messageID is null)) { var setMessage = await SetWarningContextMessageAsync(warning, messageID.Value, ct); if (!setMessage.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setMessage)); } } if (!(expiresOn is null)) { var setExpiry = await SetWarningExpiryDateAsync(warning, expiresOn.Value, ct); if (!setExpiry.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setExpiry)); } } await _database.SaveChangesAsync(ct); return(warning); }
/// <summary> /// Creates a ban for the given user. /// </summary> /// <param name="authorUser">The author of the ban.</param> /// <param name="guildUser">The user.</param> /// <param name="reason">The reason of the ban.</param> /// <param name="messageID">The message that caused the ban, if any.</param> /// <param name="expiresOn">The expiry date for the ban, if any.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <CreateEntityResult <UserBan> > CreateBanAsync ( IUser authorUser, IGuildUser guildUser, string reason, long?messageID = null, DateTime?expiresOn = null ) { var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild); if (!getServer.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(guildUser); if (!getUser.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorUser); if (!getAuthor.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(getAuthor)); } var author = getAuthor.Entity; var ban = new UserBan(server, user, author, string.Empty); var setReason = await SetBanReasonAsync(ban, reason); if (!setReason.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(setReason)); } if (!(messageID is null)) { var setMessage = await SetBanContextMessageAsync(ban, messageID.Value); if (!setMessage.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(setMessage)); } } if (!(expiresOn is null)) { var setExpiry = await SetBanExpiryDateAsync(ban, expiresOn.Value); if (!setExpiry.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(setExpiry)); } } _database.UserBans.Update(ban); await _database.SaveChangesAsync(); // Requery the database var getBan = await GetBanAsync(guildUser.Guild, ban.ID); if (!getBan.IsSuccess) { return(CreateEntityResult <UserBan> .FromError(getBan)); } return(CreateEntityResult <UserBan> .FromSuccess(getBan.Entity)); }
/// <summary> /// Creates a ban for the given user. /// </summary> /// <param name="authorID">The ID of the author of the warning.</param> /// <param name="userID">The ID of the warned user.</param> /// <param name="guildID">The ID of the guild the user is on.</param> /// <param name="reason">The reason of the ban.</param> /// <param name="messageID">The message that caused the ban, if any.</param> /// <param name="expiresOn">The expiry date for the ban, if any.</param> /// <param name="ct">The cancellation token in use.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <Result <UserBan> > CreateBanAsync ( Snowflake authorID, Snowflake userID, Snowflake guildID, string reason, Snowflake?messageID = null, DateTimeOffset?expiresOn = null, CancellationToken ct = default ) { var getServer = await _servers.GetOrRegisterServerAsync(guildID, ct); if (!getServer.IsSuccess) { return(Result <UserBan> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(userID, ct); if (!getUser.IsSuccess) { return(Result <UserBan> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorID, ct); if (!getAuthor.IsSuccess) { return(Result <UserBan> .FromError(getAuthor)); } var author = getAuthor.Entity; var ban = _database.CreateProxy <UserBan>(server, user, author, string.Empty, null !, null !); _database.UserBans.Update(ban); var setReason = await SetBanReasonAsync(ban, reason, ct); if (!setReason.IsSuccess) { return(Result <UserBan> .FromError(setReason)); } if (messageID is not null) { var setMessage = await SetBanContextMessageAsync(ban, messageID.Value, ct); if (!setMessage.IsSuccess) { return(Result <UserBan> .FromError(setMessage)); } } if (expiresOn is not null) { var setExpiry = await SetBanExpiryDateAsync(ban, expiresOn.Value, ct); if (!setExpiry.IsSuccess) { return(Result <UserBan> .FromError(setExpiry)); } } await _database.SaveChangesAsync(ct); return(ban); }
/// <summary> /// Creates a warning for the given user. /// </summary> /// <param name="authorUser">The author of the warning.</param> /// <param name="guildUser">The user.</param> /// <param name="reason">The reason of the warning.</param> /// <param name="messageID">The message that caused the warning, if any.</param> /// <param name="expiresOn">The expiry date for the warning, if any.</param> /// <returns>A creation result which may or may not have succeeded.</returns> public async Task <CreateEntityResult <UserWarning> > CreateWarningAsync ( [NotNull] IUser authorUser, [NotNull] IGuildUser guildUser, [NotNull] string reason, [CanBeNull] long?messageID = null, [CanBeNull] DateTime?expiresOn = null ) { var getServer = await _servers.GetOrRegisterServerAsync(guildUser.Guild); if (!getServer.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getServer)); } var server = getServer.Entity; var getUser = await _users.GetOrRegisterUserAsync(guildUser); if (!getUser.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getUser)); } var user = getUser.Entity; var getAuthor = await _users.GetOrRegisterUserAsync(authorUser); if (!getAuthor.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getAuthor)); } var author = getAuthor.Entity; var warning = new UserWarning(server, user, author, string.Empty); var setReason = await SetWarningReasonAsync(warning, reason); if (!setReason.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setReason)); } if (!(messageID is null)) { var setMessage = await SetWarningContextMessageAsync(warning, messageID.Value); if (!setMessage.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setMessage)); } } if (!(expiresOn is null)) { var setExpiry = await SetWarningExpiryDateAsync(warning, expiresOn.Value); if (!setExpiry.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(setExpiry)); } } _database.UserWarnings.Update(warning); await _database.SaveChangesAsync(); // Requery the database var getWarning = await GetWarningAsync(guildUser.Guild, warning.ID); if (!getWarning.IsSuccess) { return(CreateEntityResult <UserWarning> .FromError(getWarning)); } return(CreateEntityResult <UserWarning> .FromSuccess(getWarning.Entity)); }