Ejemplo n.º 1
0
        public async Task <ITextChannel> CreateChannelsForFinals(
            ISelfUser botUser, ITournamentState state, Game finalsGame, int finalsRoundNumber, int roomIndex)
        {
            Verify.IsNotNull(this.Guild, "guild");
            Verify.IsNotNull(state, nameof(state));
            Verify.IsNotNull(finalsGame, nameof(finalsGame));

            TournamentRoles roles = this.GetTournamentRoles(state);

            ICategoryChannel finalsCategoryChannel = await this.Guild.CreateCategoryAsync("Finals");

            ITextChannel channel = await this.CreateTextChannelAsync(
                botUser,
                finalsCategoryChannel,
                finalsGame,
                roles,
                finalsRoundNumber,
                roomIndex);

            state.ChannelIds = state.ChannelIds
                               .Concat(new ulong[] { channel.Id })
                               .Concat(new ulong[] { finalsCategoryChannel.Id });

            return(channel);
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Constructs a new <see cref="MutePersistingHandler"/> object with the given injected dependencies.
 /// </summary>
 /// <param name="moderationService">A moderation service to interact with the infractions system.</param>
 /// <param name="botUser">The Discord user that the bot is running as.</param>
 public MutePersistingHandler(
     IModerationService moderationService,
     ISelfUser botUser)
 {
     _moderationService = moderationService;
     _botUser           = botUser;
 }
Ejemplo n.º 3
0
        public MockMessageChannel(ISelfUser bot, string name = null)
        {
            Bot = bot;
            var random = new Random();

            Id   = (ulong)random.Next(0, int.MaxValue);
            Name = name;
        }
Ejemplo n.º 4
0
        public IDiscordClient CreateClient()
        {
            Mock <IDiscordClient> mockClient = new Mock <IDiscordClient>();
            ISelfUser             selfUser   = CreateSelfUser();

            mockClient.Setup(o => o.CurrentUser).Returns(selfUser);
            return(mockClient.Object);
        }
Ejemplo n.º 5
0
        public async Task statusAsync()
        {
            ISelfUser SelfUser = Context.Client.CurrentUser;

            EmbedAuthorBuilder eab = new EmbedAuthorBuilder
            {
                IconUrl = SelfUser.GetAvatarUrl(),
                Name    = SelfUser.Username
            };

            EmbedBuilder builder = new EmbedBuilder();

            builder.WithAuthor(eab);
            builder.WithDescription(SelfUser.Username + " Statistics");

            TimeSpan startTime = (DateTime.Now - Process.GetCurrentProcess().StartTime);

            DiscordShardedClient client = Context.Client as DiscordShardedClient;

            SocketSelfUser SocketSelf = Context.Client.CurrentUser as SocketSelfUser;

            string status = "Online";

            switch (SocketSelf.Status)
            {
            case UserStatus.Offline: status = "Offline"; break;

            case UserStatus.Online: status = "Online"; break;

            case UserStatus.Idle: status = "Idle"; break;

            case UserStatus.AFK: status = "AFK"; break;

            case UserStatus.DoNotDisturb: status = "Do Not Disturb"; break;

            case UserStatus.Invisible: status = "Invisible/Offline"; break;
            }

            string assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();

            int fixedCmdGlobalCount         = GlobalVars.CommandExecutions + 1;
            int fixedCmdGlobalCount_Servers = GlobalVars.CommandExecutions_Servers + 1;
            int fixedCmdGlobalCount_DMs     = GlobalVars.CommandExecutions_DMs + 1;

            builder.AddField("Bot Uptime: ", startTime.ToReadableString(), true);
            builder.AddField("Server Uptime: ", GlobalVars.SystemUpTime().ToReadableString(), true);
            builder.AddField("Usercount: ", (await userService.GetUserCountAsync()).ToString(), true);
            builder.AddField("Servercount: ", client.Guilds.Count, true);
            builder.AddField("Commands used since bot start: ", fixedCmdGlobalCount);
            builder.AddField("Commands in servers: ", fixedCmdGlobalCount_Servers);
            builder.AddField("Commands in DMs ", fixedCmdGlobalCount_DMs);
            builder.AddField("Bot status: ", status, true);
            builder.AddField("Latency: ", client.Latency + "ms", true);
            builder.AddField("Shards: ", client.Shards.Count, true);
            builder.AddField("Bot version: ", assemblyVersion, true);

            await Context.Channel.SendMessageAsync("", false, builder.Build()).ConfigureAwait(false);
        }
Ejemplo n.º 6
0
 public ModuleA(IDiscordClient c, ISelfUser s)
 {
     if (!(c is DiscordSocketClient))
     {
         throw new InvalidOperationException("This module requires a DiscordSocketClient");
     }
     client = c as DiscordSocketClient;
     self   = s;
 }
Ejemplo n.º 7
0
        /// <inheritdoc />
        public Task OnAuthenticatedAsync(ISelfUser self)
        {
            CurrentGuildId = null;
            CurrentUserId  = self.Id;
            CurrentClaims  = Enum.GetValues(typeof(AuthorizationClaim))
                             .Cast <AuthorizationClaim>()
                             .ToHashSet();

            return(Task.CompletedTask);
        }
Ejemplo n.º 8
0
 /// <summary>
 /// Constructs a new <see cref="ModerationInvitePurgingHandler"/> object, with the given injected dependencies.
 /// </summary>
 /// <param name="designatedChannelService"></param>
 /// <param name="authorizationService"></param>
 /// <param name="moderationService"></param>
 /// <param name="botUser">The Discord user that the bot is running as.</param>
 public ModerationInvitePurgingHandler(
     IDesignatedChannelService designatedChannelService,
     IAuthorizationService authorizationService,
     IModerationService moderationService,
     ISelfUser botUser)
 {
     _designatedChannelService = designatedChannelService;
     _authorizationService     = authorizationService;
     _moderationService        = moderationService;
     _botUser = botUser;
 }
Ejemplo n.º 9
0
 public ModerationService(
     IAuthorizationService authorizationService,
     IDesignatedRoleService designatedRoleService,
     IInfractionRepository infractionRepository,
     ISelfUser selfUser,
     IUserService userService)
 {
     AuthorizationService  = authorizationService;
     DesignatedRoleService = designatedRoleService;
     InfractionRepository  = infractionRepository;
     SelfUser    = selfUser;
     UserService = userService;
 }
Ejemplo n.º 10
0
        public async Task DmAsync(string user, [Remainder] string dm = "")
        {
            IUser User = await Context.Client.GetUserAsync(ulong.Parse(user));

            IDMChannel Dm = await User.GetOrCreateDMChannelAsync();

            ISelfUser client = Context.Client.CurrentUser;
            var       embed  = new EmbedBuilder();

            embed.WithAuthor($"Owner of {client}");
            embed.WithThumbnailUrl(client.GetAvatarUrl());
            embed.WithColor(Color.DarkTeal);
            embed.WithDescription(dm);
            embed.WithFooter("You can reply to this message with =>contact");
            await Dm.SendMessageAsync(embed : embed.Build());
        }
Ejemplo n.º 11
0
        private async Task LogoutInternalAsync()
        {
            if (LoginState == LoginState.LoggedOut)
            {
                return;
            }
            LoginState = LoginState.LoggingOut;

            await ApiClient.LogoutAsync().ConfigureAwait(false);

            await OnLogoutAsync().ConfigureAwait(false);

            CurrentUser = null;
            LoginState  = LoginState.LoggedOut;

            await _loggedOutEvent.InvokeAsync().ConfigureAwait(false);
        }
Ejemplo n.º 12
0
        public static async Task <bool> changeName(IDiscordClient client, string name)
        {
            ISelfUser self = client.CurrentUser;

            try
            {
                await self.ModifyAsync(x =>
                {
                    x.Username = name;
                });

                return(true);
            }
            catch
            {
                return(false);
            }
        }
Ejemplo n.º 13
0
        public static async Task <Model> ModifyAsync(ISelfUser user, BaseDiscordClient client, Action <SelfUserProperties> func,
                                                     RequestOptions options)
        {
            SelfUserProperties args = new SelfUserProperties();

            func(args);
            ModifyCurrentUserParams apiArgs = new API.Rest.ModifyCurrentUserParams
            {
                Avatar   = args.Avatar.IsSpecified ? args.Avatar.Value?.ToModel() : Optional.Create <ImageModel?>(),
                Username = args.Username
            };

            if (!apiArgs.Avatar.IsSpecified && user.AvatarId != null)
            {
                apiArgs.Avatar = new ImageModel(user.AvatarId);
            }

            return(await client.ApiClient.ModifySelfAsync(apiArgs, options).ConfigureAwait(false));
        }
Ejemplo n.º 14
0
        public static async Task <bool> changeProfile(IDiscordClient client, string path)
        {
            ISelfUser self = client.CurrentUser;

            try
            {
                Image image = new(path);

                await self.ModifyAsync(x =>
                {
                    x.Avatar = image;
                });

                return(true);
            }
            catch
            {
                return(false);
            }
        }
Ejemplo n.º 15
0
        public async Task CreateChannelsForRebracket(
            ISelfUser botUser,
            ITournamentState state,
            IEnumerable <Round> rounds,
            int startingRoundNumber)
        {
            Verify.IsNotNull(this.Guild, "guild");
            Verify.IsNotNull(state, nameof(state));
            Verify.IsNotNull(rounds, nameof(rounds));

            TournamentRoles roles = this.GetTournamentRoles(state);

            ITextChannel[] textChannels = await this.CreateTextChannelsForRounds(
                botUser, rounds, roles, startingRoundNumber);

            IEnumerable <ulong> textCategoryChannelIds = GetCategoryChannelIds(textChannels);

            state.ChannelIds = state.ChannelIds
                               .Concat(textChannels.Select(channel => channel.Id))
                               .Concat(textCategoryChannelIds);
        }
Ejemplo n.º 16
0
        public static void SetUserAgent(ISelfUser self)
        {
            StringBuilder userAgent = new();

            userAgent.Append(self.Username);
            userAgent.Append('-');
            userAgent.Append(self.Discriminator);
            userAgent.Append('/');
            userAgent.Append(
                Assembly
                .GetExecutingAssembly()
                .GetName()
                .Version
                .ToString()
                );
            userAgent.Append(" (Discord.Net; +");
            userAgent.Append(SkuldAppContext.Website);
            userAgent.Append(") DBots/");
            userAgent.Append(self.Id);

            UAGENT = userAgent.ToString();
        }
Ejemplo n.º 17
0
        public async Task CreateChannelsForPrelims(ISelfUser botUser, ITournamentState state, TournamentRoles roles)
        {
            Verify.IsNotNull(this.Guild, "guild");
            Verify.IsNotNull(state, nameof(state));
            Verify.IsNotNull(roles, nameof(roles));

            List <Task <IVoiceChannel> > createVoiceChannelsTasks = new List <Task <IVoiceChannel> >();
            // We only need to go through the games for the first round to get all of the readers.
            Round firstRound = state.Schedule.Rounds.First();

            Debug.Assert(firstRound.Games.Select(game => game.Reader.Name).Count() ==
                         firstRound.Games.Select(game => game.Reader.Name).Distinct().Count(),
                         "All reader names should be unique.");
            ICategoryChannel voiceCategoryChannel = await this.Guild.CreateCategoryAsync(
                "Readers", options : RequestOptionsSettings.Default);

            foreach (Game game in firstRound.Games)
            {
                createVoiceChannelsTasks.Add(
                    this.CreateVoiceChannelAsync(voiceCategoryChannel, game.Reader));
            }

            IVoiceChannel[] voiceChannels = await Task.WhenAll(createVoiceChannelsTasks);

            // Create the text channels
            const int startingRoundNumber = 1;

            ITextChannel[] textChannels = await this.CreateTextChannelsForRounds(
                botUser, state.Schedule.Rounds, roles, startingRoundNumber);

            IEnumerable <ulong> textCategoryChannelIds = GetCategoryChannelIds(textChannels);

            state.ChannelIds = voiceChannels.Select(channel => channel.Id)
                               .Concat(textChannels.Select(channel => channel.Id))
                               .Concat(new ulong[] { voiceCategoryChannel.Id })
                               .Concat(textCategoryChannelIds)
                               .ToArray();
        }
Ejemplo n.º 18
0
        public async Task fmfeaturedAsync()
        {
            try
            {
                EmbedBuilder builder = new EmbedBuilder
                {
                    Color = new Discord.Color(186, 0, 0)
                };

                ISelfUser SelfUser = Context.Client.CurrentUser;
                builder.WithThumbnailUrl(SelfUser.GetAvatarUrl());
                builder.AddField("Featured:", _timer.GetTrackString());

                await Context.Channel.SendMessageAsync("", false, builder.Build());

                this._logger.LogCommandUsed(Context.Guild?.Id, Context.Channel.Id, Context.User.Id, Context.Message.Content);
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, Context.Message.Content, Context.User.Username, Context.Guild?.Name, Context.Guild?.Id);
                await ReplyAsync("Unable to show the featured avatar on FMBot due to an internal error. The timer service cannot be loaded. Please wait for the bot to fully load.");
            }
        }
