SHARE
TWEET

OctoPrint-Telegram __init__.py

a guest Jun 6th, 2019 110 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. from __future__ import absolute_import
  2. from PIL import Image
  3. import threading, requests, re, time, datetime, StringIO, json, random, logging, traceback, io, collections, os, flask,base64,PIL, pkg_resources
  4. import octoprint.plugin, octoprint.util, octoprint.filemanager
  5. from flask.ext.babel import gettext
  6. from flask.ext.login import current_user
  7. from .telegramCommands import TCMD # telegramCommands.
  8. from .telegramNotifications import TMSG # telegramNotifications
  9. from .telegramNotifications import telegramMsgDict # dict of known notification messages
  10. from .emojiDict import telegramEmojiDict # dict of known emojis
  11. ####################################################
  12. #        TelegramListener Thread Class
  13. # Connects to Telegram and will listen for messages.
  14. # On incomming message the listener will process it.
  15. ####################################################
  16.  
  17. class TelegramListener(threading.Thread):
  18.     def __init__(self, main):
  19.         threading.Thread.__init__(self)
  20.         self.update_offset = 0
  21.         self.first_contact = True
  22.         self.main = main
  23.         self.do_stop = False
  24.         self.username = "UNKNOWN"
  25.         self._logger = main._logger.getChild("listener")
  26.         self.gEmo = self.main.gEmo
  27.        
  28.  
  29.     def run(self):
  30.         self._logger.debug("Try first connect.")
  31.         self.tryFirstContact()
  32.         # repeat fetching and processing messages unitil thread stopped
  33.         self._logger.debug("Listener is running.")
  34.         try:
  35.             while not self.do_stop:
  36.                 try:
  37.                     self.loop()
  38.                 except ExitThisLoopException:
  39.                     # do nothing, just go to the next loop
  40.                     pass
  41.         except Exception as ex:
  42.             self._logger.error("An Exception crashed the Listener: " + str(ex) + " Traceback: " + traceback.format_exc() )
  43.            
  44.         self._logger.debug("Listener exits NOW.")
  45.  
  46.     # Try to get first contact. Repeat every 120sek if no success
  47.     # or stop if task stopped
  48.     def tryFirstContact(self):
  49.         gotContact = False
  50.         while not self.do_stop and not gotContact:
  51.             try:
  52.                 self.username = self.main.test_token()
  53.                 gotContact = True
  54.                 self.set_status(gettext("Connected as %(username)s.", username=self.username), ok=True)
  55.             except Exception as ex:
  56.                 self.set_status(gettext("Got an exception while initially trying to connect to telegram (Listener not running: %(ex)s.  Waiting 2 minutes before trying again.)", ex=ex))
  57.                 time.sleep(120)
  58.        
  59.     def loop(self):
  60.         chat_id = ""
  61.         json = self.getUpdates()
  62.         try:
  63.             # seems like we got a message, so lets process it.
  64.             for message in json['result']:
  65.                 self.processMessage(message)
  66.         except ExitThisLoopException as exit:
  67.             raise exit
  68.         #wooooops. can't handle the message
  69.         except Exception as ex:
  70.             self._logger.error("Exception caught! " + str(ex))
  71.         self.set_status(gettext("Connected as %(username)s.", username=self.username), ok=True)
  72.         # we had first contact after octoprint startup
  73.         # so lets send startup message
  74.         if self.first_contact:
  75.             self.first_contact = False
  76.             self.main.on_event("PrinterStart",{})
  77.    
  78.     def set_update_offset(self, new_value):
  79.         if new_value >= self.update_offset:
  80.             self._logger.debug("Updating update_offset from {} to {}".format(self.update_offset, 1 + new_value))
  81.             self.update_offset = 1 + new_value
  82.         else:
  83.             self._logger.debug("Not changing update_offset - otherwise would reduce it from {} to {}".format(self.update_offset, 1 + new_value))
  84.    
  85.     def processMessage(self, message):
  86.         self._logger.debug("MESSAGE: " + str(message))
  87.         # Get the update_id to only request newer Messages the next time
  88.         self.set_update_offset(message['update_id'])
  89.         # no message no cookies
  90.         if 'message' in message and message['message']['chat']:
  91.        
  92.             chat_id, from_id = self.parseUserData(message) 
  93.            
  94.             # if we come here without a continue (discard message)
  95.             # we have a message from a known and not new user
  96.             # so let's check what he send us
  97.             # if message is a text message, we probably got a command
  98.             # when the command is not known, the following handler will discard it
  99.             if "text" in message['message']:
  100.                 self.handleTextMessage(message, chat_id, from_id)
  101.             # we got no message with text (command) so lets check if we got a file
  102.             # the following handler will check file and saves it to disk
  103.             elif "document" in message['message']:
  104.                 self.handleDocumentMessage(message, chat_id, from_id)
  105.             # we got message with notification for a new chat title photo
  106.             # so lets download it
  107.             elif "new_chat_photo" in message['message']:
  108.                 self.handleNewChatPhotoMessage(message, chat_id, from_id)
  109.             # we got message with notification for a deleted chat title photo
  110.             # so we do the same
  111.             elif "delete_chat_photo" in message['message']:
  112.                 self.handleDeleteChatPhotoMessage(message, chat_id, from_id)
  113.             # a member was removed from a group, so lets check if it's our bot and
  114.             # delete the group from our chats if it is our bot
  115.             elif "left_chat_member" in message['message']:
  116.                 self.handleLeftChatMemberMessage(message, chat_id, from_id)
  117.             # we are at the end. At this point we don't know what message type it is, so we do nothing
  118.             else:
  119.                 self._logger.warn("Got an unknown message. Doing nothing. Data: " + str(message))
  120.         elif 'callback_query' in message:
  121.             self.handleCallbackQuery(message)
  122.         else:
  123.             self._logger.warn("Response is missing .message or .message.chat or callback_query. Skipping it.")
  124.             raise ExitThisLoopException()
  125.  
  126.    
  127.     def handleCallbackQuery(self, message):
  128.         message['callback_query']['message']['text'] = message['callback_query']['data']
  129.         chat_id, from_id = self.parseUserData(message['callback_query'])
  130.         self.handleTextMessage(message['callback_query'],chat_id, from_id)
  131.  
  132.     def handleLeftChatMemberMessage(self, message, chat_id, from_id):
  133.         self._logger.debug("Message Del_Chat")
  134.         if message['message']['left_chat_member']['username'] == self.username[1:] and str(message['message']['chat']['id']) in self.main.chats:
  135.             del self.main.chats[str(message['message']['chat']['id'])]
  136.             # do a self._settings.save() ???
  137.             self._logger.debug("Chat deleted")
  138.            
  139.     def handleDeleteChatPhotoMessage(self, message, chat_id, from_id):
  140.         self._logger.debug("Message Del_Chat_Photo")
  141.         try:
  142.             os.remove(self.main.get_plugin_data_folder()+"/img/user/pic" +str(message['message']['chat']['id'])+".jpg")
  143.             self._logger.debug("File removed")
  144.         except OSError:
  145.             pass
  146.            
  147.     def handleNewChatPhotoMessage(self, message, chat_id, from_id):
  148.         self._logger.debug("Message New_Chat_Photo")
  149.         # only if we know the chat
  150.         if str(message['message']['chat']['id']) in self.main.chats:
  151.             self._logger.debug("New_Chat_Photo Found User")
  152.             kwargs = {'chat_id':int(message['message']['chat']['id']), 'file_id': message['message']['new_chat_photo'][0]['file_id'] }
  153.             t = threading.Thread(target=self.main.get_usrPic, kwargs=kwargs)
  154.             t.daemon = True
  155.             t.run()
  156.            
  157.     def handleDocumentMessage(self, message, chat_id, from_id):
  158.         # first we have to check if chat or group is allowed to upload
  159.         from_id = chat_id
  160.         if not self.main.chats[chat_id]['private']: #is this needed? can one send files from groups to bots?
  161.             from_id = str(message['message']['from']['id'])
  162.         # is /upload allowed?
  163.         if self.main.isCommandAllowed(chat_id,from_id,'/upload'):
  164.             self.main.track_action("command/upload_exec")
  165.             try:
  166.                 file_name = message['message']['document']['file_name']
  167.                 #if not (file_name.lower().endswith('.gcode') or file_name.lower().endswith('.gco') or file_name.lower().endswith('.g')):
  168.                 self._logger.debug(str(file_name.lower().split('.')[-1]))
  169.                 if not octoprint.filemanager.valid_file_type(file_name,"machinecode"):
  170.                     self.main.send_msg(self.gEmo('warning') + " Sorry, I only accept files with .gcode, .gco or .g extension.", chatID=chat_id)
  171.                     raise ExitThisLoopException()
  172.                 # download the file
  173.                 if self.main.version >= 1.3:
  174.                     target_filename = "TelegramPlugin/"+file_name
  175.                     from octoprint.server.api.files import _verifyFolderExists
  176.                     if not _verifyFolderExists(octoprint.filemanager.FileDestinations.LOCAL, "TelegramPlugin"):
  177.                         self.main._file_manager.add_folder(octoprint.filemanager.FileDestinations.LOCAL,"TelegramPlugin")
  178.                 else:
  179.                     target_filename = "telegram_"+file_name
  180.                 # for parameter no_markup see _send_edit_msg()
  181.                 self.main.send_msg(self.gEmo('save') + gettext(" Saving file {}...".format(target_filename)), chatID=chat_id)
  182.                 requests.get(self.main.bot_url + "/sendChatAction", params = {'chat_id': chat_id, 'action': 'upload_document'}, proxies=self.getProxies())
  183.                 data = self.main.get_file(message['message']['document']['file_id'])
  184.                 stream = octoprint.filemanager.util.StreamWrapper(file_name, io.BytesIO(data))
  185.                 self.main._file_manager.add_file(octoprint.filemanager.FileDestinations.LOCAL, target_filename, stream, allow_overwrite=True)
  186.                 # for parameter msg_id see _send_edit_msg()
  187.                 self.main.send_msg(self.gEmo('upload') + " I've successfully saved the file you sent me as {}.".format(target_filename),msg_id=self.main.getUpdateMsgId(chat_id),chatID=chat_id)
  188.             except ExitThisLoopException:
  189.                 pass
  190.             except Exception as ex:
  191.                 self.main.send_msg(self.gEmo('warning') + " Something went wrong during processing of your file."+self.gEmo('mistake')+" Sorry. More details are in octoprint.log.",msg_id=self.main.getUpdateMsgId(chat_id),chatID=chat_id)
  192.                 self._logger.debug("Exception occured during processing of a file: "+ traceback.format_exc() )
  193.         else:
  194.             self._logger.warn("Previous file was from an unauthorized user.")
  195.             self.main.send_msg("Don't feed the octopuses! " + self.gEmo('octo'),chatID=chat_id)
  196.            
  197.     def handleTextMessage(self, message, chat_id, from_id):
  198.         # We got a chat message.
  199.         # handle special messages from groups (/commad@BotName)
  200.         command = str(message['message']['text'].split('@')[0].encode('utf-8'))
  201.         parameter = ""
  202.         # TODO: Do we need this anymore?
  203.         # reply_to_messages will be send on value inputs (eg notification height)
  204.         # but also on android when pushing a button. Then we have to switch command and parameter.
  205.         #if "reply_to_message" in message['message'] and "text" in message['message']['reply_to_message']:
  206.             #command = message['message']['reply_to_message']['text']
  207.             #parameter = message['message']['text']
  208.             #if command.encode('utf-8') not in [str(k.encode('utf-8')) for k in self.main.tcmd.commandDict.keys()]:
  209.                 #command = message['message']['text']
  210.                 #parameter = message['message']['reply_to_message']['text']
  211.         # if command is with parameter, get the parameter
  212.         if any((k+"_") in command for k,v in self.main.tcmd.commandDict.iteritems() if 'param' in v):
  213.             parameter = '_'.join(command.split('_')[1:])
  214.             command = command.split('_')[0]
  215.         self._logger.info("Got a command: '" + str(command.encode('utf-8')) + "' with parameter: '" + str(parameter.encode('utf-8')) + "' in chat " + str(message['message']['chat']['id']))
  216.         # is command  known?
  217.         if command not in self.main.tcmd.commandDict:
  218.             # we dont know the command so skip the message
  219.             self._logger.warn("Previous command was an unknown command.")
  220.             self.main.send_msg("I do not understand you! " + self.gEmo('mistake'),chatID=chat_id)
  221.             raise ExitThisLoopException()
  222.         # check if user is allowed to execute the command
  223.         if self.main.isCommandAllowed(chat_id,from_id,command):
  224.             # Track command
  225.             if command.startswith("/"):
  226.                 self.main.track_action("command/" + command[1:])
  227.             # execute command
  228.             self.main.tcmd.commandDict[command]['cmd'](chat_id,from_id,command,parameter)
  229.         else:
  230.             # user was not alloed to execute this command
  231.             self._logger.warn("Previous command was from an unauthorized user.")
  232.             self.main.send_msg("You are not allowed to do this! " + self.gEmo('notallowed'),chatID=chat_id)
  233.    
  234.     def parseUserData(self, message):
  235.         self.main.chats = self.main._settings.get(["chats"])
  236.         chat = message['message']['chat']
  237.         chat_id = str(chat['id'])
  238.         data = self.main.newChat # data for new user
  239.         # if we know the user or chat, overwrite data with user data
  240.         if chat_id in self.main.chats:
  241.             data = self.main.chats[chat_id]
  242.         # update data or get data for new user
  243.         data['type'] = chat['type'].upper()
  244.         if chat['type']=='group' or chat['type'] == 'supergroup':
  245.             data['private'] = False
  246.             data['title'] = chat['title']
  247.         elif chat['type']=='private':
  248.             data['private'] = True
  249.             data['title'] = ""
  250.             if "first_name" in chat:
  251.                 data['title'] += chat['first_name'] + " - "
  252.             if "last_name" in chat:
  253.                 data['title'] += chat['last_name'] + " - "
  254.             if "username" in chat:
  255.                 data['title'] += "@" + chat['username']
  256.         from_id = chat_id
  257.         # if message is from a group, chat_id will be left as id of group
  258.         # and from_id is set to id of user who send the message
  259.         if not data['private']:
  260.             if 'from' in message:
  261.                 from_id = str(message['from']['id'])
  262.             else:
  263.                 from_id = str(message['message']['from']['id'])
  264.             # if group accepts only commands from known users (allow_users = true, accept_commands=false)
  265.             # and user is not in known chats, then he is unknown and we dont wnat to listen to him.
  266.             if chat_id in self.main.chats:
  267.                 if self.main.chats[chat_id]['allow_users'] and from_id not in self.main.chats and not self.main.chats[chat_id]['accept_commands']:
  268.                     self._logger.warn("Previous command was from an unknown user.")
  269.                     self.main.send_msg("I don't know you! Certainly you are a nice Person " + self.gEmo('heart'),chatID=chat_id)
  270.                     raise ExitThisLoopException()
  271.         # if we dont know the user or group, create new user
  272.         # send welcome message and skip message
  273.         if chat_id not in self.main.chats:
  274.             self.main.chats[chat_id] = data
  275.             self.main.send_msg(self.gEmo('info') + "Now I know you. Before you can do anything, go to OctoPrint Settings and edit some rights.",chatID=chat_id)
  276.             kwargs = {'chat_id':int(chat_id)}
  277.             t = threading.Thread(target=self.main.get_usrPic, kwargs=kwargs)
  278.             t.daemon = True
  279.             t.run()
  280.             self._logger.debug("Got new User")
  281.             raise ExitThisLoopException()
  282.         return (chat_id, from_id)
  283.    
  284.     def getUpdates(self):
  285.         self._logger.debug("listener: sending request with offset " + str(self.update_offset) + "...")
  286.         req = None
  287.        
  288.         # try to check for incoming messages. wait 120sek and repeat on failure
  289.         try:
  290.             if self.update_offset == 0 and self.first_contact:
  291.                 res = ["0","0"]
  292.                 while len(res) > 0:
  293.                     req = requests.get(self.main.bot_url + "/getUpdates", params={'offset':self.update_offset, 'timeout':0}, allow_redirects=False, timeout=10, proxies=self.getProxies())
  294.                     json = req.json()
  295.                     if not json['ok']:
  296.                         self.set_status(gettext("Response didn't include 'ok:true'. Waiting 2 minutes before trying again. Response was: %(response)s", json))
  297.                         time.sleep(120)
  298.                         raise ExitThisLoopException()
  299.                     if len(json['result']) > 0 and 'update_id' in json['result'][0]:
  300.                         self.set_update_offset(json['result'][0]['update_id'])
  301.                     res = json['result']
  302.                     if len(res) < 1:
  303.                         self._logger.debug("Ignoring message because first_contact is True.")
  304.                 if self.update_offset == 0:
  305.                     self.set_update_offset(0)
  306.             else:
  307.                 req = requests.get(self.main.bot_url + "/getUpdates", params={'offset':self.update_offset, 'timeout':30}, allow_redirects=False, timeout=40, proxies=self.getProxies())
  308.         except requests.exceptions.Timeout:
  309.             # Just start the next loop.
  310.             raise ExitThisLoopException()
  311.         except Exception as ex:
  312.             self.set_status(gettext("Got an exception while trying to connect to telegram API: %(exception)s. Waiting 2 minutes before trying again.", exception=ex))
  313.             time.sleep(120)
  314.             raise ExitThisLoopException()
  315.         if req.status_code != 200:
  316.             self.set_status(gettext("Telegram API responded with code %(status_code)s. Waiting 2 minutes before trying again.", status_code=req.status_code))
  317.             time.sleep(120)
  318.             raise ExitThisLoopException()
  319.         if req.headers['content-type'] != 'application/json':
  320.             self.set_status(gettext("Unexpected Content-Type. Expected: application/json. Was: %(type)s. Waiting 2 minutes before trying again.", type=req.headers['content-type']))
  321.             time.sleep(120)
  322.             raise ExitThisLoopException()
  323.         json = req.json()
  324.         if not json['ok']:
  325.             self.set_status(gettext("Response didn't include 'ok:true'. Waiting 2 minutes before trying again. Response was: %(response)s", json))
  326.             time.sleep(120)
  327.             raise ExitThisLoopException()
  328.         if "result" in json and len(json['result']) > 0:
  329.             for entry in json['result']:
  330.                 self.set_update_offset(entry['update_id'])
  331.         return json
  332.  
  333.     # stop the listener
  334.     def stop(self):
  335.         self.do_stop = True
  336.    
  337.     def set_status(self, status, ok=False):
  338.         if status != self.main.connection_state_str:
  339.             if self.do_stop:
  340.                 self._logger.debug("Would set status but do_stop is True: %s", status)
  341.                 return
  342.             if ok:
  343.                 self._logger.debug("Setting status: %s", status)
  344.             else:
  345.                 self._logger.error("Setting status: %s", status)
  346.         self.connection_ok = ok
  347.         self.main.connection_state_str = status
  348.  
  349.     def getProxies(self):
  350.         http_proxy = self.main._settings.get(["http_proxy"])
  351.         https_proxy = self.main._settings.get(["https_proxy"])
  352.         return {
  353.             'http': http_proxy,
  354.             'https': https_proxy
  355.             }
  356.  
  357. class TelegramPluginLoggingFilter(logging.Filter):
  358.     def filter(self, record):
  359.         for match in re.findall("[0-9]+:[a-zA-Z0-9_\-]+", record.msg):
  360.             new = re.sub("[0-9]", "1", re.sub("[a-z]", "a", re.sub("[A-Z]", "A", match)))
  361.             record.msg = record.msg.replace(match, new)
  362.         return True
  363.  
  364. class ExitThisLoopException(Exception):
  365.     pass
  366.  
  367. ########################################
  368. ########################################
  369. ############## THE PLUGIN ##############
  370. ########################################
  371. ########################################
  372. class TelegramPlugin(octoprint.plugin.EventHandlerPlugin,
  373.                      octoprint.plugin.SettingsPlugin,
  374.                      octoprint.plugin.StartupPlugin,
  375.                      octoprint.plugin.ShutdownPlugin,
  376.                      octoprint.plugin.TemplatePlugin,
  377.                      octoprint.plugin.SimpleApiPlugin,
  378.                      octoprint.plugin.AssetPlugin
  379.                      ):
  380.  
  381.     def __init__(self,version):
  382.         self.version = float(version)
  383.         # for more init stuff see on_after_startup()
  384.         self.thread = None
  385.         self.bot_url = None
  386.         self.chats = {}
  387.         self.connection_state_str = gettext("Disconnected.")
  388.         self.connection_ok = False
  389.         requests.packages.urllib3.disable_warnings()
  390.         self.updateMessageID = {}
  391.         self.shut_up = {}
  392.         self.send_messages = True
  393.         self.tcmd = None
  394.         self.tmsg = None
  395.         self.sending_okay_minute = None
  396.         self.sending_okay_count = 0
  397.         # initial settings for new chat. See on_after_startup()
  398.         # !!! sync with newUsrDict in on_settings_migrate() !!!
  399.         self.newChat = {}
  400.         # use of emojis see below at method gEmo()
  401.         self.emojis = {
  402.             'octo':     u'\U0001F419', #octopus
  403.             'mistake':  u'\U0001F616',
  404.             'notify': u'\U0001F514',
  405.             'shutdown' : u'\U0001F4A4',
  406.             'shutup':    u'\U0001F64A',
  407.             'noNotify': u'\U0001F515',
  408.             'notallowed': u'\U0001F62C',
  409.             'rocket': u'\U0001F680',
  410.             'save': u'\U0001F4BE',
  411.             'heart': u'\U00002764',
  412.             'info': u'\U00002139',
  413.             'settings': u'\U0001F4DD',
  414.             'clock': u'\U000023F0',
  415.             'height': u'\U00002B06',
  416.             'question': u'\U00002753',
  417.             'warning': u'\U000026A0',
  418.             'enter': u'\U0000270F',
  419.             'upload': u'\U0001F4E5',
  420.             'check': u'\U00002705',
  421.             'lamp': u'\U0001F4A1',
  422.             'movie': u'\U0001F3AC',
  423.             'finish': u'\U0001F3C1',
  424.             'cam': u'\U0001F3A6',
  425.             'hooray': u'\U0001F389',
  426.             'error': u'\U000026D4',
  427.             'play': u'\U000025B6',
  428.             'stop': u'\U000025FC'
  429.         }
  430.         self.emojis.update(telegramEmojiDict)
  431.     # all emojis will be get via this method to disable them globaly by the corrosponding setting  
  432.     # so if you want to use emojis anywhere use gEmo("...") istead of emojis["..."]
  433.     def gEmo(self,key):
  434.         if self._settings.get(["send_icon"]) and key in self.emojis:
  435.             return self.emojis[key]
  436.         return ""
  437.  
  438.     # starts the telegram listener thread
  439.     def start_listening(self):
  440.         if self._settings.get(['token']) != "" and self.thread is None:
  441.             self._logger.debug("Starting listener.")
  442.             self.bot_url = "https://api.telegram.org/bot" + self._settings.get(['token'])
  443.             self.bot_file_url = "https://api.telegram.org/file/bot" + self._settings.get(['token'])
  444.             self.thread = TelegramListener(self)
  445.             self.thread.daemon = True
  446.             self.thread.start()
  447.    
  448.     # stops the telegram listener thread
  449.     def stop_listening(self):
  450.         if self.thread is not None:
  451.             self._logger.debug("Stopping listener.")
  452.             self.thread.stop()
  453.             self.thread = None
  454.    
  455.     def shutdown(self):
  456.         self._logger.warn("shutdown() running!")
  457.         self.stop_listening()
  458.         self.send_messages = False
  459.    
  460.     def sending_okay(self):
  461.         # If the count ever goeas above 10, we stop doing everything else and just return False
  462.         # so if this is ever reached, it will stay this way.
  463.         if self.sending_okay_count > 10:
  464.             self._logger.warn("Sent more than 10 messages in the last minute. Shutting down...")
  465.             self.shutdown()
  466.             return False
  467.        
  468.         if self.sending_okay_minute != datetime.datetime.now().minute:
  469.             self.sending_okay_minute = datetime.datetime.now().minute
  470.             self.sending_okay_count = 1
  471.         else:
  472.             self.sending_okay_count += 1
  473.            
  474.         return True
  475.  
  476. ##########
  477. ### Asset API
  478. ##########
  479.  
  480.     def get_assets(self):
  481.         return dict(js=["js/telegram.js"])
  482.  
  483. ##########
  484. ### Template API
  485. ##########
  486.  
  487.     def get_template_configs(self):
  488.         return [
  489.             dict(type="settings", name="Telegram", custom_bindings=True)
  490.         ]
  491.  
  492. ##########
  493. ### Wizard API
  494. ##########
  495.  
  496.     def is_wizard_required(self):
  497.         return self._settings.get(["token"]) is ""
  498.  
  499.     def get_wizard_version(self):
  500.         return 1
  501.         # Wizard version numbers used in releases
  502.         # < 1.4.2 : no wizard
  503.         # 1.4.2 : 1
  504.         # 1.4.3 : 1
  505.  
  506. ##########
  507. ### Startup/Shutdown API
  508. ##########
  509.  
  510.     def on_after_startup(self):
  511.         self.set_log_level()
  512.         self._logger.addFilter(TelegramPluginLoggingFilter())
  513.         self.tcmd = TCMD(self)
  514.         self.tmsg = TMSG(self) # Notification Message Handler class. called only by on_event()
  515.         # initial settings for new chat.
  516.         # !!! sync this dict with newUsrDict in on_settings_migrate() !!!
  517.         self.newChat = {
  518.             'private': True,
  519.             'title': "[UNKNOWN]",
  520.             'accept_commands' : False,
  521.             'send_notifications' : False,
  522.             'new': True,
  523.             'type': '',
  524.             'allow_users': False,
  525.             'commands': {k: False for k,v in self.tcmd.commandDict.iteritems()},
  526.             'notifications': {k: False for k,v in telegramMsgDict.iteritems()}
  527.             }
  528.         self.chats = self._settings.get(["chats"])
  529.         self.start_listening()
  530.         self.track_action("started")
  531.         # Delete user profile photos if user doesn't exist anymore
  532.         for f in os.listdir(self.get_plugin_data_folder()+"/img/user"):
  533.             fcut = f.split('.')[0][3:]
  534.             self._logger.debug("Testing Pic ID " + str(fcut))
  535.             if fcut not in self.chats:
  536.                 self._logger.debug("Removing pic" +fcut+".jpg")
  537.                 try:
  538.                     os.remove(self.get_plugin_data_folder()+"/img/user/"+f)
  539.                 except OSError:
  540.                     pass
  541.         #Update user profile photos
  542.         for key in self.chats:
  543.             try:
  544.                 if key is not 'zBOTTOMOFCHATS':
  545.                     kwargs = {}
  546.                     kwargs['chat_id'] = int(key)
  547.                     t = threading.Thread(target=self.get_usrPic, kwargs=kwargs)
  548.                     t.daemon = True
  549.                     t.run()
  550.             except Exception:
  551.                 pass
  552.    
  553.     def on_shutdown(self):
  554.         self.on_event("PrinterShutdown",{})
  555.         self.stop_listening()
  556.  
  557. ##########
  558. ### Settings API
  559. ##########
  560.  
  561.     def get_settings_version(self):
  562.         return 4
  563.         # Settings version numbers used in releases
  564.         # < 1.3.0: no settings versioning
  565.         # 1.3.0 : 1
  566.         # 1.3.1 : 2
  567.         # 1.3.2 : 2
  568.         # 1.3.3 : 2
  569.         # 1.4.0 : 3
  570.         # 1.4.1 : 3
  571.         # 1.4.2 : 3
  572.         # 1.4.3 : 4
  573.  
  574.     def get_settings_defaults(self):
  575.         return dict(
  576.             token = "",
  577.             notification_height = 5.0,
  578.             notification_time = 15,
  579.             message_at_print_done_delay = 0,
  580.             messages = telegramMsgDict,
  581.             tracking_activated = False,
  582.             tracking_token = None,
  583.             chats = {'zBOTTOMOFCHATS':{'send_notifications': False,'accept_commands':False,'private':False}},
  584.             debug = False,
  585.             send_icon = True,
  586.             image_not_connected = True,
  587.             fileOrder = False
  588.         )
  589.  
  590.     def get_settings_preprocessors(self):
  591.         return dict(), dict(
  592.             notification_height=lambda x: float(x),
  593.             notification_time=lambda x: int(x)
  594.         )
  595.  
  596.     def on_settings_migrate(self, target, current=None):
  597.         self._logger.setLevel(logging.DEBUG)
  598.         self._logger.debug("MIGRATE DO")
  599.         tcmd = TCMD(self)
  600.         # initial settings for new chat.
  601.         # !!! sync this dict with newChat in on_after_startup() !!!
  602.         newUsrDict = {
  603.             'private': True,
  604.             'title': "[UNKNOWN]",
  605.             'accept_commands' : False,
  606.             'send_notifications' : False,
  607.             'new': False,
  608.             'type': '',
  609.             'allow_users': False,
  610.             'commands': {k: False for k,v in tcmd.commandDict.iteritems()},
  611.             'notifications': {k: False for k,v in telegramMsgDict.iteritems()}
  612.             }
  613.  
  614.         ##########
  615.         ### migrate from old plugin Versions < 1.3 (old versions had no settings version check)
  616.         ##########
  617.         chats = {k: v for k, v in self._settings.get(['chats']).iteritems() if k != 'zBOTTOMOFCHATS'}
  618.         self._logger.debug("LOADED CHATS: " + str(chats))
  619.         self._settings.set(['chats'], {})
  620.         if current is None or current < 1:
  621.             ########## Update Chats
  622.             # there shouldn't be any chats, but maybe somone had installed any test branch.
  623.             # Then we have to check if all needed settings are populated
  624.             for chat in chats:
  625.                 for setting in newUsrDict:
  626.                     if setting not in chats[chat]:
  627.                         if setting == "commands":
  628.                             chats[chat]['commands'] = {k: False for k,v in tcmd.commandDict.iteritems() if 'bind_none' not in v}
  629.                         elif setting == "notifications":
  630.                             chats[chat]['notifications'] = {k: False for k,v in telegramMsgDict.iteritems()}
  631.                         else:
  632.                             chats[chat][setting] = False
  633.             ########## Is there a chat from old single user plugin version?
  634.             # then migrate it into chats
  635.             chat = self._settings.get(["chat"])
  636.             if chat is not None:
  637.                 self._settings.set(["chat"], None)
  638.                 data = {}
  639.                 data.update(newUsrDict)
  640.                 data['private'] = True
  641.                 data['title'] = "[UNKNOWN]"
  642.                 #try to get infos from telegram by sending a "you are migrated" message
  643.                 try:
  644.                     message = {}
  645.                     message['text'] = "The OctoPrint Plugin " + self._plugin_name + " has been updated to new Version "+self._plugin_version+ ".\n\nPlease open your " + self._plugin_name + " settings in OctoPrint and set configurations for this chat. Until then you are not able to send or receive anything useful with this Bot.\n\nMore informations on: https://github.com/fabianonline/OctoPrint-Telegram"
  646.                     message['chat_id'] = chat
  647.                     message['disable_web_page_preview'] = True
  648.                     r = requests.post("https://api.telegram.org/bot" + self._settings.get(['token']) + "/sendMessage", data =  message, proxies=self.getProxies())
  649.                     r.raise_for_status()
  650.                     if r.headers['content-type'] != 'application/json':
  651.                         raise Exception("invalid content-type")
  652.                     json = r.json()
  653.                     if not json['ok']:
  654.                         raise Exception("invalid request")
  655.                     chat = json['result']['chat']
  656.                     if chat['type']=='group':
  657.                         data['private'] = False
  658.                         data['title'] = chat['title']
  659.                     elif chat['type']=='private':
  660.                         data['private'] = True
  661.                         data['title'] = ""
  662.                         if "first_name" in chat:
  663.                             data['title'] += chat['first_name'] + " - "
  664.                         if "last_name" in chat:
  665.                             data['title'] += chat['last_name'] + " - "
  666.                         if "username" in chat:
  667.                             data['title'] += "@" + chat['username']
  668.                 except Exception as ex:
  669.                     self._logger.debug("ERROR migrating chat. Done with defaults private=true,title=[UNKNOWN] : " + str(ex))
  670.                 # place the migrated chat in chats
  671.                 chats.update({str(chat['id']): data})
  672.             self._logger.debug("MIGRATED Chats: " + str(chats))
  673.             ########## Update messages. Old text will be taken to new structure
  674.             messages = self._settings.get(['messages'])
  675.             msgOut = {}
  676.             for msg in messages:
  677.                 if msg == 'TelegramSendNotPrintingStatus':
  678.                     msg2 = 'StatusNotPrinting'
  679.                 elif msg == 'TelegramSendPrintingStatus':
  680.                     msg2 = 'StatusPrinting'
  681.                 else:
  682.                     msg2 = msg
  683.                 if type(messages[msg]) is not type({}):
  684.                     newMsg = telegramMsgDict[msg2].copy()
  685.                     newMsg['text'] = str(messages[msg])
  686.                     msgOut.update({msg2: newMsg})
  687.                 else:
  688.                     msgOut.update({msg2: messages[msg]})
  689.             self._settings.set(['messages'], msgOut)
  690.             ########## Delete old settings
  691.             self._settings.set(["message_at_startup"], None)
  692.             self._settings.set(["message_at_shutdown"], None)
  693.             self._settings.set(["message_at_print_started"], None)
  694.             self._settings.set(["message_at_print_done"], None)
  695.             self._settings.set(["message_at_print_failed"], None)
  696.  
  697.         ##########
  698.         ### Migrate to new command/notification settings version.
  699.         ### This should work on all future versions. So if you add/del
  700.         ### some commands/notifications, then increment settings version counter
  701.         ### in  get_settings_version(). This will trigger octoprint to update settings
  702.         ##########
  703.         if current is None or current < target:
  704.             # first we have to check if anything has changed in commandDict or telegramMsgDict
  705.             # then we have to update user comamnd or notification settings
  706.             if chats is not None and chats is not {}:
  707.                 # this for loop updates commands and notifications settings items of chats
  708.                 # if there are changes in commandDict or telegramMsgDict
  709.                 for chat in chats:
  710.                     # handle renamed commands
  711.                     if '/list' in chats[chat]['commands']:
  712.                         chats[chat]['commands'].update({'/files':chats[chat]['commands']['/list']})
  713.                     if '/imsorrydontshutup' in chats[chat]['commands']:
  714.                         chats[chat]['commands'].update({'/dontshutup':chats[chat]['commands']['/imsorrydontshutup']})
  715.                     if 'type' not in chats[chat]:
  716.                         chats[chat].update({'type': 'PRIVATE' if chats[chat]['private'] else 'GROUP'})
  717.                     delCmd = []
  718.                     # collect remove 'bind_none' commands
  719.                     for cmd in tcmd.commandDict:
  720.                         if cmd in chats[chat]['commands'] and 'bind_none' in tcmd.commandDict[cmd]:
  721.                             delCmd.append(cmd)
  722.                     # collect Delete commands from settings if they don't belong to commandDict anymore
  723.                     for cmd in chats[chat]['commands']:
  724.                         if cmd not in tcmd.commandDict:
  725.                             delCmd.append(cmd)
  726.                     # finally delete commands
  727.                     for cmd in delCmd:
  728.                         del chats[chat]['commands'][cmd]
  729.                     # If there are new commands in comamndDict, add them to settings
  730.                     for cmd in tcmd.commandDict:
  731.                         if cmd not in chats[chat]['commands']:
  732.                             if 'bind_none' not in tcmd.commandDict[cmd]:
  733.                                 chats[chat]['commands'].update({cmd: False})
  734.                     # Delete notifications from settings if they don't belong to msgDict anymore
  735.                     delMsg = []
  736.                     for msg in chats[chat]['notifications']:
  737.                         if msg not in telegramMsgDict:
  738.                             delMsg.append(msg)
  739.                     for msg in delMsg:
  740.                         del chats[chat]['notifications'][msg]
  741.                     # If there are new notifications in msgDict, add them to settings
  742.                     for msg in telegramMsgDict:
  743.                         if msg not in chats[chat]['notifications']:
  744.                             chats[chat]['notifications'].update({msg: False})
  745.                 self._settings.set(['chats'],chats)
  746.             ########## if anything changed in telegramMsgDict, we also have to update settings for messages
  747.             messages = self._settings.get(['messages'])
  748.             if messages is not None and messages is not {}:
  749.                 # this for loop deletes items from messages settings
  750.                 # if they dont't belong to telegramMsgDict anymore
  751.                 delMsg = []
  752.                 for msg in messages:
  753.                     if msg not in telegramMsgDict:
  754.                         delMsg.append(msg)
  755.                 for msg in delMsg:
  756.                     del messages[msg]
  757.                 # this for loop adds new message settings from telegramMsgDict to settings
  758.                 for msg in telegramMsgDict:
  759.                     if msg not in messages:
  760.                         messages.update({msg: telegramMsgDict[msg]})
  761.                     elif 'combined' not in messages[msg]:
  762.                         messages[msg].update({'combined' : True})
  763.  
  764.                 self._settings.set(['messages'],messages)
  765.                 self._logger.debug("MESSAGES: " + str(self._settings.get(['messages'])))
  766.  
  767.  
  768.         if current is not None:
  769.             if current < 2:
  770.                 if chats is not None and chats is not {}:
  771.                     for chat in chats:
  772.                         if os.path.isfile(self.get_plugin_data_folder()+"/pic"+chat+".jpg"):
  773.                             os.remove(self.get_plugin_data_folder()+"/pic"+chat+".jpg")
  774.  
  775.  
  776.         ##########
  777.         ### save the settings after Migration is done
  778.         ##########
  779.         self._logger.debug("SAVED Chats: " + str(self._settings.get(['chats'])))
  780.         try:
  781.             self._settings.save()
  782.         except Exception as ex:
  783.             self._logger.error("MIGRATED Save failed - " + str(ex))
  784.         self._logger.debug("MIGRATED Saved")
  785.  
  786.  
  787.     def on_settings_save(self, data):
  788.         # Remove 'new'-flag and apply bindings for all chats
  789.         if 'chats' in data and data['chats']:
  790.             delList = []
  791.             for key in data['chats']:
  792.                 if 'new' in data['chats'][key] or 'new' in data['chats'][key]:
  793.                     data['chats'][key]['new'] = False
  794.                 # Look for deleted chats
  795.                 if not key in self.chats and not key == "zBOTTOMOFCHATS":
  796.                     delList.append(key)
  797.             # Delete chats finally
  798.             for key in delList:
  799.                 del data['chats'][key]
  800.         # Also remove 'new'-flag from self.chats so settingsUI is consistent
  801.         # self.chats will only update to settings data on first received message after saving done
  802.         for key in self.chats:
  803.             if 'new' in self.chats[key]:
  804.                 self.chats[key]['new'] = False
  805.  
  806.         self._logger.debug("Saving data: " + str(data))
  807.         # Check token for right format
  808.         if 'token' in data:
  809.             data['token'] = data['token'].strip()
  810.             if not re.match("^[0-9]+:[a-zA-Z0-9_\-]+$", data['token']):
  811.                 self._logger.error("Not saving token because it doesn't seem to have the right format.")
  812.                 self.connection_state_str = gettext("The previously entered token doesn't seem to have the correct format. It should look like this: 12345678:AbCdEfGhIjKlMnOpZhGtDsrgkjkZTCHJKkzvjhb")
  813.                 data['token'] = ""
  814.         old_token = self._settings.get(["token"])
  815.         # Update Tracking
  816.         if 'tracking_activated' in data and not data['tracking_activated']:
  817.             data['tracking_token'] = None
  818.         # Now save settings
  819.         octoprint.plugin.SettingsPlugin.on_settings_save(self, data)
  820.         self.set_log_level()
  821.         # Reconnect on new token
  822.         # Will stop listener on invalid token
  823.         if 'token' in data:
  824.             if data['token']!=old_token:
  825.                 self.stop_listening()
  826.             if data['token']!="":
  827.                 self.start_listening()
  828.             else:
  829.                 self.connection_state_str = gettext("No token given.")
  830.  
  831.     def on_settings_load(self):
  832.         data = octoprint.plugin.SettingsPlugin.on_settings_load(self)
  833.  
  834.         # only return our restricted settings to admin users - this is only needed for OctoPrint <= 1.2.16
  835.         restricted = (("token", None), ("tracking_token", None), ("chats", dict()))
  836.         for r, v in restricted:
  837.             if r in data and (current_user is None or current_user.is_anonymous() or not current_user.is_admin()):
  838.                 data[r] = v
  839.  
  840.         return data
  841.  
  842.     def get_settings_restricted_paths(self):
  843.         # only used in OctoPrint versions > 1.2.16
  844.         return dict(admin=[["token"], ["tracking_token"], ["chats"]])
  845.  
  846. ##########
  847. ### Softwareupdate API
  848. ##########
  849.    
  850.     def get_update_information(self, *args, **kwargs):
  851.         return dict(
  852.             telegram=dict(
  853.                 displayName=self._plugin_name,
  854.                 displayVersion=self._plugin_version,
  855.                 type="github_release",
  856.                 current=self._plugin_version,
  857.                 user="fabianonline",
  858.                 repo="OctoPrint-Telegram",
  859.                 pip="https://github.com/fabianonline/OctoPrint-Telegram/releases/{target_version}/download/release.zip"
  860.             )
  861.         )
  862.  
  863. ##########
  864. ### EventHandler API
  865. ##########
  866.        
  867.     def on_event(self, event, payload, **kwargs):
  868.         try:
  869.             # if we know the event, start handler
  870.             if event in self.tmsg.msgCmdDict:
  871.                 self._logger.debug("Got an event: " + event + " Payload: " + str(payload))
  872.                 # Start event handler
  873.                 self.tmsg.startEvent(event, payload, **kwargs)
  874.             else:
  875.                 # return as fast as possible
  876.                 return
  877.         except Exception as e:
  878.             self._logger.debug("Exception: " + str(e))
  879.  
  880. ##########
  881. ### SimpleApi API
  882. ##########
  883.  
  884.     def get_api_commands(self):
  885.         return dict(
  886.             testToken=["token"],
  887.             delChat=["ID"]
  888.         )
  889.  
  890.     def on_api_get(self, request):
  891.         # got an user-update with this command. so lets do that
  892.         if 'id' in request.args and 'cmd' in request.args and 'note' in request.args  and 'allow' in request.args:
  893.             self.chats[request.args['id']]['accept_commands'] = self.str2bool(str(request.args['cmd']))
  894.             self.chats[request.args['id']]['send_notifications'] = self.str2bool(str(request.args['note']))
  895.             self.chats[request.args['id']]['allow_users'] = self.str2bool(str(request.args['allow']))
  896.             self._logger.debug("Updated chat - " + str(request.args['id']))
  897.         elif 'bindings' in request.args:
  898.             bind_text = {}
  899.             for key in {k: v for k, v in telegramMsgDict.iteritems() if 'bind_msg' in v }:
  900.                 if telegramMsgDict[key]['bind_msg'] in bind_text:
  901.                     bind_text[telegramMsgDict[key]['bind_msg']].append(key)
  902.                 else:
  903.                     bind_text[telegramMsgDict[key]['bind_msg']] = [key]
  904.             return json.dumps({
  905.                 'bind_cmd':[k for k, v in self.tcmd.commandDict.iteritems() if 'bind_none' not in v ],
  906.                 'bind_msg':[k for k, v in telegramMsgDict.iteritems() if 'bind_msg' not in v ],
  907.                 'bind_text':bind_text,
  908.                 'no_setting':[k for k, v in telegramMsgDict.iteritems() if 'no_setting' in v ]})
  909.        
  910.         retChats = {k: v for k, v in self.chats.iteritems() if 'delMe' not in v and k != 'zBOTTOMOFCHATS'}
  911.         for chat in retChats:
  912.             if os.path.isfile(self.get_plugin_data_folder()+"/img/user/pic" +chat+".jpg"):
  913.                 retChats[chat]['image'] = "/plugin/telegram/img/user/pic" +chat+".jpg"
  914.             elif int(chat) < 0:
  915.                 retChats[chat]['image'] = "/plugin/telegram/img/static/group.jpg"
  916.             else:
  917.                 retChats[chat]['image'] = "/plugin/telegram/img/static/default.jpg"
  918.  
  919.         return json.dumps({'chats':retChats, 'connection_state_str':self.connection_state_str, 'connection_ok':self.connection_ok})
  920.    
  921.     def on_api_command(self, command, data):
  922.         if command=="testToken":
  923.             self._logger.debug("Testing token {}".format(data['token']))
  924.             try:
  925.                 if self._settings.get(["token"]) != data["token"]:
  926.                     username = self.test_token(data['token'])
  927.                     self._settings.set(['token'], data['token'])
  928.                     self.stop_listening() #to start with new token if already running
  929.                     self.start_listening()
  930.                     return json.dumps({'ok': True, 'connection_state_str': gettext("Token valid for %(username)s.", username=username), 'error_msg': None, 'username': username})
  931.                 return json.dumps({'ok': True, 'connection_state_str': gettext("Token valid for %(username)s.", username=self.thread.username), 'error_msg': None, 'username': self.thread.username})
  932.             except Exception as ex:
  933.                 return json.dumps({'ok': False, 'connection_state_str': gettext("Error: %(error)s", error=ex), 'username': None, 'error_msg': str(ex)})
  934.         # delete a chat (will not be removed and show up again on octorint restart
  935.         # if save button is not pressed on settings dialog)
  936.         elif command=="delChat":
  937.             strId = str(data['ID'])
  938.             if strId in self.chats:
  939.                 del self.chats[strId]
  940.                 # do self._settings.save() here???????
  941.             return json.dumps({'chats':{k: v for k, v in self.chats.iteritems() if 'delMe' not in v and k != 'zBOTTOMOFCHATS'}, 'connection_state_str':self.connection_state_str, 'connection_ok':self.connection_ok})
  942.  
  943. ##########
  944. ### Telegram API-Functions
  945. ##########
  946.  
  947.     def send_msg(self, message, **kwargs):
  948.         if not self.send_messages:
  949.             return
  950.            
  951.         kwargs['message'] = message
  952.         try:
  953.             # If it's a regular event notification
  954.             if 'chatID' not in kwargs and 'event' in kwargs:
  955.                 self._logger.debug("Send_msg() found event: " + str(kwargs['event']))
  956.                 for key in self.chats:
  957.                     if key != 'zBOTTOMOFCHATS':
  958.                         if self.chats[key]['notifications'][kwargs['event']] and (key not in self.shut_up or self.shut_up[key]==0) and self.chats[key]['send_notifications']:
  959.                             kwargs['chatID'] = key
  960.                             t = threading.Thread(target=self._send_msg, kwargs = kwargs).run()
  961.             # Seems to be a broadcast
  962.             elif 'chatID' not in kwargs:
  963.                 for key in self.chats:
  964.                     kwargs['chatID'] = key
  965.                     t = threading.Thread(target=self._send_msg, kwargs = kwargs).run()
  966.             # This is a 'editMessageText' message
  967.             elif 'msg_id' in kwargs and kwargs['msg_id'] is not "" and  kwargs['msg_id'] is not None:
  968.                 t = threading.Thread(target=self._send_edit_msg, kwargs = kwargs).run()
  969.             # direct message or event notification to a chat_id
  970.             else:
  971.                 t = threading.Thread(target=self._send_msg, kwargs = kwargs).run()
  972.         except Exception as ex:
  973.             self._logger.debug("Caught an exception in send_msg(): " + str(ex))
  974.  
  975.  
  976.     # this method is used to update a message text of a sent message
  977.     # the sent message had to have no_markup = true when calling send_msg() (otherwise it would not work)
  978.     # by setting no_markup = true we got a messageg_id on sending the message which is saved in selfupdateMessageID
  979.     # if this message_id is passed in msg_id to send_msg() then this method will be called
  980.     def _send_edit_msg(self,message="",msg_id="",chatID="", responses= None, inline=True, markup=None,delay=0, **kwargs):
  981.         if not self.send_messages:
  982.             return
  983.            
  984.         if delay > 0:
  985.             time.sleep(delay)
  986.         try:
  987.             self._logger.debug("Sending a message UPDATE: " + message.replace("\n", "\\n") + " chatID= " + str(chatID))
  988.             data = {}
  989.             data['text'] = message
  990.             data['message_id'] = msg_id
  991.             data['chat_id'] = int(chatID)
  992.             if markup is not None:
  993.                 if "HTML" in markup  or "Markdown" in markup:
  994.                     data["parse_mode"] = markup
  995.             if responses and inline:
  996.                 myArr = []
  997.                 for k in responses:
  998.                     myArr.append(map(lambda x: {"text":x[0],"callback_data":x[1]}, k))
  999.                 keyboard = {'inline_keyboard':myArr}
  1000.                 data['reply_markup'] = json.dumps(keyboard)
  1001.             self._logger.debug("SENDING UPDATE: " + str(data))
  1002.             req = requests.post(self.bot_url + "/editMessageText", data=data, proxies=self.getProxies())
  1003.             if req.headers['content-type'] != 'application/json':
  1004.                 self._logger.debug(gettext("Unexpected Content-Type. Expected: application/json. Was: %(type)s. Waiting 2 minutes before trying again.", type=req.headers['content-type']))
  1005.                 return
  1006.             myJson = req.json()
  1007.             self._logger.debug("REQUEST RES: "+str(myJson))
  1008.             if inline:
  1009.                 self.updateMessageID[chatID] = msg_id
  1010.         except Exception as ex:
  1011.             self._logger.debug("Caught an exception in _send_edit_msg(): " + str(ex))
  1012.  
  1013.     def _send_msg(self, message="", with_image=False, responses=None, delay=0, inline = True, chatID = "", markup=None, showWeb=False, **kwargs):
  1014.         if not self.send_messages:
  1015.             return
  1016.            
  1017.         if delay > 0:
  1018.             time.sleep(delay)
  1019.         try:
  1020.             if with_image:
  1021.                 if 'event' in kwargs and not self._settings.get(["messages",kwargs['event'],"combined"]):
  1022.                     args = locals()
  1023.                     del args['kwargs']['event']
  1024.                     del args['self']
  1025.                     args['message'] = ""
  1026.                     self._logger.debug("Sending image...")
  1027.                     t = threading.Thread(target=self._send_msg, kwargs = args).run()
  1028.                     args['message'] = message
  1029.                     args['with_image'] = False
  1030.                     self._logger.debug("Sending text...")
  1031.                     t = threading.Thread(target=self._send_msg, kwargs = args).run()
  1032.                     return
  1033.  
  1034.             self._logger.debug("Sending a message: " + message.replace("\n", "\\n") + " with_image=" + str(with_image) + " chatID= " + str(chatID))
  1035.             data = {}
  1036.             # Do we want to show web link previews?
  1037.             data['disable_web_page_preview'] = not showWeb  
  1038.             # Do we want the message to be parsed in any markup?
  1039.             if markup is not None:
  1040.                 if "HTML" in markup  or "Markdown" in markup:
  1041.                     data["parse_mode"] = markup
  1042.             if responses:
  1043.                 myArr = []
  1044.                 for k in responses:
  1045.                     myArr.append(map(lambda x: {"text":x[0],"callback_data":x[1]}, k))
  1046.                 keyboard = {'inline_keyboard':myArr}
  1047.                 data['reply_markup'] = json.dumps(keyboard)
  1048.                
  1049.             image_data = None
  1050.             if with_image:
  1051.                 image_data = self.take_image()
  1052.             self._logger.debug("data so far: " + str(data))
  1053.  
  1054.             if not image_data and with_image:
  1055.                 message = "[ERR GET IMAGE]\n\n" + message
  1056.  
  1057.             r = None
  1058.             data['chat_id'] = chatID
  1059.             if image_data:
  1060.                 self._logger.debug("Sending with image.. " + str(chatID))
  1061.                 files = {'photo':("image.jpg", image_data)}
  1062.                 if message is not "":
  1063.                     data['caption'] = message
  1064.                 r = requests.post(self.bot_url + "/sendPhoto", files=files, data=data, proxies=self.getProxies())
  1065.                 self._logger.debug("Sending finished. " + str(r.status_code))
  1066.             else:
  1067.                 self._logger.debug("Sending without image.. " + str(chatID))
  1068.                 data['text'] = message
  1069.                 r =requests.post(self.bot_url + "/sendMessage", data=data, proxies=self.getProxies())
  1070.                 self._logger.debug("Sending finished. " + str(r.status_code))
  1071.  
  1072.             if r is not None and inline:
  1073.                 r.raise_for_status()
  1074.                 myJson = r.json()
  1075.                 if not myJson['ok']:
  1076.                     raise NameError("ReqErr")
  1077.                 if 'message_id' in myJson['result']:
  1078.                     self.updateMessageID[chatID] = myJson['result']['message_id']
  1079.         except Exception as ex:
  1080.             self._logger.debug("Caught an exception in _send_msg(): " + str(ex))
  1081.    
  1082.     def send_file(self,chat_id,path):
  1083.         if not self.send_messages:
  1084.             return
  1085.            
  1086.         try:
  1087.             requests.get(self.bot_url + "/sendChatAction", params = {'chat_id': chat_id, 'action': 'upload_document'}, proxies=self.getProxies())
  1088.             files = {'document': open(path, 'rb')}
  1089.             r = requests.post(self.bot_url + "/sendDocument", files=files, data={'chat_id':chat_id}, proxies=self.getProxies())
  1090.         except Exception as ex:
  1091.             pass
  1092.  
  1093.     def send_video(self, message, video_file):
  1094.         if not self.send_messages:
  1095.             return
  1096.            
  1097.         files = {'video': open(video_file, 'rb')}
  1098.         #r = requests.post(self.bot_url + "/sendVideo", files=files, data={'chat_id':self._settings.get(["chat"]), 'caption':message})
  1099.         self._logger.debug("Sending finished. " + str(r.status_code) + " " + str(r.content))
  1100.    
  1101.     def get_file(self, file_id):
  1102.         if not self.send_messages:
  1103.             return
  1104.            
  1105.         self._logger.debug("Requesting file with id %s.", file_id)
  1106.         r = requests.get(self.bot_url + "/getFile", data={'file_id': file_id}, proxies=self.getProxies())
  1107.         # {"ok":true,"result":{"file_id":"BQADAgADCgADrWJxCW_eFdzxDPpQAg","file_size":26,"file_path":"document\/file_3.gcode"}}
  1108.         r.raise_for_status()
  1109.         data = r.json()
  1110.         if not "ok" in data:
  1111.             raise Exception(_("Telegram didn't respond well to getFile. The response was: %(response)s", response=r.text))
  1112.         url = self.bot_file_url + "/" + data['result']['file_path']
  1113.         self._logger.debug("Downloading file: %s", url)
  1114.         r = requests.get(url, proxies=self.getProxies())
  1115.         r.raise_for_status()
  1116.         return r.content
  1117.  
  1118.     def get_usrPic(self,chat_id, file_id=""):
  1119.         if not self.send_messages:
  1120.             return
  1121.            
  1122.         self._logger.debug("Requesting Profile Photo for chat_id: " + str(chat_id))
  1123.         try:
  1124.             if file_id == "":
  1125.                 if int(chat_id) < 0:
  1126.                     self._logger.debug("Not able to load group photos. "+ str(chat_id)+" EXIT")
  1127.                     return
  1128.                 r = requests.get(self.bot_url + "/getUserProfilePhotos", params = {'limit': 1, "user_id": chat_id}, proxies=self.getProxies())
  1129.                 r.raise_for_status()
  1130.                 data = r.json()
  1131.                 if not "ok" in data:
  1132.                     raise Exception(_("Telegram didn't respond well to getUserProfilePhoto "+ str(chat_id)+". The response was: %(response)s", response=r.text))
  1133.                 if data['result']['total_count'] < 1:
  1134.                     self._logger.debug("NO PHOTOS "+ str(chat_id)+". EXIT")
  1135.                     return
  1136.                 r = self.get_file(data['result']['photos'][0][0]['file_id'])
  1137.             else:
  1138.                 r = self.get_file(file_id)
  1139.             file_name = self.get_plugin_data_folder() + "/img/user/pic" + str(chat_id) + ".jpg"
  1140.             img = Image.open(StringIO.StringIO(r))
  1141.             img = img.resize((40, 40), PIL.Image.ANTIALIAS)
  1142.             img.save(file_name, format="JPEG")
  1143.             self._logger.debug("Saved Photo "+ str(chat_id))
  1144.  
  1145.         except Exception as ex:
  1146.             self._logger.error("Can't load UserImage: " + str(ex))
  1147.    
  1148.     def test_token(self, token=None):
  1149.         if not self.send_messages:
  1150.             return
  1151.            
  1152.         if token is None:
  1153.             token = self._settings.get(["token"])
  1154.         response = requests.get("https://api.telegram.org/bot" + token + "/getMe", proxies=self.getProxies())
  1155.         self._logger.debug("getMe returned: " + str(response.json()))
  1156.         self._logger.debug("getMe status code: " + str(response.status_code))
  1157.         json = response.json()
  1158.         if not 'ok' in json or not json['ok']:
  1159.             if json['description']:
  1160.                 raise(Exception(gettext("Telegram returned error code %(error)s: %(message)s", error=json['error_code'], message=json['description'])))
  1161.             else:
  1162.                 raise(Exception(gettext("Telegram returned an unspecified error.")))
  1163.         else:
  1164.             return "@" + json['result']['username']
  1165.  
  1166. ##########
  1167. ### Helper methods
  1168. ##########
  1169.  
  1170.     def str2bool(self,v):
  1171.         return v.lower() in ("yes", "true", "t", "1")
  1172.  
  1173.     def set_log_level(self):
  1174.         self._logger.setLevel(logging.DEBUG if self._settings.get_boolean(["debug"]) else logging.NOTSET)
  1175.  
  1176.  
  1177.     def getProxies(self):
  1178.         http_proxy = self._settings.get(["http_proxy"])
  1179.         https_proxy = self._settings.get(["https_proxy"])
  1180.         return {
  1181.             'http': http_proxy,
  1182.             'https': https_proxy
  1183.             }
  1184.  
  1185. # checks if the received command is allowed to execute by the user
  1186.     def isCommandAllowed(self, chat_id, from_id, command):
  1187.         if 'bind_none' in self.tcmd.commandDict[command]:
  1188.             return True
  1189.         if command is not None or command is not "":
  1190.             if self.chats[chat_id]['accept_commands']:
  1191.                 if self.chats[chat_id]['commands'][command]:
  1192.                         return True
  1193.                 elif int(chat_id) < 0 and self.chats[chat_id]['allow_users']:
  1194.                     if self.chats[from_id]['commands'][command] and self.chats[from_id]['accept_commands']:
  1195.                         return True
  1196.             elif int(chat_id) < 0 and self.chats[chat_id]['allow_users']:
  1197.                 if self.chats[from_id]['commands'][command] and self.chats[from_id]['accept_commands']:
  1198.                         return True
  1199.         return False
  1200.  
  1201.     # Helper function to handle /editMessageText Telegram API commands
  1202.     # see main._send_edit_msg()
  1203.     def getUpdateMsgId(self,id):
  1204.         uMsgID = ""
  1205.         if id in self.updateMessageID:
  1206.             uMsgID = self.updateMessageID[id]
  1207.             del self.updateMessageID[id]
  1208.         return uMsgID
  1209.  
  1210.     def take_image(self):
  1211.         snapshot_url = self._settings.global_get(["webcam", "snapshot"])
  1212.         self._logger.debug("Snapshot URL: " + str(snapshot_url))
  1213.         data = None
  1214.         if snapshot_url:
  1215.             try:
  1216.                 r = requests.get(snapshot_url)
  1217.                 data = r.content
  1218.             except Exception as e:
  1219.                 return None
  1220.         flipH = self._settings.global_get(["webcam", "flipH"])
  1221.         flipV = self._settings.global_get(["webcam", "flipV"])
  1222.         rotate= self._settings.global_get(["webcam", "rotate90"])
  1223.        
  1224.         if flipH or flipV or rotate:
  1225.             image = Image.open(StringIO.StringIO(data))
  1226.             if flipH:
  1227.                 image = image.transpose(Image.FLIP_LEFT_RIGHT)
  1228.             if flipV:
  1229.                 image = image.transpose(Image.FLIP_TOP_BOTTOM)
  1230.             if rotate:
  1231.                 image = image.transpose(Image.ROTATE_90)
  1232.             output = StringIO.StringIO()
  1233.             image.save(output, format="JPEG")
  1234.             data = output.getvalue()
  1235.             output.close()
  1236.         return data
  1237.        
  1238.     def track_action(self, action):
  1239.         if not self._settings.get_boolean(["tracking_activated"]):
  1240.             return
  1241.         if self._settings.get(["tracking_token"]) is None:
  1242.             token = "".join(random.choice("abcdef0123456789") for i in xrange(16))
  1243.             self._settings.set(["tracking_token"], token)
  1244.         params = {
  1245.             'idsite': '3',
  1246.             'rec': '1',
  1247.             'url': 'http://octoprint-telegram/'+action,
  1248.             'action_name': ("%20/%20".join(action.split("/"))),
  1249.             '_id': self._settings.get(["tracking_token"]),
  1250.             'uid': self._settings.get(["tracking_token"]),
  1251.             'cid': self._settings.get(["tracking_token"]),
  1252.             'send_image': '0',
  1253.             '_idvc': '1',
  1254.             'dimension1': str(self._plugin_version)
  1255.         }
  1256.         t = threading.Thread(target=requests.get, args=("http://piwik.schlenz.ruhr/piwik.php",), kwargs={'params': params})
  1257.         t.daemon = True
  1258.         t.run()
  1259.  
  1260.     def route_hook(self, server_routes, *args, **kwargs):
  1261.         from octoprint.server.util.tornado import LargeResponseHandler, UrlProxyHandler, path_validation_factory
  1262.         from octoprint.util import is_hidden_path
  1263.         if not os.path.exists(self.get_plugin_data_folder()+"/img"):
  1264.             os.mkdir(self.get_plugin_data_folder()+"/img")
  1265.         if not os.path.exists(self.get_plugin_data_folder()+"/img/user"):
  1266.             os.mkdir(self.get_plugin_data_folder()+"/img/user")
  1267.  
  1268.         return [
  1269.                 (r"/img/user/(.*)", LargeResponseHandler, dict(path=self.get_plugin_data_folder() + r"/img/user/", as_attachment=True,allow_client_caching =False)),
  1270.                 (r"/img/static/(.*)", LargeResponseHandler, dict(path=self._basefolder + "/static/img/", as_attachment=True,allow_client_caching =True))
  1271.                 ]
  1272.  
  1273. ########################################
  1274. ########################################
  1275. ### Some methods to check version and
  1276. ### get the right implementation
  1277. ########################################
  1278. ########################################
  1279.  
  1280. # copied from pluginmanager plugin
  1281. def _is_octoprint_compatible(compatibility_entries):
  1282.     """
  1283.     Tests if the current octoprint_version is compatible to any of the provided ``compatibility_entries``.
  1284.     """
  1285.  
  1286.     octoprint_version = _get_octoprint_version()
  1287.     for octo_compat in compatibility_entries:
  1288.         if not any(octo_compat.startswith(c) for c in ("<", "<=", "!=", "==", ">=", ">", "~=", "===")):
  1289.             octo_compat = ">={}".format(octo_compat)
  1290.  
  1291.         s = next(pkg_resources.parse_requirements("OctoPrint" + octo_compat))
  1292.         if octoprint_version in s:
  1293.             break
  1294.     else:
  1295.         return False
  1296.  
  1297.     return True
  1298.  
  1299. # copied from pluginmanager plugin
  1300. def _get_octoprint_version():
  1301.     from octoprint.server import VERSION
  1302.     octoprint_version_string = VERSION
  1303.  
  1304.     if "-" in octoprint_version_string:
  1305.         octoprint_version_string = octoprint_version_string[:octoprint_version_string.find("-")]
  1306.  
  1307.     octoprint_version = pkg_resources.parse_version(octoprint_version_string)
  1308.     if isinstance(octoprint_version, tuple):
  1309.         # old setuptools
  1310.         base_version = []
  1311.         for part in octoprint_version:
  1312.             if part.startswith("*"):
  1313.                 break
  1314.             base_version.append(part)
  1315.         octoprint_version = ".".join(base_version)
  1316.     else:
  1317.         # new setuptools
  1318.         octoprint_version = pkg_resources.parse_version(octoprint_version.base_version)
  1319.  
  1320.     return octoprint_version
  1321. # check if we have min version 1.3.0
  1322. # this is important because of WizardPlugin mixin and folders in filebrowser
  1323. def get_implementation_class():
  1324.     if not _is_octoprint_compatible(["1.3.0"]):
  1325.         return TelegramPlugin(1.2)
  1326.     else:
  1327.         class NewTelegramPlugin(TelegramPlugin,octoprint.plugin.WizardPlugin):
  1328.             def __init__(self,version):
  1329.                 super(self.__class__, self).__init__(version)
  1330.         return NewTelegramPlugin(1.3)
  1331.  
  1332.        
  1333. __plugin_name__ = "Telegram Notifications"
  1334. __plugin_implementation__ = get_implementation_class()
  1335. __plugin_hooks__ = {
  1336.     "octoprint.plugin.softwareupdate.check_config": __plugin_implementation__.get_update_information,
  1337.     "octoprint.server.http.routes": __plugin_implementation__.route_hook
  1338. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top