public async Task <ChannelPair?> GetOrCreateChannelPair(SocketGuild guild, string lang) { string safeLang = GetSafeLangString(lang); string guildLang = _serverConfig.GetLanguageForGuild(guild.Id); string safeGuildLang = GetSafeLangString(guildLang); if (_channelPairs.TryGetValue(safeLang, out var pair)) { return(pair); } var category = guild.CategoryChannels.SingleOrDefault(a => a.Name == TranslationConstants.CategoryName); if (category == default) { throw new InvalidOperationException($"The channel category {TranslationConstants.CategoryName} does not exist"); } var supportedLang = await _translation.IsLangSupported(lang); if (!supportedLang) { throw new LanguageNotSupportedException($"{lang} is not supported at this time."); } var fromLangName = $"{safeLang}-to-{safeGuildLang}"; var toLangName = $"{safeGuildLang}-to-{safeLang}"; var fromLangChannel = await guild.CreateTextChannelAsync(fromLangName, p => p.CategoryId = category.Id); var toLangChannel = await guild.CreateTextChannelAsync(toLangName, p => p.CategoryId = category.Id); var localizedTopic = await _translation.GetTranslation(guildLang, lang, $"Responses will be translated to {guildLang} and posted in this channel's pair {toLangChannel.Mention}"); await fromLangChannel.ModifyAsync(p => p.Topic = localizedTopic.Translated.Text); var unlocalizedTopic = $"Responses will be translated to {lang} and posted in this channel's pair {fromLangChannel.Mention}"; await toLangChannel.ModifyAsync(p => p.Topic = unlocalizedTopic); pair = new ChannelPair { TranslationChannel = fromLangChannel, StandardLangChanel = toLangChannel }; if (!_channelPairs.TryAdd(safeLang, pair)) { _logger.LogWarning($"The channel pairs {{{fromLangName}, {toLangName}}} have already been tracked, cleaning up"); await pair.TranslationChannel.DeleteAsync(); await pair.StandardLangChanel.DeleteAsync(); _channelPairs.TryGetValue(safeLang, out pair); } return(pair); }
// 특정 이름을 가진 채널을 검색, 있을 경우 검색된 채널 반환, 없을 경우 생성한 후 생성한 채널 반환 public async static Task <SocketTextChannel> CreateChannelIfNotExist(this SocketGuild guild, string name) { try { SocketTextChannel osuTrackerChannel = null; bool isThereOsuTrackerChannel = false; IReadOnlyCollection <SocketTextChannel> channelList = guild.TextChannels; foreach (SocketTextChannel channel in channelList) { if (channel.Name.ToLower() == name.ToLower()) { isThereOsuTrackerChannel = true; osuTrackerChannel = channel; break; } } if (!isThereOsuTrackerChannel) { ulong osuTrackerChannelId = (await guild.CreateTextChannelAsync("osu-tracker")).Id; osuTrackerChannel = guild.GetTextChannel(osuTrackerChannelId); } return(osuTrackerChannel); } catch (Exception e) { throw e; } }
private async Task <ITextChannel> CreateApplicationChannel(SocketGuild guild, GuildTB dbentry) { logger.Log(new LogMessage(LogSeverity.Info, "State", $"Creating an application channel for {guild.Name}.")); // find the correct category SocketCategoryChannel category = null; if (dbentry.Public != null) { foreach (var c in guild.CategoryChannels) { if (c.Channels.Any(x => x.Id == dbentry.Public)) { category = c; break; } } } try { // try to create a text channel return(await guild.CreateTextChannelAsync("Applications", (x) => { x.Topic = "Are you interested in our community? Write your application here!"; x.CategoryId = category?.Id; })); } catch (Exception e) { // report failure logger.Log(new LogMessage(LogSeverity.Error, "State", $"Attempted to create a channel for '{guild.Name}', but failed: {e.Message}\n{e.StackTrace}")); return(null); } }
/******************************************************** * Creates Public Anon Channel * ********************************************************/ public async Task CreatePublicAnonChannel(SocketGuild guild) { var everyoneRole = guild.Roles.FirstOrDefault(x => x.IsEveryone); Console.WriteLine($"Creating PublicChannel for Guild {guild.Name}"); var text = await guild.CreateTextChannelAsync("Anon"); ICategoryChannel category = guild.CategoryChannels.FirstOrDefault(x => x.Id == CatagoryID); //if catagory exits make a new one if (category == null) { category = await guild.CreateCategoryChannelAsync("Anonyomus Channels"); await category.AddPermissionOverwriteAsync(everyoneRole, PermissionsDenyAll); } await text.AddPermissionOverwriteAsync(everyoneRole, PermissionsReadOnly); await text.ModifyAsync(x => x.CategoryId = category.Id); var message = await text.SendMessageAsync($"**Welcome to {guild.Name}'s Anonamus Channel!**\n\n" + "This channel allows all the users on the server to see the anonamous chat without being in it." + "The bot grabs all messages sent by users and sends them to everyone elses channel. " + "Becouse the bot posts the message you don't know who sent the message.\n\n" + "You can view the source code at https://github.com/doc543/AnonBot \n"); await message.PinAsync(); Console.WriteLine("Created Text Channel: " + CatagoryID.ToString()); }
/// <summary> /// Finds the first channel, which is private to everybody, but, viewable by admins. /// </summary> /// <param name="Guild"></param> /// /// <returns></returns> public static async Task <ITextChannel> findFirstAdminChannel(SocketGuild Guild) { var ME = Guild.CurrentUser; //Next, Just loop through channels, until we find a writeable channel. foreach (SocketTextChannel tch in Guild.Channels.OfType <SocketTextChannel>()) { //Simple stupid way. //ToDo - Add better logic in the future. //Summary - Find a channel we can write to, but, everybody cannot. if (!PermissionHelper.TestPermission(tch, ChannelPermission.ReadMessages, Guild.EveryoneRole) && ME.GetPermissions(tch).SendMessages) { return(tch); } } //If, there are no writable channels. Lets create one? if (ME.GuildPermissions.ManageChannels && ME.GuildPermissions.SendMessages) { var newCh = await Guild.CreateTextChannelAsync("Admins"); //Block EVERYONE role from all permissions related to this channel. await newCh.AddPermissionOverwriteAsync(Guild.EveryoneRole, OverwritePermissions.DenyAll(newCh)); //Grant the highest role, all permissions. await newCh.AddPermissionOverwriteAsync(Guild.Roles.First(), OverwritePermissions.AllowAll(newCh)); await newCh.SendMessageAsync(@"I was unable to find a channel to which I could sent leadership/officer messages to... So, I created this channel automatically. I will leadership-related messages into this channel."); return(newCh); } return(null); }
private async Task <IGuildChannel> CreateOrUpdateChannel(SocketGuild guild, ICategoryChannel category, string name, string topic, int position) { var channel = guild.Channels.OfType <SocketTextChannel>().SingleOrDefault(a => a.Name == name && a.CategoryId == category.Id) as IGuildChannel; if (channel == null) { _logger.LogDebug($"'#{name}' channel not found, creating."); _waitingForChannel = name; channel = await guild.CreateTextChannelAsync(name, a => { a.CategoryId = category.Id; a.Position = position; a.Topic = topic; }); _channelCreatedWaiter.WaitOne(); } _logger.LogDebug($"Enforcing deny to send messages, or reactions to @everyone in the '#{name}' channel"); await channel.AddPermissionOverwriteAsync(guild.EveryoneRole, new OverwritePermissions(sendMessages : PermValue.Deny, addReactions : PermValue.Deny)); var botRole = guild.Roles.SingleOrDefault(a => a.Name == _bot.DiscordClient.CurrentUser.Username); if (botRole != null) { await channel.AddPermissionOverwriteAsync(botRole, new OverwritePermissions(sendMessages : PermValue.Allow, addReactions : PermValue.Allow)); } else { await channel.AddPermissionOverwriteAsync(_bot.DiscordClient.CurrentUser, new OverwritePermissions(sendMessages : PermValue.Allow, addReactions : PermValue.Allow)); } return(channel); }
private async Task <SocketChannel> GenerateChannelAsync(SocketGuild guild, string channelName) { var category = await GetBaseCategoryAsync(guild); var adminChannel = await guild.CreateTextChannelAsync(channelName, func : x => { x.CategoryId = category.Id; }); return(await GetChannelAsync(guild, channelName)); }
/// <summary> /// Creates an opt-in channel in the given guild. /// </summary> /// <param name="guildConnection"> /// The connection to the guild this channel is being created in. May not be null. /// </param> /// <param name="guildData">Information about this guild. May not be null.</param> /// <param name="requestAuthor">The author of the channel create request. May not be null.</param> /// <param name="channelName">The requested name of the new channel. May not be null.</param> /// <param name="description">The requested description of the new channel.</param> /// <returns>The result of the request.</returns> public static async Task <CreateResult> Create( SocketGuild guildConnection, Guild guildData, SocketGuildUser requestAuthor, string channelName, string description) { ValidateArg.IsNotNullOrWhiteSpace(channelName, nameof(channelName)); if (!guildData.OptinParentCategory.HasValue) { return(CreateResult.NoOptinCategory); } var optinsCategory = guildData.OptinParentCategory.GetValueOrDefault(); // TODO: requestAuthor.Roles gets cached. How do I refresh this value so that it's accurate? var hasPermission = PermissionsUtilities.HasPermission( userRoles: requestAuthor.Roles.Select(x => new Snowflake(x.Id)), allowedRoles: guildData.OptinCreatorsRoles); if (!hasPermission) { return(CreateResult.NoPermissions); } var optinsCategoryConnection = guildConnection.GetCategoryChannel(optinsCategory.Value); var alreadyExists = optinsCategoryConnection.Channels .Select(x => x.Name) .Any(x => string.Compare(x, channelName, ignoreCase: false) == 0); if (alreadyExists) { return(CreateResult.ChannelNameUsed); } var createdTextChannel = await guildConnection.CreateTextChannelAsync(channelName, settings => { settings.CategoryId = optinsCategory.Value; settings.Topic = description ?? string.Empty; }).ConfigureAwait(false); var createdRole = await guildConnection.CreateRoleAsync( name : OptinChannel.GetRoleName(createdTextChannel.Id), permissions : null, color : null, isHoisted : false, isMentionable : false) .ConfigureAwait(false); var newPermissions = createdTextChannel.AddPermissionOverwriteAsync( role: createdRole, permissions: new OverwritePermissions(viewChannel: PermValue.Allow)); await requestAuthor.AddRoleAsync(createdRole).ConfigureAwait(false); return(CreateResult.Success); }
private async Task <RestTextChannel> CreatePrivateGroupTextChannel(SocketGuild guild, string name, string description) { var everyoneRole = guild.Roles.FirstOrDefault(r => r.Name == "@everyone"); RestTextChannel channel = await guild.CreateTextChannelAsync(name, (properties) => { properties.Topic = description; }); await channel.AddPermissionOverwriteAsync(everyoneRole, OverwritePermissions.DenyAll(channel)); return(channel); }
public static async Task <RestTextChannel> AddChannel(string name, SocketGuild guild, string topic = "", ulong catergory = 0, bool isNSFW = false) { return(await guild.CreateTextChannelAsync(name, x => { x.Topic = topic; x.CategoryId = catergory; x.IsNsfw = isNSFW; })); }
public static async Task <ITextChannel> GetPickupQueuesChannel(SocketGuild guild) { var queuesChannel = (ITextChannel)guild.TextChannels.FirstOrDefault(c => c.Name.Equals(ChannelNames.ActivePickups, StringComparison.OrdinalIgnoreCase)) ?? await guild.CreateTextChannelAsync(ChannelNames.ActivePickups, properties => { properties.Topic = "Active pickups, use reactions to signup"; }); return(queuesChannel); }
public static async Task <ITextChannel> GetOrCreateTextChannelAsync(this SocketGuild guild, string channelName, Action <TextChannelProperties> func = null) { var existingChannel = guild.TextChannels.FirstOrDefault(c => c.Name == channelName.ToLower().Replace(' ', '-')); if (existingChannel != null) { return(existingChannel); } else { return(await guild.CreateTextChannelAsync(channelName, func)); } }
public static async Task <RestTextChannel> CreateSuggestionChannel(this SocketGuild guild, ulong categoryId, SuggestionType type, string name) { var suffix = ChannelSuffixes[type]; var res = await guild.CreateTextChannelAsync(suffix + name, c => { c.CategoryId = categoryId; }); await ReorderChannels(guild); return(res); }
private static async Task CreateChannel(SocketGuild guild, string name, string topic, ulong categoryId) { // create #pickup channel if missing var activePickupsChannel = guild.Channels.FirstOrDefault(c => c.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); if (activePickupsChannel == null) { await guild.CreateTextChannelAsync(name, properties => { properties.Topic = topic; properties.CategoryId = categoryId; }); } }
public static GameSession Build(SocketGuild g, Server s, IGame game) { EmbedBuilder panel = game.Embedder.DefaultPanel(); RestTextChannel channel = g.CreateTextChannelAsync(game.ChannelName, x => { x = GameChannelProperties; }).Result; RestUserMessage msg = channel.SendMessageAsync(embed: panel.Build()).Result; GameSession session = new GameSession(channel.Id, msg, panel); if (!s.OpenGameSessions.Exists()) { s.OpenGameSessions = new List <GameSession>(); } s.OpenGameSessions.Add(session); return(session); }
public DiscordBot(string key) { _bot.MessageReceived += OnMessageReceived; _bot.LoginAsync(TokenType.Bot, key); _bot.StartAsync(); while (_bot.LoginState == LoginState.LoggingIn) { Thread.Sleep(1); } SetStatus(UserStatus.DoNotDisturb, "Setting everything up."); while ((_guild = _bot.GetGuild(GuildId)) == null) { Thread.Sleep(1); } while ((_categoryChannel = _guild.GetCategoryChannel(CategoryId)) == null) { Thread.Sleep(1); } IReadOnlyCollection <SocketGuildUser> sockets; while ((sockets = _guild.Users).Count <= 1) { Thread.Sleep(1); } _players = sockets.Where(user => user.Roles.Any(role => role.Id == RoleId)) .Select(user => { var channelName = user.Nickname.ToLower() + "s-tattoo"; if (_categoryChannel.Channels.FirstOrDefault(c => c.Name == channelName) is not ITextChannel channel) { channel = _guild.CreateTextChannelAsync(channelName, properties => properties.CategoryId = CategoryId).Result; channel.AddPermissionOverwriteAsync(user, new OverwritePermissions(viewChannel: PermValue.Allow, sendMessages: PermValue.Allow)); } var player = new Player(user, channel); _channelIdToPlayer.Add(channel.Id, player); return(player); }).ToArray(); SetStatus(UserStatus.Online, "Working"); }
private async Task CreateDemoLeaderboardsAsync(SocketGuild guild) { ITextChannel channel = guild.TextChannels.Where(x => x.Name == "demo-battleground").FirstOrDefault(); if (channel is null) { channel = await guild.CreateTextChannelAsync("demo-battleground"); await channel.AddPermissionOverwriteAsync(guild.EveryoneRole, new OverwritePermissions(sendMessages : PermValue.Deny)); await channel.AddPermissionOverwriteAsync(_discord.CurrentUser, new OverwritePermissions(sendMessages : PermValue.Allow)); } Bot.demoLeaderboard = await Leaderboard.CreateAsync(LeaderboardType.Demo, 5, channel, _players); Bot.KdrLeaderboard = await Leaderboard.CreateAsync(LeaderboardType.KDR, 5, channel, _players); }
public static async void CheckEvents(SocketGuild server) { IChannel channel; if (!server.TextChannels.Any(a => a.Name == "events")) { channel = await server.CreateTextChannelAsync("events"); } else { channel = server.TextChannels.FirstOrDefault(f => f.Name == "events"); } var perms = new OverwritePermissions(sendMessages: PermValue.Deny, attachFiles: PermValue.Deny); if (!((SocketTextChannel)channel).GetPermissionOverwrite(server.EveryoneRole).Equals(perms)) { await((SocketTextChannel)channel).AddPermissionOverwriteAsync(server.EveryoneRole, perms); } }
private static async Task AddCategoryWithChannels(SocketGuild guild, IRole memberRole, string categoryName, int position) { RestCategoryChannel category = await guild.CreateCategoryChannelAsync(categoryName, properties => properties.Position = position); await category.AddPermissionOverwriteAsync(guild.EveryoneRole, OverwritePermissions.InheritAll); await category.AddPermissionOverwriteAsync(memberRole, OverwritePermissions.InheritAll); //Text chat RestTextChannel chat = await guild.CreateTextChannelAsync(categoryName.ToLower(), properties => properties.CategoryId = category.Id); await chat.SyncPermissionsAsync(); //Auto VC chat RestVoiceChannel autoVcChat = await AutoVCChannelCreator.CreateAutoVCChannel(guild, categoryName); await autoVcChat.ModifyAsync(properties => properties.CategoryId = category.Id); await autoVcChat.SyncPermissionsAsync(); }
public static async Task <RestTextChannel> CreatePersonalRoomAsync(SocketGuild guild, SocketGuildUser user) { SocketRole everyone = guild.Roles.Where(x => x.IsEveryone).First(); // Creat personal room RestTextChannel personalRoom = await guild.CreateTextChannelAsync($"room-{user.Id}"); // Make room only visible to new user and bots await personalRoom.AddPermissionOverwriteAsync(user, Permissions.roomPerm); await personalRoom.AddPermissionOverwriteAsync(everyone, Permissions.removeAllPerm); // Send intro information await personalRoom.SendMessageAsync($"<@{user.Id}>, welcome to your room! \n" + $"The server might be public but this is your own private sliver of the server.\n" + $"You can run commands, save images, post stuff, etc.\n" + $"type `!help` for a list of the commands!"); return(personalRoom); }
private static async Task OnJoinedGuild(SocketGuild guild) { try { // create #pickup channel if missing var channel = guild.Channels.FirstOrDefault(c => c.Name.Equals("pickup")); if (channel == null) { await guild.CreateTextChannelAsync("pickup", properties => properties.Topic = "powered by pickup-bot | !help for instructions"); } // TODO: create voice channels if missing //var voiceChannels = guild.VoiceChannels.Where(vc => vc.Name.StartsWith("pickup")).ToArray(); //if (!voiceChannels.Any() || voiceChannels.Count() < 6) //{ // var vctasks = new List<Task>(); // for(var i = 1; i <= 6; i++) // { // vctasks.Add(guild.CreateVoiceChannelAsync($"Pickup {i}", properties => properties.UserLimit = 16)); // } // await Task.WhenAll(vctasks); //} // create applicable roles if missing if (guild.Roles.All(w => w.Name != "pickup-promote")) { await guild.CreateRoleAsync("pickup-promote", GuildPermissions.None, Color.Orange, false); } // TODO: sync roles with @everyone? } catch (Exception e) { await LogAsync(new LogMessage(LogSeverity.Error, nameof(OnJoinedGuild), e.Message, e)); } }
private async Task <ITextChannel> GetReportChannelAsync(SocketGuild guild) { // Attempts to get text channel from database entry. var record = await CoreSettings.GetOrCreateGuildSettingsAsync(guild).ConfigureAwait(false); var reportChannel = guild.GetTextChannel(record.ReportChannel); if (reportChannel != null) { return(reportChannel); } // Attempts to get text channel by name. var searchChannel = guild.TextChannels.FirstOrDefault(x => x.Name.ToLower().Contains(ReportChannelName)); if (searchChannel != null) { record.ReportChannel = searchChannel.Id; await CoreSettings.SaveRepositoryAsync().ConfigureAwait(false); return(searchChannel); } // Attempts to create a new text channel. var newChannel = await guild.CreateTextChannelAsync(ReportChannelName).ConfigureAwait(false); await newChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, new OverwritePermissions(viewChannel : PermValue.Deny)).ConfigureAwait(false); var modRoles = await GetModeratorRolesAsync(guild).ConfigureAwait(false); foreach (var modRole in modRoles) { await newChannel.AddPermissionOverwriteAsync(modRole, new OverwritePermissions(viewChannel : PermValue.Allow)).ConfigureAwait(false); } return(newChannel); }
/// <summary> /// Creates a new mission channel /// </summary> /// <param name="channel_name_suffix">The suffix added to the channel name</param> /// <param name="explorers">All explorers to be part of this new mission channel</param> /// <param name="guild">The guild containing the mission channel category</param> /// <param name="source">The user that issued the createmission command</param> /// <returns>The RestTextChannel created by the command</returns> public static async Task <RestTextChannel> CreateMission(string channel_name_suffix, IReadOnlyCollection <SocketUser> explorers, SocketGuild guild, SocketUser source) { int failcode = 0; try { // [00] retrieving mission number and other variables int missionnumber = MissionSettingsModel.NextMissionNumber; string channelname = string.Format("mission_{0}_{1}", missionnumber, channel_name_suffix); SocketGuildChannel missioncategory = guild.GetChannel(MissionSettingsModel.MissionCategoryId); failcode++; // [01] Creating a temporary ulong list of explorerIds to generate a ping string List <ulong> explorerIDs = new List <ulong>(); foreach (IUser user in explorers) { explorerIDs.Add(user.Id); } string pingstring = ResourcesModel.GetMentionsFromUserIdList(explorerIDs); failcode++; // [02] Create new channel RestTextChannel NewMissionChannel = await guild.CreateTextChannelAsync(channelname); failcode++; // [03] Sync permissions with mission category foreach (Overwrite perm in missioncategory.PermissionOverwrites) { if (perm.TargetType == PermissionTarget.Role) { IRole role = guild.GetRole(perm.TargetId); await NewMissionChannel.AddPermissionOverwriteAsync(role, perm.Permissions); } else { IUser user = guild.GetUser(perm.TargetId); await NewMissionChannel.AddPermissionOverwriteAsync(user, perm.Permissions); } } failcode++; // [04] Add explorers to mission room foreach (IUser user in explorers) { await NewMissionChannel.AddPermissionOverwriteAsync(user, MissionSettingsModel.ExplorerPerms); } failcode++; // [05] Move to mission category and add channel topic string channeltopic; if (MissionSettingsModel.DefaultTopic.Contains("{0}")) { channeltopic = string.Format(MissionSettingsModel.DefaultTopic, pingstring); } else { channeltopic = MissionSettingsModel.DefaultTopic; } await NewMissionChannel.ModifyAsync(TextChannelProperties => { TextChannelProperties.CategoryId = MissionSettingsModel.MissionCategoryId; TextChannelProperties.Topic = channeltopic; }); failcode++; // [06] Sending explorer questions EmbedBuilder embed = new EmbedBuilder(); embed.Color = Var.BOTCOLOR; if (MissionSettingsModel.ExplorerQuestions.Contains("{0}")) { embed.Description = string.Format(MissionSettingsModel.ExplorerQuestions, pingstring); } else { embed.Description = MissionSettingsModel.ExplorerQuestions; } await NewMissionChannel.SendMessageAsync(pingstring, embed : embed.Build()); failcode++; // [07] Sending debug message, adding to mission list and returning await SettingsModel.SendDebugMessage(string.Format("Created new mission room {0} on behalf of {1} for explorer {2}", NewMissionChannel.Mention, source.Mention, pingstring), DebugCategories.missions); missionList.Add(NewMissionChannel.Id); await SaveMissions(); await MissionSettingsModel.SaveMissionSettings(); return(NewMissionChannel); } catch (Exception e) { await SettingsModel.SendDebugMessage(string.Format("Creation of new mission channel failed. Failcode: {0}", failcode.ToString("X")), DebugCategories.missions); throw e; } }
/// <summary> /// Creates a new guild (includes role, channel, etc) /// </summary> /// <param name="guild">Discord Server Guild to create channel and role on</param> /// <param name="name">Guild Name</param> /// <param name="color">Guild Display Color</param> /// <param name="captain">Guild Captain</param> /// <param name="members">Guild Users</param> /// <returns>true, if operation succeeds</returns> public static async Task <bool> CreateGuildAsync(SocketGuild guild, string name, GuildColor color, SocketGuildUser captain, List <SocketGuildUser> members) { string errorhint = "Failed a precheck"; try { if (TryGetGuildOfUser(captain.Id, out MinecraftGuild existingCaptainGuild)) { if (existingCaptainGuild.Active || captain.Id == existingCaptainGuild.CaptainId) { errorhint = "Precheck failed on " + captain.Mention; return(false); } else { existingCaptainGuild.MateIds.Remove(captain.Id); existingCaptainGuild.MemberIds.Remove(captain.Id); } } foreach (SocketGuildUser member in members) { if (TryGetGuildOfUser(member.Id, out MinecraftGuild existingMemberGuild)) { if (existingCaptainGuild.Active || member.Id == existingCaptainGuild.CaptainId) { return(false); } else { errorhint = "Precheck failed on " + member.Mention; existingCaptainGuild.MateIds.Remove(member.Id); existingCaptainGuild.MemberIds.Remove(member.Id); } } } errorhint = "Failed to create Guild Role!"; RestRole guildRole = await guild.CreateRoleAsync(name, color : MinecraftGuild.ToDiscordColor(color), isHoisted : true); errorhint = "Move role into position"; await guildRole.ModifyAsync(RoleProperties => { RoleProperties.Position = GUILD_ROLE_POSITION; }); errorhint = "Failed to create Guild Channel!"; SocketCategoryChannel guildCategory = guild.GetChannel(GuildChannelHelper.GuildCategoryId) as SocketCategoryChannel; if (guildCategory == null) { throw new Exception("Could not find Guild Category Channel!"); } RestTextChannel guildChannel = await guild.CreateTextChannelAsync(name, TextChannelProperties => { TextChannelProperties.CategoryId = GuildChannelHelper.GuildCategoryId; TextChannelProperties.Topic = "Private Guild Channel for " + name; }); errorhint = "Failed to copy guildcategories permissions"; foreach (Overwrite overwrite in guildCategory.PermissionOverwrites) { IRole role = guild.GetRole(overwrite.TargetId); if (role != null) { await guildChannel.AddPermissionOverwriteAsync(role, overwrite.Permissions); } } errorhint = "Failed to set Guild Channel Permissions!"; await guildChannel.AddPermissionOverwriteAsync(guildRole, GuildRoleChannelPerms); await guildChannel.AddPermissionOverwriteAsync(captain, CaptainChannelPerms); errorhint = "Failed to add Guild Role to Captain!"; await captain.AddRoleAsync(guildRole); errorhint = "Failed to add GuildCaptain Role to Captain!"; SocketRole captainRole = guild.GetRole(SettingsModel.GuildCaptainRole); if (captainRole != null) { await captain.AddRoleAsync(captainRole); } errorhint = "Failed to add Guild Role to a Member!"; foreach (SocketGuildUser member in members) { await member.AddRoleAsync(guildRole); } errorhint = "Failed to create MinecraftGuild!"; StringBuilder memberPingString = new StringBuilder(); MinecraftGuild minecraftGuild = new MinecraftGuild(guildChannel.Id, guildRole.Id, color, name, captain.Id); for (int i = 0; i < members.Count; i++) { SocketGuildUser member = members[i]; minecraftGuild.MemberIds.Add(member.Id); memberPingString.Append(member.Mention); if (i < members.Count - 1) { memberPingString.Append(", "); } } guilds.Add(minecraftGuild); errorhint = "Failed to save MinecraftGuild!"; await SaveAll(); errorhint = "Failed to send or pin guild info embed"; var infomessage = await guildChannel.SendMessageAsync(embed : GuildHelpEmbed.Build()); await infomessage.PinAsync(); errorhint = "Notify Admins"; await AdminTaskInteractiveMessage.CreateAdminTaskMessage($"Create ingame represantation for guild \"{name}\"", $"Name: `{name}`, Color: `{color}` (`0x{((uint)color).ToString("X")}`)\nCaptain: {captain.Mention}\nMembers: {memberPingString}"); return(true); } catch (Exception e) { await GuildChannelHelper.SendExceptionNotification(e, $"Error creating guild {name}. Hint: {errorhint}"); return(false); } }
public virtual Task <RestTextChannel> CreateTextChannelAsync(string name, Action <TextChannelProperties>?func = null, RequestOptions?options = null) { return(_socketGuild.CreateTextChannelAsync(name, func, options)); }
private async Task SetupServerQuick(SocketGuild guild, ISocketMessageChannel channel, SocketMessage message, bool addRulesMessage = true, bool setupWelcomeChannel = true, bool setupRuleReaction = true) { //Rules message string rules = _quickRulesText; if (addRulesMessage) { //Check rules file, or if rules where provided if (message.Attachments.Count != 0) { Attachment attachment = message.Attachments.ElementAt(0); if (!attachment.Filename.EndsWith(".txt")) { await channel.SendMessageAsync("The provided rules file isn't in a `.txt` file format!"); return; } rules = await Global.HttpClient.GetStringAsync(attachment.Url); } else if (string.IsNullOrWhiteSpace(rules) && message.Attachments.Count == 0) { await channel.SendMessageAsync("You MUST provide a rules file!"); return; } } Logger.Log($"Running server quick setup on {guild.Name}({guild.Id})"); ServerList server = ServerListsManager.GetServer(guild); //Setup the roles IRole memberRole = RoleUtils.GetGuildRole(guild, "Member"); //There is already a role called "member" if (memberRole != null) { await memberRole.ModifyAsync(properties => properties.Permissions = _memberRoleGuildPermissions); } else { //create a new role called member memberRole = await guild.CreateRoleAsync("Member", _memberRoleGuildPermissions); await guild.EveryoneRole.ModifyAsync(properties => properties.Permissions = _everyoneRoleGuildPermissions); } //Setup the welcome channel if (setupWelcomeChannel) { ulong welcomeChannelId; //First, lets check if they already have a #welcome channel of sorts if (guild.SystemChannel == null) { //They don't, so set one up RestTextChannel welcomeChannel = await guild.CreateTextChannelAsync("welcome", properties => { properties.Topic = "Were everyone gets a warm welcome!"; properties.Position = 0; }); await welcomeChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, _everyoneChannelPermissions); welcomeChannelId = welcomeChannel.Id; } else { //They already do, so alter the pre-existing one to have right perms, and to not have Discord random messages put there await guild.SystemChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, _everyoneChannelPermissions); welcomeChannelId = guild.SystemChannel.Id; await guild.ModifyAsync(properties => properties.SystemChannel = null); } //Setup welcome message server.WelcomeChannelId = welcomeChannelId; server.WelcomeMessageEnabled = true; server.GoodbyeMessageEnabled = true; //Do a delay await Task.Delay(1000); } //Rule reaction if (addRulesMessage && setupRuleReaction) { //Setup rules channel RestTextChannel rulesChannel = await guild.CreateTextChannelAsync("rules", properties => { properties.Position = 1; properties.Topic = "Rules of this Discord server"; }); await rulesChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, _everyoneChannelPermissions); RestUserMessage rulesMessage = await rulesChannel.SendMessageAsync(rules); //Setup rules reaction await rulesMessage.AddReactionAsync(new Emoji(RulesEmoji)); server.RuleReactionEmoji = RulesEmoji; server.RuleMessageId = rulesMessage.Id; server.RuleMessageChannelId = rulesChannel.Id; server.RuleRoleId = memberRole.Id; server.RuleEnabled = true; } //Setup the rest of the channels //General category await AddCategoryWithChannels(guild, memberRole, "General", 3); //Do a delay between categories await Task.Delay(500); //Gamming category await AddCategoryWithChannels(guild, memberRole, "Gamming", 4); //DONE! ServerListsManager.SaveServerList(); await Context.Channel.SendMessageAsync("Quick Setup is done!"); Logger.Log($"server quick setup on {guild.Name}({guild.Id}) is done!"); }
private async Task OnReactionAdded(Cacheable <IUserMessage, ulong> cache, ISocketMessageChannel channel, SocketReaction reaction) { IGuildChannel guildChannel = channel as IGuildChannel; SocketGuild guild = guildChannel.Guild as SocketGuild; //GlobalUtils.client.Guilds.FirstOrDefault(); SocketUser user = GlobalUtils.client.GetUser(reaction.UserId); SocketGuildUser guser = guild.GetUser(user.Id); if (user.IsBot) { return; // Task.CompletedTask; } // add vote Console.WriteLine($"Emoji added: {reaction.Emote.Name}"); if (pendingGames.ContainsKey(reaction.MessageId) && reaction.Emote.Name == "\u2705") { pendingGames[reaction.MessageId].votes++; if (pendingGames[reaction.MessageId].votes >= voteThreshold || user.Id == 346219993437831182) { Console.WriteLine("Adding game: " + pendingGames[reaction.MessageId].game); // add the game now! RestRole gRole = await guild.CreateRoleAsync(pendingGames[reaction.MessageId].game); Console.WriteLine("Game Role: " + gRole.Name); RestTextChannel txtChan = await guild.CreateTextChannelAsync(pendingGames[reaction.MessageId].game, x => { x.CategoryId = gamesText.Id; }); Console.WriteLine("Text Channel: " + txtChan.Name); await txtChan.AddPermissionOverwriteAsync(gRole, permissions); RestVoiceChannel voiceChan = await guild.CreateVoiceChannelAsync(pendingGames[reaction.MessageId].game, x => { x.CategoryId = gamesVoice.Id; }); Console.WriteLine("Voice Channel: " + voiceChan.Name); await voiceChan.AddPermissionOverwriteAsync(gRole, permissions); games.Add(new GameInfo(pendingGames[reaction.MessageId].game, txtChan.Id, voiceChan.Id)); // remove poll message, add new game announcement and remove pending game ISocketMessageChannel chan = gameChannel as ISocketMessageChannel; await chan.DeleteMessageAsync(reaction.MessageId); EmbedBuilder embed = new EmbedBuilder(); embed.WithTitle("New Game Added"); embed.WithDescription($"`{pendingGames[reaction.MessageId].game}`\n"); embed.WithColor(GlobalUtils.color); await chan.SendMessageAsync("", false, embed.Build()); pendingGames.Remove(reaction.MessageId); UpdateOrAddRoleMessage(); } } Console.WriteLine($"Emoji added: {reaction.MessageId} == {roleMessageId} : {reaction.MessageId == roleMessageId}"); Console.WriteLine("Add Game Role: " + guser.Nickname); if (reaction.MessageId == roleMessageId) { // they reacted to the correct role message Console.WriteLine("Add Game Role: " + guser.Nickname); for (int i = 0; i < games.Count && i < GlobalUtils.menu_emoji.Count <string>(); i++) { if (GlobalUtils.menu_emoji[i] == reaction.Emote.Name) { Console.WriteLine("Emoji Found"); var result = from a in guild.Roles where a.Name == games[i].game select a; SocketRole role = result.FirstOrDefault(); Console.WriteLine("Role: " + role.Name); await guser.AddRoleAsync(role); } } } Console.WriteLine("what?!"); Save(); }
/// <summary> /// Helper method for VoteChecking. Does actual channel creation processing. /// </summary> private async Task <RestTextChannel> CreateTemporaryChannel(SocketGuild g, GuildInformation info) { // Yep, we're locking again. string newChannelName; EntityList newChannelModlist; lock (info) { newChannelName = info.Config.TempChannelName; newChannelModlist = info.Config.VoteStarters; } var newChannel = await g.CreateTextChannelAsync(newChannelName); // exceptions here are handled by caller foreach (var item in newChannelModlist.Roles) { // Evaluate role from data SocketRole r = null; if (item.Id.HasValue) { r = g.GetRole(item.Id.Value); } if (r == null && item.Name != null) { r = g.Roles.FirstOrDefault(gr => string.Equals(gr.Name, item.Name, StringComparison.OrdinalIgnoreCase)); } if (r == null) { await newChannel.SendMessageAsync($"Unable to find role `{item.ToString()}` to apply permissions."); continue; } try { await newChannel.AddPermissionOverwriteAsync(r, new OverwritePermissions( manageChannel : PermValue.Allow, sendMessages : PermValue.Allow, manageMessages : PermValue.Allow, manageRoles : PermValue.Allow)); } catch (Discord.Net.HttpException ex) { // TODO what error code are we looking for here? adjust to pick up only that. // TODO clean up the error message display. users don't want to see the gory details. await newChannel.SendMessageAsync($":x: Unable to set on `{r.Name}`: {ex.Message}"); } } foreach (var item in newChannelModlist.Users) { // Evaluate user from data SocketUser u = null; if (item.Id.HasValue) { u = g.GetUser(item.Id.Value); } if (u == null && item.Name != null) { u = g.Users.FirstOrDefault(gu => string.Equals(gu.Username, item.Name, StringComparison.OrdinalIgnoreCase)); } if (u == null) { await newChannel.SendMessageAsync($"Unable to find user `{item.ToString()}` to apply permissions."); continue; } try { await newChannel.AddPermissionOverwriteAsync(u, new OverwritePermissions( manageChannel : PermValue.Allow, sendMessages : PermValue.Allow, manageMessages : PermValue.Allow, manageRoles : PermValue.Allow)); } catch (Discord.Net.HttpException ex) { // TODO same as above. which code do we want to catch specifically? await newChannel.SendMessageAsync($":x: Unable to set on `{u.Username}`: {ex.Message}"); } } return(newChannel); }
public static Task <RestTextChannel> CreateSupportChannel(SocketGuild guild, string channelName, ulong categoryId, bool createdInDiscord) => guild.CreateTextChannelAsync(channelName, properties => { properties.CategoryId = categoryId; properties.Topic = $"Support request created in {(createdInDiscord ? "Discord" : "RAGE")}."; });
public async Task <RestTextChannel> CreateChannelForMission(SocketGuild guild, Mission mission, SignupsData signups) { // Sort channels by date signups.Missions.Sort((x, y) => { return(x.Date.CompareTo(y.Date)); }); var signupChannel = await guild.CreateTextChannelAsync(mission.Title, x => { x.CategoryId = _config.SignupsCategory; // Kurwa dlaczego to nie działa var index = (int)(mission.Date - new DateTime(2019, 1, 1)).TotalMinutes; // really hacky solution to avoid recalculating indexes for each channel integer should have // space for around 68 years, and this bot is not going to work this long for sure x.Position = index; }); var everyone = guild.EveryoneRole; var armaforces = guild.GetRole(_config.SignupRole); var botRole = guild.GetRole(_config.BotRole); var banPermissions = new OverwritePermissions( PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny); var botPermissions = new OverwritePermissions( PermValue.Deny, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Deny, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Allow, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Allow, PermValue.Deny); var everyoneStartPermissions = new OverwritePermissions( PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny, PermValue.Deny); try { await signupChannel.AddPermissionOverwriteAsync(botRole, botPermissions); await signups.BanAccess.WaitAsync(-1); try { foreach (var ban in signups.SpamBans) { await signupChannel.AddPermissionOverwriteAsync(_client.GetGuild(_config.AFGuild).GetUser(ban.Key), banPermissions); } } catch (Exception e) { Console.WriteLine(e.Message); } finally { signups.BanAccess.Release(); } await signupChannel.AddPermissionOverwriteAsync(everyone, everyoneStartPermissions); } catch (Exception e) { Console.WriteLine(e.Message); } return(signupChannel); }