Ejemplo n.º 19
0
        private async Task <ITextChannel[]> CreateTextChannelsForRounds(
            ISelfUser botUser,
            IEnumerable <Round> rounds,
            TournamentRoles roles,
            int startingRoundNumber)
        {
            Verify.IsNotNull(this.Guild, "guild");
            Verify.IsNotNull(rounds, nameof(rounds));
            Verify.IsNotNull(roles, nameof(roles));

            List <Task <ITextChannel> > createTextChannelsTasks = new List <Task <ITextChannel> >();
            List <ulong> textCategoryChannelIds = new List <ulong>();
            int          roundNumber            = startingRoundNumber;

            foreach (Round round in rounds)
            {
                int roomNumber = 0;
                ICategoryChannel roundCategoryChannel = await this.Guild.CreateCategoryAsync(
                    $"Round {roundNumber}",
                    options : RequestOptionsSettings.Default);

                textCategoryChannelIds.Add(roundCategoryChannel.Id);

                foreach (Game game in round.Games)
                {
                    createTextChannelsTasks.Add(this.CreateTextChannelAsync(
                                                    botUser, roundCategoryChannel, game, roles, roundNumber, roomNumber));
                    roomNumber++;
                }

                roundNumber++;
            }

            ITextChannel[] textChannels = await Task.WhenAll(createTextChannelsTasks);

            return(textChannels);
        }
