/// <summary> /// Handle a failed outbound message that a plugin expects a reply for. /// </summary> /// <param name="er"></param> public void parseFailedReply(ExpectedReply er) { expectedReplies.Remove(er); Modules.RobotoModuleTemplate pluginToCall = null; foreach (Modules.RobotoModuleTemplate plugin in settings.plugins) { if (er.pluginType == plugin.GetType().ToString()) { //stash these for calling outside of the "foreach" loop. This is so we can be sure it is called ONCE only, and so that we can remove //the expected reply before calling the method, so any post-processing works smoother. pluginToCall = plugin; } } //now send it to the plugin (remove first, so any checks can be done) if (pluginToCall == null) { Roboto.log.log("Expected Reply wasnt on the stack - probably sent in immediate-mode! Couldnt remove it", logging.loglevel.normal); } else { bool pluginProcessed = pluginToCall.replyReceived(er, null, true); if (!pluginProcessed) { Roboto.log.log("Plugin " + pluginToCall.GetType().ToString() + " didnt process the message it expected a reply to!", logging.loglevel.high); throw new InvalidProgramException("Plugin didnt process the message it expected a reply to!"); } } }
/// <summary> /// Add a new expected reply to the stack. Should be called internally only - New messages should be sent via TelegramAPI.GetExpectedReply /// </summary> /// <param name="e"></param> /// <param name="trySendImmediately">Try and send the message immediately, assuming nothing is outstanding. Will jump the queue, but not override any existing messages</param> /// <returns>An integer specifying the message id. -1 indicates it is queueed, long.MinValue indicates a failure</returns> public long newExpectedReply(ExpectedReply e, bool trySendImmediately) { //flag the user as present in the chat if (e.isPrivateMessage) { markPresence(e.userID, e.chatID, e.userName); } //check if we can send it? Get the messageID back long messageID = -1; //is this a message to a group? if (!e.isPrivateMessage) { //send, dont queue. //TODO - doesnt handle group PMs messageID = e.sendMessage(); } //this is a PM. Does the user have anything in the queue? else if (!userHasOutstandingMessages(e.userID)) { //send the message. messageID = e.sendMessage(); //queue if it was a question if (e.expectsReply) { expectedReplies.Add(e); } } //If they have messages in the queue, and we want to jump ahead, has one already been asked, or are we open? else if (trySendImmediately && !userHasOutstandingQuestions(e.userID)) { Roboto.log.log("Message jumping queue due to immediatemode", logging.loglevel.verbose); //send the message, grab the ID. messageID = e.sendMessage(); //did it work/ if (messageID == long.MinValue) { Roboto.log.log("Tried to send message using immediateMode, but it failed.", logging.loglevel.warn); return(messageID); } //queue if it was a question else if (e.expectsReply) { expectedReplies.Add(e); } } else { //chuck it on the stack if its going to be queued expectedReplies.Add(e); } //make sure we are in a safe state. This will make sure if we sent a message-only, that the next message(s) are processed. expectedReplyBackgroundProcessing(); return(messageID); }
/// <summary> /// Send a message, which we are expecting a reply to. Message can be sent publically or privately. Replies will be detected and sent via the plugin replyReceived method. /// </summary> /// <param name="chatID"></param> /// <param name="text"></param> /// <param name="replyToMessageID"></param> /// <param name="selective"></param> /// <param name="answerKeyboard"></param> /// <returns>An integer specifying the message id. -1 indicates it is queueed, long.MinValue indicates a failure</returns> public static long GetExpectedReply(long chatID, long userID, string text, bool isPrivateMessage, Type pluginType, string messageData, string userName = null, long replyToMessageID = -1, bool selective = false, string answerKeyboard = "", bool useMarkdown = false, bool clearKeyboard = false, bool trySendImmediately = false) { ExpectedReply e = new ExpectedReply(chatID, userID, userName, text, isPrivateMessage, pluginType, messageData, replyToMessageID, selective, answerKeyboard, useMarkdown, clearKeyboard, true); //add the message to the stack. If it is sent, get the messageID back. long messageID = Roboto.Settings.newExpectedReply(e, trySendImmediately); return(messageID); }
/// <summary> /// Send a message. Returns the ID of the send message /// </summary> /// <param name="chatID">User or Chat ID</param> /// <param name="text"></param> /// <param name="markDown"></param> /// <param name="replyToMessageID"></param> /// <returns>An integer specifying the message id. -1 indicates it is queued, int.MinValue indicates a failure</returns> public static long SendMessage(long chatID, string text, string userName = null, bool markDown = false, long replyToMessageID = -1, bool clearKeyboard = false, bool trySendImmediately = false) { bool isPM = (chatID < 0 ? false : true); ExpectedReply e = new ExpectedReply(chatID, chatID, userName, text, isPM, null, null, replyToMessageID, false, "", markDown, clearKeyboard, false); //add the message to the stack. If it is sent, get the messageID back. long messageID = Roboto.Settings.newExpectedReply(e, trySendImmediately); return(messageID); }
/// <summary> /// Send the message in the expected reply. Should only be called from the expectedReply Class. May or may not expect a reply. /// </summary> /// <param name="e"></param> /// <returns>A long specifying the message id. long.MinValue indicates a failure. Negative values are error codes</returns> public static long postExpectedReplyToPlayer(ExpectedReply e) { Roboto.Settings.stats.logStat(new statItem("Outgoing Msgs", typeof(TelegramAPI))); string postURL = Roboto.Settings.telegramAPIURL + Roboto.Settings.telegramAPIKey + "/sendMessage"; //assemble collection of name/value data var pairs = new NameValueCollection(); string chatID = e.isPrivateMessage ? e.userID.ToString() : e.chatID.ToString(); //send to chat or privately try { pairs.Add("chat_id", chatID); if (e.text.Length > 1950) { e.text = e.text.Substring(0, 1950); } //check if the user has participated in multiple chats recently, so we can stamp the message with the current chat title. //only do this where the message relates to a chat. The chat ID shouldnt = the user id if this is the case. if (e.isPrivateMessage && e.chatID != e.userID && e.chatID < 0) { int nrChats = Roboto.Settings.getChatPresence(e.userID).Count(); if (nrChats > 1) { //get the current chat; chat c = Roboto.Settings.getChat(e.chatID); if (c == null) { Roboto.log.log("Couldnt find chat for " + e.chatID + " - did you use the userID accidentally?", logging.loglevel.high); } else { if (e.markDown && c.chatTitle != null) { e.text = "*" + c.chatTitle + "* :" + "\r\n" + e.text; } else { e.text = "=>" + c.chatTitle + "\r\n" + e.text; } } } } pairs.Add("text", e.text); if (e.markDown) { pairs["parse_mode"] = "Markdown"; } } catch (Exception ex) { Roboto.log.log("Error assembling message!. " + ex.ToString(), logging.loglevel.critical); } try //TODO - cant see how this is erroring here. Added try/catch to try debug it. { //force a reply if we expect one, and the keyboard is empty if (e.expectsReply && (e.keyboard == null || e.keyboard == "")) { bool forceReply = (!e.isPrivateMessage); //pairs.Add("reply_markup", "{\"force_reply\":true,\"selective\":" + e.selective.ToString().ToLower() + "}"); pairs.Add("reply_markup", "{\"force_reply\":" //force reply if we are NOT in a PM + forceReply.ToString().ToLower() //mark selective if passed in + ",\"selective\":" + e.selective.ToString().ToLower() + "}"); } else if (e.clearKeyboard) { pairs["reply_markup"] = "{\"hide_keyboard\":true}"; } else if (e.keyboard != null && e.keyboard != "") { pairs.Add("reply_markup", "{" + e.keyboard + "}"); } } catch (Exception ex) { //if we failed to attach, it probably wasnt important! Roboto.log.log("Error assembling message pairs. " + ex.ToString(), logging.loglevel.high); } try //TODO - cant see how this is erroring here. Added try/catch to try debug it. { if (e.replyToMessageID != -1) { pairs.Add("reply_to_message_id", e.replyToMessageID.ToString()); } } catch (Exception ex) { //if we failed to attach, it probably wasnt important! Roboto.log.log("Error attaching Reply Message ID to message. " + ex.ToString(), logging.loglevel.high); } try { JObject response = sendPOST(postURL, pairs).Result; if (response != null) { bool success = response.SelectToken("ok").Value <Boolean>(); if (success) { JToken response_token = response.SelectToken("result"); if (response_token != null) { JToken messageID_token = response.SelectToken("result.message_id"); if (messageID_token != null) { int messageID = messageID_token.Value <int>(); return(messageID); } else { Roboto.log.log("MessageID Token was null.", logging.loglevel.high); } } else { Roboto.log.log("Response Token was null.", logging.loglevel.high); } } else { int errorCode = response.SelectToken("error_code").Value <int>(); string errorDesc = response.SelectToken("description").Value <string>(); int result = parseErrorCode(errorCode, errorDesc); Roboto.log.log("Message failed with code " + result, logging.loglevel.high); Roboto.Settings.parseFailedReply(e); return(result); } } else { Roboto.log.log("Response was null.", logging.loglevel.high); } Roboto.Settings.parseFailedReply(e); return(long.MinValue); } catch (WebException ex) { Roboto.log.log("Couldnt send message to " + chatID.ToString() + " because " + ex.ToString(), logging.loglevel.high); //Mark as failed and return the failure to the calling method if (e.expectsReply) { Roboto.log.log("Returning message " + e.messageData + " to plugin " + e.pluginType.ToString() + " as failed.", logging.loglevel.high); Roboto.Settings.parseFailedReply(e); } return(long.MinValue); } catch (Exception ex) { Roboto.log.log("Exception sending message to " + chatID.ToString() + " because " + ex.ToString(), logging.loglevel.high); //Mark as failed and return the failure to the calling method if (e.expectsReply) { Roboto.log.log("Returning message " + e.messageData + " to plugin " + e.pluginType.ToString() + " as failed.", logging.loglevel.high); Roboto.Settings.parseFailedReply(e); } return(long.MinValue); } }
public void removeReply(ExpectedReply r) { expectedReplies.Remove(r); }
public bool parseExpectedReplies(message m) { //are we expecteing this? bool processed = false; Modules.RobotoModuleTemplate pluginToCall = null; ExpectedReply er = null; try { foreach (ExpectedReply e in expectedReplies) { //we are looking for direct messages from the user where c_id = m_id, OR reply messages where m_id = reply_id //could trigger twice if we f****d something up - dont think this is an issue but checking processed flag for safety if (!processed && e.isSent() && m.userID == e.userID) { if (m.chatID == e.userID || m.replyMessageID == e.outboundMessageID) { //find the plugin, send the expectedreply to it foreach (Modules.RobotoModuleTemplate plugin in settings.plugins) { if (e.isOfType(plugin.GetType())) { //stash these for calling outside of the "foreach" loop. This is so we can be sure it is called ONCE only, and so that we can remove //the expected reply before calling the method, so any post-processing works smoother. pluginToCall = plugin; er = e; } } processed = true; } } } } catch (Exception e) { Roboto.log.log("Error matching incoming message to plugin - " + e.ToString(), logging.loglevel.critical); } if (processed) { if (er == null) { Roboto.log.log("Expected reply found, but er not available.", logging.loglevel.critical); return(true); } if (pluginToCall == null) { Roboto.log.log("Expected reply plugin found, but not available.", logging.loglevel.critical); return(true); } //now send it to the plugin (remove first, so any checks can be done) expectedReplies.Remove(er); try { bool pluginProcessed = pluginToCall.replyReceived(er, m); if (pluginProcessed) { //reset our chat timer chat c = getChat(er.chatID); if (c != null) { c.resetLastUpdateTime(); } else { Roboto.log.log("Chat not found for update.", logging.loglevel.critical); } } else { throw new InvalidProgramException("Plugin didnt process the message it expected a reply to!"); } } catch (Exception e) { Roboto.log.log("Error calling plugin " + pluginToCall.GetType().ToString() + " with expected reply. " + e.ToString(), logging.loglevel.critical); } //Do any follow up er actions. expectedReplyBackgroundProcessing(); } return(processed); }
/// <summary> /// Do a healthcheck, and archive any old presence data /// Called from mod_standard's backgorund loop. /// </summary> public void expectedReplyBackgroundProcessing() { RecentChatMembers.RemoveAll(x => x.chatID == x.userID); //TODO <- this should be a startup housekeeping check only. //TODO - are we calling this whole thing every loop at the moment? Move to mod_standard.background? //Remove any stale presence info RecentChatMembers.RemoveAll(x => x.lastSeen < DateTime.Now.Subtract(new TimeSpan(chatPresenceExpiresAfterHours, 0, 0))); Roboto.log.log("There are " + expectedReplies.Count() + " expected replies on the stack", logging.loglevel.verbose); //main processing try { //Remove any ERs that are for dead chats List <ExpectedReply> deadERs = new List <ExpectedReply>(); foreach (ExpectedReply er in expectedReplies) { chat c = getChat(er.chatID); if (c == null) { deadERs.Add(er); } } foreach (ExpectedReply er in deadERs) { expectedReplies.Remove(er); } Roboto.log.log("Removed " + deadERs.Count() + " dead expected replies, now " + expectedReplies.Count() + " remain", deadERs.Count() == 0 ? logging.loglevel.verbose : logging.loglevel.warn); //remove any expired ones int i = expectedReplies.RemoveAll(x => x.timeLogged < DateTime.Now.Subtract(TimeSpan.FromDays(Roboto.Settings.killInactiveChatsAfterXDays))); Roboto.log.log("Removed " + i + " expected replies, now " + expectedReplies.Count() + " remain", i == 0 ? logging.loglevel.verbose : logging.loglevel.warn); //Build up a list of user IDs List <long> userIDs = expectedReplies.Select(e => e.userID).Distinct().ToList <long>(); //remove any invalid messages List <ExpectedReply> messagesToRemove = expectedReplies.Where(e => e.outboundMessageID > 0 && e.expectsReply == false).ToList(); if (messagesToRemove.Count > 0) { Roboto.log.log("Removing " + messagesToRemove.Count() + " messages from queue as they are sent and dont require a reply", logging.loglevel.warn); } foreach (ExpectedReply e in messagesToRemove) { expectedReplies.Remove(e); } foreach (long userID in userIDs) { bool retry = true; while (retry) { //for each user, check if a message has been sent, and track the oldest message ExpectedReply oldest = null; List <ExpectedReply> userReplies = expectedReplies.Where(e => e.userID == userID).ToList(); //try find a message to send. Drop out if we already have a sent message on the stack (waiting for a reply) bool sent = false; foreach (ExpectedReply e in userReplies) { if (e.isSent()) { sent = true; } //message is waiting else { if (oldest == null || e.timeLogged < oldest.timeLogged) { oldest = e; } } } //send the message if neccessary if (!sent && oldest != null) { oldest.sendMessage(); if (!oldest.expectsReply) { expectedReplies.Remove(oldest); } //make sure we are in a safe state. This will make sure if we sent a message-only, that the next message(s) are processed. } //what do we do next? if (sent == true) { retry = false; } // drop out if we have a message awaiting an answer else if (oldest == null) { retry = false; } // drop out if we have no messages to send else if (oldest.expectsReply) { retry = false; } //drop out if we sent a message that expects a reply } } } catch (Exception e) { Roboto.log.log("Error during expected reply housekeeping " + e.ToString(), logging.loglevel.critical); } }