示例#1
0
        private async Task AddMessage(ChatMessageViewModel message)
        {
            this.Messages.Add(message);

            if (!this.ChatUsers.ContainsKey(message.User.ID))
            {
                await this.AddUser(message.User);
            }

            if (this.DisableChat && !message.ID.Equals(Guid.Empty))
            {
                await this.DeleteMessage(message.ID);

                return;
            }

            string moderationReason;

            if (message.ShouldBeModerated(out moderationReason))
            {
                await this.DeleteMessage(message.ID);

                string whisperMessage = " due to chat moderation for the following reason: " + moderationReason + ". Please watch what you type in chat or further actions will be taken.";

                message.User.ChatOffenses++;
                if (ChannelSession.Settings.ModerationTimeout5MinuteOffenseCount > 0 && message.User.ChatOffenses >= ChannelSession.Settings.ModerationTimeout5MinuteOffenseCount)
                {
                    await this.Whisper(message.User.UserName, "You have been timed out from chat for 5 minutes" + whisperMessage);

                    await this.TimeoutUser(message.User.UserName, 300);
                }
                else if (ChannelSession.Settings.ModerationTimeout1MinuteOffenseCount > 0 && message.User.ChatOffenses >= ChannelSession.Settings.ModerationTimeout1MinuteOffenseCount)
                {
                    await this.Whisper(message.User.UserName, "You have been timed out from chat for 1 minute" + whisperMessage);

                    await this.TimeoutUser(message.User.UserName, 60);
                }
                else
                {
                    await this.Whisper(message.User.UserName, "Your message has been deleted" + whisperMessage);
                }
                return;
            }

            if (ChannelSession.IsStreamer && ChatMessageCommandViewModel.IsCommand(message) && !message.User.Roles.Contains(UserRole.Banned))
            {
                ChatMessageCommandViewModel messageCommand = new ChatMessageCommandViewModel(message);

                GlobalEvents.ChatCommandMessageReceived(messageCommand);

                PermissionsCommandBase command = ChannelSession.AllChatCommands.FirstOrDefault(c => c.ContainsCommand(messageCommand.CommandName));
                if (command != null)
                {
                    await command.Perform(message.User, messageCommand.CommandArguments);
                }
            }
        }
示例#2
0
        private async Task <bool> CheckMessageForCommandAndRun(ChatMessageViewModel message)
        {
            if (!ChannelSession.Settings.AllowCommandWhispering && message.IsWhisper)
            {
                return(false);
            }

            if (ChannelSession.BotUser != null && ChannelSession.Settings.IgnoreBotAccountCommands && message.User != null && message.User.ID.Equals(ChannelSession.BotUser.id))
            {
                return(false);
            }

            if (ChannelSession.Settings.CommandsOnlyInYourStream && !message.IsInUsersChannel)
            {
                return(false);
            }

            if (ChannelSession.IsStreamer && !message.User.MixerRoles.Contains(MixerRoleEnum.Banned))
            {
                GlobalEvents.ChatCommandMessageReceived(message);

                List <PermissionsCommandBase> commandsToCheck = new List <PermissionsCommandBase>(ChannelSession.AllChatCommands);
                commandsToCheck.AddRange(message.User.Data.CustomCommands);
                PermissionsCommandBase command = commandsToCheck.FirstOrDefault(c => c.ContainsCommand(message.CommandName));
                if (command != null)
                {
                    await command.Perform(message.User, message.CommandArguments);

                    if (ChannelSession.Settings.DeleteChatCommandsWhenRun)
                    {
                        await this.DeleteMessage(message.ID);
                    }

                    return(true);
                }
            }

            return(false);
        }
        private PermissionsCommandBase CheckMessageForCommand(ChatMessageViewModel message)
        {
            Util.Logger.LogDiagnostic(string.Format("Checking Message For Command - {0}", message.ToString()));

            if (!ChannelSession.Settings.AllowCommandWhispering && message.IsWhisper)
            {
                return(null);
            }

            if (ChannelSession.BotUser != null && ChannelSession.Settings.IgnoreBotAccountCommands && message.User != null && message.User.ID.Equals(ChannelSession.BotUser.id))
            {
                return(null);
            }

            if (ChannelSession.Settings.CommandsOnlyInYourStream && !message.IsInUsersChannel)
            {
                return(null);
            }

            if (ChannelSession.IsStreamer && !message.User.MixerRoles.Contains(MixerRoleEnum.Banned))
            {
                GlobalEvents.ChatCommandMessageReceived(message);

                List <PermissionsCommandBase> commandsToCheck = new List <PermissionsCommandBase>(ChannelSession.AllEnabledChatCommands);
                commandsToCheck.AddRange(message.User.Data.CustomCommands);

                PermissionsCommandBase command = commandsToCheck.FirstOrDefault(c => c.MatchesCommand(message.Message));
                if (command == null)
                {
                    command = commandsToCheck.FirstOrDefault(c => c.ContainsCommand(message.Message));
                }

                return(command);
            }

            return(null);
        }