Ejemplo n.º 20
0
        public async Task fmfullhelpAsync()
        {
            string prefix = ConfigData.Data.CommandPrefix;

            ISelfUser SelfUser = Context.Client.CurrentUser;

            string description = null;
            int    length      = 0;

            EmbedBuilder builder = new EmbedBuilder();

            foreach (ModuleInfo module in _service.Modules.OrderByDescending(o => o.Commands.Count()).Where(w => !w.Name.Contains("SecretCommands") && !w.Name.Contains("OwnerCommands") && !w.Name.Contains("AdminCommands") && !w.Name.Contains("GuildCommands")))
            {
                foreach (CommandInfo cmd in module.Commands)
                {
                    PreconditionResult result = await cmd.CheckPreconditionsAsync(Context);

                    if (result.IsSuccess)
                    {
                        if (!string.IsNullOrWhiteSpace(cmd.Summary))
                        {
                            description += $"{prefix}{cmd.Aliases.First()} - {cmd.Summary}\n";
                        }
                        else
                        {
                            description += $"{prefix}{cmd.Aliases.First()}\n";
                        }
                    }
                }


                if (description.Length < 1024)
                {
                    builder.AddField
                        (module.Name + (module.Summary != null ? " - " + module.Summary : ""),
                        description != null ? description : "");
                }


                length     += description.Length;
                description = null;

                if (length < 1990)
                {
                    await Context.User.SendMessageAsync("", false, builder.Build()).ConfigureAwait(false);

                    builder = new EmbedBuilder();
                    length  = 0;
                }
            }


            builder = new EmbedBuilder
            {
                Title = "Additional information",
            };

            builder.AddField("Quick tips",
                             "- Be sure to use 'help' after a command name to see the parameters. \n" +
                             "- Chart sizes range from 3x3 to 10x10 \n" +
                             "- Most commands have no required parameters");


            builder.AddField("Setting your username",
                             "Use `" + prefix + "fmset 'username' 'embedfull/embedmini/textfull/textmini'` to set your global LastFM username. " +
                             "The last parameter means the mode that your embed will be");


            builder.AddField("Making album charts",
                             "`" + prefix + "fmchart '3x3-10x10' 'weekly/monthly/yearly/overall' 'notitles/titles' 'user'`");


            builder.AddField("Making artist charts",
                             "`" + prefix + "fmartistchart '3x3-10x10' 'weekly/monthly/yearly/overall' 'notitles/titles' 'user'`");


            builder.AddField("Setting the default server settings",
                             "Please note that server defaults are a planned feature. \n" +
                             "Only users with the 'Ban Members' permission or admins can use this command. \n" +
                             "`" + prefix + "fmserverset 'embedfull/embedmini/textfull/textmini' 'Weekly/Monthly/Yearly/AllTime'`");

            builder.WithFooter("Still need help? Join the FMBot Discord Server: https://discord.gg/srmpCaa");

            await Context.User.SendMessageAsync("", false, builder.Build()).ConfigureAwait(false);

            if (!guildService.CheckIfDM(Context))
            {
                await Context.Channel.SendMessageAsync("Check your DMs!").ConfigureAwait(false);
            }
        }
