private async Task <ChatMessageViewModel> AddMessage(ChatMessageEventModel messageEvent)
        {
            UserViewModel user = await ChannelSession.ActiveUsers.AddOrUpdateUser(messageEvent.GetUser());

            if (user == null)
            {
                user = new UserViewModel(messageEvent);
            }
            else
            {
                await user.RefreshDetails();
            }
            user.UpdateLastActivity();

            ChatMessageViewModel message = new ChatMessageViewModel(messageEvent, user);

            Util.Logger.LogDiagnostic(string.Format("Message Received - {0}", message.ToString()));

            if (!message.IsWhisper && !this.userEntranceCommands.Contains(user.ID))
            {
                this.userEntranceCommands.Add(user.ID);
                if (user.Data.EntranceCommand != null)
                {
                    await user.Data.EntranceCommand.Perform(user);
                }
            }

            if (this.Messages.ContainsKey(message.ID))
            {
                return(null);
            }
            this.Messages[message.ID] = message;

            if (this.DisableChat && !message.ID.Equals(Guid.Empty))
            {
                Util.Logger.LogDiagnostic(string.Format("Deleting Message As Chat Disabled - {0}", message.Message));
                await this.DeleteMessage(message);

                return(message);
            }

            if (!ModerationHelper.MeetsChatInteractiveParticipationRequirement(user) || !ModerationHelper.MeetsChatEmoteSkillsOnlyParticipationRequirement(user, message))
            {
                Util.Logger.LogDiagnostic(string.Format("Deleting Message As User does not meet requirement - {0} - {1}", ChannelSession.Settings.ModerationChatInteractiveParticipation, message.Message));

                await this.DeleteMessage(message);

                await ModerationHelper.SendChatInteractiveParticipationWhisper(user, isChat : true);

                return(message);
            }

            string moderationReason = await message.ShouldBeModerated();

            if (!string.IsNullOrEmpty(moderationReason))
            {
                Util.Logger.LogDiagnostic(string.Format("Message Should Be Moderated - {0}", message.ToString()));

                bool shouldBeModerated         = true;
                PermissionsCommandBase command = this.CheckMessageForCommand(message);
                if (command != null && string.IsNullOrEmpty(await ModerationHelper.ShouldBeFilteredWordModerated(user, message.Message)))
                {
                    shouldBeModerated = false;
                }

                if (shouldBeModerated)
                {
                    Util.Logger.LogDiagnostic(string.Format("Moderation Being Performed - {0}", message.ToString()));

                    message.ModerationReason = moderationReason;
                    await this.DeleteMessage(message);

                    return(message);
                }
            }

            if (!string.IsNullOrEmpty(ChannelSession.Settings.NotificationChatWhisperSoundFilePath) && message.IsWhisper)
            {
                await ChannelSession.Services.AudioService.Play(ChannelSession.Settings.NotificationChatWhisperSoundFilePath, 100);
            }
            else if (!string.IsNullOrEmpty(ChannelSession.Settings.NotificationChatTaggedSoundFilePath) && message.IsUserTagged)
            {
                await ChannelSession.Services.AudioService.Play(ChannelSession.Settings.NotificationChatTaggedSoundFilePath, 100);
            }
            else if (!string.IsNullOrEmpty(ChannelSession.Settings.NotificationChatMessageSoundFilePath))
            {
                await ChannelSession.Services.AudioService.Play(ChannelSession.Settings.NotificationChatMessageSoundFilePath, 100);
            }

            GlobalEvents.ChatMessageReceived(message);

            if (!await this.CheckMessageForCommandAndRun(message))
            {
                if (message.IsWhisper && ChannelSession.Settings.TrackWhispererNumber && !message.IsStreamerOrBot())
                {
                    await this.whisperNumberLock.WaitAndRelease(() =>
                    {
                        if (!whisperMap.ContainsKey(message.User.ID))
                        {
                            whisperMap[message.User.ID] = whisperMap.Count + 1;
                        }
                        message.User.WhispererNumber = whisperMap[message.User.ID];
                        return(Task.FromResult(0));
                    });

                    await ChannelSession.Chat.Whisper(message.User.UserName, $"You are whisperer #{message.User.WhispererNumber}.", false);
                }
            }

            return(message);
        }
