public async Task DroneAsync(IGuildUser user)
{
if (!(this.Context.User is IGuildUser target))
{
await _feedback.SendErrorAsync(this.Context, "The target user wasn't a guild user.");
return;
}
var droneMessage = user == target
? _content.GetRandomSelfDroneMessage()
: _content.GetRandomTurnTheTablesMessage();
await _feedback.SendConfirmationAsync(this.Context, droneMessage);
var droneResult = await _drone.DroneUserAsync(target);
if (!droneResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, droneResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, _content.GetRandomConfirmationMessage());
}
public async Task AddConditionAsync(AutoroleConfiguration autorole, IRole role)
{
var condition = _autoroles.CreateConditionProxy <RoleCondition>
(
role
);
if (condition is null)
{
await _feedback.SendErrorAsync(this.Context, "Failed to create a condition object. Yikes!");
return;
}
var addCondition = await _autoroles.AddConditionAsync(autorole, condition);
if (!addCondition.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, addCondition.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Condition added.");
}
public async Task SetDedicatedRoleplayChannelCategory(ICategoryChannel category)
{
var getServerResult = await _servers.GetOrRegisterServerAsync(this.Context.Guild);
if (!getServerResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getServerResult.ErrorReason);
return;
}
var server = getServerResult.Entity;
var result = await _roleplaying.SetDedicatedRoleplayChannelCategoryAsync
(
server,
category
);
if (!result.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, result.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Dedicated channel category set.");
}
public async Task SetRoleplayNameAsync
(
string newRoleplayName,
[RequireEntityOwnerOrPermission(typeof(EditRoleplay), PermissionTarget.Other)]
Roleplay roleplay
)
{
var result = await _discordRoleplays.SetRoleplayNameAsync
(
roleplay,
newRoleplayName
);
if (!result.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, result.ErrorReason);
return;
}
var getDedicatedChannelResult = await _dedicatedChannels.GetDedicatedChannelAsync
(
this.Context.Guild,
roleplay
);
if (getDedicatedChannelResult.IsSuccess)
{
var dedicatedChannel = getDedicatedChannelResult.Entity;
await dedicatedChannel.ModifyAsync(p => p.Name = $"{roleplay.Name}-rp");
}
await _feedback.SendConfirmationAsync(this.Context, "Roleplay name set.");
}
public async Task AddBanAsync
(
[NotNull] IGuildUser user,
[NotNull] string reason,
TimeSpan?expiresAfter = null
)
{
DateTime?expiresOn = null;
if (!(expiresAfter is null))
{
expiresOn = DateTime.Now.Add(expiresAfter.Value);
}
var addBan = await _bans.CreateBanAsync(this.Context.User, user, reason, expiresOn : expiresOn);
if (!addBan.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, addBan.ErrorReason);
return;
}
var ban = addBan.Entity;
await this.Context.Guild.AddBanAsync((ulong)ban.User.DiscordID, reason : reason);
await _feedback.SendConfirmationAsync(this.Context, $"User banned (ban ID {ban.ID}).");
await _logging.NotifyUserBanned(ban);
}
public async Task ShowAvailablePronounFamiliesAsync()
{
EmbedFieldBuilder CreatePronounField(IPronounProvider pronounProvider)
{
var ef = new EmbedFieldBuilder();
ef.WithName(pronounProvider.Family);
var value = $"{pronounProvider.GetSubjectForm()} ate {pronounProvider.GetPossessiveAdjectiveForm()} " +
$"pie that {pronounProvider.GetSubjectForm()} brought with " +
$"{pronounProvider.GetReflexiveForm()}.";
value = value.Transform(To.SentenceCase);
ef.WithValue($"*{value}*");
return(ef);
}
var pronounProviders = _pronouns.GetAvailablePronounProviders().ToList();
if (!pronounProviders.Any())
{
await _feedback.SendErrorAsync(this.Context, "There doesn't seem to be any pronouns available.");
return;
}
var fields = pronounProviders.Select(CreatePronounField);
var description = "Each field below represents a pronoun that can be used with a character. The title of " +
"each field is the pronoun family that you use when selecting the pronoun, and below it" +
"is a short example of how it might be used.";
var paginatedEmbedPages = PageFactory.FromFields
(
fields,
description: description
);
var paginatedEmbed = new PaginatedEmbed(_feedback, _interactivity, this.Context.User).WithPages
(
paginatedEmbedPages.Select
(
p => p.WithColor(Color.DarkPurple).WithTitle("Available pronouns")
)
);
await _interactivity.SendInteractiveMessageAndDeleteAsync
(
this.Context.Channel,
paginatedEmbed,
TimeSpan.FromMinutes(5.0)
);
}
public async Task SetModerationLogChannelAsync(ITextChannel channel)
{
var setChannel = await _moderation.SetModerationLogChannelAsync(this.Context.Guild, channel);
if (!setChannel.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setChannel.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Channel set.");
}
public async Task CreateAutoroleAsync(IRole discordRole)
{
var create = await _autoroles.CreateAutoroleAsync(discordRole);
if (!create.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, create.ErrorReason);
}
await _feedback.SendConfirmationAsync(this.Context, "Autorole configuration created.");
}
public async Task <RuntimeResult> ResetChannelPermissionsAsync()
{
await _feedback.SendConfirmationAsync(this.Context, "Working...");
var getRoleplays = await _discordRoleplays.GetRoleplaysAsync(this.Context.Guild);
if (!getRoleplays.IsSuccess)
{
return(getRoleplays.ToRuntimeResult());
}
var roleplays = getRoleplays.Entity.ToList();
foreach (var roleplay in roleplays)
{
if (!roleplay.DedicatedChannelID.HasValue)
{
continue;
}
var reset = await _dedicatedChannels.ResetChannelPermissionsAsync(this.Context.Guild, roleplay);
if (!reset.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, reset.ErrorReason);
}
}
return(RuntimeCommandResult.FromSuccess("Permissions reset."));
}
public async Task AddNoteAsync([NotNull] IGuildUser user, [NotNull] string content)
{
var addNote = await _notes.CreateNoteAsync(this.Context.User, user, content);
if (!addNote.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, addNote.ErrorReason);
return;
}
var note = addNote.Entity;
await _feedback.SendConfirmationAsync(this.Context, $"Note added (ID {note.ID}).");
await _logging.NotifyUserNoteAdded(note);
}
public async Task AddWarningAsync
(
[NotNull] IGuildUser user,
[NotNull] string content,
TimeSpan?expiresAfter = null
)
{
DateTime?expiresOn = null;
if (!(expiresAfter is null))
{
expiresOn = DateTime.Now.Add(expiresAfter.Value);
}
var addWarning = await _warnings.CreateWarningAsync(this.Context.User, user, content, expiresOn : expiresOn);
if (!addWarning.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, addWarning.ErrorReason);
return;
}
var warning = addWarning.Entity;
await _feedback.SendConfirmationAsync(this.Context, $"Warning added (ID {warning.ID}).");
await _logging.NotifyUserWarningAdded(warning);
var getSettings = await _moderation.GetOrCreateServerSettingsAsync(this.Context.Guild);
if (!getSettings.IsSuccess)
{
return;
}
var settings = getSettings.Entity;
var warningCount = await _warnings.GetWarnings(user).CountAsync();
if (warningCount >= settings.WarningThreshold)
{
await _feedback.SendWarningAsync
(
this.Context, $"The warned user now has {warningCount} warnings. Consider further action."
);
}
}
/// <inheritdoc />
protected override async Task OnCommandFailedAsync
(
SocketCommandContext context,
int commandStart,
IResult result
)
{
switch (result)
{
case ExecuteResult executeResult when executeResult.Error == CommandError.Exception:
{
await HandleInternalErrorAsync(context, executeResult);
break;
}
case RuntimeCommandResult runtimeResult:
{
await _feedback.SendErrorAsync(context, runtimeResult.Reason);
return;
}
}
switch (result.Error)
{
case CommandError.UnknownCommand:
{
break;
}
case CommandError.ObjectNotFound:
case CommandError.MultipleMatches:
case CommandError.Unsuccessful:
case CommandError.UnmetPrecondition:
case CommandError.ParseFailed:
case CommandError.BadArgCount:
{
var userDMChannel = await context.Message.Author.GetOrCreateDMChannelAsync();
await SendPrivateMessageAsync(context, result.ErrorReason);
var searchResult = this.Commands.Search(context, commandStart);
if (searchResult.Commands.Any())
{
await userDMChannel.SendMessageAsync
(
string.Empty,
false,
_help.CreateCommandUsageEmbed(searchResult.Commands)
);
}
break;
}
}
}
public async Task ContactUserAsync([NotNull] IUser discordUser)
{
if (discordUser.Id == this.Context.Client.CurrentUser.Id)
{
await _feedback.SendErrorAsync(this.Context, "That's a splendid idea - at least then, I'd get an intelligent reply.");
return;
}
if (discordUser.IsBot)
{
await _feedback.SendErrorAsync(this.Context, "I could do that, but I doubt I'd get a reply.");
return;
}
var eb = _feedback.CreateFeedbackEmbed
(
discordUser,
Color.DarkPurple,
$"Hello there, {discordUser.Mention}. I've been instructed to initiate... negotiations... with you. \nA good place to start would be the \"!help <topic>\" command."
);
var userDMChannel = await discordUser.GetOrCreateDMChannelAsync();
try
{
await userDMChannel.SendMessageAsync(string.Empty, false, eb);
}
catch (HttpException hex) when(hex.WasCausedByDMsNotAccepted())
{
return;
}
finally
{
await userDMChannel.CloseAsync();
}
await _feedback.SendConfirmationAsync(this.Context, "User contacted.");
}
public async Task ListAvailableRolesAsync()
{
var getServerRolesResult = await _characterRoles.GetCharacterRolesAsync(this.Context.Guild);
if (!getServerRolesResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getServerRolesResult.ErrorReason);
return;
}
var serverRoles = getServerRolesResult.Entity;
var eb = _feedback.CreateEmbedBase();
eb.WithTitle("Available character roles");
eb.WithDescription
(
"These are the roles you can apply to your characters to automatically switch you to that role " +
"when you assume the character.\n" +
"\n" +
"In order to avoid mentioning everyone that has the role, use the numerical ID or role name" +
" instead of the actual mention. The ID is listed below along with the role name."
);
if (!await serverRoles.AnyAsync())
{
eb.WithFooter("There aren't any character roles available in this server.");
}
else
{
foreach (var characterRole in serverRoles)
{
var discordRole = this.Context.Guild.GetRole((ulong)characterRole.DiscordID);
if (discordRole is null)
{
continue;
}
var ef = new EmbedFieldBuilder();
ef.WithName($"{discordRole.Name} ({discordRole.Id})");
var roleStatus = characterRole.Access == RoleAccess.Open
? "open to everyone"
: "restricted";
ef.WithValue($"*This role is {roleStatus}.*");
eb.AddField(ef);
}
}
await _feedback.SendEmbedAsync(this.Context.Channel, eb.Build());
}
public async Task Default
(
[NotNull] IUser discordUser,
string permissionName,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <PermissionTarget>))]
PermissionTarget revokedTarget = PermissionTarget.Self
)
{
var getPermissionResult = _permissionRegistry.GetPermission(permissionName);
if (!getPermissionResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getPermissionResult.ErrorReason);
return;
}
var permission = getPermissionResult.Entity;
var revokePermissionResult = await _permissions.RevokePermissionAsync
(
this.Context.Guild,
discordUser,
permission,
revokedTarget
);
if (!revokePermissionResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, revokePermissionResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync
(
this.Context,
$"{permission.FriendlyName} revoked from {discordUser.Mention}."
);
}
public async Task ShowSettingsAsync()
{
var getSettings = await _autoroles.GetOrCreateServerSettingsAsync(this.Context.Guild);
if (!getSettings.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getSettings.ErrorReason);
return;
}
var settings = getSettings.Entity;
var notificationChannelValue = settings.AffirmationRequiredNotificationChannelID.HasValue
? MentionUtils.MentionChannel((ulong)settings.AffirmationRequiredNotificationChannelID.Value)
: "None";
var embed = _feedback.CreateEmbedBase()
.WithTitle("Autorole Settings")
.AddField("Confirmation Notification Channel", notificationChannelValue);
await _feedback.SendEmbedAsync(this.Context.Channel, embed.Build());
}
public async Task SetAffirmationNotificationChannel(IChannel channel)
{
if (!(channel is ITextChannel textChannel))
{
await _feedback.SendErrorAsync(this.Context, "That's not a text channel.");
return;
}
var setResult = await _autoroles.SetAffirmationNotificationChannelAsync
(
this.Context.Guild,
textChannel
);
if (!setResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Channel set.");
}
public async Task SetNoteContentsAsync(long noteID, string newContents)
{
var getNote = await _notes.GetNoteAsync(this.Context.Guild, noteID);
if (!getNote.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getNote.ErrorReason);
return;
}
var note = getNote.Entity;
var setContents = await _notes.SetNoteContentsAsync(note, newContents);
if (!setContents.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setContents.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Note contents updated.");
}
public async Task ShowInfoAsync([NotNull] IUser discordUser)
{
var getUserResult = await _users.GetOrRegisterUserAsync(discordUser);
if (!getUserResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getUserResult.ErrorReason);
return;
}
var user = getUserResult.Entity;
await ShowUserInfoAsync(discordUser, user);
}
public async Task RemoveConditionAsync
(
AutoroleConfiguration autorole,
long conditionID
)
{
var removeCondition = await _autoroles.RemoveConditionAsync(autorole, conditionID);
if (!removeCondition.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, removeCondition.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Condition removed.");
}
public async Task ShowServerAsync()
{
var eb = _feedback.CreateEmbedBase();
var guild = this.Context.Guild;
var getServerResult = await _servers.GetOrRegisterServerAsync(this.Context.Guild);
if (!getServerResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getServerResult.ErrorReason);
return;
}
var server = getServerResult.Entity;
eb.WithTitle(guild.Name);
if (!(guild.SplashUrl is null))
{
eb.WithThumbnailUrl(guild.SplashUrl);
}
public async Task ShowServerSettingsAsync()
{
var guild = this.Context.Guild;
var getSettings = await _moderation.GetOrCreateServerSettingsAsync(guild);
if (!getSettings.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getSettings.ErrorReason);
return;
}
var settings = getSettings.Entity;
var eb = _feedback.CreateEmbedBase();
eb.WithTitle(guild.Name);
eb.WithThumbnailUrl(guild.IconUrl);
var moderationLogChannelName = settings.ModerationLogChannel.HasValue
? MentionUtils.MentionChannel((ulong)settings.ModerationLogChannel)
: "None";
eb.AddField("Moderation Log Channel", moderationLogChannelName);
var monitoringChannelName = settings.MonitoringChannel.HasValue
? MentionUtils.MentionChannel((ulong)settings.MonitoringChannel)
: "None";
eb.AddField("Event Monitor Channel", monitoringChannelName);
eb.AddField("Warning Threshold", settings.WarningThreshold);
await _feedback.SendEmbedAsync(this.Context.Channel, eb.Build());
}
public async Task SetBanReasonAsync(long banID, string newReason)
{
var getBan = await _bans.GetBanAsync(this.Context.Guild, banID);
if (!getBan.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getBan.ErrorReason);
return;
}
var ban = getBan.Entity;
var setContents = await _bans.SetBanReasonAsync(ban, newReason);
if (!setContents.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setContents.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Ban reason updated.");
}
public async Task SetWarningReasonAsync(long warningID, string newReason)
{
var getWarning = await _warnings.GetWarningAsync(this.Context.Guild, warningID);
if (!getWarning.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getWarning.ErrorReason);
return;
}
var warning = getWarning.Entity;
var setContents = await _warnings.SetWarningReasonAsync(warning, newReason);
if (!setContents.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setContents.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Warning reason updated.");
}
public async Task SetTitleAsync(string title, string newTitle)
{
var getDossierResult = await _dossiers.GetDossierByTitleAsync(title);
if (!getDossierResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getDossierResult.ErrorReason);
return;
}
var dossier = getDossierResult.Entity;
var modifyResult = await _dossiers.SetDossierTitleAsync(dossier, newTitle);
if (!modifyResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, modifyResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "New dossier title set.");
}
public async Task ShowKinkAsync(string kinkName)
{
var getKinkInfoResult = await _kinks.GetKinkByNameAsync(kinkName);
if (!getKinkInfoResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getKinkInfoResult.ErrorReason);
return;
}
var kink = getKinkInfoResult.Entity;
var display = _kinks.BuildKinkInfoEmbed(kink);
await _feedback.SendPrivateEmbedAsync(this.Context, this.Context.User, display);
}
public async Task ShowRoleplayAsync()
{
if (!(this.Context.Channel is ITextChannel textChannel))
{
return;
}
var getCurrentRoleplayResult = await _discordRoleplays.GetActiveRoleplayAsync(textChannel);
if (!getCurrentRoleplayResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getCurrentRoleplayResult.ErrorReason);
return;
}
var roleplay = getCurrentRoleplayResult.Entity;
var eb = await CreateRoleplayInfoEmbedAsync(roleplay);
await _feedback.SendEmbedAsync(this.Context.Channel, eb);
}
public async Task ShiftAsync
(
[NotNull]
IUser target,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <Chirality>))]
Chirality chirality,
[OverrideTypeReader(typeof(HumanizerEnumTypeReader <Bodypart>))]
Bodypart bodyPart,
[NotNull] string species
)
{
var getTargetUserResult = await _users.GetOrRegisterUserAsync(target);
if (!getTargetUserResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getTargetUserResult.ErrorReason);
return;
}
var targetUser = getTargetUserResult.Entity;
var getCurrentCharacterResult = await _characters.GetCurrentCharacterAsync(this.Context, targetUser);
if (!getCurrentCharacterResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, getCurrentCharacterResult.ErrorReason);
return;
}
var character = getCurrentCharacterResult.Entity;
ShiftBodypartResult result;
if (species.Equals("remove", StringComparison.OrdinalIgnoreCase))
{
result = await _transformation.RemoveBodypartAsync(this.Context, character, bodyPart, chirality);
}
else
{
result = await _transformation.ShiftBodypartAsync(this.Context, character, bodyPart, species, chirality);
}
if (!result.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, result.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, result.ShiftMessage);
}
public async Task SetCharacterNameAsync
(
[RequireEntityOwnerOrPermission(typeof(EditCharacter), PermissionTarget.Other)]
Character character,
string newCharacterName
)
{
var setNameResult = await _characters.SetCharacterNameAsync(character, newCharacterName);
if (!setNameResult.IsSuccess)
{
await _feedback.SendErrorAsync(this.Context, setNameResult.ErrorReason);
return;
}
await _feedback.SendConfirmationAsync(this.Context, "Character name set.");
}