public static ChannelPermissions CalculatePermissions(IGuild guild, IGuildChannel channel, IMember member, IEnumerable <IRole> roles)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
var guildPermissions = CalculatePermissions(guild, member, roles);
if (guildPermissions.Administrator)
{
return(ChannelPermissions.All);
}
var permissions = ChannelPermissions.Mask(guildPermissions, channel);
foreach (var role in roles.OrderBy(x => x.Position))
{
for (var i = 0; i < channel.Overwrites.Count; i++)
{
var overwrite = channel.Overwrites[i];
if (overwrite.TargetId != role.Id)
{
continue;
}
permissions -= overwrite.Permissions.Denied;
permissions += overwrite.Permissions.Allowed;
}
}
for (var i = 0; i < channel.Overwrites.Count; i++)
{
var overwrite = channel.Overwrites[i];
if (overwrite.TargetId != member.Id)
{
continue;
}
permissions -= overwrite.Permissions.Denied;
permissions += overwrite.Permissions.Allowed;
}
if (!permissions.ViewChannel)
{
return(ChannelPermissions.None);
}
if (channel is ITextChannel && !permissions.SendMessages)
{
permissions -= Permission.AttachFiles |
Permission.EmbedLinks |
Permission.MentionEveryone |
Permission.SendTtsMessages;
}
return(permissions);
}
public async Task SetGreetChannel(IGuildChannel channel)
{
using (var uow = DBHandler.UnitOfWork())
{
uow.Guild.SetGuildGreetChannel(Context.Guild.Id, channel.Id);
}
await Context.Channel.SendSuccessAsync($"Set guild's greeings channel to: {channel.Name}");
}
public void AssertChannelPermission(ChannelPermission permission, ulong channelId)
{
IGuildChannel channel = GetChannel(channelId);
if (!HasChannelPermission(permission, channelId))
{
throw new MissingPermissionException($"Bot does not have channel {nameof (permission)} '{permission} in channel '{channel.Name}'");
}
}
public static string Channel(IGuildChannel channel)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
return(Channel(channel.Id));
}
private async Task MoveMemberAsync(SocketGuildUser guildUser, IGuildChannel channel)
{
await guildUser.ModifyAsync(props =>
{
props.ChannelId = channel.Id;
});
logger.LogInformation("Moved user {username}#{discriminator} to channel {channelName}", guildUser.Username, guildUser.Discriminator, channel.Name);
}
public async Task SetDeletedLogChannel(IGuildChannel channel)
{
using (var uow = DBHandler.UnitOfWork())
{
uow.Guild.SetGuildDelChannel(Context.Guild.Id, channel.Id);
}
await Context.Channel.SendSuccessAsync($"Set guild's delete log channel to: {channel.Name}");
}
public ByRoleTeamManager(IGuildChannel channel, string teamRolePrefix)
{
Verify.IsNotNull(channel, nameof(channel));
this.Guild = channel.Guild;
this.Channel = channel;
this.TeamRolePrefix = teamRolePrefix;
this.InitiailzeTeamIdToName();
}
public ChannelCreatedEventArgs(IGuildChannel channel)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
Channel = channel;
}
public static Embed ShowWarns(IGuildChannel channel, SocketGuildUser user = null)
{
List <string> warns = UserSettings.Warns.List(channel.Guild.Id);
var eBuilder = new EmbedBuilder()
.WithDescription($"The following warns have been issued: \n\n{String.Join($"\n", warns.ToArray())}")
.WithColor(new Color(0xD0021B));
return(eBuilder.Build());
}
public static async Task <Model> ModifyAsync(IGuildChannel channel, BaseDiscordClient client,
Action <ModifyGuildChannelParams> func,
RequestOptions options)
{
var args = new ModifyGuildChannelParams();
func(args);
return(await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args, options).ConfigureAwait(false));
}
public static bool IsVerificationChannel(IGuildChannel channel)
{
if (UserSettings.Verification.VerificationChannelId(channel.Guild.Id) == channel.Id)
{
return(true);
}
return(false);
}
public static bool IsMediaOnlyChannel(IGuildChannel channel)
{
if (UserSettings.Channels.MediaOnlyChannels(channel.Guild.Id).Any(c => c.Equals(channel.Id)))
{
return(true);
}
return(false);
}
/// <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 <ChannelConfig> GetOrCreateConfigAsync(IGuildChannel channel)
{
var config = await GetConfigAsync(channel);
if (config != null)
{
return(config);
}
return(await CreateAsync(new ChannelConfig { Id = channel.Id, GuildId = channel.GuildId }));
}
public async Task SetScoreChannelAsync(IGuildChannel channel, [Remainder] string paramString)
{
if (IsAdmin())
{
var eventId = paramString.ParseArgs("eventId");
if (string.IsNullOrEmpty(eventId))
{
await ReplyAsync(embed : "Usage: `setScoreChannel #channel -eventId \"[event id]\"`\nTo find event ids, please run `listEvents`".ErrorEmbed());
}
else
{
var server = ServerService.GetServer();
if (server == null)
{
await ReplyAsync(embed : "The Server is not running, so we can't can't add events to it".ErrorEmbed());
}
else
{
var knownPairs = await HostScraper.ScrapeHosts(server.State.KnownHosts, $"{server.CoreServer.Address}:{server.CoreServer.Port}", 0);
var targetPair = knownPairs.FirstOrDefault(x => x.Value.Events.Any(y => y.EventId.ToString() == eventId));
if (targetPair.Key != null)
{
var targetEvent = targetPair.Value.Events.First(x => x.EventId.ToString() == eventId);
targetEvent.InfoChannel = new Models.Discord.Channel
{
Id = channel?.Id ?? 0,
Name = channel?.Name ?? ""
};
var response = await server.SendUpdateQualifierEvent(targetPair.Key, targetEvent);
if (response.Type == Response.ResponseType.Success)
{
await ReplyAsync(embed : response.Message.SuccessEmbed());
}
else if (response.Type == Response.ResponseType.Fail)
{
await ReplyAsync(embed : response.Message.ErrorEmbed());
}
}
else
{
await ReplyAsync(embed : "Could not find an event with that ID".ErrorEmbed());
}
}
}
}
else
{
await ReplyAsync(embed : "You do not have sufficient permissions to use this command".ErrorEmbed());
}
}
public async Task SetScoreChannelAsync(IGuildChannel channel, [Remainder] string paramString)
{
if (IsAdmin())
{
var eventId = paramString.ParseArgs("赛事");
if (string.IsNullOrEmpty(eventId))
{
await ReplyAsync(embed : "用法: `计分频道 #频道 -赛事 \"[赛事ID]\"`\n赛事ID可以通过`赛事列表`命令查找".ErrorEmbed());
}
else
{
var server = ServerService.GetServer();
if (server == null)
{
await ReplyAsync(embed : "服务器不在线，所以不能创建赛事".ErrorEmbed());
}
else
{
var knownPairs = await HostScraper.ScrapeHosts(server.State.KnownHosts, $"{server.CoreServer.Address}:{server.CoreServer.Port}", 0);
var targetPair = knownPairs.FirstOrDefault(x => x.Value.Events.Any(y => y.EventId.ToString() == eventId));
if (targetPair.Key != null)
{
var targetEvent = targetPair.Value.Events.First(x => x.EventId.ToString() == eventId);
targetEvent.InfoChannel = new Models.Discord.Channel
{
Id = channel?.Id ?? 0,
Name = channel?.Name ?? ""
};
var response = await server.SendUpdateQualifierEvent(targetPair.Key, targetEvent);
if (response.Type == Response.ResponseType.Success)
{
await ReplyAsync(embed : response.Message.SuccessEmbed());
}
else if (response.Type == Response.ResponseType.Fail)
{
await ReplyAsync(embed : response.Message.ErrorEmbed());
}
}
else
{
await ReplyAsync(embed : "Could not find an event with that ID".ErrorEmbed());
}
}
}
}
else
{
await ReplyAsync(embed : "你没有足够的权限使用该命令".ErrorEmbed());
}
}
public async Task AddTwitter(string twitterName, IGuildChannel guildChannel)
{
var userResponse = await _twitterService.GetUserFromHandle(twitterName);
if (userResponse?.Id is null)
{
await ReplyAsync("User Not Found");
return;
}
var user = await _botContext.TwitterUsers.Include(x => x.TwitterAlertSubscriptions)
.FirstOrDefaultAsync(x => x.Id == userResponse.Id);
if (user is null)
{
user = new TwitterUser
{
Id = userResponse.Id.Value,
Name = userResponse.Name,
TwitterAlertSubscriptions = new List <TwitterAlertSubscription>(),
ScreenName = userResponse.ScreenName
};
_botContext.TwitterUsers.Add(user);
JobManager.AddJob(
() => new TwitterMonitoringJob(user.Id, _twitterService,
_provider.GetService <JakeBotContext>(), Context.Client).Execute(),
s => s.WithName($"Twitter: {userResponse.ScreenName}").ToRunEvery(30).Seconds());
}
if (user.TwitterAlertSubscriptions.Any(x => x.DiscordChannelId == (long)guildChannel.Id))
{
await ReplyAsync($"You already subscribed to {user.ScreenName} in {guildChannel.Name}");
return;
}
user.TwitterAlertSubscriptions.Add(new TwitterAlertSubscription
{
DiscordChannelId = (long)guildChannel.Id,
TwitterUserId = user.Id
});
var changes = _botContext.SaveChanges();
if (changes > 0)
{
await ReplyAsync($"Alert for {user.ScreenName} added to {guildChannel.Name}");
}
else
{
await ReplyAsync($"Unable to create Alert for {user.ScreenName}");
}
}
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 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 LockChannel(IGuildChannel chn, [Remainder] string reason)
{
await Context.Message.DeleteAsync();
string Message = "Command **!lockchannel** requested by " + Context.User.Mention + Environment.NewLine +
"in channel <#" + Context.Channel.Id + "> " + "Channel: " + chn.Id + " Lock reason: " + reason;
string IMessage = "Command **!lockchannel** requested by " + Context.User.Mention + Environment.NewLine +
"in channel <#" + Context.Channel.Id + "> " + "Channel: " + chn.Id + " Lock reason: " + reason;
await Helper.LoggingAsync(new LogMessage (LogSeverity.Verbose, "Module", Message));
}
public static Embed ShowColors(IGuildChannel channel, List <string> colorRoleNames, ulong guildId)
{
var eBuilder = new EmbedBuilder()
.WithDescription($"You can assign yourself the following color roles using " +
$"``{UserSettings.BotOptions.CommandPrefix(guildId)}give color roleName``, " +
$"or add your own using ``{UserSettings.BotOptions.CommandPrefix(guildId)}create color #hexValue roleName``: " +
$"\n{String.Join(Environment.NewLine, colorRoleNames.ToArray())}")
.WithColor(new Color(0xF5DA23));
return(eBuilder.Build());
}
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 Channel GetChannel(IGuildChannel ichannel)
{
var channel = FindChannel(ichannel);
if (channel == null)
{
channel = new Channel(ichannel);
Channels.Add(channel);
}
return(channel);
}
public bool RemoveChannel(IGuildChannel ichannel)
{
var channel = FindChannel(ichannel);
if (channel == null)
{
return(false);
}
Channels.Remove(channel);
return(true);
}
private MultiRoleEntry GetEntry(IGuildChannel channel, ulong msgId)
{
foreach (MultiRoleEntry entry in Entries)
{
if (entry.ChannelId == channel.Id && entry.GuildId == channel.GuildId && entry.MessageId == msgId)
{
return(entry);
}
}
return(null);
}
int GetIndex(IGuildChannel channel)
{
foreach (var c in plugin.Config.Channels)
{
if (c.Guild == channel.GuildId && c.Channel == channel.Id)
{
return(plugin.Config.Channels.IndexOf(c));
}
}
return(-1);
}
public static bool IsPublic(this IGuildChannel channel)
{
if (channel?.Guild is IGuild guild)
{
var permissions = channel.GetPermissionOverwrite(guild.EveryoneRole);
return(!permissions.HasValue || permissions.Value.ViewChannel != PermValue.Deny);
}
return(false);
}
private bool CommandAllowedInChannel(CommandInfo command, STDTContext db, IGuildChannel channel)
{
List <long> AllowedChannelIDs = db.CommandChannelPermissions.ToList().Where(x => x.CommandName.ToLower() == command.Name.ToLower()).Select(x => x.ChannelID).ToList();
if (AllowedChannelIDs.Count == 0)
{
return(true);
}
return(AllowedChannelIDs.Contains((long)channel.Id));
}
public async Task AddTwitch(string twitchName, IGuildChannel guildChannel, string streamMessage)
{
var userResponse = await _twitchService.GetUserByNameAsync(twitchName);
if (userResponse is null)
{
await ReplyAsync("User Not Found");
return;
}
var user = await _botContext.TwitchStreamers.Include(x => x.TwitchAlertSubscriptions)
.FirstOrDefaultAsync(x => x.Id == long.Parse(userResponse.Id));
if (user is null)
{
user = new TwitchStreamer
{
Id = long.Parse(userResponse.Id),
Name = userResponse.DisplayName,
TwitchAlertSubscriptions = new List <TwitchAlertSubscription>()
};
_botContext.TwitchStreamers.Add(user);
JobManager.AddJob(
() => new TwitchMonitoringJob(user.Id, _twitchService,
_provider.GetService <SteveBotContext>(), Context.Client).Execute(),
s => s.WithName(userResponse.DisplayName).ToRunEvery(60).Seconds());
}
if (user.TwitchAlertSubscriptions.Any(x => x.DiscordChannelId == (long)guildChannel.Id))
{
await ReplyAsync($"You already subscribed to {user.Name} in {guildChannel.Name}");
return;
}
user.TwitchAlertSubscriptions.Add(new TwitchAlertSubscription
{
DiscordChannelId = (long)guildChannel.Id,
StreamMessage = streamMessage,
TwitchStreamerId = user.Id
});
var changes = _botContext.SaveChanges();
if (changes > 0)
{
await ReplyAsync($"Alert for {user.Name} added to {guildChannel.Name}");
}
else
{
await ReplyAsync($"Unable to create Alert for {user.Name}");
}
}
/*public static ulong ResolveChannel(IGuildUser user, IGuildChannel channel)
* {
* return ResolveChannel(user, channel, ResolveGuild(user));
* }*/
public static ulong ResolveChannel(IGuildUser user, IGuildChannel channel, ulong guildPermissions)
{
ulong resolvedPermissions = 0;
ulong mask = ChannelPermissions.All(channel).RawValue;
if (/*user.Id == user.Guild.OwnerId || */ GetValue(guildPermissions, GuildPermission.Administrator))
{
resolvedPermissions = mask; //Owners and administrators always have all permissions
}
else
{
//Start with this user's guild permissions
resolvedPermissions = guildPermissions;
OverwritePermissions?perms;
var roles = user.Roles;
if (roles.Count > 0)
{
ulong deniedPermissions = 0UL, allowedPermissions = 0UL;
foreach (var role in roles)
{
perms = channel.GetPermissionOverwrite(role);
if (perms != null)
{
deniedPermissions |= perms.Value.DenyValue;
allowedPermissions |= perms.Value.AllowValue;
}
}
resolvedPermissions = (resolvedPermissions & ~deniedPermissions) | allowedPermissions;
}
perms = channel.GetPermissionOverwrite(user);
if (perms != null)
{
resolvedPermissions = (resolvedPermissions & ~perms.Value.DenyValue) | perms.Value.AllowValue;
}
//TODO: C#7 Typeswitch candidate
var textChannel = channel as ITextChannel;
var voiceChannel = channel as IVoiceChannel;
if (textChannel != null && !GetValue(resolvedPermissions, ChannelPermission.ReadMessages))
{
resolvedPermissions = 0; //No read permission on a text channel removes all other permissions
}
else if (voiceChannel != null && !GetValue(resolvedPermissions, ChannelPermission.Connect))
{
resolvedPermissions = 0; //No connect permission on a voice channel removes all other permissions
}
resolvedPermissions &= mask; //Ensure we didnt get any permissions this channel doesnt support (from guildPerms, for example)
}
return(resolvedPermissions);
}