Ejemplo n.º 21
0
        internal async Task UpdateFriend(CMsgClientPersonaState persona)
        {
            var users = new List <(IUser Before, IUser After)>();
            var clans = new List <(IClan Before, IClan After)>();

            ISelfUser currentBefore = null;
            ISelfUser currentAfter  = null;

            await _slim.WaitAsync();

            try
            {
                var flag = (ClientPersonaStateFlag)persona.status_flags;

                foreach (var friend in persona.friends)
                {
                    SteamId friendId = friend.friendid;

                    if (friendId == Client.SteamId) // that's us!
                    {
                        currentBefore = _currentUser;

                        if (currentBefore is OfflineSelfUser)
                        {
                            currentAfter = SelfUser.Create(Client, friend, flag);
                        }
                        else
                        {
                            currentAfter = (currentBefore as SelfUser).WithState(friend, flag);
                        }
                    }
                    else if (friendId.IsClan)
                    {
                        IClan before;
                        IClan after;

                        before = _clans[friend.friendid];

                        if (before is UnknownUser)
                        {
                            after = Clan.Create(Client, before.Relationship, friend, flag);
                        }
                        else
                        {
                            after = (before as Clan).WithPersonaState(friend, flag);
                        }

                        _clans[after.Id] = after;

                        clans.Add((before, after));
                    }
                    else
                    {
                        IUser before;
                        IUser after;

                        before = _users[friend.friendid];

                        if (before is UnknownUser)
                        {
                            after = User.Create(Client, before.Relationship, friend, flag);
                        }
                        else
                        {
                            after = (before as User).WithState(friend, flag);
                        }

                        _users[after.Id] = after;

                        users.Add((before, after));
                    }
                }
            }
            finally
            {
                _slim.Release();
            }

            if (currentBefore != null || currentAfter != null)
            {
                _currentUser = currentAfter;
                await InvokeCurrentUserUpdated(currentBefore, currentAfter).ConfigureAwait(false);
            }

            await Task.WhenAll(users.Select(t => InvokeUserUpdated(t.Before, t.After)).Concat(clans.Select(t => InvokeClanUpdated(t.Before, t.After)))).ConfigureAwait(false);
        }
