コード例 #1
0
 /// <summary>
 /// Add data about a chat to the store.
 /// </summary>
 /// <param name="chat_id"></param>
 public chat addChat(long chat_id, string chatTitle)
 {
     if (getChat(chat_id) == null)
     {
         Console.WriteLine("Creating data for chat " + chat_id.ToString());
         chat chatObj = new chat(chat_id, chatTitle);
         chatData.Add(chatObj);
         return(chatObj);
     }
     else
     {
         throw new InvalidDataException("Chat already exists!");
     }
 }
コード例 #2
0
        /// <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);
            }
        }
コード例 #3
0
        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)
            {
                expectedReplies.Remove(er);
                //now send it to the plugin (remove first, so any checks can be done)
                try
                {
                    bool pluginProcessed = pluginToCall.replyReceived(er, m);

                    if (pluginProcessed)
                    {
                        //reset our chat timer
                        chat c = getChat(er.chatID);
                        c.resetLastUpdateTime();
                    }
                    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);
                }

                /*/are there any more messages for the user? If so, find & send
                 * ExpectedReply messageToSend = null;
                 * foreach (ExpectedReply e in expectedReplies)
                 * {
                 *  if (e.userID == m.userID)
                 *  {
                 *      if (messageToSend == null || e.timeLogged < messageToSend.timeLogged)
                 *      {
                 *          messageToSend = e;
                 *      }
                 *
                 *  }
                 * }
                 *
                 * //send it
                 * //note that the plugin might send an urgent message during this processing that may have jumped the queue (using trySendImmediate param)
                 * if ( !userHasOutstandingMessages(m.userID) && messageToSend != null)
                 * {
                 *  messageToSend.sendMessage();
                 *  //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.
                 *  expectedReplyHousekeeping();
                 * }
                 */
                expectedReplyHousekeeping();
            }
            return(processed);
        }
コード例 #4
0
        /// <summary>
        /// Main Roboto process. Connects to Telegram and processes any updates.
        /// </summary>
        private static void Process()
        {
            DateTime lastUpdate = DateTime.MinValue;


            while (!endLoop)
            {
                //store the time to prevent hammering the service when its down. Pause for a couple of seconds if things are getting toasty
                if (lastUpdate > DateTime.Now.Subtract(TimeSpan.FromSeconds(10)))
                {
                    Roboto.Settings.stats.logStat(new statItem("Hammering Prevention", typeof(Roboto)));
                    log.log("Too quick, sleeping", logging.loglevel.warn);
                    Thread.Sleep(2000);
                }
                lastUpdate = DateTime.Now;

                //TODO - move this code to the webADI class
                string updateURL = Settings.telegramAPIURL + Settings.telegramAPIKey + "/getUpdates" +
                                   "?offset=" + Settings.getUpdateID() +
                                   "&timeout=" + Settings.waitDuration +
                                   "&limit=10";

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(updateURL);
                log.log(".", logging.loglevel.low, ConsoleColor.White, true);
                request.Method      = "GET";
                request.ContentType = "application/json";

                try
                {
                    WebResponse webResponse = request.GetResponse();
                    using (Stream webStream = webResponse.GetResponseStream())
                    {
                        if (webStream != null)
                        {
                            using (StreamReader responseReader = new StreamReader(webStream))
                            {
                                string response = responseReader.ReadToEnd();

                                JObject jo = JObject.Parse(response);

                                //success?
                                string path   = jo.First.Path;
                                string result = jo.First.First.Value <string>();


                                if (path != "ok" || result != "True")
                                {
                                    endLoop = true;
                                    log.log("Failure code from web service", logging.loglevel.high);
                                    throw new WebException("Failure code from web service");
                                }
                                else
                                {
                                    int resultID = 0;
                                    //open the response and parse it using JSON. Probably only one result, but should be more?
                                    foreach (JToken token in jo.SelectTokens("result.[*]"))//jo.Children()) //) records[*].data.importedPath"
                                    {
                                        string logText = Regex.Replace(token.ToString(), @"(\s|\n|\r|\r\n)+", " ");
                                        log.log(logText, logging.loglevel.verbose);

                                        //Find out what kind of message this is.

                                        //TOP LEVEL TOKENS
                                        JToken updateID_TK = token.First;
                                        JToken update_TK   = updateID_TK.Next.First;

                                        //Flag the update ID as processed.
                                        int updateID = updateID_TK.First.Value <int>();
                                        Settings.lastUpdate = updateID;

                                        //is this for a group chat?

                                        long chatID = update_TK.SelectToken("chat.id").Value <long>();

                                        chat chatData = null;
                                        if (chatID < 0)
                                        {
                                            //find the chat
                                            chatData = Settings.getChat(chatID);
                                            string chatTitle = update_TK.SelectToken("chat.title").Value <string>();
                                            //new chat, add
                                            if (chatData == null)
                                            {
                                                chatData = Settings.addChat(chatID, chatTitle);
                                            }
                                            if (chatData == null)
                                            {
                                                throw new DataMisalignedException("Something went wrong creating the new chat data");
                                            }
                                            chatData.setTitle(chatTitle);
                                        }



                                        //Do we have an incoming message?
                                        if (update_TK.Path == "result[" + resultID.ToString() + "].message" && update_TK.SelectToken(".text") != null)
                                        {
                                            //prevent delays - its sent something valid back to us so we are probably OK.
                                            lastUpdate = DateTime.MinValue;
                                            if (chatData != null)
                                            {
                                                chatData.resetLastUpdateTime();
                                            }

                                            message m = new message(update_TK);

                                            //now decide what to do with this stuff.
                                            bool processed = false;

                                            //check if this is an expected reply, and if so route it to the
                                            Settings.parseExpectedReplies(m);


                                            //TODO - call plugins in some kind of priority order
                                            foreach (Modules.RobotoModuleTemplate plugin in settings.plugins)
                                            {
                                                //Skip this message if the chat is muted.
                                                if (plugin.chatHook && (chatData == null || (chatData.muted == false || plugin.chatIfMuted)))
                                                {
                                                    if ((!processed || plugin.chatEvenIfAlreadyMatched))
                                                    {
                                                        processed = plugin.chatEvent(m, chatData);
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            log.log("No text in update", logging.loglevel.verbose);
                                        }
                                        //dont know what other update types we want to monitor?
                                        //TODO - leave / kicked / chat deleted
                                        resultID++;
                                    }

                                    //housekeeping
                                    //check that all players have been sent a message, if there is one in the stack. This is to double check that if e.g. a game is cancelled the player doesnt get stuck
                                    Settings.expectedReplyHousekeeping();
                                }
                            }
                        }
                    }
                }
                catch (System.Net.WebException e)
                {
                    log.log("Web Service Timeout during getUpdates: " + e.ToString(), logging.loglevel.high);
                    Settings.stats.logStat(new statItem("BotAPI Timeouts", typeof(Roboto)));
                }

                catch (Exception e)
                {
                    try
                    {
                        log.log("Exception caught at main loop. " + e.ToString(), logging.loglevel.critical, ConsoleColor.White, false, false, false, false, 2);
                    }

                    catch (Exception ex)
                    {
                        Console.Out.WriteLine("-----------------");
                        Console.Out.WriteLine("Error During LOGGING! Original Error was");
                        Console.Out.WriteLine(e.Message);
                        Console.Out.WriteLine("Logging Error was");
                        Console.Out.WriteLine(ex.Message);
                    }
                }

                Settings.backgroundProcessing(false);
            }
        }