private void btnSendMessage_Click_1(object sender, EventArgs e)
{
if (!string.IsNullOrWhiteSpace(tbChatMessage.Text))
{
string bericht = tbChatMessage.Text;
DateTime datum = DateTime.Now;
if (lbChatVrijwilligers.SelectedItem != null)
{
foreach (Vrijwilliger vw in AccountHandler.Vrijwilligers)
{
if (vw.ToString() == (string)lbChatVrijwilligers.SelectedItem)
{
DatabaseHandler.AddChatMessage(bericht, datum, 2, vw.Id);
ChatMessage chatMessage = new ChatMessage(bericht, datum);
HelpHandler.AddChatMessage(chatMessage);
lbChatMessage.Items.Add(chatMessage.ToString());
}
}
}
}
else
{
MessageBox.Show("Vul een chatbericht in");
}
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
if (IsFriendshipCannonRunning)
return false;
IsFriendshipCannonRunning = true;
_msg = msg;
await SendMessage("Orbital Friendship Cannon - Online");
await Task.Delay(TimeSpan.FromMilliseconds(3000));
await SendMessage("Acquiring Target...");
await Task.Delay(TimeSpan.FromMilliseconds(2000));
await SendMessage("Target Locked");
await Task.Delay(TimeSpan.FromMilliseconds(2000));
await SendMessage("Firing : " + "http://www.allmystery.de/i/t1ce2b1_FiringOrbitalFriendshipCannon.gif?bc");
int asdf = 3;
IsFriendshipCannonRunning = false;
//Timer t = new Timer(AcquireTarget, 5, 0, 8000);
return true;
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
var files = Directory.GetFiles("G:\\Dropbox\\Public\\Pics\\pony", "*", SearchOption.AllDirectories).ToList();
if (files.Count == 0)
return true;
//files = Directory.GetFiles("G:\\Dropbox\\Public\\Pics\\pony\\Luna\\NSFW", "*", SearchOption.AllDirectories).ToList();
var random = new LunaRandom();
var file = files[random.Next(files.Count)];
var dropboxLink = await Utils.GetDropboxLinkForFilePath(file);
bool nsfw = false;
if (ConfigManager.Config.SFWOnly)
{
while (dropboxLink.Contains(@"/nsfw/"))
dropboxLink = await Utils.GetDropboxLinkForFilePath(file);
}
if (dropboxLink.Contains(@"/nsfw/", StringComparison.OrdinalIgnoreCase))
nsfw = true;
if(nsfw)
msg.SendBotMessage("NSFW : " + dropboxLink);
else
msg.SendBotMessage(dropboxLink);
return true;
}
public bool IsAdmin(ChatMessage msg)
{
if (ConfigManager.GlobalConfig.GlobalAdmins.Contains(msg.Sender.Handle.ToLowerInvariant()))
return true;
return false;
}
public object Any(PostChatToChannel request)
{
var sub = ServerEvents.GetSubscriptionInfo(request.From);
if (sub == null)
throw HttpError.NotFound("Subscription {0} does not exist".Fmt(request.From));
var msg = new ChatMessage
{
Id = Interlocked.Increment(ref msgId),
FromUserId = sub.UserId,
FromName = sub.DisplayName,
Message = request.Message,
};
if (request.ToUserId != null)
{
msg.Private = true;
ServerEvents.NotifyUserId(request.ToUserId, request.Selector, msg);
var toSubs = ServerEvents.GetSubscriptionInfosByUserId(request.ToUserId);
foreach (var toSub in toSubs)
{
msg.Message = "@{0}: {1}".Fmt(toSub.DisplayName, msg.Message);
ServerEvents.NotifySubscription(request.From, request.Selector, msg);
}
}
else
{
ServerEvents.NotifyChannel(request.Channel, request.Selector, msg);
}
return msg;
}
/// <summary>
/// The skype on message status.
/// </summary>
/// <param name="chatMessage">
/// The chat message.
/// </param>
/// <param name="status">
/// The status.
/// </param>
private void SkypeOnMessageStatus(ChatMessage chatMessage, TChatMessageStatus status)
{
if (chatMessage.Body.StartsWith("!mail"))
{
chatMessage.Chat.SendMessage("mailer called.");
}
}
public ChatItem(ChatMessage chat)
: base()
{
this.messageLabel = new Label();
this.timeLabel = new Label();
this.AutoSize = true;
this.setAppearance(chat.IsDoctor);
this.Controls.Add(this.messageLabel);
this.Controls.Add(this.timeLabel);
this.MinimumSize = new System.Drawing.Size(150, 60);
this.Name = "messageContainer";
this.Padding = new System.Windows.Forms.Padding(6);
//
// Message Label
//
this.messageLabel.AutoSize = true;
this.messageLabel.Dock = System.Windows.Forms.DockStyle.Fill;
this.messageLabel.Font = new System.Drawing.Font("Segoe UI Semibold", 11.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.messageLabel.Location = new System.Drawing.Point(6, 6);
this.messageLabel.MaximumSize = new System.Drawing.Size(250, 0);
this.messageLabel.Size = new System.Drawing.Size(121, 20);
this.messageLabel.Text = chat.Message.Replace("\n", "");
//
// Time Label
//
this.timeLabel.AutoSize = true;
this.timeLabel.Dock = System.Windows.Forms.DockStyle.Bottom;
this.timeLabel.Font = new System.Drawing.Font("Segoe UI Semilight", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.timeLabel.Location = new System.Drawing.Point(6, 26);
this.timeLabel.Margin = new System.Windows.Forms.Padding(6);
this.timeLabel.Size = new System.Drawing.Size(32, 13);
this.timeLabel.Text = Helper.MillisecondsToTime(chat.TimeStamp);
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
// var chatHandler = msg.
ChatClass chat = (ChatClass) msg.Chat;
var chatname = chat.Name;
var list = ConfigManager.GlobalConfig.LunaOfTheDayList;
if (list.Contains(chatname))
{
ConfigManager.GlobalConfig.LunaOfTheDayList.Remove(chatname);
msg.SendBotMessage("Removed from the Luna Of The Day List");
}
else
{
ConfigManager.GlobalConfig.LunaOfTheDayList.Add(chatname);
msg.SendBotMessage("Registered to the Luna Of The Day List");
}
ConfigManager.GlobalConfig.Save();
return true;
}
private static void _OnMessageReceived(ChatMessage pMessage, TChatMessageStatus status)
{
if ((status == TChatMessageStatus.cmsReceived || status == TChatMessageStatus.cmsSent) && pMessage.ChatName.IndexOf(_SkypeChatUniqueCode) >= 0)
{
SlackSender.SendMessage("*" + (String.IsNullOrEmpty(pMessage.Sender.DisplayName) ? _BotSkypeName : pMessage.Sender.DisplayName) + "* : " + pMessage.Body);
}
}
public IList<ChatMessage> GetRelativeEntries (ChatMessage message, int entriesBefore, int entriesAfter)
{
IEnumerable<ChatMessage> result = null;
lock (this) {
if (0 != entriesBefore) {
IEnumerable<ChatMessage> beforeResult = this.Query<ChatMessage> (@"SELECT * FROM ? ORDER BY When, _id DESC LIMIT ? WHERE When <= ? AND _id != ?", tableName, entriesBefore, message.When.Ticks, message.Id);
result = beforeResult.Reverse ();
}
if (0 != entriesAfter) {
IEnumerable<ChatMessage> afterResult = this.Query<ChatMessage> (@"SELECT * FROM ? ORDER BY When, _id ASC LIMIT ? WHERE When >= ? AND _id != ?", tableName, entriesAfter, message.When.Ticks, message.Id);
if (null == result)
return afterResult.ToList ();
return result.Concat (afterResult).ToList ();
}
if (null != result) {
return result.ToList ();
}
}
return new List<ChatMessage> ();
}
/// <summary>
/// Shows the Messaging application, using the specified recipient list and message body.
/// </summary>
/// <param name="recipient">The recipient list for the new SMS message.</param>
/// <param name="body">The body text of the new SMS message.</param>
/// <returns>The <see cref="Task"/> object representing the asynchronous operation.</returns>
public virtual Task ShowAsync(string recipient, string body)
{
#if WINDOWS_PHONE || WINDOWS_PHONE_81
new SmsComposeTask()
{
To = recipient,
Body = body
}.Show();
return Task.FromResult(0);
#elif WINDOWS_PHONE_APP || WINDOWS_UWP
var chatMessage = new ChatMessage
{
Body = body
};
if (!string.IsNullOrEmpty(recipient))
{
chatMessage.Recipients.Add(recipient);
}
return ChatMessageManager.ShowComposeSmsMessageAsync(chatMessage).AsTask();
#else
var smsUri = new UriBuilder("sms:")
.SetPath(recipient)
.AppendQueryParameterIfValueNotEmpty("body", body)
.Uri;
return Launcher.LaunchUriAsync(smsUri).AsTask();
#endif
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
var parameter = GetParameter(command);
var secondary = GetSecondaryParameter(command);
int newAccessLevel;
if (!int.TryParse(secondary, out newAccessLevel))
{
msg.SendBotMessage("Failed to parse new Access Level : ( " + secondary + " )" + " - For the user : ( " + parameter + " )");
return true;
}
if (!ConfigManager.Config.AccessLevels.ContainsKey(parameter.ToLowerInvariant()))
{
ConfigManager.Config.AccessLevels.Add(parameter.ToLowerInvariant(), newAccessLevel);
}
else
{
ConfigManager.Config.AccessLevels[parameter.ToLowerInvariant()] = newAccessLevel;
}
msg.SendBotMessage("Set the Access Level for the User : ( " + parameter + " )" + " - To Level : ( " + newAccessLevel + " )");
ConfigManager.Config.Save();
// msg.SendBotMessage("Adding Quote : \"" + quoteToAdd + "\" - To Pony (" + pony + ")");
return true;
}
public override void OnChatMessage(ChatMessage c)
{
if (State == MeterState.Stopped)
{
return;
}
if (c.IsCombat)
{
CombatMessage msg = c as CombatMessage;
if (msg.CombatType == CombatLogType.DamageDone)
{
if (String.Compare(msg.Damage.Target, target, true) == 0 ||
String.IsNullOrEmpty(target) )
{
damagedone += msg.Damage.Points;
if (State != MeterState.Running)
{ // change state to running since we hit our target
State = MeterState.Running;
}
}
}
else if (msg.CombatType == CombatLogType.TargetKilled)
{
// Stop if our target was killed.
if (String.Compare(msg.Target, target, true) == 0)
{
Stop();
}
}
}
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
msg.SendBotMessage(GetRandomCelestiaPic());
return true;
}
public override async Task<bool> ProcessCommand(ChatMessage msg, string command)
{
var searchMessage = msg.SendBotMessage("Searching....");
var searchTerms = "";
if (command.StartsWith("s "))
searchTerms = command.Remove(0, 1).Trim();
else
{
searchTerms = command.Remove(0, 6).Trim();
}
var result = DatabaseManager.GetRandomImageSearch(searchTerms);
if(result.Length == 0)
searchMessage.EditMessage("No Results Found");
else
{
searchMessage.EditMessage(result);
}
return true;
}
public static void Main()
{
// Client2 client = new Client2();
// client.sendText("this should be printed and also returned");
User from = new User();
User to = new User();
from.id = 1;
from.name = "test1";
from.password = "******";
to.id = 2;
to.name = "test2";
to.password = "******";
ChatMessage msg = new ChatMessage();
msg.from = from;
msg.to = to;
msg.content = "Hello";
msg.toXml();
//System.Console.Write("{0}",msg.toXml());
System.Console.ReadKey();
}
public void SetPersonalInfo(ChatMessage chatInfo)
{
this.mChatInfo = chatInfo;
if (this.mChatInfo != null)
{
this.mSb.Remove(0, this.mSb.Length).Append("Lv").Append(chatInfo.Level).Append(" ").Append(chatInfo.Name);
this.mNameLabel.text = this.mSb.ToString();
if (string.IsNullOrEmpty(chatInfo.GuildName))
{
this.mGuildNameLabel.text = Singleton<StringManager>.Instance.GetString("chatTxt10");
}
else
{
this.mGuildNameLabel.text = chatInfo.GuildName;
}
this.mIcon.spriteName = Tools.GetPlayerIcon(this.mChatInfo.FashionID);
this.mQualityMask.spriteName = Tools.GetItemQualityIcon(LocalPlayer.GetQuality(this.mChatInfo.ConstellationLevel));
FriendData friendData = Globals.Instance.Player.FriendSystem.GetFriendData(this.mChatInfo.PlayerID);
if (friendData != null)
{
this.friendType = friendData.FriendType;
}
bool flag = friendData != null && friendData.FriendType == 1;
bool flag2 = friendData != null && friendData.FriendType == 2;
this.mBacklistLabel.text = Singleton<StringManager>.Instance.GetString((!flag2) ? "friend_25" : "friend_26");
this.mFriendLabel.text = Singleton<StringManager>.Instance.GetString((!flag) ? "friend_27" : "friend_28");
}
}
/// <summary>
/// Shows the Messaging application, using the specified recipient list and message body.
/// </summary>
/// <param name="recipient">The recipient list for the new SMS message.</param>
/// <param name="body">The body text of the new SMS message.</param>
/// <returns>The <see cref="Task"/> object representing the asynchronous operation.</returns>
public async Task ShowAsync(string recipient, string body)
{
#if WINDOWS_PHONE
new SmsComposeTask()
{
To = recipient,
Body = body
}.Show();
await Task.FromResult(0);
#elif WINDOWS_PHONE_APP
var chatMessage = new ChatMessage
{
Body = body
};
chatMessage.Recipients.Add(recipient);
await ChatMessageManager.ShowComposeSmsMessageAsync(chatMessage);
#else
var smsUrl = "sms:" + Uri.EscapeDataString(recipient);
if (!string.IsNullOrEmpty(body))
{
smsUrl += "?body=" + Uri.EscapeDataString(body);
}
await Launcher.LaunchUriAsync(new Uri(smsUrl, UriKind.Absolute));
#endif
}
internal void AddMessage(ChatMessage msg)
{
lock (messages) {
messages.Enqueue(msg);
while (messages.Count > 10) messages.Dequeue();
}
}
protected void HandleRawMessagesReceived(ChatMessage[] messages)
{
for (int i = 0; i < messages.Length; ++i)
{
string line = "[" + messages[i].UserName + "] " + messages[i].Message;
DebugOverlay.Instance.AddViewportText(line);
}
}
// This is sent to the server
public void SendChatMessage(InputField input)
{
ChatMessage chatMessage = new ChatMessage();
chatMessage.text = input.text;
input.text = string.Empty;
//MyNetworkManager.myClient.Send(MyMsgType.chatMessageType, chatMessage);
}
private void button1_Click(object sender, EventArgs e)
{
ChatMessage message = new ChatMessage();
message.content = rtMessage.Text;
rtChat.AppendText(String.Format("You wrote: {0}\n", message.content));
controller.send(message);
rtMessage.Clear();
}
public void AddCostumePartyMsg(ChatMessage chatMsg)
{
if (this.mBaseLayer.GetCurChanel() != 3)
{
return;
}
this.DoAddChatMessage(chatMsg);
}
/// <summary>
/// Add a message to the message list
/// </summary>
/// <param name="message"></param>
private void AddMessage(ChatMessage message)
{
string sent = message.Timestamp.ToShortTimeString();
string msgText = "[" + sent + "] " + message.FromHandle + ":" + message.Body;
//TODO - sort message list, so that latest message is always at the top
messages.Items.Add(msgText);
}
public void AddGuildMsg(ChatMessage chatMsg)
{
if (this.mBaseLayer.GetCurChanel() != 1)
{
return;
}
this.DoAddChatMessage(chatMsg);
}
public void AddPersonalMsg(ChatMessage chatMsg)
{
if (this.mBaseLayer.GetCurChanel() != 2)
{
return;
}
this.DoAddChatMessage(chatMsg);
}
private static void MessageCallback(ChatMessage m)
{
foreach (var subscriber in _streammessage)
{
subscriber.WriteLine("data:" + JsonConvert.SerializeObject(m) + "\n");
subscriber.Flush();
}
}
public void setMessageHistorySize(int newSize)
{
//messageHistory = newSize;
messages = new ChatMessage[newSize];
for (int i = 0; i < messages.Length; i++) {
messages[i] = new ChatMessage();
}
}
private void MessageProcessor(ChatMessage msg, TChatMessageStatus status)
{
if (!IsLocalUser(msg)) return;
var response = _messageProcessor.Process(msg.Body);
if(response.Success)
{
_skype.SendMessage(msg.Sender.Handle, response.Message);
}
}
public void AddChatMessage(string playerName, string chatText, float timeStamp, int messageType)
{
ChatMessage cm = new ChatMessage();
cm.playerName = playerName;
cm.message = chatText;
cm.timeStamp = timeStamp;
GUIManager.Instance.chatGUI.AddChatBox(cm);
worldChatMessages.Add(cm);
}
/// <summary>
/// Sends a <see cref="ChatMessage" /> to all clients
/// </summary>
/// <param name="message"></param>
public static void SendChatMessage(ChatMessage message)
{
NetworkServer.SendToAll(message, Channels.Unreliable, true);
Logger.Info($"Chat: {message.Player}: {message.Message.String}");
}
public async Task TryToSendChatMessageMail(User user, string senderUsername, string senderTenancyName, ChatMessage chatMessage)
{
try
{
var emailTemplate = GetTitleAndSubTitle(user.TenantId, L("NewChatMessageEmail_Title"), L("NewChatMessageEmail_SubTitle"));
var mailMessage = new StringBuilder();
mailMessage.AppendLine("<b>" + L("Sender") + "</b>: " + senderTenancyName + "/" + senderUsername + "<br />");
mailMessage.AppendLine("<b>" + L("Time") + "</b>: " + chatMessage.CreationTime.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss") + " UTC<br />");
mailMessage.AppendLine("<b>" + L("Message") + "</b>: " + chatMessage.Message + "<br />");
mailMessage.AppendLine("<br />");
await ReplaceBodyAndSend(user.EmailAddress, L("NewChatMessageEmail_Subject"), emailTemplate, mailMessage);
}
catch (Exception exception)
{
Logger.Error(exception.Message, exception);
}
}
public async void ButtonSendChatMessage(string sMessageText)
{
try
{
if (!string.IsNullOrEmpty(sMessageText) || lstAttachments.Count > 0)
{
var chatModel = new ChatMessageViewModel
{
Attachments = lstAttachments ?? new List <AttachmentViewModel>(),
ContactId = contactId,
Message = sMessageText.Trim(' ', '\n'),
IsRead = false,
IsRecieved = false,
IsSend = false,
MessageTime = DateTime.Now.ToUniversalTime()
};
var chatConversationResponse = ChatConversationRepository.GetConversationbyContactId(contactId);
if (chatConversationResponse.success)
{
if (chatConversationResponse.chatConversation != null)
{
var message = ChatMessageRepository.SaveChatMessage(chatModel, chatConversationResponse.chatConversation.ChatId);
chatModel.MobiledatabaseId = message.id;
chatModel.ChatId = chatConversationResponse.chatConversation.ChatId;
chatModel.IsRead = false;
chatModel.IsRecieved = false;
chatModel.IsSend = false;
//var msg = new Message
//{
// Type = MessageType.Outgoing,
// Text = sMessageText.Trim()
//};
//tblChatList.InsertRows(new NSIndexPath[] { NSIndexPath.FromRowSection(messages.Count - 1, 0) }, UITableViewRowAnimation.None);
//ScrollToBottom(true);
}
}
lstAttachments = new List <AttachmentViewModel>();
try
{
var result = await new ChatService().PostChat(chatModel);
if (result.Status == 2 || result.Status == 1)
{
var ChatResponse = JsonConvert.DeserializeObject <PostChatResponseViewModel>(result.Response.ToString());
if (chatConversationResponse.chatConversation == null)
{
ChatMessage savedMessages = new ChatMessage();
ChatConversationRepository.SaveConverstionNewFromServer(ChatResponse.Chat);
chatConversationResponse = ChatConversationRepository.GetConversationbyContactId(contactId);
if (chatConversationResponse.success)
{
ChatConversationRepository.UpdateChatLastMessage(chatConversationResponse.chatConversation.id, ChatResponse.ChatMessage.Message, "");
savedMessages = ChatMessageRepository.SaveChatMessage(ChatResponse.ChatMessage, chatConversationResponse.chatConversation.ChatId);
}
RefreshNewAddedRows(chatModel, savedMessages);
//LoadLocalLatestMessages();
Console.WriteLine("CHAT POSTED : " + result);
}
else
{
chatConversationResponse = ChatConversationRepository.GetConversationbyContactId(contactId);
if (chatConversationResponse.success)
{
ChatConversationRepository.UpdateChatLastMessage(chatConversationResponse.chatConversation.id, ChatResponse.ChatMessage.Message, "");
var savedMessages = ChatMessageRepository.updateChatMessage(ChatResponse.ChatMessage);
RefreshNewAddedRows(chatModel, savedMessages);
// tblChatList.ScrollToRow(NSIndexPath.FromRowSection(consolidatedList.Count, 0), UITableViewScrollPosition.Bottom, true);
//LoadLocalLatestMessages();
await _objChatSignalRService.Send(chatConversationResponse.chatConversation.ContactId.ToString(), ChatResponse.ChatMessage);
}
}
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
txt_TextMessage.Text = "";
}
catch (Exception ex)
{
Crashes.TrackError(ex);
}
}
public static bool SendToChatroom(ChatMessage msg)
{
return(true);
}
public void Post([FromBody] ChatMessage data)
{
data.Time = DateTime.Now;
Message.AddMessage(data);
}
public SelfMessageViewModel(ChatMessage chatMessage) : base(chatMessage)
{
}
public async Task <IHttpActionResult> SendMessage(ChatMessageBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = UserManager.FindByName(User.Identity.Name);
var partner = await UserManager.FindByIdAsync(model.Destination);
if (partner == null)
{
return(BadRequest("You must provide the destination of the message."));
}
var filters = Builders <ChatConversation> .Filter;
var collection = IlevusDBContext.Create().GetConversationsCollection();
var first = string.Compare(partner.Id, user.Id) > 0 ? user : partner;
var second = string.Compare(partner.Id, user.Id) < 0 ? user : partner;
var docFilter = filters.And(
filters.Eq("FirstUser", first.Id),
filters.Eq("SecondUser", second.Id)
// filters.Eq("Day", DateTime.Today) // Uncomment if per-day conversation is active
);
try
{
var results = await collection.FindAsync(docFilter);
ChatMessage msg;
var conversation = await results.FirstOrDefaultAsync();
if (conversation == null)
{
conversation = new ChatConversation()
{
FirstUser = first.Id,
SecondUser = second.Id
};
msg = new ChatMessage()
{
AuthorId = user.Id,
Content = model.Content
};
conversation.Messages.Add(msg);
await collection.InsertOneAsync(conversation);
return(Ok(msg));
}
else
{
msg = new ChatMessage()
{
AuthorId = user.Id,
Content = model.Content
};
await collection.UpdateOneAsync(
docFilter, Builders <ChatConversation> .Update.AddToSet("Messages", msg)
);
return(Ok(msg));
}
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public static bool AllowCommand(ChatMessage msg)
{
return(true);
}
/// <summary>Handles a message</summary>
public void HandleMessage(ChatMessage message)
{
PreviousMessage = message;
}
protected void OnNewChatMessageReceived(ChatMessage e)
{
NewChatMessageReceived?.Invoke(this, e);
}
public static void ParseMessage(ChatMessage msg)
{
RequestBot.COMMAND.Parse(msg.GetTwitchUser(), msg.Message);
}
/// <summary>
/// New chat message received from server
/// </summary>
/// <param name="chatMessage"></param>
public void ChatMessageFromServer(ChatMessage chatMessage)
{
OnNewChatMessageReceived(chatMessage);
}
public override Task <ParseResult> ParseAsync(ChatState state, Chat_ParseField chatParseField, ChatMessage message)
{
string text = GetTextSource(chatParseField, message);
if (Regex.IsMatch(text, CancelRegex, RegexOptions.IgnoreCase))
{
return(Task.FromResult(ParseResultCancel));
}
return(Task.FromResult(ParseResultContinue));
}
public override bool CanExecute(ChatMessage msg)
{
return(msg.Message.Length > 0 && msg.Message.Split(' ')[0].Equals("!" + COMMAND));
}
/// <summary>
/// When we get a chat message from a client
/// </summary>
/// <param name="conn"></param>
/// <param name="message"></param>
internal static void ReceivedChatMessage(NetworkConnection conn, ChatMessage message)
{
message.Player = TCNetworkManager.Authenticator.GetAccount(conn.connectionId).UserName;
SendChatMessage(message);
}
public override void RunCommand(ChatMessage message)
{
TwitchWrapper.SendChatMessage($"@{message.Username} " + "TwitchToolkitPurchaseList".Translate() + $" {ToolkitSettings.CustomPricingSheetLink}");
}
/// <summary>
/// Функция создания сообщения
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ChatMessage> CreateAsync(ChatMessage chatMessage)
{
await _domainContext.AddAsync(chatMessage);
return(chatMessage);
}
public void Execute(IDungeonMasterApp dungeonMasterApp, ChatMessage chatMessage)
{
dungeonMasterApp.ReStackConditions();
}
/// <summary>
/// Invokes the chat to prevent cross-threaded errors
/// Chat goes by type
/// </summary>
/// <param name="richTextBox"></param>
/// <param name="chatMessage"></param>
/// <param name="msg"></param>
private void InvokeChat(RichTextBox richTextBox, ChatMessage chatMessage = null, string msg = null)
{
if (chatMessage != null)
{
switch (chatMessage.Type)
{
case ChatType.CHAT_TYPE_SYSTEM:
BeginInvoke(new MethodInvoker(delegate
{
if (!string.IsNullOrEmpty(chatMessage.Message))
{
richTextBox.AppendText(string.Format("{0} \n", WorldMgr.Server.ReceiveCMDSyntax()));
}
chatMessage.Message = null;
WorldMgr.Server.CmdList.Clear();
}));
break;
case ChatType.CHAT_TYPE_SAY:
case ChatType.CHAT_TYPE_YELL:
if (string.IsNullOrEmpty(chatMessage.Name))
{
return;
}
BeginInvoke(new MethodInvoker(delegate
{
if (!string.IsNullOrEmpty(chatMessage.Message))
{
richTextBox.AppendText(string.Format("[{0}] says: {1} \n", chatMessage.Name, chatMessage.Message));
}
chatMessage.Message = null;
chatMessage.Name = null;
}));
break;
case ChatType.CHAT_TYPE_CHANNEL:
if (string.IsNullOrEmpty(chatMessage.Name) || string.IsNullOrEmpty(chatMessage.ChannelName))
{
return;
}
BeginInvoke(new MethodInvoker(delegate
{
if (!string.IsNullOrEmpty(chatMessage.Message))
{
richTextBox.AppendText(string.Format("[{0}] [{1}]: {2} \n", chatMessage.ChannelName, chatMessage.Name, chatMessage.Message));
}
chatMessage.Message = null;
}));
break;
}
}
if (!string.IsNullOrEmpty(msg))
{
BeginInvoke(new MethodInvoker(delegate
{
richTextBox.AppendText(string.Format("{0} \n", msg));
msg = null;
}));
}
}
public static void Handle(TwitchBot twitchBot, ChatMessage chatMessage, string alias)
{
if (chatMessage.GetMessage().IsMatch(PatternCreator.Create(alias, PrefixHelper.GetPrefix(chatMessage.Channel), @"\sprefix\s\S{1," + Config.MaxPrefixLength + "}")))
{
twitchBot.SendSetPrefix(chatMessage, chatMessage.GetLowerSplit()[2][..(chatMessage.GetLowerSplit()[2].Length > Config.MaxPrefixLength ? Config.MaxPrefixLength : chatMessage.GetLowerSplit()[2].Length)]);
private void skype_MessageStatus(ChatMessage msg, TChatMessageStatus status)
{
msg.Body = "_" + msg.Body + "_";
}
public void ProcessOutgoingMessage(ChatMessage message)
{
}
private void ProcessMessage(Message message, string room)
{
// Ignore replies from self
if (message.User.Name.Equals(Name, StringComparison.OrdinalIgnoreCase))
{
return;
}
if (message.Content.Equals("enabledebug"))
{
_debugMode = true;
}
if (message.Content.Equals("disabledebug"))
{
_debugMode = false;
}
WriteDebugInfo(string.Format("{0} {1} {2}", room, message.Content, message.User.Name));
if (message.User.Name != Name)
{
WriteDebugInfo("Received " + message.Content + " from " + message.User.Name + " in " + room);
}
Task.Factory.StartNew(() =>
{
WriteDebugInfo("Message Processing Task Started");
string content = message.Content;
string name = message.User.Name;
WriteDebugInfo("Content: " + content + " from " + name);
if (MessageReceived != null)
{
MessageReceived(message, room);
}
ChatMessage chatMessage = new ChatMessage(message.Content, message.User.Name, room);
bool handled = false;
WriteDebugInfo("Handling Message with Sprockets");
handled = HandleMessageWithSprockets(chatMessage, handled);
WriteDebugInfo("Handling complete: " + handled);
if (!handled)
{
WriteDebugInfo("Unhandled Message Handling");
ProcessUnhandledMessage(chatMessage);
WriteDebugInfo("Unhandled Complete");
}
})
.ContinueWith(task =>
{
// Just write to debug output if it failed
if (task.IsFaulted)
{
Debug.WriteLine("JABBOT: Failed to process messages. {0}", task.Exception.GetBaseException());
Send("JABBOT: Failed to process messages:" + task.Exception.GetBaseException().ToString(), room);
WriteDebugInfo(task.Exception.GetBaseException().ToString());
}
});
}
public void Execute(IDungeonMasterApp dungeonMasterApp, ChatMessage chatMessage)
{
dungeonMasterApp.BreakConcentration(dungeonMasterApp.GetPlayerIdFromName(playerInitial));
}
public static void CheckCommand(ChatMessage msg)
{
if (msg == null)
{
return;
}
if (msg.Message == null)
{
return;
}
string message = msg.Message;
string user = msg.Username;
if (message.Split(' ')[0] == "/w")
{
List <string> messagewhisper = message.Split(' ').ToList();
messagewhisper.RemoveAt(0);
message = string.Join(" ", messagewhisper.ToArray());
Helper.Log(message);
}
Viewer viewer = Viewers.GetViewer(user);
viewer.last_seen = DateTime.Now;
if (viewer.IsBanned)
{
return;
}
Command commandDef = DefDatabase <Command> .AllDefs.ToList().Find(s => msg.Message.StartsWith("!" + s.command));
if (commandDef != null)
{
bool runCommand = true;
if (commandDef.requiresMod && (!viewer.mod && viewer.username.ToLower() != ToolkitSettings.Channel.ToLower()))
{
runCommand = false;
}
if (commandDef.requiresAdmin && msg.Username.ToLower() != ToolkitSettings.Channel.ToLower())
{
runCommand = false;
}
if (!commandDef.enabled)
{
runCommand = false;
}
if (commandDef.shouldBeInSeparateRoom && !AllowCommand(msg))
{
runCommand = false;
}
if (runCommand)
{
commandDef.RunCommand(msg);
}
}
//Deprecated, Use RimTwitch Library instead
//List<TwitchInterfaceBase> modExtensions = Current.Game.components.OfType<TwitchInterfaceBase>().ToList();
//if (modExtensions == null)
//{
// return;
//}
//foreach(TwitchInterfaceBase parser in modExtensions)
//{
// parser.ParseCommand(msg);
//}
}
public void NewChatMessage(ChatMessage chatMessage)
{
PrintChatMessageInConsole(chatMessage);
// PrintThreadId(); // Метод вызывается в другом потоке, не в потоке метода Run()
}
public void AddChat(ChatMessage chatItem)
{
_chatStore.ChatList.Add(chatItem);
}
public void PresentChatMessage(ChatMessage message)
{
StringBuilder sb = new StringBuilder();
sb.Append(message.Sender.Type == ChatMessageType.WhisperInform ? "To: " : message.Sender.Type.ToString());
//! Color codes taken from default chat_cache in WTF folder
//! TODO: RTF form?
switch (message.Sender.Type)
{
case ChatMessageType.Channel:
{
//sb.ForeColor(Color.FromArgb(255, 192, 192));
Console.ForegroundColor = ConsoleColor.DarkYellow; //Color.DarkSalmon;
sb.Append(" [");
sb.Append(message.Sender.ChannelName);
sb.Append("] ");
break;
}
case ChatMessageType.Whisper:
Game.World.LastWhisperers.Enqueue(message.Sender.Sender);
goto case ChatMessageType.WhisperInform;
case ChatMessageType.WhisperInform:
case ChatMessageType.WhisperForeign:
//sb.ForeColor(Color.FromArgb(255, 128, 255));
Console.ForegroundColor = ConsoleColor.Magenta;//Color.DeepPink;
break;
case ChatMessageType.System:
case ChatMessageType.Money:
case ChatMessageType.TargetIcons:
case ChatMessageType.Achievement:
//sb.ForeColor(Color.FromArgb(255, 255, 0));
Console.ForegroundColor = ConsoleColor.Yellow;//Color.Gold;
break;
case ChatMessageType.Emote:
case ChatMessageType.TextEmote:
case ChatMessageType.MonsterEmote:
//sb.ForeColor(Color.FromArgb(255, 128, 64));
Console.ForegroundColor = ConsoleColor.DarkRed;//Color.Chocolate;
break;
case ChatMessageType.Party:
//sb.ForeColor(Color.FromArgb(170, 170, 255));
Console.ForegroundColor = ConsoleColor.DarkCyan;//Color.CornflowerBlue;
break;
case ChatMessageType.PartyLeader:
//sb.ForeColor(Color.FromArgb(118, 200, 255));
Console.ForegroundColor = ConsoleColor.Cyan;//Color.DodgerBlue;
break;
case ChatMessageType.Raid:
//sb.ForeColor(Color.FromArgb(255, 172, 0));
Console.ForegroundColor = ConsoleColor.Red;//Color.DarkOrange;
break;
case ChatMessageType.RaidLeader:
//sb.ForeColor(Color.FromArgb(255, 72, 9));
Console.ForegroundColor = ConsoleColor.Red;//Color.DarkOrange;
break;
case ChatMessageType.RaidWarning:
//sb.ForeColor(Color.FromArgb(255, 72, 0));
Console.ForegroundColor = ConsoleColor.Red;//Color.DarkOrange;
break;
case ChatMessageType.Guild:
case ChatMessageType.GuildAchievement:
//sb.ForeColor(Color.FromArgb(64, 255, 64));
Console.ForegroundColor = ConsoleColor.Green;//Color.LimeGreen;
break;
case ChatMessageType.Officer:
//sb.ForeColor(Color.FromArgb(64, 192, 64));
Console.ForegroundColor = ConsoleColor.DarkGreen;//Color.DarkSeaGreen;
break;
case ChatMessageType.Yell:
Console.ForegroundColor = ConsoleColor.DarkRed;
break;
case ChatMessageType.Say:
default:
//sb.ForeColor(Color.FromArgb(255, 255, 255));
Console.ForegroundColor = ConsoleColor.White;
break;
}
sb.Append("[");
if (message.ChatTag.HasFlag(ChatTag.Gm))
{
sb.Append("<GM>");
}
if (message.ChatTag.HasFlag(ChatTag.Afk))
{
sb.Append("<AFK>");
}
if (message.ChatTag.HasFlag(ChatTag.Dnd))
{
sb.Append("<DND>");
}
sb.Append(message.Sender.Sender);
sb.Append("]: ");
sb.Append(message.Message);
LogLine(sb.ToString(), message.Language == Language.Addon ? LogLevel.Debug : LogLevel.Info);
}
public void SendBroadcastMessage(ChatMessage message)
{
Clients.All.BroadcastMessage(message);
}
internal CmdReceiveBroadcastEndSession(UserSession chatSession, ChatMessage chatMessage)
{
_chatUserSession = chatSession;
_chatMessage = chatMessage;
}
