private void Client_OnWhisperRecieved(object sender, OnWhisperReceivedArgs e)
{
string[] chatMessage = e.WhisperMessage.Message.Split(' ', '\t');
HandleMessagesGeneric(chatMessage, m_BotChannel, e.WhisperMessage.Username, true, false);
return;
}
private void OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username == "my_friend")
{
client.SendWhisper(e.WhisperMessage.Username, "Psst!");
}
}
public static void OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username == "KungRaseri")
{
_client.SendWhisper(e.WhisperMessage.Username, "Hey! Whispers are so cool!");
}
}
private void WhisperRecieved(object sender, OnWhisperReceivedArgs e)
{
//if not polling for answers, don't do anything
if (!Polling)
{
return;
}
if (WhisperVote == false)
{
return;
}
//if the user has not already voted
if (!UsersThatHaveVoted.Contains(e.WhisperMessage.Username))
{
//and they have typed an allowed answer
if (Results.ContainsKey(e.WhisperMessage.Message.ToLower()))
{
//increase answers count
Results[e.WhisperMessage.Message.ToLower()]++;
//add user to voted list
UsersThatHaveVoted.Add(e.WhisperMessage.Username);
//and update results textbox
Invoke(new Action(() => ResultsBox.Text = string.Join(Environment.NewLine, Results).Replace('[', ' ').Replace(']', ' ')));
}
}
}
private async void HandleWhisper(OnWhisperReceivedArgs args)
{
Log("Whisper", args.WhisperMessage);
var msg = new Message(this, args.WhisperMessage);
await MessageReceived(msg);
}
public string GetWhisperCommand(string name, OnWhisperReceivedArgs input, Command cmd)
{
foreach (KeyValuePair <string, ICommandable> dcmd in _commands)
{
var key = dcmd.Key.Substring(dcmd.Key.LastIndexOf('.') + 1);
if (key == name.Replace("!", ""))
{
string _cdKey = input.WhisperMessage.DisplayName.ToLower();
DateTime compTime = DateTime.Now;
if (_ucd.ContainsKey(_cdKey + key) && _ucd[_cdKey + key] > compTime ||
_gcd.ContainsKey(key) && _gcd[key] > compTime)
{
return("Come on thats just to fast..");
}
else
{
_ucd.Remove(_cdKey + key);
_ucd.Add(_cdKey + key, DateTime.Now.AddSeconds(cmd.ucd));
_gcd.Remove(key);
_gcd.Add(key, DateTime.Now.AddSeconds(cmd.gcd));
dcmd.Value.VoidAction(this);
if (!String.IsNullOrEmpty(input.WhisperMessage.Message))
{
return(dcmd.Value.Result(input, cmd));
}
else
{
return(dcmd.Value.Result(name));
}
}
}
}
return("");
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
LogUtil.LogText($"[{client.TwitchUsername}] - @{e.WhisperMessage.Username}: {e.WhisperMessage.Message}");
if (QueuePool.Count > 100)
{
var removed = QueuePool[0];
QueuePool.RemoveAt(0); // First in, first out
client.SendMessage(Channel, $"Removed @{removed.DisplayName} ({(Species)removed.Pokemon.Species}) from the waiting list: stale request.");
}
var user = QueuePool.FindLast(q => q.UserName == e.WhisperMessage.Username);
if (user == null)
{
return;
}
QueuePool.Remove(user);
var msg = e.WhisperMessage.Message;
try
{
int code = Util.ToInt32(msg);
var sig = GetUserSignificance(user);
var _ = AddToTradeQueue(user.Pokemon, code, e, sig, PokeRoutineType.LinkTrade, out string message);
client.SendMessage(Channel, message);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
LogUtil.LogError($"{ex.Message}", nameof(TwitchBot));
}
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
LogUtil.LogText($"[{client.TwitchUsername}] - @{e.WhisperMessage.Username}: {e.WhisperMessage.Message}");
if (QueuePool.Count > 100)
{
var removed = QueuePool[0];
QueuePool.RemoveAt(0); // First in, first out
client.SendMessage(Channel, $"Removed @{removed.DisplayName} ({(Species)removed.Pokemon.Species}) from the waiting list: stale request.");
}
var user = QueuePool.FindLast(q => q.UserName == e.WhisperMessage.Username);
if (user == null)
{
return;
}
QueuePool.Remove(user);
var msg = e.WhisperMessage.Message;
try
{
int code = Util.ToInt32(msg);
var _ = AddToTradeQueue(user.Pokemon, code, e, Settings.IsSudo(user.UserName), PokeRoutineType.LinkTrade, out string message);
client.SendMessage(Channel, message);
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
}
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username == "my_friend")
{
Client.SendWhisper(e.WhisperMessage.Username, "Hey! Whispers are so cool!!");
}
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (QueuePool.Count > 100)
{
var removed = QueuePool[0];
QueuePool.RemoveAt(0); // First in, first out
client.SendMessage(Channel, $"Removed {removed.DisplayName} from the waiting list. (list exceeded maximum count)");
}
var user = QueuePool.Find(q => q.UserName == e.WhisperMessage.Username);
if (user == null)
{
return;
}
QueuePool.Remove(user);
var msg = e.WhisperMessage.Message;
try
{
int code = int.Parse(msg);
var _ = AddToTradeQueue(user.Pokemon, code, e, Hub.IsSudo(user.UserName), PokeRoutineType.LinkTrade, out string message);
client.SendMessage(Channel, message);
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
}
}
private bool AddToTradeQueue(PK8 pk8, int code, OnWhisperReceivedArgs e, bool sudo, PokeRoutineType type, out string msg)
{
// var user = e.WhisperMessage.UserId;
var userID = ulong.Parse(e.WhisperMessage.UserId);
var name = e.WhisperMessage.DisplayName;
var trainer = new PokeTradeTrainerInfo(name);
var notifier = new TwitchTradeNotifier <PK8>(pk8, trainer, code, e.WhisperMessage.Username, client, Channel, Hub.Config.Twitch);
var tt = type == PokeRoutineType.SeedCheck ? PokeTradeType.Seed : PokeTradeType.Specific;
var detail = new PokeTradeDetail <PK8>(pk8, trainer, notifier, tt, code: code);
var trade = new TradeEntry <PK8>(detail, userID, type, name);
var added = Info.AddToTradeQueue(trade, userID, sudo);
if (added == QueueResultAdd.AlreadyInQueue)
{
msg = $"@{name}: Sorry, you are already in the queue.";
return(false);
}
var position = Info.CheckPosition(userID, type);
msg = $"@{name}: Added to the {type} queue, unique ID: {detail.ID}. Current Position: {position.Position}";
var botct = Info.Hub.Bots.Count;
if (position.Position > botct)
{
var eta = Info.Hub.Config.Queues.EstimateDelay(position.Position, botct);
msg += $". Estimated: {eta:F1} minutes.";
}
return(true);
}
/// <summary>
/// Called when the Twitch bot has received a whisper from another user.
/// </summary>
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username == TokenHandler.Tokens.ChannelName)
{
client.SendWhisper(e.WhisperMessage.Username, "Hello!");
}
Console.WriteLine($"[{e.WhisperMessage.BotUsername}] Received Whisper From {e.WhisperMessage.DisplayName} ({e.WhisperMessage.UserId}). {e.WhisperMessage.Message}");
}
public static WhisperReceivedEventArgs ToWhisperReceivedEventArgs(this OnWhisperReceivedArgs src)
{
return(new WhisperReceivedEventArgs
{
FromDisplayName = src.WhisperMessage.DisplayName,
Message = src.WhisperMessage.Message
});
}
private static void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
Debug.WriteLine("Received message of" + e.WhisperMessage.Username + " Message body: " + e.WhisperMessage.Message);
if (e.WhisperMessage.Username == "Saintjoow")
{
TwitchChatForm.Instance.client.SendWhisper(e.WhisperMessage.Username, "Hey! Whispers are so cool!!");
}
}
private void commandRecived(OnWhisperReceivedArgs e, out ChatCommandRequest cmd, out string[] arg)
{
cmd = new ChatCommandRequest();
arg = e.WhisperMessage.Message.Split(" ");
cmd.Key = arg[0];
cmd.Value = e.WhisperMessage.Message.Replace(cmd.Key + " ", "");
cmd.argumentos = limpiarMensaje(e.WhisperMessage.Message.Replace(cmd.Key + " ", "")).Split(" ");
cmd.Channel = Channel;
}
protected virtual void OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
Task.Run(async() =>
{
try
{
var user = await _twitchNetService.GetUserByTwitchUsernameAsync(e.WhisperMessage.Username.Trim().ToLower());
if (user == null)
{
user = await _twitchNetService.CreateUserAsync(new UserDTO
{
DisplayName = e.WhisperMessage.DisplayName,
TwitchId = e.WhisperMessage.ThreadId,
Username = e.WhisperMessage.Username,
});
}
else if (user.DisplayName != e.WhisperMessage.DisplayName ||
user.TwitchId != e.WhisperMessage.UserId ||
user.Username != e.WhisperMessage.Username)
{
user = await _twitchNetService.UpdateUserAsync(new UserDTO
{
DisplayName = e.WhisperMessage.DisplayName,
TwitchId = e.WhisperMessage.UserId,
Username = e.WhisperMessage.Username,
Id = user.Id
});
}
await FireMessageWhisperEventAsync(sender, new MessageWhisperEventArgs
{
Message = new MessageWhisper
{
Bot = this,
MessageText = e.WhisperMessage.Message,
User = user,
MessageType = Enums.MessageType.Received,
Id = Guid.NewGuid(),
Timestamp = DateTime.UtcNow,
},
MessageWhisperEventType = MessageWhisperEventType.Received
});
}
catch (Exception ex)
{
await FireErrorEventAsync(sender, new ErrorMessageWhisperEventArgs
{
Bot = this,
ErrorMessageEventType = ErrorMessageEventType.Receiving,
Exception = ex,
ErrorMessageSendType = ErrorMessageSendType.Received,
Message = e.WhisperMessage.Message
});
}
});
}
// Whisper events
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
consoleMessage[1] = "**";
consoleMessage[3] = e.WhisperMessage.Username;
consoleMessage[4] = e.WhisperMessage.BotUsername;
consoleMessage[5] = e.WhisperMessage.Message;
//string message = $"[{DateTime.Now.ToString("MM/dd - HH:mm")} | Twitch.W**>>] {e.WhisperMessage.Username}: {e.WhisperMessage.Message}";
Program.SendToConsole(consoleMessage);
}
/// <summary>
/// Invokes the whisper received.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="badges">The badges.</param>
/// <param name="colorHex">The color hexadecimal.</param>
/// <param name="color">The color.</param>
/// <param name="username">The username.</param>
/// <param name="displayName">The display name.</param>
/// <param name="emoteSet">The emote set.</param>
/// <param name="threadId">The thread identifier.</param>
/// <param name="messageId">The message identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="isTurbo">if set to <c>true</c> [is turbo].</param>
/// <param name="botUsername">The bot username.</param>
/// <param name="message">The message.</param>
/// <param name="userType">Type of the user.</param>
public static void InvokeWhisperReceived(this TwitchClient client, List <KeyValuePair <string, string> > badges, string colorHex, Color color, string username, string displayName, EmoteSet emoteSet, string threadId, string messageId,
string userId, bool isTurbo, string botUsername, string message, UserType userType)
{
OnWhisperReceivedArgs model = new OnWhisperReceivedArgs()
{
WhisperMessage = new WhisperMessage(badges, colorHex, color, username, displayName, emoteSet, threadId, messageId, userId, isTurbo, botUsername, message, userType)
};
client.RaiseEvent("OnWhisperReceived", model);
}
private async void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (!IsCommand(e.WhisperMessage.Message))
{
return;
}
Log.Debug($"{e.WhisperMessage.Username}: {e.WhisperMessage.Message}");
await this.timeConstraint;
CheckUserAccount(e.WhisperMessage.Username);
new HandleWhisperCommand(client, e);
}
private async void SayAsBot(OnWhisperReceivedArgs e)
{
var parts = e.WhisperMessage.Message.Split(' ');
if (parts.Length < 2)
{
return;
}
var message = e.WhisperMessage.Message.Replace("#botsay", "").Trim();
await Client.SendMessage(message).ConfigureAwait(false);
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username.ToLower() == "StreamElements".ToLower())
{
if (LastWhisper != e.WhisperMessage.Message)
{
LogInfo(e.WhisperMessage.Message);
LastWhisper = e.WhisperMessage.Message;
}
}
}
private void OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
EvtWhisperMessageArgs whisperMsg = new EvtWhisperMessageArgs()
{
WhsprMessage = new EvtWhisperMsgData(e.WhisperMessage.UserId, e.WhisperMessage.Username,
e.WhisperMessage.DisplayName, e.WhisperMessage.MessageId, e.WhisperMessage.ThreadId,
e.WhisperMessage.Message)
};
WhisperReceivedEvent?.Invoke(whisperMsg);
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
Arrrgs chatArgs = new Arrrgs();
chatArgs.message = e.WhisperMessage.Message;
chatArgs.userID = e.WhisperMessage.UserId;
chatArgs.displayName = e.WhisperMessage.DisplayName;
chatArgs.commandText = ConvertWhisperToCommand(e.WhisperMessage.Message);
chatArgs.commandArgs = ConvertWhisperToArguments(e.WhisperMessage.Message);
commandQueue.FirstCommandBuckets(chatArgs);
}
private void TwitchClient_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
// If sender is allowed
if (!UserFilter.IsUserAllowed(e.WhisperMessage.Username, e.WhisperMessage.UserType))
{
return;
}
OnNotificationArgs notificationArgs = new OnNotificationArgs(DateTime.Now, e.WhisperMessage.DisplayName, e.WhisperMessage.Message, NotificationType.Whisper, e.WhisperMessage.Message.GetUrls());
OnNotification(notificationArgs);
}
private void Client_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Message == "balance")
{
client.SendWhisper(e.WhisperMessage.Username, $"{e.WhisperMessage.Username}, you have 1500.00000000 CITY!");
}
if (e.WhisperMessage.Username == "my_friend")
{
client.SendWhisper(e.WhisperMessage.Username, "Hey! Whispers are so cool!!");
}
}
public string Result(OnWhisperReceivedArgs e, Command c)
{
if (!String.IsNullOrEmpty(e.WhisperMessage.Message))
{
_queryDic = _query.extractQuery(c.respons, e.WhisperMessage.Message);
return(CmdProcessor(e.WhisperMessage.DisplayName, c));
}
else
{
return("Uhm me no understand");
}
}
private void _TwitchClient_OnWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
ChatMessage?.Invoke(this, new ChatMessageEventArgs
{
IsModerator = false,
IsOwner = false,
IsWhisper = true,
Message = e.WhisperMessage.Message,
ServiceName = "Twitch",
UserName = e.WhisperMessage.Username
});
}
private void onWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
if (e.WhisperMessage.Username == "hideyho119")
{
switch (e.WhisperMessage.Message)
{
case "add":
{
var user = new DAL.Entities.User {
Id = e.WhisperMessage.Username, Role = Resources.Ranks.r1, Points = 1, Credits = 1, TempTime = DateTime.Now.TimeOfDay
};
userService.Create(user);
client.SendWhisper(e.WhisperMessage.Username, "Added");
break;
}
case "view":
{
var users = userService.GetAll();
foreach (var i in users)
{
client.SendWhisper(e.WhisperMessage.Username, i.Id);
}
break;
}
case "up":
{
var user = userService.Get(e.WhisperMessage.Username);
user.Points += (int)(DateTime.Now.TimeOfDay - user.TempTime).TotalMinutes;
switch (user.Points)
{
case 1:
{
user.Role = Resources.Ranks.r1;
break;
}
case 3:
{
user.Role = Resources.Ranks.r2;
break;
}
default: break;
}
userService.Update(user);
break;
}
}
}
}
private void WhisperReceived(object sender, OnWhisperReceivedArgs e)
{
Task.Run(() => _logger.LogInformation($"Message Received from Chat user : {e.WhisperMessage.Username} message: {e.WhisperMessage.Message}"));
var eventArgs = new WhisperReceivedEventArgs(new WhisperMessage(
e.WhisperMessage.Message,
e.WhisperMessage.UserId,
e.WhisperMessage.Username,
e.WhisperMessage.DisplayName
));
WhisperReceived(eventArgs);
}
private void OnWisperReceived(object sender, OnWhisperReceivedArgs e)
{
// TODO: I think I should handle wisper commands as normal commands and ignore simple messages.
string userName = e.WhisperMessage.DisplayName;
string message = e.WhisperMessage.Message;
if (logType == DebugLogType.Full)
{
Logger.LogMessage($"Got a wisper from {userName}: {message}");
}
client.SendWhisper(e.WhisperMessage.Username, $"Hey, {userName} no reason going stealth-mode," +
" I can't handle wispers yet.");
}
private void globalWhisperReceived(object sender, OnWhisperReceivedArgs e)
{
//Don't do this in production
CheckForIllegalCrossThreadCalls = false;
richTextBox2.Text = String.Format("{0} -> {1}: {2}", e.WhisperMessage.Username, e.WhisperMessage.BotUsername, e.WhisperMessage.Message) +
"\n" + richTextBox2.Text;
}