Beispiel #2
0
        private async void Client_OnGiveInput(object sender, InteractiveGiveInputModel e)
        {
            try
            {
                if (e != null && e.input != null)
                {
                    InteractiveControlModel            control          = this.Controls[e.input.controlID];
                    InteractiveConnectedControlCommand connectedControl = null;
                    if (this.ControlCommands.ContainsKey(e.input.controlID))
                    {
                        connectedControl = this.ControlCommands[e.input.controlID];

                        if (!connectedControl.DoesInputMatchCommand(e))
                        {
                            return;
                        }

                        if (!connectedControl.Command.IsEnabled)
                        {
                            return;
                        }
                    }

                    UserViewModel user = null;
                    if (!string.IsNullOrEmpty(e.participantID))
                    {
                        user = await ChannelSession.ActiveUsers.GetUserByParticipantID(e.participantID);

                        if (user == null)
                        {
                            InteractiveParticipantModel participant = null;
                            if (this.Participants.TryGetValue(e.participantID, out participant))
                            {
                                user = new UserViewModel(participant);
                            }
                            else
                            {
                                IEnumerable <InteractiveParticipantModel> recentParticipants = await this.GetRecentParticipants();

                                participant = recentParticipants.FirstOrDefault(p => p.sessionID.Equals(e.participantID));
                                if (participant != null)
                                {
                                    user = await ChannelSession.ActiveUsers.AddOrUpdateUser(participant);
                                }
                            }
                        }
                    }

                    if (user == null)
                    {
                        user = new UserViewModel(0, "Unknown User");
                        user.InteractiveIDs[e.participantID] = new InteractiveParticipantModel()
                        {
                            sessionID = e.participantID, anonymous = true
                        };
                    }
                    else
                    {
                        await user.RefreshDetails();
                    }
                    user.UpdateLastActivity();

                    if (ChannelSession.Settings.PreventUnknownInteractiveUsers && user.IsAnonymous)
                    {
                        return;
                    }

                    if (user.IsInInteractiveTimeout)
                    {
                        return;
                    }

                    if (!ModerationHelper.MeetsChatInteractiveParticipationRequirement(user))
                    {
                        await ModerationHelper.SendChatInteractiveParticipationWhisper(user, isInteractive : true);

                        return;
                    }

                    if (!this.Controls.ContainsKey(e.input.controlID))
                    {
                        return;
                    }

                    if (connectedControl != null)
                    {
                        int sparkCost = 0;

                        await this.giveInputLock.WaitAndRelease(async() =>
                        {
                            if (await connectedControl.CheckAllRequirements(user))
                            {
                                if (!string.IsNullOrEmpty(e.transactionID) && !user.Data.IsSparkExempt)
                                {
                                    Util.Logger.LogDiagnostic("Sending Spark Transaction Capture - " + e.transactionID);

                                    await this.CaptureSparkTransaction(e.transactionID);

                                    if (control is InteractiveButtonControlModel)
                                    {
                                        sparkCost = ((InteractiveButtonControlModel)control).cost.GetValueOrDefault();
                                    }
                                    else if (control is InteractiveTextBoxControlModel)
                                    {
                                        sparkCost = ((InteractiveTextBoxControlModel)control).cost.GetValueOrDefault();
                                    }
                                }

                                List <string> arguments = new List <string>();

                                if (connectedControl is InteractiveConnectedJoystickCommand)
                                {
                                    arguments.Add(e.input.x.ToString());
                                    arguments.Add(e.input.y.ToString());
                                }
                                else if (connectedControl is InteractiveConnectedTextBoxCommand)
                                {
                                    arguments.Add(e.input.value);
                                }

                                await connectedControl.Perform(user, arguments);
                            }
                        });

                        if (sparkCost > 0)
                        {
                            GlobalEvents.SparkUseOccurred(new Tuple <UserViewModel, int>(user, sparkCost));
                        }
                    }

                    this.OnGiveInput(this, e);

                    this.OnInteractiveControlUsed(this, new InteractiveInputEvent(user, e, connectedControl));
                }
            }
            catch (Exception ex) { MixItUp.Base.Util.Logger.Log(ex); }
        }