private async void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = await this.AddMessage(e);
if (message != null)
{
this.OnMessageOccurred(sender, message);
if (message.IsChatSkill)
{
GlobalEvents.ChatSkillOccurred(new Tuple <UserViewModel, ChatSkillModel>(message.User, message.ChatSkill));
if (message.IsInUsersChannel)
{
GlobalEvents.SparkUseOccurred(new Tuple <UserViewModel, int>(message.User, (int)message.ChatSkill.cost));
Dictionary <string, string> specialIdentifiers = new Dictionary <string, string>()
{
{ "skillname", message.ChatSkill.skill_name },
{ "skilltype", EnumHelper.GetEnumName(SkillTypeEnum.Sticker) },
{ "skillcost", message.ChatSkill.cost.ToString() },
{ "skillimage", message.ChatSkill.icon_url },
};
await ChannelSession.Constellation.RunEventCommand(ChannelSession.Constellation.FindMatchingEventCommand(EnumHelper.GetEnumName(OtherEventTypeEnum.MixerSkillUsed)), message.User, specialIdentifiers);
}
}
}
}
private async void SendChatMessageButton_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrEmpty(this.ChatMessageTextBox.Text))
{
string message = this.ChatMessageTextBox.Text;
if (message.Contains(SpecialIdentifierStringBuilder.SpecialIdentifierHeader))
{
SpecialIdentifierStringBuilder spReplacement = new SpecialIdentifierStringBuilder(message, Guid.NewGuid());
await spReplacement.ReplaceCommonSpecialModifiers(await ChannelSession.GetCurrentUser());
message = spReplacement.ToString();
}
if (messageHistory.Contains(message))
{
// Remove so we can move to the end
messageHistory.Remove(message);
}
messageHistory.Add(message);
activeMessageHistory = messageHistory.Count;
this.ChatMessageTextBox.Text = string.Empty;
if (ChatAction.WhisperRegex.IsMatch(message))
{
Match whisperRegexMatch = ChatAction.WhisperRegex.Match(message);
message = message.Substring(whisperRegexMatch.Value.Length);
Match usernNameMatch = ChatAction.UserNameTagRegex.Match(whisperRegexMatch.Value);
string username = usernNameMatch.Value;
username = username.Trim();
username = username.Replace("@", "");
await this.Window.RunAsyncOperation(async() =>
{
ChatMessageEventModel response = await ChannelSession.Chat.WhisperWithResponse(username, message, ShouldSendAsStreamer());
if (response != null)
{
await this.AddMessage(ChatMessageViewModel.CreateChatMessageViewModel(response));
}
});
}
else if (ChatAction.ClearRegex.IsMatch(message))
{
await ChannelSession.Chat.ClearMessages();
}
else
{
await this.Window.RunAsyncOperation((Func <Task>)(async() =>
{
await ChannelSession.Chat.SendMessage(message, ShouldSendAsStreamer());
}));
}
this.ChatMessageTextBox.Focus();
}
}
public static ChatUserModel GetUser(this ChatMessageEventModel chatMessageEvent)
{
return(new ChatUserModel()
{
userId = chatMessageEvent.user_id, userName = chatMessageEvent.user_name, userRoles = chatMessageEvent.user_roles
});
}
public async Task <UserViewModel> AddUser(ChatMessageEventModel chatMessageEvent)
{
return(await this.AddUser(new ChatUserModel()
{
userId = chatMessageEvent.user_id, userName = chatMessageEvent.user_name, userRoles = chatMessageEvent.user_roles
}));
}
private static void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
string message = "";
foreach (ChatMessageDataModel m in e.message.message)
{
message += m.text;
}
//Plugin.Log("Got message: " + message);
//OnMessageReceived(message);
MixerMessageHandlers.InvokeHandler(new MixerMessage()
{
id = e.id.ToString(),
message = message,
messageType = "Message",
user = new MixerUser()
{
id = e.user_id.ToString(),
color = ColorFromRoles(e.user_roles),
displayName = e.user_name,
Avatar = e.user_avatar
},
MessageModel = e
}, "");
}
private async void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = new ChatMessageViewModel(e);
await this.AddMessage(message);
this.OnMessageOccurred(sender, message);
}
private async Task SendBasicMessage(ChatClient chatClient)
{
this.ClearAllPackets();
string messageText = "Hello World!";
ChatMessageEventModel message = await chatClient.SendMessageWithResponse(messageText);
this.ValidateMessage(chatClient, message, messageText);
}
private async void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = await this.AddMessage(e);
if (message != null)
{
this.OnMessageOccurred(sender, message);
}
}
private static void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
string message = "";
foreach (ChatMessageDataModel m in e.message.message)
{
message += m.text;
}
System.Console.WriteLine(string.Format("{0}: {1}", e.user_name, message));
}
private ChatMessageViewModel(ChatMessageEventModel chatMessageEvent, UserViewModel user = null)
{
this.ChatMessageEvent = chatMessageEvent;
this.ID = this.ChatMessageEvent.id;
this.User = (user != null) ? user : new UserViewModel(this.ChatMessageEvent);
this.IsInUsersChannel = ChannelSession.Channel.id.Equals(this.ChatMessageEvent.channel);
this.TargetUsername = this.ChatMessageEvent.target;
this.Message = string.Empty;
}
public ChatMessage(ChatMessageEventModel chatMessageEvent)
{
this.chatMessageEvent = chatMessageEvent;
this.UserName = this.chatMessageEvent.user_name;
this.Timestamp = DateTimeOffset.Now;
this.Message = string.Empty;
foreach (ChatMessageDataModel message in this.chatMessageEvent.message.message)
{
this.Message += message.text;
}
}
public void Whisper()
{
this.ChatWrapper(async(MixerConnection connection, ChatClient chatClient) =>
{
this.ClearAllPackets();
string messageText = "Hello World!";
ChatMessageEventModel message = await chatClient.WhisperWithResponse(chatClient.User.username, messageText);
this.ValidateMessage(chatClient, message, messageText);
Assert.AreEqual(message.target.ToString(), chatClient.User.username, true);
});
}
private async void BotChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = ChatMessageViewModel.CreateChatMessageViewModel(e);
if (message.IsWhisper)
{
message = await this.AddMessage(e);
if (message != null)
{
this.OnMessageOccurred(sender, message);
}
}
}
private void ValidateMessage(ChatClient chatClient, string messageText)
{
Assert.IsTrue(this.replyPackets.Count > 0);
ChatReplyPacket replyPacket = this.replyPackets.First();
Assert.IsTrue(replyPacket.id == (uint)(chatClient.CurrentPacketID - 1));
Assert.IsTrue(replyPacket.data["user_name"].ToString().Equals(chatClient.User.username));
Assert.IsTrue(replyPacket.data["message"]["message"][0]["text"].ToString().Equals(messageText));
Assert.IsTrue(this.messages.Count > 0);
ChatMessageEventModel message = this.messages.First();
Assert.IsTrue(message.message.message.First().text.Equals(messageText));
}
public void DeleteMessage()
{
this.ChatWrapper(async(MixerConnection connection, ChatClient chatClient) =>
{
await this.SendBasicMessage(chatClient);
ChatMessageEventModel message = this.messages.First();
this.ClearAllPackets();
bool result = await chatClient.DeleteMessageWithResponse(message.id);
Assert.IsTrue(result);
});
}
private void ChatClient_MessageOccurred(object sender, ChatMessageEventModel e)
{
var message = new ChatMessage(e);
if (message.UserName != Settings.Default.BotName)
{
Log(message.UserName + ": " + message.Message);
var output = Bot.parseInput(message.Message, message.UserName);
if (output != null)
{
ChatClient.SendMessage(output);
}
}
}
public ChatMessageViewModel(ChatMessageEventModel chatMessageEvent, UserViewModel user = null)
: this(chatMessageEvent.message, user)
{
this.ChatMessageEvent = chatMessageEvent;
this.ID = this.ChatMessageEvent.id;
this.User = (user != null) ? user : new UserViewModel(this.ChatMessageEvent);
this.IsInUsersChannel = ChannelSession.Channel.id.Equals(this.ChatMessageEvent.channel);
this.TargetUsername = this.ChatMessageEvent.target;
if (this.ChatMessageEvent.message.ContainsSkill)
{
this.ChatSkill = this.ChatMessageEvent.message.Skill;
}
}
public override Task LoadTestData()
{
ChatMessageEventModel messageEvent = new ChatMessageEventModel()
{
id = Guid.NewGuid(),
user_id = ChannelSession.User.id,
user_name = ChannelSession.User.username,
channel = ChannelSession.Channel.id,
message = new ChatMessageContentsModel()
{
message = new ChatMessageDataModel[] { new ChatMessageDataModel()
{
type = "text", text = "Test Message"
} }
}
};
this.GlobalEvents_OnChatMessageReceived(this, new ChatMessageViewModel(messageEvent));
return(Task.FromResult(0));
}
public void DeleteMessage()
{
this.ChatWrapper(async(MixerClient client, ChatClient chatClient) =>
{
await this.SendBasicMessage(chatClient);
ChatMessageEventModel message = this.messages.First();
this.ClearRepliesAndEvents();
await chatClient.DeleteMessage(message.id);
await Task.Delay(1000);
Assert.IsTrue(this.replyPackets.Count > 0);
ChatReplyPacket replyPacket = this.replyPackets.First();
Assert.IsTrue(replyPacket.id == (uint)(chatClient.CurrentPacketID - 1));
Assert.IsTrue(replyPacket.data.ToString().Equals("Message deleted."));
});
}
public async Task <ChatMessageEventModel> WhisperWithResponse(string username, string message, bool sendAsStreamer = false)
{
if (this.GetBotClient(sendAsStreamer) != null)
{
message = this.SplitLargeMessage(message, out string subMessage);
ChatMessageEventModel firstChatMessage = await this.RunAsync(this.GetBotClient(sendAsStreamer).WhisperWithResponse(username, message));
// Adding delay to prevent messages from arriving in wrong order
await Task.Delay(250);
if (!string.IsNullOrEmpty(subMessage))
{
await this.WhisperWithResponse(username, subMessage, sendAsStreamer : sendAsStreamer);
}
return(firstChatMessage);
}
return(null);
}
public static ChatMessageViewModel CreateChatMessageViewModel(ChatMessageEventModel chatMessageEvent, UserViewModel user = null)
{
ChatMessageViewModel newChatMessageViewModel = new ChatMessageViewModel(chatMessageEvent, user);
foreach (ChatMessageDataModel message in newChatMessageViewModel.ChatMessageEvent.message.message)
{
newChatMessageViewModel.MessageComponents.Add(message);
switch (message.type)
{
case "emoticon":
// Special code here to process emoticons
ChannelSession.EnsureEmoticonForMessage(message);
newChatMessageViewModel.Message += message.text;
break;
case "link":
newChatMessageViewModel.ContainsLink = true;
newChatMessageViewModel.Message += message.text;
break;
case "image":
newChatMessageViewModel.Images[message.text] = message.url;
newChatMessageViewModel.Message += string.Format(" *{0}* ", message.text);
break;
case "text":
case "tag":
default:
newChatMessageViewModel.Message += message.text;
break;
}
}
if (newChatMessageViewModel.ChatMessageEvent.message.ContainsSkill)
{
newChatMessageViewModel.ChatSkill = newChatMessageViewModel.ChatMessageEvent.message.Skill;
}
return(newChatMessageViewModel);
}
private async void ChatClient_OnMessageOccurred(object sender, ChatMessageEventModel e)
{
ChatMessageViewModel message = await this.AddMessage(e);
if (message != null)
{
this.OnMessageOccurred(sender, message);
if (message.IsChatSkill && message.IsInUsersChannel)
{
if (SkillUsageModel.IsSparksChatSkill(message.ChatSkill))
{
GlobalEvents.SparkUseOccurred(new Tuple <UserViewModel, int>(message.User, (int)message.ChatSkill.cost));
}
else if (SkillUsageModel.IsEmbersChatSkill(message.ChatSkill))
{
GlobalEvents.EmberUseOccurred(new UserEmberUsageModel(message.User, (int)message.ChatSkill.cost, message.Message));
}
GlobalEvents.SkillUseOccurred(new SkillUsageModel(message.User, message.ChatSkill, message.Message));
}
}
}
public override async Task LoadTestData()
{
for (int i = 0; i < 5; i++)
{
ChatMessageEventModel messageEvent = new ChatMessageEventModel()
{
id = Guid.NewGuid(),
user_id = ChannelSession.User.id,
user_name = ChannelSession.User.username,
channel = ChannelSession.Channel.id,
message = new ChatMessageContentsModel()
{
message = new ChatMessageDataModel[] { new ChatMessageDataModel()
{
type = "text", text = "Test Message"
} }
}
};
this.GlobalEvents_OnChatMessageReceived(this, ChatMessageViewModel.CreateChatMessageViewModel(messageEvent));
await Task.Delay(1000);
}
}
public UserViewModel(ChatMessageEventModel messageEvent) : this(messageEvent.user_id, messageEvent.user_name, messageEvent.user_roles)
{
this.IsInChat = true;
}
private void ChatClient_MessageOccurred(object sender, ChatMessageEventModel e)
{
this.messages.Add(e);
}
private void ChatClient_MessageOccurred(object sender, ChatMessageEventModel e)
{
this.AddChatMessage(new ChatMessage(e, new ChatUser(e)));
}
private void ValidateMessage(ChatClient chatClient, ChatMessageEventModel message, string messageText)
{
Assert.IsNotNull(message);
Assert.AreEqual(message.user_name.ToString(), chatClient.User.username, true);
Assert.IsTrue(message.message.message.First().text.Equals(messageText));
}
private async Task <ChatMessageViewModel> AddMessage(ChatMessageEventModel messageEvent)
{
UserViewModel user = await this.AddUser(messageEvent);
if (user != null && !this.userEntranceCommands.Contains(user.ID))
{
this.userEntranceCommands.Add(user.ID);
if (user.Data.EntranceCommand != null)
{
await user.Data.EntranceCommand.Perform(user);
}
}
ChatMessageViewModel message = new ChatMessageViewModel(messageEvent, user);
if (this.Messages.ContainsKey(message.ID))
{
return(null);
}
this.Messages[message.ID] = message;
if (this.DisableChat && !message.ID.Equals(Guid.Empty))
{
await this.DeleteMessage(message.ID);
return(message);
}
string moderationReason = await message.ShouldBeModerated();
if (!string.IsNullOrEmpty(moderationReason))
{
await this.DeleteMessage(message.ID);
await ModerationHelper.SendModerationWhisper(user, moderationReason);
return(message);
}
if (!string.IsNullOrEmpty(ChannelSession.Settings.NotificationChatTaggedSoundFilePath) && message.IsUserTagged)
{
await ChannelSession.Services.AudioService.Play(ChannelSession.Settings.NotificationChatTaggedSoundFilePath, 100);
}
if (!string.IsNullOrEmpty(ChannelSession.Settings.NotificationChatWhisperSoundFilePath) && message.IsWhisper)
{
await ChannelSession.Services.AudioService.Play(ChannelSession.Settings.NotificationChatWhisperSoundFilePath, 100);
}
if (!await this.CheckMessageForCommandAndRun(message))
{
if (message.IsWhisper && ChannelSession.Settings.TrackWhispererNumber && !message.IsStreamerOrBot())
{
await this.whisperNumberLock.WaitAsync();
if (!whisperMap.ContainsKey(message.User.ID))
{
whisperMap[message.User.ID] = whisperMap.Count + 1;
}
message.User.WhispererNumber = whisperMap[message.User.ID];
this.whisperNumberLock.Release();
await ChannelSession.Chat.Whisper(message.User.UserName, $"You are whisperer #{message.User.WhispererNumber}.", false);
}
}
return(message);
}
public ChatUser(ChatMessageEventModel messageEvent) : this(messageEvent.user_id, messageEvent.user_name, messageEvent.user_roles)
{
}
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);
}