Ejemplo n.º 22
0
 internal async Task InitCurrentUser(string personaName)
 {
     _currentUser = new OfflineSelfUser(Client, Client.SteamId, personaName);
     await InvokeCurrentUserUpdated(null, _currentUser).ConfigureAwait(false);
 }
Ejemplo n.º 23
0
 private async Task InvokeCurrentUserUpdated(ISelfUser before, ISelfUser after)
 {
     await CurrentUserUpdated.InvokeAsync(this, new CurrentUserUpdatedEventArgs(before, after)).ConfigureAwait(false);
 }
Ejemplo n.º 24
0
 /// <summary>
 /// Converts an existing <see cref="ISelfUser"/> to an abstracted <see cref="ISelfUser"/> value.
 /// </summary>
 /// <param name="selfUser">The existing <see cref="ISelfUser"/> to be abstracted.</param>
 /// <exception cref="ArgumentNullException">Throws for <paramref name="selfUser"/>.</exception>
 /// <returns>An <see cref="ISelfUser"/> that abstracts <paramref name="selfUser"/>.</returns>
 public static ISelfUser Abstract(this ISelfUser selfUser)
 => selfUser switch
 {
     null
     => throw new ArgumentNullException(nameof(selfUser)),
Ejemplo n.º 25
0
 public MockTextChannel(ISelfUser user, IGuild guild, string name) : base(user, name)
 {
     Guild = guild;
 }
Ejemplo n.º 26
0
 public MockDMChannel(ISelfUser bot, IUser user) : base(bot, $"{user.Username}'s DM")
 {
     Recipients = new IUser[] { user, bot }.ToImmutableArray();
     Recipient  = user;
 }
 public CurrentUserUpdatedEventArgs(ISelfUser before, ISelfUser after)
 {
     Before = before;
     After  = after;
 }
Ejemplo n.º 28
0
        private async Task <ITextChannel> CreateTextChannelAsync(
            ISelfUser botUser,
            ICategoryChannel parent,
            Game game,
            TournamentRoles roles,
            int roundNumber,
            int roomNumber)
        {
            Verify.IsNotNull(this.Guild, "guild");
            Verify.IsNotNull(parent, nameof(parent));
            Verify.IsNotNull(game, nameof(game));
            Verify.IsNotNull(roles, nameof(roles));

            // The room and role names will be the same.
            this.Logger.Debug("Creating text channel for room {0} in round {1}", roomNumber, roundNumber);
            string       name    = GetTextRoomName(game.Reader, roundNumber);
            ITextChannel channel = await this.Guild.CreateTextChannelAsync(
                name,
                channelProps =>
            {
                channelProps.CategoryId = parent.Id;
            },
                RequestOptionsSettings.Default);

            this.Logger.Debug("Text channel for room {0} in round {1} created", roomNumber, roundNumber);

            // We need to add the bot's permissions first before we disable permissions for everyone.
            await channel.AddPermissionOverwriteAsync(
                botUser, PrivilegedOverwritePermissions, RequestOptionsSettings.Default);

            this.Logger.Debug("Adding permissions to text channel for room {0} in round {1}", roomNumber, roundNumber);
            await channel.AddPermissionOverwriteAsync(
                this.Guild.EveryoneRole, EveryonePermissions, RequestOptionsSettings.Default);

            await channel.AddPermissionOverwriteAsync(
                roles.DirectorRole, PrivilegedOverwritePermissions, RequestOptionsSettings.Default);

            if (roles.RoomReaderRoles.TryGetValue(game.Reader, out IRole readerRole))
            {
                await channel.AddPermissionOverwriteAsync(
                    readerRole, PrivilegedOverwritePermissions, RequestOptionsSettings.Default);
            }
            else
            {
                this.Logger.Warning("Could not find a reader role for a reader with ID {0}.", game.Reader?.Id);
            }

            List <Task> addTeamRolesToChannel = new List <Task>();

            foreach (Team team in game.Teams)
            {
                if (!roles.TeamRoles.TryGetValue(team, out IRole role))
                {
                    this.Logger.Warning("Team {name} did not have a role defined.", team.Name);
                    continue;
                }

                // TODO: Investigate if it's possible to parallelize this. Other attempts to do so (Task.WhenAll,
                // AsyncEnumerable's ParallelForEachAsync) have had bugs where roles sometimes aren't assigned to a
                // channel. Adding an await in the loop seems to be the only thing that
                await this.AddPermission(channel, role);
            }

            await Task.WhenAll(addTeamRolesToChannel);

            this.Logger.Debug("Added permissions to text channel for room {0} in round {1}", roomNumber, roundNumber);
            return(channel);
        }