private async Task <ModifyEntityResult> ConfigureDefaultUserRolePermissions
(
IGuild guild,
IGuildChannel dedicatedChannel
)
{
var getServer = await _servers.GetOrRegisterServerAsync(guild);
if (!getServer.IsSuccess)
{
return(ModifyEntityResult.FromError(getServer));
}
var server = getServer.Entity;
var getSettings = await _serverSettings.GetOrCreateServerRoleplaySettingsAsync(server);
if (!getSettings.IsSuccess)
{
return(ModifyEntityResult.FromError(getSettings));
}
var settings = getSettings.Entity;
var denyView = OverwritePermissions.InheritAll.Modify
(
viewChannel: PermValue.Deny,
sendMessages: PermValue.Deny,
addReactions: PermValue.Deny
);
// Configure visibility for everyone
// viewChannel starts off as deny, since starting or stopping the RP will set the correct permissions.
IRole defaultUserRole;
if (settings.DefaultUserRole.HasValue)
{
var defaultRole = guild.GetRole((ulong)settings.DefaultUserRole.Value);
defaultUserRole = defaultRole ?? guild.EveryoneRole;
}
else
{
defaultUserRole = guild.EveryoneRole;
}
await dedicatedChannel.AddPermissionOverwriteAsync(defaultUserRole, denyView);
if (defaultUserRole != guild.EveryoneRole)
{
// Also override @everyone so it can't see anything
await dedicatedChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, denyView);
}
return(ModifyEntityResult.FromSuccess());
}
public async Task <ModifyEntityResult> SetDedicatedChannelWritabilityForUserAsync
(
[NotNull] IGuildChannel dedicatedChannel,
[NotNull] IUser participant,
bool isVisible
)
{
var permissions = OverwritePermissions.InheritAll;
var existingOverwrite = dedicatedChannel.GetPermissionOverwrite(participant);
if (!(existingOverwrite is null))
{
permissions = existingOverwrite.Value;
}
permissions = permissions.Modify
(
sendMessages: isVisible ? PermValue.Allow : PermValue.Deny,
addReactions: isVisible ? PermValue.Allow : PermValue.Deny,
embedLinks: isVisible ? PermValue.Allow : PermValue.Deny,
attachFiles: isVisible ? PermValue.Allow : PermValue.Deny,
useExternalEmojis: isVisible ? PermValue.Allow : PermValue.Deny
);
await dedicatedChannel.AddPermissionOverwriteAsync(participant, permissions);
// Ugly hack - there seems to be some kind of race condition on Discord's end.
await Task.Delay(20);
return(ModifyEntityResult.FromSuccess());
}
private async Task AddPermission(IGuildChannel channel, IRole role)
{
this.Logger.Debug("Adding role {0} to channel {1}", role.Id, channel.Id);
await channel.AddPermissionOverwriteAsync(role, TeamPermissions, RequestOptionsSettings.Default);
this.Logger.Debug("Added role {0} to channel {1}", role.Id, channel.Id);
}
private static async Task ConfigureChannelMuteRolePermissionsAsync(IGuildChannel channel, IRole muteRole)
{
try
{
var permissionOverwrite = channel.GetPermissionOverwrite(muteRole);
if (permissionOverwrite != null)
{
var deniedPermissions = permissionOverwrite.GetValueOrDefault().ToDenyList();
if (!_mutePermissions.ToDenyList().Except(deniedPermissions).Any())
{
Log.Debug("Skipping setting mute permissions for channel #{Channel} as they're already set.", channel.Name);
return;
}
Log.Debug("Removing permission overwrite for channel #{Channel}.", channel.Name);
await channel.RemovePermissionOverwriteAsync(muteRole);
}
await channel.AddPermissionOverwriteAsync(muteRole, _mutePermissions);
Log.Debug("Set mute permissions for role {Role} in channel #{Channel}.", muteRole.Name, channel.Name);
}
catch (Exception e)
{
Log.Error(e, "Failed setting channel mute role on #{Channel}", channel.Name);
throw;
}
}
public async Task LockAllChannels()
{
IRole defaultRole = Context.Guild.EveryoneRole;
IReadOnlyCollection <IGuildChannel> guildChannels = await Context.Guild.GetChannelsAsync();
for (int idLoc = 0; idLoc < GlobalConfiguration.LockableChannelIds.Length; idLoc++)
{
ulong channelId = ulong.Parse(GlobalConfiguration.LockableChannelIds[idLoc]);
IGuildChannel channel = guildChannels.FirstOrDefault(c => c.Id == channelId);
if (channel != null)
{
OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions();
permissions = permissions.Modify(sendMessages: PermValue.Inherit, addReactions: PermValue.Inherit);
await channel.AddPermissionOverwriteAsync(defaultRole, permissions);
}
else
{
_logger.LogWarning(string.Format("Channel '{0}' was not found for locking.", channelId));
}
}
await ReplyAsync("all the chawnnels hawv bween unlocked~!! uwu p-please reward me.. ///");
_logger.LogInformation(Context.User.ToString() + " unlocked all channels [ " + string.Join(", ", GlobalConfiguration.LockableChannelIds) + " ].");
}
public async Task ShowChannelAsync(IGuildChannel channel)
{
await channel.AddPermissionOverwriteAsync(Context.User,
new OverwritePermissions(readMessages : PermValue.Allow, sendMessages : PermValue.Allow));
await ReplyAsync("Channel hidden.");
}
public async Task <ModifyEntityResult> SetDedicatedChannelVisibilityForRoleAsync
(
[NotNull] IGuildChannel dedicatedChannel,
[NotNull] IRole role,
bool isVisible
)
{
var permissions = OverwritePermissions.InheritAll;
var existingOverwrite = dedicatedChannel.GetPermissionOverwrite(role);
if (!(existingOverwrite is null))
{
permissions = existingOverwrite.Value;
}
permissions = permissions.Modify
(
readMessageHistory: isVisible ? PermValue.Allow : PermValue.Deny,
viewChannel: isVisible ? PermValue.Allow : PermValue.Deny
);
await dedicatedChannel.AddPermissionOverwriteAsync(role, permissions);
// Ugly hack - there seems to be some kind of race condition on Discord's end.
await Task.Delay(20);
return(ModifyEntityResult.FromSuccess());
}
/// <summary>
/// Clears all channel permission overwrites from the given channel.
/// </summary>
/// <param name="channel">The channel.</param>
/// <returns>A modification result which may or may not have succeeded.</returns>
private async Task <ModifyEntityResult> ClearChannelPermissionOverwrites(IGuildChannel channel)
{
var guild = channel.Guild;
foreach (var overwrite in channel.PermissionOverwrites)
{
switch (overwrite.TargetType)
{
case PermissionTarget.Role:
{
var role = guild.GetRole(overwrite.TargetId);
if (role is null)
{
continue;
}
if (role.Id == guild.EveryoneRole.Id)
{
await channel.AddPermissionOverwriteAsync(role, OverwritePermissions.InheritAll);
}
else
{
await channel.RemovePermissionOverwriteAsync(role);
}
break;
}
case PermissionTarget.User:
{
var user = await guild.GetUserAsync(overwrite.TargetId);
if (user is null)
{
continue;
}
if (user.IsMe(_client))
{
continue;
}
await channel.RemovePermissionOverwriteAsync(user);
break;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
}
return(ModifyEntityResult.FromSuccess());
}
public async Task Unlock(IGuildChannel channel, IGuildUser agent)
{
try
{
IRole role = channel.Guild.EveryoneRole;
var permission = channel.GetPermissionOverwrite(role);
if (permission.HasValue && permission.Value.ViewChannel == PermValue.Deny)
{
await channel.AddPermissionOverwriteAsync(role, new OverwritePermissions(viewChannel : PermValue.Allow));
{
var eb = new EmbedBuilder()
{
Author = new EmbedAuthorBuilder()
{
IconUrl = $"{agent.GetAvatarUrl()}",
Name = $"Channel unlocked"
},
Description = $"{agent.Username}#{agent.Discriminator} ({agent.Mention}) unlocked a channel!",
Fields =
{
new EmbedFieldBuilder()
{
Name = "Perpetrator",
Value = $"• **Agent:** {agent.Username}#{agent.Discriminator}\n• **Agent ID:** {agent.Id}",
IsInline = false
},
new EmbedFieldBuilder()
{
Name = "Source",
Value = $"• **Server:** {agent.Guild.Name}\n• **Channel:** <#{channel.Id}>",
IsInline = false
}
},
Footer = new EmbedFooterBuilder()
{
Text = $"{DateTime.Now}",
},
};
eb.WithColor(Color.Blue);
DiscordReply("", eb);
await Utils.LogChannel.SendMessageAsync("", false, eb.Build());
}
}
else
{
DiscordReply("This channel is already unlocked.");
}
}
catch
{
Console.WriteLine($"Error while trying to set or remove lockdown on channel.");
DiscordReply("Unable to lock this channel down");
}
}
public async Task ArchiveChannel([Remainder] IGuildChannel channel)
{
//First we need to move channel
var cat = await Context.Guild.GetCategoriesAsync();
ICategoryChannel category = cat.Where(x => x.Id == 548238743476240405).FirstOrDefault();
if (category == null)
{
return;
}
//Move it now
await channel.ModifyAsync(x => x.CategoryId = category.Id);
//Get role overwrites
var everyoneOverwrite = category.GetPermissionOverwrite(Context.Guild.EveryoneRole);
var adminOverwrite = category.GetPermissionOverwrite(Context.Guild.GetRole(217696310168518657));
//First remove all perms
var curPerms = channel.PermissionOverwrites;
foreach (Overwrite ow in curPerms)
{
if (ow.TargetType == PermissionTarget.Role)
{
await channel.RemovePermissionOverwriteAsync(Context.Guild.GetRole(ow.TargetId));
}
else
{
await channel.RemovePermissionOverwriteAsync(await Context.Guild.GetUserAsync(ow.TargetId));
}
}
//Okay now we set perms
await channel.AddPermissionOverwriteAsync(Context.Guild.EveryoneRole, everyoneOverwrite.Value);
await channel.AddPermissionOverwriteAsync(Context.Guild.GetRole(217696310168518657), adminOverwrite.Value);
//Will add an output
await Context.Channel.SendSuccessAsync($"The channel {channel.Name} has been archived.");
}
public async Task LockModule()
{
IGuildChannel channel = (IGuildChannel)Context.Channel;
PermValue permission = channel.GetPermissionOverwrite(Context.Guild.EveryoneRole)?.SendMessages ?? PermValue.Allow;
PermValue flippedPermission = permission == PermValue.Allow ? PermValue.Deny : PermValue.Allow;
await ReplyAsync(flippedPermission == PermValue.Allow? "> Channel Has Been Unlocked" : "> Channel Has Been Locked");
await channel.AddPermissionOverwriteAsync(Context.Guild.EveryoneRole, new OverwritePermissions(sendMessages : flippedPermission));
}
public async Task LockCurrentChannel()
{
IGuildChannel channel = (IGuildChannel)Context.Channel;
IRole defaultRole = channel.Guild.EveryoneRole;
OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions();
permissions = permissions.Modify(sendMessages: PermValue.Inherit, addReactions: PermValue.Inherit);
await channel.AddPermissionOverwriteAsync(defaultRole, permissions);
await ReplyAsync("uwu!! #" + channel.Name + " is nyow unlowcked!1! uguuuu yes im so c-c-ccreative");
_logger.LogInformation(Context.User.ToString() + " unlocked channel #" + channel.Name + " [" + channel.Id + "].");
}
public async Task LockCurrentChannel()
{
IGuildChannel channel = (IGuildChannel)Context.Channel;
IRole defaultRole = channel.Guild.EveryoneRole;
OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions();
permissions = permissions.Modify(sendMessages: PermValue.Deny, addReactions: PermValue.Deny);
await channel.AddPermissionOverwriteAsync(defaultRole, permissions);
await ReplyAsync("i-i nylocked #" + channel.Name + " f-for you s-s-s-senpai :0 a-are you p-proud??! >//////<");
_logger.LogInformation(Context.User.ToString() + " locked channel #" + channel.Name + " [" + channel.Id + "].");
}
//updates channel permissions when a user joins a voice channel
public Task HandleConnect(SocketUser socketUser, ISocketMessageChannel targetChannel)
{
OverwritePermissions overwrite = new OverwritePermissions(readMessages: PermValue.Allow);
IGuildChannel textChannel = (IGuildChannel)targetChannel;
textChannel.AddPermissionOverwriteAsync(socketUser, overwrite);
EmbedBuilder builder = new EmbedBuilder()
{
Description = ":speaker: " + socketUser.Mention + " has joined the voice channel",
Color = Color.Green,
ThumbnailUrl = socketUser.GetAvatarUrl(ImageFormat.Auto, 128)
};
targetChannel.SendMessageAsync("", false, builder.Build());
return(Task.CompletedTask);
}
//updates channel permissions when a user leaves a voice channel
public Task HandleDisconnect(SocketUser socketUser, ISocketMessageChannel targetChannel)
{
// Don't hide the channel for users that can manage messages
if (!((SocketGuildUser)socketUser).GuildPermissions.ManageMessages)
{
OverwritePermissions overwrite = new OverwritePermissions(readMessages: PermValue.Deny);
IGuildChannel textChannel = (IGuildChannel)targetChannel;
textChannel.AddPermissionOverwriteAsync(socketUser, overwrite);
}
EmbedBuilder builder = new EmbedBuilder()
{
Description = ":mute: " + socketUser.Mention + " has left the voice channel ",
Color = Color.Orange,
ThumbnailUrl = socketUser.GetAvatarUrl(ImageFormat.Auto, 128)
};
targetChannel.SendMessageAsync("", false, builder.Build());
return(Task.CompletedTask);
}
private async Task ConfigureChannelMuteRolePermissionsAsync(IGuildChannel channel, IRole muteRole)
{
var permissionOverwrite = channel.GetPermissionOverwrite(muteRole);
if (permissionOverwrite != null)
{
if ((permissionOverwrite.Value.AllowValue == _mutePermissions.AllowValue) &&
(permissionOverwrite.Value.DenyValue == _mutePermissions.DenyValue))
{
Log.Debug("Skipping setting mute permissions for channel #{Channel} as they're already set.", channel.Name);
return;
}
Log.Debug("Removing permission overwrite for channel #{Channel}.", channel.Name);
await channel.RemovePermissionOverwriteAsync(muteRole);
}
await channel.AddPermissionOverwriteAsync(muteRole, _mutePermissions);
Log.Debug("Set mute permissions for role {Role} in channel #{Channel}.", muteRole.Name, channel.Name);
}
public async Task MuteUserAsync(IGuildUser user, IGuildChannel channel)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
// Fetches the previous overwrite and bail if one is found
var previousOverwrite = channel.GetPermissionOverwrite(user);
if (previousOverwrite.HasValue && previousOverwrite.Value.SendMessages == PermValue.Deny)
{
throw new InvalidOperationException($"User {user.Username} had already been muted in this channel.");
}
// Creates a new OverwritePermissions with send message set to deny and pass it into the method
await channel.AddPermissionOverwriteAsync(user, new OverwritePermissions(sendMessages : PermValue.Deny));
}
