Ejemplo n.º 1
0
        public async Task SetRoleAsSafe(DiscordRequest request, Contexts contexts)
        {
            var args = request.Arguments.Skip(1).ToArray(); // 1 args is string "role", so it's not needed

            if (args.Length < 2)
            {
                throw new NotEnoughArgumentsException();
            }

            var roleName    = args[0].Value;
            var toSetAsSafe = args[1].Value == "safe";

            var serverRole = _usersRolesService.GetRoleByName(roleName, contexts.Server);

            if (serverRole == null)
            {
                throw new RoleNotFoundException(roleName);
            }

            if (toSetAsSafe)
            {
                var command = new SetRoleAsSafeCommand(roleName, contexts.Server.Id);
                await _commandBus.ExecuteAsync(command);
            }
            else
            {
                var command = new SetRoleAsUnsafeCommand(roleName, contexts.Server.Id);
                await _commandBus.ExecuteAsync(command);
            }

            var messagesService = _messagesServiceFactory.Create(contexts);
            await messagesService.SendResponse(x => x.RoleSettingsChanged(roleName), contexts);
        }
        public void UnmuteUsersInit(DiscordServerContext server)
        {
            var users    = _usersService.GetUsers(server).ToList();
            var muteRole = _usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server);

            if (!users.Any() || muteRole == null)
            {
                return;
            }

            var query            = new GetMuteEventsQuery(server.Id);
            var notUnmutedEvents = _queryBus.Execute(query).MuteEvents
                                   .Where(x => x.Unmuted == false)
                                   .ToList();

            foreach (var muteEvent in notUnmutedEvents)
            {
                if (muteEvent.TimeRange.End < DateTime.UtcNow)
                {
                    RemoveMuteRole(muteEvent, server, users, muteRole);
                }
                else
                {
                    RemoveInFuture(muteEvent, server, users, muteRole);
                }
            }
        }
Ejemplo n.º 3
0
        private UserRole GetMuteRole(DiscordServerContext server)
        {
            var muteRole = _usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server);

            if (muteRole == null)
            {
                throw new RoleNotFoundException(UsersRolesService.MUTED_ROLE_NAME);
            }
            return(muteRole);
        }
Ejemplo n.º 4
0
        public void AddRoleToUser(IEnumerable <Role> safeRoles, MessagesService messagesService, Contexts contexts, string commandRole)
        {
            var role = safeRoles.FirstOrDefault(x => x.Name == commandRole);

            if (role == null)
            {
                messagesService.SendResponse(x => x.RoleNotFoundOrIsNotSafe(contexts, commandRole), contexts);
                return;
            }
            if (contexts.User.Roles.Any(x => x.Name == role.Name))
            {
                messagesService.SendResponse(x => x.RoleIsInUserAlready(contexts, commandRole), contexts);
                return;
            }
            var serverRole = _usersRolesService.GetRoleByName(commandRole, contexts.Server);

            _usersService.AddRole(serverRole, contexts.User, contexts.Server).Wait();
            messagesService.SendResponse(x => x.RoleAddedToUser(contexts, commandRole), contexts);
        }
Ejemplo n.º 5
0
        private async Task MuteRoleInit(DiscordServerContext server)
        {
            var mutedRole = _usersRolesService.GetRoleByName(UsersRolesService.MUTED_ROLE_NAME, server);

            if (mutedRole == null)
            {
                await _muteRoleInitService.InitForServer(server);
            }

            Log.Information($"Mute role initialized: {server.Name}");
        }