def retrieve_telegram_id(self, data): api_token = dict(data)['value'][0] auth = dict(data)['auth_code'][0] bot = TelegramBot(api_token) bot.update_bot_info().wait() if bot.username is not None: updates = bot.get_updates().wait() data = dict() for update in updates: id = update._asdict()['message']._asdict()['sender']._asdict( )['id'] text = update._asdict()['message']._asdict()['text'] data[id] = text if auth in list(data.values()): user_id = list(data.keys())[list(data.values()).index(auth)] return 'er1' # Send a welcome message welcome_message = """Welcome to HealthChecks B Notifications via Telegram Messanger.""" bot.send_message(user_id, welcome_message).wait() return user_id return 'er2'
def telegram_bot(url, regexs): bot = TelegramBot(BOT_API_TOKEN) bot.update_bot_info().wait() print(bot.username) bot.send_message(CHAT_ID, "[%s] Bot Starting" % str(datetime.now())).wait() while (True): diff = diff_html(url, regexs) if diff: for diff_message in diff: ticket = ["Ticket", "ticket"] print diff_message for t in ticket: print t if t in diff_message: bot.send_message( CHAT_ID, "TICKET WORD APPEARED IN A DIFF!!1111").wait() sleep(2) bot.send_message( CHAT_ID, "TICKET WORD APPEARED IN A DIFF!!1111").wait() bot.send_message(CHAT_ID, "Last updates:\n %s" % diff_message).wait() else: print("LOG: No diff") sleep(CYCLE_TIME)
def main(): try: with open('API_KEY', 'r') as f: api_key = f.read().replace('\n', '') except IOError: print "please write the api key in file `API_KEY`" exit(1) bot = TelegramBot(api_key) bot.update_bot_info().wait() print(bot.username) last_update_id = int(0) while True: try: updates = bot.get_updates(offset=last_update_id+1, timeout=5).wait() for update in updates: last_update_id = update.update_id #print(update) process_update(bot, update) except KeyboardInterrupt: # Allow ctrl-c. raise KeyboardInterrupt except Exception as e: print "---\nException: " print e traceback.print_exc() pass
def setupBot(apitoken): """ Setup the bot """ bot = TelegramBot(apitoken) bot.update_bot_info().wait() return bot
def main(): print '[+] Starting bot...' # Read the config file print '[+] Reading config file...' config = ConfigParser.ConfigParser() config.read([os.path.expanduser('./config')]) # Read data bot_name = config.get('bot', 'name') bot_token = config.get('bot', 'token') cool_answers_raw = config.get('phrases', 'cool_answers') cool_answers = [ answer for answer in cool_answers_raw.split('"') if answer and answer!=','] # Last mssg id: last_id = int(load_last_id()) print '[+] Last id: %d' % last_id # Configure regex regex = re.compile('[%s]' % re.escape(string.punctuation)) # Create bot print '[+] Connecting bot...' bot = TelegramBot(bot_token) bot.update_bot_info().wait() print '\tBot connected! Bot name: %s' % bot.username while True: try: updates = bot.get_updates(offset=last_id).wait() for update in updates: id = update.message.message_id update_id = update.update_id user = update.message.sender chat_id = update.message.chat.id text = update.message.text if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) #text = regex.sub('', text) words = text.split() for word in words: # Process commands: if 'http://' in word or 'https://' in word: # Get a random answer phrase: answer = random.choice(cool_answers) bot.send_message(chat_id, answer) except (KeyboardInterrupt, SystemExit): print '\nkeyboardinterrupt caught (again)' print '\n...Program Stopped Manually!' raise
def notify(self, check): bot = TelegramBot(self.channel.value) bot.update_bot_info().wait() if bot.username is not None: # Send a welcome message notification = 'The check with name:' + check.name + \ 'and code:' + str(check.code) + ' has gone ' + check.status bot.send_message(self.channel.telegram_id, notification).wait()
def start(): bot = TelegramBot(token) bot.update_bot_info().wait() print(bot.username) #foto belle -33909375 #user_id = int(23263342) #result = bot.send_message(user_id, 'Salve ragazzi').wait() #XXX WebHook automatico non funzionante result = bot.set_webhook(token) print('*****Il risultato:' % (result)) return "ok"
def run(self): init_logging() """ TODO: create directory for archive if it does not excist already """ bot = TelegramBot(BOT_ID) bot.update_bot_info().wait() print(bot.username) logging.info("Bot %s running", bot.username) page_source = download(URL) old_titles = titles(page_source) logging.info("First set of titles parsed") minutes = 60 * INTERVAL # Disabled sending messages to the channel to decrease spam result = bot.send_message(DEV_PERSONAL_ID, "The blog will be watched").wait() # print("Sending channel: " + str(result)) logging.info("Sending channel: " + str(result)) while True: time.sleep(minutes) try: page_source = download(URL) new_titles = titles(page_source) diff = new_titles.has_changed(old_titles) except socket.error: diff = -2 if (diff == -2): print("No internet connection") logging.info("No internet connection") elif (diff < 0): print("no changes were made") logging.info("No changes were made") else: print("Changes on target") logging.info("Changes on target") save_index(page_source) message = message_hj() old_titles = new_titles try: message.add_title_in_cleartxt(new_titles.get_title(diff)) message.send_to_telegram(bot) except: fallback_msg = message_hj() fallback_msg.fallback_without_title() fallback_msg.send_to_telegram(bot)
class TelegramBroadcaster(): """ Setup the bot """ def __init__(self): self.bot = TelegramBot('<BOT_KEY>') self.bot.update_bot_info().wait() self.user_id = int(<CHANNEL_KEY>) # channel goyanglib print(self.bot.username) def send(self, message): result = self.bot.send_message(self.user_id, message).wait() print(result)
def update(): bot = TelegramBot(token) bot.update_bot_info().wait() if 'chat' in request.json['message']: chat = request.json['message']['chat']['id'] if 'text' in request.json['message']: text = request.json['message']['text'] if text.find('vice') != -1: bot.send_message(chat, vice()).wait() if text.find('drink') != -1: bot.send_photo(chat, bill()).wait() #Print in console for fast Debugging print(json.dumps(request.json)) return "ok"
def update(): bot = TelegramBot(token) bot.update_bot_info().wait() if 'chat' in request.json['message']: chat = request.json['message']['chat']['id'] if 'text' in request.json['message']: text = request.json['message']['text'] if text.find('vice') != -1: bot.send_message(chat, vice()).wait() if text.find('drink') != -1: bot.send_photo(chat,bill()).wait() #Print in console for fast Debugging print(json.dumps(request.json)) return "ok"
def telebot(news): """ This Telegram bot sends a message about stock news to a user using TWX bot library. More about this library may be find at: https://pythonhosted.org/twx/twx/botapi/botapi.html#module-twx.botapi """ bot = TelegramBot('182387487:AAGiA489MZtosNOkhLjzo3_6l7xCYkG4N5A') bot.update_bot_info().wait() updates = bot.get_updates().wait() for update in updates: user_id, = re.findall("sender=User.id=(\d+)", str(update)) if user_id not in users: users.append(user_id) for user in users: user_id = int(user) bot.send_message(user_id, news)
class Botonio: """Principal class to run the Bot""" def __init__(self, token): self.users = {} self.bot = TelegramBot(token) self.bot.update_bot_info().wait() self.offset = 1 updates = self.bot.get_updates().wait() if isinstance(updates, Error): print(updates) raise Exception('Error to conect with Telegram.') if len(updates): self.offset = updates[-1].update_id def start(self): while True: updates = self.bot.get_updates(offset=self.offset).wait() if not len(updates): continue self.offset = updates[-1].update_id self.offset += 1 for update in updates: if update.message is None: continue sender = update.message.sender if sender.id not in self.users: user = User(sender.first_name, sender.id) self.users[user.user_id] = user else: user = self.users[sender.id] if update.message.text == 'stop': del self.users[user] continue messages = user.process_message(update.message.text) if isinstance(messages, tuple): self.bot.send_message( user.user_id, messages[0], reply_markup=self._numeric_keyboard()).wait() else: self.bot.send_message(user.user_id, messages).wait() @staticmethod def _numeric_keyboard(): keyboard = [['1', '2'], ['3', '4']] return ReplyKeyboardMarkup.create(keyboard)
def main(): try: with open('API_KEY', 'r') as f: api_key = f.read().replace('\n', '') except IOError: print "please write the api key in file `API_KEY`" exit(1) bot = TelegramBot(api_key) bot.update_bot_info().wait() print(bot.username) last_update_id = int(0) last_fortune = (datetime.now() - timedelta(minutes=31)) while True: try: updates = bot.get_updates(offset=last_update_id+1, timeout=5).wait() for update in updates: last_update_id = update.update_id print(update) process_update(bot, update) global rems for rem in rems: if rem.when < datetime.now(): bot.send_message(rem.chatid, "=== RAPPEL ===\n\n" + unicode(rem.what)) print "removing reminder " + str(rem.id) rems = [r for r in rems if r.id != rem.id] print "rems = " + str(rems) odd = random.randint(0, 100) thirty_minutes = (datetime.now() - datetime.timedelta(minutes=5)) if last_fortune < thirty_minutes and 50 < odd: last_fortune = datetime.datetime.now() msg = subprocess.check_output("fortune") + ' #fortune' bot.send_message(update.message.chat.id, msg) except KeyboardInterrupt: # Allow ctrl-c. raise KeyboardInterrupt except Exception as e: print "---\nException: " print e traceback.print_exc() pass
def main(): try: with open('API_KEY', 'r') as f: api_key = f.read().replace('\n', '') except IOError: print "please write the api key in file `API_KEY`" exit(1) bot = TelegramBot(api_key) bot.update_bot_info().wait() print(bot.username) last_update_id = int(0) while True: try: updates = bot.get_updates(offset=last_update_id+1, timeout=5).wait() for update in updates: last_update_id = update.update_id print(update) process_update(bot, update) global rems for rem in rems: if rem.when < datetime.now(): bot.send_message(rem.chatid, "=== RAPPEL ===\n\n" + unicode(rem.what)) print "removing reminder " + str(rem.id) rems = [r for r in rems if r.id != rem.id] print "rems = " + str(rems) except KeyboardInterrupt: # Allow ctrl-c. raise KeyboardInterrupt except Exception as e: print "---\nException: " print e traceback.print_exc() pass
class DevopsBot: def __init__(self): self.bot=None self.conn=None self.c=None self.queue=Queue() self.keyboard = [] self.row = [] self.items_in_row = 3 # Set keyboard buttons from commands.allowable_commands list for key in commands.allowable_commands.keys(): self.row.append(key) if len(self.row) == self.items_in_row: self.keyboard.append(self.row) self.row = [] self.reply_markup = ReplyKeyboardMarkup.create(self.keyboard) # Initialize bot # self.bot = TelegramBot('162715180:AAFvQCJjdpws6T3lp45t8svt9X-ENVd_zwo') self.bot = TelegramBot('172231085:AAHdG-B_ch2RTRXIupshiBpPqf7j21XLCik') self.bot.update_bot_info().wait() def _monitor(): print("Monitor") def _listen(): print("Listen") def new_user(self, name, lastname, userid): # Insert a row of data strr="INSERT INTO Telegram VALUES (\""+name+"\",\""+lastname+"\",\""+str(userid)+"\")" print(strr) # Save (commit) the changes try: self.c.execute(strr) self.conn.commit() self._send_message(userid, "Welcome, "+name+" "+lastname) except Exception as e:# sqlite3.IntegrityError: print(e) self._send_message(userid, "Thanks, "+name+" "+lastname+". No need to reregister") def handle_messages(self): # Initialize DB self.conn = sqlite3.connect('telegram.db') self.c = self.conn.cursor() # Create tables self.c.execute('''create table if not exists Telegram (name STRING, last_name STRING, userid STRING UNIQUE)''') while True: print ("Waiting for message in queue") message = self.queue.get() user_info = message[1] user_id = user_info[0] first_name = user_info[1] last_name = user_info[2] if last_name is None: last_name = "N/A" print ("Got and handle message "+str(message.text)) res="Command not understood" try: #Extract the command cmd_list = message.text.split() if str(message.text) == "/start": self.new_user(first_name, last_name, user_id) continue #Replace protocol command with OS command cmd = commands.allowable_commands[cmd_list[0]] cmd_list[0] = cmd runner = Command(cmd_list) runner.run(5) print("RES "+str(runner.res)+" /RES") self._send_message(message.sender.id, runner.res) except Exception as e: print ("Except: "+str(e)) def _send_message(self, uid, message): self.bot.send_message(int(uid), message, reply_markup=self.reply_markup) def listen(self): offset=0 while (True): updates = self.bot.get_updates(offset).wait() for cnt,update in enumerate(updates): offset=update.update_id+1 print("Putting message: "+str(update.message.text)) self.queue.put(update.message)
class DevopsBot: authenticated = False auth_token = None MESSAGE_TYPE_START = "/start" def __init__(self): self.bot=None self.conn=None self.c=None self.mem_alert = False self.disk_alert = False # Initialize DB self.conn = sqlite3.connect('telegram.db') self.c = self.conn.cursor() # Create tables self.c.execute('''create table if not exists Telegram (name STRING, last_name STRING, userid STRING UNIQUE)''') # Initialize bot self.bot = TelegramBot('TELEGRAM_BOT_UNIQUE_ID_GOES_HERE') self.bot.update_bot_info().wait() def new_user(self, name, lastname, userid): # Insert a row of data print "DEBUG: %s , %s , %s " % (name , lastname, userid) strr="INSERT INTO Telegram VALUES (\""+name+"\",\""+lastname+"\",\""+str(userid)+"\")" print(strr) # Save (commit) the changes try: self.c.execute(strr) self.conn.commit() self._send_message(userid, "Welcome, "+name+" "+lastname) except:# sqlite3.IntegrityError: self._send_message(userid, "Thanks, "+name+" "+lastname+". No need to reregister") def _subproc_run(self, cmd, decode=True): print(cmd) log = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) if not decode: return log.communicate()[0] return log.communicate()[0].strip() def _handle_message(self,message): print(str(message.text)) if message.text == self.MESSAGE_TYPE_START: from random import randint rand_seed = randint(1000, 1999) send_factor.two_factor_authenticate(rand_seed, str(message.sender.id)) self._send_message(message.sender.id, "Please enter the number token your received via SMS") self.auth_token = str(rand_seed) return if not self.authenticated and message.text.isdigit(): if self.auth_token == message.text: self.new_user(message.sender.first_name, message.sender.last_name, message.sender.id) self.authenticated = True return else: self._send_message(message.sender.id, 'Wrong token, try again.') return if not self.authenticated: if message.sender.id in self._get_users_list(): self.authenticated = True else: self._send_message(message.sender.id, "Please authenticate using /start first.") return res="Command not understood" try: cmd_list = message.text.split() print(cmd_list) print(cmd_list[0]) print(commands.allowable_commands) cmd = commands.allowable_commands[cmd_list[0]] cmd_list[0] = cmd print "DEBUG: %s" % cmd print("FINAL:"+cmd+"END") res = self._subproc_run(cmd_list) self._send_message(message.sender.id, res) except: self._send_message(message.sender.id, res) def _send_message(self, uid, message): self.bot.send_message(int(uid), message) def operation_loop(self): offset=0 while (True): print(offset) updates = self.bot.get_updates(offset).wait() for cnt,update in enumerate(updates): self._handle_message(update.message) offset=update.update_id+1 self._fire_alert() def _get_users_list(self): userslist = [] self.c.execute("SELECT userid FROM Telegram") for row in self.c.fetchall(): userslist.append(row[0]) return userslist def _fire_alert(self): self.userlist = self._get_users_list() self.memory = os.path.isfile("/tmp/memfile") if self.memory is True and self.mem_alert is False: self.mem_alert = True for user in self.userlist: self._send_message(int(user), "Your system is unstable, check out Memory by typing /mem -m") if self.memory is False and self.mem_alert is True: for user in self.userlist: self._send_message(int(user), "Your system is now OK, Memory-wise") self.mem_alert = False self.disk_space = os.path.isfile("/tmp/diskfile") if self.disk_space is True and self.disk_alert is False: self.disk_alert = True for user in self.userlist: self._send_message(int(user), "Your system is unstable, check out disk_space by typing /df -h") if self.disk_space is False and self.disk_alert is True: for user in self.userlist: self._send_message(int(user), "Your system is now OK, Disk-wise") self.disk_alert = False
def main(): print '[+] Starting bot...' # Read the config file print '[+] Reading config file...' config = ConfigParser.ConfigParser() config.read([os.path.expanduser('./config')]) # Read data bot_name = config.get('bot', 'name') bot_token = config.get('bot', 'token') user_id = config.get('user', 'allowed') # Last mssg id: last_id = int(load_last_id()) print '[+] Last id: %d' % last_id # Configure regex regex = re.compile('[%s]' % re.escape(string.punctuation)) # Create bot print '[+] Connecting bot...' bot = TelegramBot(bot_token) bot.update_bot_info().wait() print '\tBot connected! Bot name: %s' % bot.username # Create media player controllers: player = MediaPlayer() if not player.connect_to_player(): print 'Error connecting to player. Exiting...' return -1 # Send special keyboard: send_keyboard(bot, user_id) while True: try: updates = bot.get_updates(offset=last_id).wait() for update in updates: id = update.message.message_id update_id = update.update_id user = update.message.sender chat_id = update.message.chat.id text = update.message.text if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) #text = regex.sub('', text) words = text.split() for word in words: # Process commands: if word == '/start': print "New user started the app: " + str(user) # Restricted API if int(user_id) == user.id: if 'Play' in word: print '[+] Play command' player.play() elif 'Pause' in word: print '[+] Pause command' player.pause() elif 'Previous' in word: print '[+] Previous command' player.previous() elif 'Next' in word: print '[+] Next command' player.next() except (KeyboardInterrupt, SystemExit): print '\nkeyboardinterrupt caught (again)' print '\n...Program Stopped Manually!' raise
class RepeaterStatusBot(object): def __init__(self, tg_group, tg_credentials, repeater_info_url, repeater_json_stream_url): self.logger = logging.getLogger(__name__) self.tg_group = tg_group self.tg_credentials = tg_credentials self.repeater_json_stream_url = repeater_json_stream_url self.repeater_info_url = repeater_info_url self.rx_status = {} self.statuses = { True: 'in', False: 'uit', } self.last_updated = datetime(1970, 1, 1) self.RXes = {} self.update_rxes() self.last_message_send = datetime(1970, 1, 1) self._init_telegram() def _init_telegram(self): self.telegram = TelegramBot(self.tg_credentials) self.telegram.update_bot_info().wait() def update_rxes(self): if datetime.now() - self.last_updated > timedelta(minutes=60): self.logger.info('Updating repeater info') try: repeater_info = requests.get(self.repeater_info_url).json() except ValueError: repeater_info = {} self.last_updated = datetime.now() self.RXes = repeater_info.get('rx', {}) def signal_telegram(self, message, retry=3): self.logger.info('Sending via TGL: {msg}'.format(msg=message)) if retry < 1: self.logger.error('Failed sending message, exceeded retries') return False try: result = self.telegram.send_message(self.tg_group, message).wait() if not result: new_retry = retry - 1 self.signal_telegram(message, retry=new_retry) else: return True except Exception as error: self.logger.error('Caught exception while transmitting message: {type}: {message}'.format( type=type(error), message=str(error) )) self._init_telegram() new_retry = retry - 1 return self.signal_telegram(message, retry=new_retry) def queue_message(self, receiver, enabled): if receiver in self.RXes: receiver = self.RXes[receiver]['name'] msg = '"{receiver} is {status}geschakeld"'.format( receiver=receiver, status=self.statuses[enabled] ) self.logger.info('Queueing: {msg}'.format(msg=msg)) result = self.signal_telegram(msg) def run(self): for line in requests.get(self.repeater_json_stream_url, stream=True).iter_lines(1): self.logger.debug('Received: {data}'.format(data=line)) if line.startswith('data: '): data = line.split('data: ')[1].strip() try: line_json = json.loads(data) except Exception as e: self.logger.warn('FAILED (%s): %s', data, e.message) else: self.update_rxes() if line_json.get('event') == 'Voter:sql_state': for rx in line_json.get('rx', []).keys(): if rx not in self.rx_status: self.rx_status[rx] = None status = line_json['rx'][rx]['sql'] != "off" if self.rx_status[rx] is not None and \ self.rx_status[rx] != status: self.queue_message(rx, status) self.rx_status[rx] = status
def main(): bot = TelegramBot(token) #Connect with the bot bot.update_bot_info().wait() print("botUsername: "******"\n chat_id: ", chat_id) print("user: \n", user) if u.message.document: print(" \n BOT.MESSAGE.DOCUMENT, Layer 9") print(u.message.document) print("\n") # Get file info file_Info = botto.get_file(u.message.document.file_id) # Download locally to manipulate later file_Info.download(u.message.document.file_name) filesToSend.append(u.message.document.file_name) print("\n Layer 9: Esperando por archivo o Send") keyboard = [['Send'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message( chat_id, "Do you have another file? or do you want to send email?", reply_markup=reply_markup).wait() layer9(bot, last_update_id, usr, pwd, dest, sub, content, filesToSend) elif u.message.photo: print(" \n BOT.MESSAGE.PHOTO, Layer 9") print(u.message.photo) print("\n") # Get file info file_Info = botto.get_file(u.message.photo[3].file_id) # Download locally to manipulate later tofu = u.message.photo[3].file_id file_Info.download(tofu) filesToSend.append(tofu) print("\n Layer 9: Esperando por archivo o Send") keyboard = [['Send'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message( chat_id, "Do you have another file? or do you want to send email?", reply_markup=reply_markup).wait() layer9(bot, last_update_id, usr, pwd, dest, sub, content, filesToSend) elif u.message.text: if u.message.text == 'Send': print("Sending mail, Layer 9") bot.send_message(chat_id, 'Sending email') if sendMessage(dest, sub, content, filesToSend, usr, pwd, chat_id) == 0: bot.send_message(chat_id, 'Email send') print("Select an option, Layer 9") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) elif u.message.text == 'Back': print("Select an option, Layer 9") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) else: print("Select an option, Layer 9") keyboard = [['Send'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() else: print("Select an option, Layer 9") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) def layer9(bot, last_update_id, usr, pwd, dest, sub, content, filesToSend): # Send mail with or without files print("\n Layer 9\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer9(bot, update, last_update_id, usr, pwd, dest, sub, content, filesToSend) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer8(bot, u, last_update_id, usr, pwd, dest, sub, content): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': print("Select an option, Layer 8") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) elif message == 'Attach files': print("Enviame los archivos, Layer 8") keyboard = [['Send'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Send me your files', reply_markup=reply_markup).wait() layer9(bot, last_update_id, usr, pwd, dest, sub, content, []) elif message == 'Do not attach files': print("Sending mail, Layer 8") bot.send_message(chat_id, 'Sending email') if sendMessage(dest, sub, content, [], usr, pwd, chat_id) == 0: bot.send_message(chat_id, 'Email send') print("Select an option, Layer 8") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) else: print("Select an option, Layer 8") keyboard = [['Attach files'], ['Do not attach files'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer8(bot, last_update_id, usr, pwd, dest, sub, content) else: print("Select an option, Layer 8") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) def layer8(bot, last_update_id, usr, pwd, dest, sub, content): # Send mail with or without files print("\n Layer 8\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer8(bot, update, last_update_id, usr, pwd, dest, sub, content) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer7(bot, u, last_update_id, usr, pwd, dest, sub): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': print("Select an option, Layer 7") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) else: print("Select an option, Layer 7") keyboard = [['Attach files'], ['Do not attach files'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer8(bot, last_update_id, usr, pwd, dest, sub, message) else: print("Select an option, Layer 7") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) def layer7(bot, last_update_id, usr, pwd, dest, sub): # Content print("\n Layer 7\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer7(bot, update, last_update_id, usr, pwd, dest, sub) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer6(bot, u, last_update_id, usr, pwd, dest): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': print("Select an option, Layer 6") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) else: print("Send me the body, Layer 6") keyboard = [['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Send me the body', reply_markup=reply_markup).wait() layer7(bot, last_update_id, usr, pwd, dest, message) else: print("Select an option, Layer 6") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) def layer6(bot, last_update_id, usr, pwd, dest): #Subject print("\n Layer 6\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer6(bot, update, last_update_id, usr, pwd, dest) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer5(bot, u, last_update_id, usr, pwd): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': print("Select an option, Layer 5") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) else: print("Send me the subject, Layer 5") keyboard = [['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Send me the subject', reply_markup=reply_markup).wait() layer6(bot, last_update_id, usr, pwd, message) else: print("Select an option, Layer 5") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, usr, pwd) def layer5(bot, last_update_id, usr, pwd): #Insert mail address print("\n Layer 5\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer5(bot, update, last_update_id, usr, pwd) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer4(bot, u, last_update_id, usr, pwd): global run if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': run = False print("Select a option, Layer 4") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select a option', reply_markup=reply_markup).wait() layer2(bot, last_update_id) elif message == 'Show unseen emails': print('Showing emails, Layer 4') bot.send_message(chat_id, 'Showing emails') run = True th = threading.Thread(target=analizerMail, args=( usr, pwd, chat_id, bot, last_update_id, )) th.start() elif message == 'Send a email': run = False print( 'Send me the emails of the destinations (separate with \',\'), Layer 4' ) keyboard = [['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message( chat_id, 'Send me the emails of the destinations (separate with \',\')', reply_markup=reply_markup).wait() layer5(bot, last_update_id, usr, pwd) else: print("Select an option, Layer 4") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() else: print("Select an option, Layer 4") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() def layer4(bot, last_update_id, usr, pwd): #Show emails, send email and back print("\n Layer 4\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer4(bot, update, last_update_id, usr, pwd) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer3(bot, u, last_update_id): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Back': print("Select an option, Layer 3") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer2(bot, last_update_id) else: if len(message.split()) != 2: print("Incorrect input, Layer 3") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Incorrect input', reply_markup=reply_markup).wait() bot.send_sticker(chat_id, 'CAADAgAD1wgAAgi3GQJjq91gSNeyaQI', reply_markup=reply_markup).wait() layer2(bot, last_update_id) else: user = message.split()[0] pwd = message.split()[1] # connecting to the gmail imap server imapMail = imaplib.IMAP4_SSL("imap.gmail.com") # Login try: imapMail.login(user, pwd) except: print("User or password incorrect <Sticker>, Layer 3") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'User or password incorrect', reply_markup=reply_markup).wait() bot.send_sticker(chat_id, 'CAADAgAD8wgAAgi3GQKHdYrrN-Wt_QI', reply_markup=reply_markup).wait() layer2(bot, last_update_id) print("Logging successful <Sticker>, Layer 3") bot.send_message(chat_id, 'Loggin successful').wait() bot.send_sticker(chat_id, 'CAADAgADsggAAgi3GQITL8y1531UoQI').wait() imapMail.logout() print("Select an option, Layer 3") keyboard = [['Show unseen emails'], ['Send a email'], ['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() layer4(bot, last_update_id, user, pwd) else: print("Incorrect input, Layer 3") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Incorrect input', reply_markup=reply_markup).wait() bot.send_sticker(chat_id, 'CAADAgAD1wgAAgi3GQJjq91gSNeyaQI', reply_markup=reply_markup).wait() layer2(bot, last_update_id) def layer3(bot, last_update_id): # Loggin print("\n Layer 3\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("last_update_id: ", last_update_id) process_message_layer3(bot, update, last_update_id) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer2(bot, u, last_update_id): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Loggin account': print( "Send me your User and Password (separate with space), Layer 2" ) keyboard = [['Back']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message( chat_id, 'Send me your User and Password (separate with space)', reply_markup=reply_markup).wait() layer3(bot, last_update_id) elif message == 'Exit': print("See you later, Layer 2") keyboard = [['Start LambderBot']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'See you later', reply_markup=reply_markup).wait() layer1(bot, last_update_id) else: print("Select an option, Layer 2") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() else: print("Select an option, Layer 2") keyboard = [['Loggin account'], ['Exit']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() def layer2(bot, last_update_id): # Loggin or loggout print("\n Layer 2\n") while True: updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: if int(update.update_id) > int(last_update_id): last_update_id = update.update_id print("\nlast_update_id: ", last_update_id) process_message_layer2(bot, update, last_update_id) continue continue except Exception: ex = None print(traceback.format_exc()) continue def process_message_layer1(bot, u, last_update_id): if u.message.sender and u.message.text and u.message.chat: # if the message is text chat_id = u.message.chat.id # Extract data of message user = u.message.sender.id message = u.message.text print("\n chat_id: ", chat_id) print("user: "******"message: ", message) print("\n") if message == 'Start LambderBot': # if message is ... keyboard = [['Loggin account'], ['Exit']] # Buttons Loggin account and Exit reply_markup = ReplyKeyboardMarkup.create( keyboard) # Create Button # welcome according to the time if int(time.strftime("%H")) >= 4 and int( time.strftime("%H") ) < 12: #If the time is between 4 and 12 noon then the bot will say 'Good morning' greeting = 'Good Morning' print("Good Morning") elif int(time.strftime("%H")) >= 12 and int( time.strftime("%H") ) < 16: #If the time is between 12 noon and 6 then the bot will say 'Good Afternoon' greeting = 'Good Afternoon' print("Good Afternoon") else: greeting = 'Good Nigth' #Else say 'Good Nigth' print("Good Nigth") bot.send_message(chat_id, greeting + '\nSelect an option', reply_markup=reply_markup).wait( ) # Show message and Button bot.send_sticker(chat_id, 'CAADAgAD5QgAAgi3GQLR-yMPZfVRlAI', reply_markup=reply_markup).wait() print('Hello, Select an option, Layer 1') layer2(bot, last_update_id) # Call Second Layer elif message == '/start': print("Select an option, Layer 1") keyboard = [['Start LambderBot']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait( ) # update buttons and stay in this layer else: print("Select an option, Layer 1") keyboard = [['Start LambderBot']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(chat_id, 'Select an option', reply_markup=reply_markup).wait() else: print("Select an option, Layer 1") keyboard = [['Start LambderBot']] reply_markup = ReplyKeyboardMarkup.create(keyboard) bot.send_message(u.message.chat.id, 'Select an option', reply_markup=reply_markup).wait() def layer1(bot, last_update_id): #Welcome layer print("\n Layer 1\n") while True: # While for message from this layer, because the user can insert bad text updates = bot.get_updates(offset=last_update_id).wait() try: for update in updates: #get message data if int(update.update_id) > int( last_update_id): #if the message is new, process last_update_id = update.update_id print("\nlast_update_id: ", last_update_id) process_message_layer1( bot, update, last_update_id) # call process message continue continue except Exception: ex = None print(traceback.format_exc()) continue layer1(bot, last_update_id) # Start first layer
elif f['actualFermataType'] == 0: output.append(station + "data not available\n") else: output.append(description) message='' for s in output: message=message+' '+s write(message) """ Setup the bot """ bot = TelegramBot('204368082:AAEfHT1b1pXmBJM3OfbSHUaL5Th30zdsmtI') bot.update_bot_info().wait() print(bot.username) """ Send a message to a user """ user_id = int(153170813) result = bot.send_message(user_id, bot.username + " is Online!").wait() print(result) """ Use a custom keyboard """ keyboard = [[':joy:', '8', '9'], ['4', '5', '6'],
class AdapterTelegram2Channel(AbstractChannel): def __init__(self, token, bot_id, my_user): self.token = token.strip() self.bot_id = int(bot_id) self.my_user = int(my_user) self.bot = TelegramBot(self.token) self.bot.update_bot_info().wait() self.queue = deque() self.offset = 0 # Needed for the bot.get_updates method to avoid getting duplicate updates def send_text(self, text): """ Send a message to the user """ # Removing the wait method will make sending multiple messages faster, of course, however in practice # it is too fast. It gives a better UX with the wait self.bot.send_message(self.my_user, text).wait() def get_user_messages(self): """ Get updates sent to the bot """ # Because many updates can happen in a short interval, we are going to store them in a queue # because to stick to the interface we need to return just one update by function call updates = self.bot.get_updates(offset=self.offset).wait() [self.queue.append(update) for update in updates if (update and update.message.sender.id != self.bot_id)] if len(updates): # Re-compute the offset self.offset = max([elem.update_id for elem in updates]) + 1 if len(self.queue): # Get the oldest element in the queue first_update = self.queue.popleft() return first_update.message.text, first_update.message.sender.id else: return None, None def send_pic(self, path2pic): with open(path2pic, 'rb') as finput: file_info = InputFileInfo(os.path.basename(path2pic), finput, 'image/jpeg') input_file = InputFile('photo', file_info) self.bot.send_photo(self.my_user, input_file) time.sleep(0.5) def allowed_user(self, user_id): return user_id == self.my_user def close(self): pass def flush(self): """ The purpose of this method is to clean the channel at the beginning of the execution. This is to fix a known issue with the usr_cmd_finish command that was left in the channel and causes the closing of Alfred every execution. This happens because at the beginning, self.offset it's initialized to 0 and many of the previous messages are recovered again """ updates = self.bot.get_updates(offset=self.offset).wait() if len(updates): # Re-compute the offset self.offset = max([elem.update_id for elem in updates]) + 1
class specsBot(): numbers = [ "\u0030\u20E3", "\u0031\u20E3", "\u0032\u20E3", "\u0033\u20E3", "\u0034\u20E3", "\u0035\u20E3", "\u0036\u20E3", "\u0037\u20E3", "\u0038\u20E3", "\u0039\u20E3", "\N{keycap ten}" ] replykeyboard = ReplyKeyboardMarkup.create( [[numbers[1], numbers[2], numbers[3]], [numbers[4], numbers[5], numbers[6]], [numbers[7], numbers[8], numbers[9]]], one_time_keyboard=True) def handleUpdate(self, update): logging.debug("received msg " + update.message.text) msg = update.message if (msg): if (msg.text): if (msg.chat in self.db): logging.debug("response") try: choice = specsBot.numbers.index(msg.text) product = self.db[msg.chat]["products"][choice - 1] text = "" for d in product["datasheets"]: text += d["description"] + "\n" + d["url"] + "\n\n" self.bot.send_message( msg.chat, text, reply_to_message_id=msg.message_id) del self.db[msg.chat] except (ValueError, IndexError) as e: self.bot.send_message( msg.chat, "invalid choice " + str(e), reply_markup=specsBot.replykeyboard, reply_to_message_id=msg.message_id) else: # TODO: check injection vulnerability products = self.dsf.searchForProducts(msg.text) text = "found %d products\n\n" % len(products) for i, p in enumerate(products): text += "%s %s\n\n" % (specsBot.numbers[i + 1], p["displayName"]) if len(products) > 0: self.db[msg.chat] = { "state": "choosing product", "products": products } self.bot.send_message( msg.chat, text, reply_markup=specsBot.replykeyboard, reply_to_message_id=msg.message_id) else: self.bot.send_message( msg.chat, text, reply_to_message_id=msg.message_id) def get_updates_cont(self): """ Get updates sent to the bot """ currentUpdateId = 0 while True: updates = self.bot.get_updates(offset=currentUpdateId).wait() for update in updates: print(update) if update: currentUpdateId = update.update_id + 1 yield update time.sleep(0.5) def run(self): try: json_data = open("settings.json").read() self.settings = json.loads(json_data) """ Setup the bot """ self.bot = TelegramBot(self.settings["tg-apiKey"]) self.dsf = DatasheetFinder(self.settings["el14-apiKey"]) self.bot.update_bot_info().wait() self.db = {} logging.info("username is %s" % self.bot.username) for update in self.get_updates_cont(): self.handleUpdate(update) except KeyboardInterrupt: logging.info("halting due to KeyboardInterrupt")
def main(): print '[+] Starting bot...' # Read the config file print '[+] Reading config file...' config = ConfigParser.ConfigParser() config.read([os.path.expanduser('./config')]) # Read data bot_name = config.get('bot', 'name') bot_token = config.get('bot', 'token') user_id = config.get('user', 'allowed') # Last mssg id: last_id = int(load_last_id()) print '[+] Last id: %d' % last_id # Configure regex regex = re.compile('[%s]' % re.escape(string.punctuation)) # Create bot print '[+] Connecting bot...' bot = TelegramBot(bot_token) bot.update_bot_info().wait() print '\tBot connected! Bot name: %s' % bot.username # Connect to hardware interface = SerialInterface() if platform.system() == 'Windows' : interface.connect('COM3', 19200) else: interface.connect('/dev/ttyUSB0', 19200) # Send special keyboard: send_keyboard(bot, user_id) print bot while True: try: updates = bot.get_updates(offset=last_id).wait() #print updates[0].message.sender #print updates[0].message.message_id #print "-------------------------------" itera = 0 for update in updates: #print len(update.message) if update.message is not None: #print update.message.text #print "*************************** iteration: " id = update.message.message_id update_id = update.update_id user = update.message.sender chat_id = update.message.chat.id text = update.message.text if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) #text = regex.sub('', text) if text: words = text.split() for i, word in enumerate(words): print word # Process commands: if word == '/start': print "New user started the app: " + str(user) send_keyboard(bot, chat_id) elif word == '/flag': if update.message.sender.username == 'paclema' : interface.sendFlagWave(1) bot.send_message(chat_id, "Moviendo la bandera " + get_user_name(update.message.sender) + "!") elif word == '/rainbow': interface.sendRainbow() break elif word == '/foto': #interface.sendFlagWave(1) interface.sendStripColor(0,0,0) for a in range(30): interface.sendStripBarColor(0, 2*a, 8.5*a, 0, 0) t.sleep(0.03) interface.sendStripColor(0,0,0) t.sleep(0.2) interface.sendStripColor(0,0,0) cam.start() bot.send_message(chat_id, get_user_name(update.message.sender) + " quiere una foto!") if platform.system() == 'Windows' : img = pygame.Surface((640,480)) cam.get_image(img) else: img = cam.get_image() pygame.image.save(img,"./snap_photo.jpg") pygame.mixer.music.load("./camera_shutter.mp3") interface.sendStripColor(255,255,255) pygame.mixer.music.play() fp = open('snap_photo.jpg', 'rb') file_info = InputFileInfo('snap_photo.jpg', fp, 'image/jpg') f = InputFile('photo', file_info) bot.send_photo(chat_id, photo=f) cam.stop() print "[" + t.strftime("%c") + "]" + " Foto enviada de " + get_user_name(update.message.sender, True, True) + "!" t.sleep(0.3) interface.sendStripColor(0,0,0) break else: bot.send_message(chat_id, "Bad syntax!") break # Restricted API if int(user_id) == user.id: if word == '/move': try: interface.sendMove(int(words[i+1])) break except Exception, e: print e except (KeyboardInterrupt, SystemExit): print '\nkeyboardinterrupt caught (again)' print '\n...Program Stopped Manually!' raise
from twx.botapi import TelegramBot with open('.tokenfile') as inf: API_TOKEN = inf.readline().split('=')[1] print API_TOKEN bot = TelegramBot(API_TOKEN) print(bot.update_bot_info().wait()) print(bot) print "I am a bot : " + str(bot.username) what_i_can_do = ['/start', '/size'] initial_offset = 0 offsets = [] while offsets == []: updates = bot.get_updates(offset=initial_offset).wait() for update in updates: offsets.append(update.update_id) chat_start_offset = max(offsets) + 1 def reply_to_chat(bot, chat_id, with_message=''): result = bot.send_message(chat_id, with_message).wait() return result def get_dir_size(hdfs_dir): with open('size.csv') as inf: for line in inf:
from twx.botapi import TelegramBot from random import randint import re, setup_photos token = str((open("token.txt", "r")).read()) # get API token bot = TelegramBot(token) # create bot with the given authorization token bot.update_bot_info().wait() # setup bot photos = setup_photos.setup() # defined in setup_photos module def send_input_location(message) : _, longitude, latitude = cur_message.text.split() # unpack array into variables for sending bot.send_location(cur_message.chat, float(latitude), float(longitude)) print "Location sent" def send_help_text(message) : bot.send_message(message.chat, "This is a basic telegram bot. This bot will send a photo if \"dank\" is in the message") print "Help message sent" def send_about_text(message) : bot.send_message(message.chat, "This bot is written in Python using a wrapper for the Telegram API written by datamachine") print "About message sent" def send_author_info(message) : bot.send_message(message.chat, "Created by: GMCtree") print "Author info sent" def send_meme(message) : bot.send_photo(message.chat, photos[randint(0, (len(photos) - 1))]) print "Photo sent"
def main(): prewarning_counter = 0 warning_counter = 0 alert_counter = 0 print "[+] Starting bot..." # Read the config file print "[+] Reading config file..." config = ConfigParser.ConfigParser() config.read([os.path.expanduser("./config")]) # Read data bot_name = config.get("bot", "name") bot_token = config.get("bot", "token") user_id = config.get("user", "allowed") # Last mssg id: last_id = int(load_last_id()) print "[+] Last id: %d" % last_id # Configure regex regex = re.compile("[%s]" % re.escape(string.punctuation)) # Create bot print "[+] Conectando tu bot..." bot = TelegramBot(bot_token) bot.update_bot_info().wait() print "\tBot conectado! El nombre de tu bot es: %s" % bot.username # Connect to hardware interface = SerialInterface() if platform.system() == "Windows": interface.connect(config.get("system", "port_Windows"), 115200) if platform.system() == "Darwin": interface.connect(config.get("system", "port_Mac"), 115200) else: interface.connect(config.get("system", "port_Ubuntu"), 115200) # Send special keyboard: send_keyboard(bot, user_id) print bot while True: try: updates = bot.get_updates(offset=last_id).wait() # print updates[0].message.sender # print "-------------------------------" for update in updates: id = update.message.message_id update_id = update.update_id user = update.message.sender chat_id = update.message.chat.id text = update.message.text if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) # text = regex.sub('', text) if text: words = text.split() for i, word in enumerate(words): # Process commands: if word == "/start": print "New user started the app: " + str(user) send_keyboard(bot, chat_id) elif word == "/pollution": # Acceso al html d = pq( url="http://www.mambiente.munimadrid.es/opencms/opencms/calaire/consulta/Gases_y_particulas/informegaseshorarios.html?__locale=es" ) # Selection of data date date_data = d("span[class=tabla_titulo_fecha]") date_data = date_data.text() # print (date_data) # Selection of station name station_name = d('td[class="primertd"]') station_name = station_name.append("**") station_name = station_name.text() station_name = station_name.split("**") # print(station_name) del station_name[0] # Delete the first empty element of the list # Selection of all the N02 data no2rawdata = d('td[headers="NO2"]') no2data = no2rawdata.text() no2data = no2data.replace("-", "0") # Replaces no data with a 0 no2data = no2data.split(" ") no2data = map(int, no2data) # int conversion # Info output print ("Contaminacion de NO2 en Madrid-Fecha: " + date_data) bot.send_message(chat_id, "\n\nContaminacion de NO2 en Madrid-Fecha: " + date_data) t.sleep(3) for x in range(len(no2data)): if no2data[x] > 400: print ("\n") print ( station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE ALERTA POR POLUCION" ) bot.send_message( chat_id, station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE ALERTA POR POLUCION", ) alert_counter = alert_counter + 1 elif no2data[x] > 250: print ("\n") print ( station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE AVISO POR POLUCION" ) bot.send_message( chat_id, station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE AVISO POR POLUCION", ) warning_counter = warning_counter + 1 elif no2data[x] > 200: print ("\n") print ( station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE PREAVISO POR POLUCION" ) bot.send_message( chat_id, station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico" + "-POSIBLE PREAVISO POR POLUCION", ) prewarning_counter = prewarning_counter + 1 else: print ("\n") print (station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico") bot.send_message( chat_id, station_name[x] + ": " + str(no2data[x]) + " microgramos/metro cubico", ) # Zowi pollution reaction if alert_counter > 0: interface.gestureZowi("sad") elif warning_counter > 0: interface.gestureZowi("angry") elif prewarning_counter > 0: interface.gestureZowi("nervous") else: interface.gestureZowi("superhappy") # interface.testZowi() # bot.send_message(chat_id, "Probando el bot!") break except (KeyboardInterrupt, SystemExit): print "\nkeyboardinterrupt caught (again)" print "\n...Program Stopped Manually!" raise
def main(): print "[+] Starting bot..." # Read the config file print "[+] Reading config file..." config = ConfigParser.ConfigParser() config.read([os.path.expanduser("./config")]) # Read data bot_name = config.get("bot", "name") bot_token = config.get("bot", "token") user_id = config.get("user", "allowed") # Last mssg id: last_id = int(load_last_id()) print "[+] Last id: %d" % last_id # Configure regex regex = re.compile("[%s]" % re.escape(string.punctuation)) # Create bot print "[+] Connecting bot..." bot = TelegramBot(bot_token) bot.update_bot_info().wait() print "\tBot connected! Bot name: %s" % bot.username # Connect to hardware interface = SerialInterface() interface.connect("/dev/ttyUSB0", 9600) # Send special keyboard: send_keyboard(bot, user_id) while True: try: updates = bot.get_updates(offset=last_id).wait() for update in updates: id = update.message.message_id update_id = update.update_id user = update.message.sender chat_id = update.message.chat.id text = update.message.text if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) # text = regex.sub('', text) if text: words = text.split() for i, word in enumerate(words): # Process commands: if word == "/start": print "New user started the app: " + str(user) send_keyboard(bot, chat_id) elif word == "/flag": if words[i + 1] == "up": interface.sendMove(90) break elif words[i + 1] == "down": interface.sendMove(0) break else: bot.send_message(chat_id, "Bad syntax!") break # Restricted API if int(user_id) == user.id: if word == "/move": try: interface.sendMove(int(words[i + 1])) break except Exception, e: print e except (KeyboardInterrupt, SystemExit): print "\nkeyboardinterrupt caught (again)" print "\n...Program Stopped Manually!" raise
def init_bot(init_token): bot = TelegramBot(init_token) bot.update_bot_info().wait() return bot
from twx.botapi import TelegramBot with open('.tokenfile') as inf: API_TOKEN = inf.readline().split('=')[1] print API_TOKEN bot = TelegramBot(API_TOKEN) print(bot.update_bot_info().wait()) print(bot) print "I am a bot : " + str(bot.username) what_i_can_do = ['/start', '/size'] initial_offset = 0 offsets = [] while offsets == []: updates = bot.get_updates(offset=initial_offset).wait() for update in updates: offsets.append(update.update_id) chat_start_offset = max(offsets) + 1 def reply_to_chat(bot, chat_id, with_message=''): result = bot.send_message(chat_id, with_message).wait() return result def get_dir_size(hdfs_dir): with open('size.csv') as inf: for line in inf: if line.startwith(hdfs_dir + ','):
def main(): prewarning_counter=0 warning_counter=0 alert_counter=0 day_alert_flag=False print '[+] Starting bot...' # Read the config file print '[+] Reading config file...' config = ConfigParser.ConfigParser() config.read([os.path.expanduser('./config')]) # Read data bot_name = config.get('bot', 'name') bot_token = config.get('bot', 'token') #user_id=[] #user_id.append(config.get('user', 'allowed')) #for x in user_id: # print(x) #misiones.append(nuevo_elemento) user_id= config.get('user', 'allowed') # Last mssg id: last_id = int(load_last_id()) print '[+] Last id: %d' % last_id # Configure regex regex = re.compile('[%s]' % re.escape(string.punctuation)) # Create bot print '[+] Conectando tu bot...' bot = TelegramBot(bot_token) bot.update_bot_info().wait() print '\tBot conectado! El nombre de tu bot es: %s' % bot.username # Send special keyboard: send_keyboard(bot, user_id) print bot global chat_id chat_id=[] while True: try: updates = bot.get_updates(offset=last_id).wait() #print updates[0].message.sender #print "-------------------------------" time_notify=t.asctime(t.localtime(t.time()) ) #print(time_notify) time_notify=time_notify.split(" "); #print(time_notify) main_hour=time_notify[3] main_hour=main_hour.split(":") main_hour=map(int, main_hour) #print(main_hour) for update in updates:#arroja un error de tiempo id = update.message.message_id update_id = update.update_id user = update.message.sender #file_chat_id=open('chat_id.txt','r') #chat_id_aux=file_chat_id.read() #print(chat_id_aux) #chat_id.append(update.message.chat.id) #for x in chat_id: # print (x) active_chat_id = update.message.chat.id #chat_id=8999128 #chat_id2=97335854 text = update.message.text #if main_hour[0]==00 and main_hour[1]==00 and main_hour[2]==00:#Reset the day_alert_flag #if main_hour[2]==50:#Reset the day_alert_flag #day_alert_flag=False #print("FLAG RESETEADA A FALSE") if (main_hour[0]==9 and main_hour[1]==30 and main_hour[2]==00) or (main_hour[0]==12 and main_hour[1]==30 and main_hour[2]==00) or (main_hour[0]==14 and main_hour[1]==30 and main_hour[2]==00) : #if main_hour[2]==00: #and main_hour[2]==00 :# and main_hour[2]==00: #day_alert_flag=True #This day the alert is done #Acceso al html d = pq(url='http://www.mambiente.munimadrid.es/opencms/opencms/calaire/consulta/Gases_y_particulas/informegaseshorarios.html?__locale=es') #Selection of data date date_data=d('span[class=tabla_titulo_fecha]') date_data=date_data.text() #print (date_data) #Selection of station name station_name=d('td[class="primertd"]') station_name=station_name.append("**") station_name=station_name.text() station_name=station_name.split("**") #print(station_name) del station_name[0] #Delete the first empty element of the list #Selection of all the N02 data no2rawdata=d('td[headers="NO2"]') no2data=no2rawdata.text() no2data=no2data.replace("-","0")#Replaces no data with a 0 no2data=no2data.split(" ") no2data = map(int, no2data) #int conversion #Info output print(date_data+" Buenos dias la media de NO2 en Madrid es: ") #bot.send_message(chat_id, "\n\n"+date_data+"\n\nBuenos dias la media de NO2 en Madrid es: ") for x in chat_id: bot.send_message(x, "\n\n"+date_data+"\n\nLa media de NO2 en Madrid es: ") t.sleep(3); #print(no2data[-1]) if no2data[-1]>400: print("\n") print(station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE ALERTA POR POLUCION") for x in chat_id: bot.send_message(x, station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE ALERTA POR POLUCION") alert_counter=alert_counter+1 elif no2data[-1]>250: print("\n") print(station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE AVISO POR POLUCION") for x in chat_id: bot.send_message(x, station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE AVISO POR POLUCION") warning_counter=warning_counter+1 elif no2data[-1]>200: print("\n") print(station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE PREAVISO POR POLUCION") for x in chat_id: bot.send_message(x, station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico"+"-POSIBLE PREAVISO POR POLUCION") prewarning_counter=prewarning_counter+1 else: print("\n") print(station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico") for x in chat_id: bot.send_message(x, station_name[-2]+": "+str(no2data[-1])+" microgramos/metro cubico") if int(update_id) > last_id: last_id = update_id save_last_id(last_id) save_log(id, update_id, chat_id, text) #chat_id pertece al usuario ultimo almacenado #text = regex.sub('', text) if text: words = text.split() for i, word in enumerate(words): # Process commands: if word == '/start': print "New user started the app: " + str(user) vara=user[0] #print("vara: "+str(vara)) chat_id.append(vara) for x in chat_id: print(x) send_keyboard(bot, active_chat_id) #send_keyboard(bot, chat_id) #send_keyboard(bot, chat_id2) elif word == '/polution': #Acceso al html d = pq(url='http://www.mambiente.munimadrid.es/opencms/opencms/calaire/consulta/Gases_y_particulas/informegaseshorarios.html?__locale=es') #Selection of data date date_data=d('span[class=tabla_titulo_fecha]') date_data=date_data.text() #print (date_data) #Selection of station name station_name=d('td[class="primertd"]') station_name=station_name.append("**") station_name=station_name.text() station_name=station_name.split("**") #print(station_name) del station_name[0] #Delete the first empty element of the list #Selection of all the N02 data no2rawdata=d('td[headers="NO2"]') no2data=no2rawdata.text() no2data=no2data.replace("-","0")#Replaces no data with a 0 no2data=no2data.split(" ") no2data = map(int, no2data) #int conversion #Info output print("Contaminacion de NO2 en Madrid-Fecha: "+date_data) bot.send_message(active_chat_id, "\n\nContaminacion de NO2 en Madrid-Fecha: "+date_data) t.sleep(3); for x in range(len(no2data)): if no2data[x]>400: print("\n") print(station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico"+"-POSIBLE ALERTA POR POLUCION") bot.send_message(active_chat_id, station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico"+"-POSIBLE ALERTA POR POLUCION") alert_counter=alert_counter+1 elif no2data[x]>250: print("\n") print(station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico"+"-POSIBLE AVISO POR POLUCION") bot.send_message(active_chat_id, station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico"+"-POSIBLE AVISO POR POLUCION") warning_counter=warning_counter+1 elif no2data[x]>200: print("\n") print(station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico"+"-POSIBLE PREAVISO POR POLUCION") prewarning_counter=prewarning_counter+1 else: print("\n") print(station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico") bot.send_message(active_chat_id, station_name[x]+": "+str(no2data[x])+" microgramos/metro cubico") break except (KeyboardInterrupt, SystemExit): print '\nkeyboardinterrupt caught (again)' print '\n...Program Stopped Manually!' #main() raise
from twx.botapi import TelegramBot import cfg token = cfg.readcfg('config.yml')['token'] channel = cfg.readcfg('config.yml')['channel'] bot = TelegramBot(token) bot.update_bot_info() def sendtextonly(message): try: bot.send_message(channel, message, disable_web_page_preview=True) except Exception: sendtextonly(message) def sendtextandphoto(photourl, message): try: bot.send_photo(channel, photourl).wait() bot.send_message(channel, message, disable_web_page_preview=True) except Exception: sendtextandphoto(photourl, message) def sendtextandvideo(message): try: bot.send_message(channel, message, parse_mode='HTML') except Exception: sendtextandvideo(message)
class AssisBot: def __init__(self): config = ConfigObj(fileInit) self.Listen = False self.IA = AssisIA() self.apikey = config['bot']['apikey'] self.name = config['bot']['name'] self.adminChatId = config['bot']['adminChatId'] self.updatesDelay = float(config['bot']['delay']) self.Telegram = TelegramBot(self.apikey) self.Telegram.update_bot_info().wait() self.ListenerUsers = threading.Thread(target=self.listeningUser, daemon=True) def changeApiKey(self, apikey): self.Telegram = TelegramBot(apikey) self.Telegram.update_bot_info().wait() def startToListen(self): self.Listen = True if (not self.ListenerUsers.is_alive()): self.ListenerUsers.start() logging.info('Corriendo programa: ' + str(self.ListenerUsers.is_alive())) def stopToListen(self): if self.ListenerUsers.is_alive(): self.Listen = False logging.info('Deja de escuchar') else: logging.info("No hay programa que detener") def listeningUser(self): logging.info("Inicio subproceso de escucha") updates = self.Telegram.get_updates().wait() last_updateId = (updates[-1].update_id) if (len(updates) > 0) else 0 while True: try: updates = self.Telegram.get_updates(offset=last_updateId + 1, timeout=100).wait() logging.info("Updates: " + str(len(updates))) if len(updates) > 0: if self.Listen: #debería responder? (Es una bandera) res = self.IA.getResponse(updates[0]) if (res['Options'] == False): self.Telegram.send_message( updates[0].message.chat.id, res['Text']).wait() if (res['Image']): fp = open(res['ImagePath'], 'rb') file_info = InputFileInfo( 'NOCData.png', fp, 'image/png') chart = InputFile('photo', file_info) self.Telegram.send_photo( updates[0].message.chat.id, photo=chart).wait() if (res['Document']): doc = open(res['DocumentPath'], 'rb') file_info = InputFileInfo( 'Details.csv', doc, 'csv') document = InputFile('document', file_info) self.Telegram.send_document( updates[0].message.chat.id, document=document).wait() else: keyboard = res['Options'] reply_markup = ReplyKeyboardMarkup.create(keyboard) msg = 'Seleccione el grupo para ver los detalles' self.Telegram.send_message( updates[0].message.chat.id, msg, reply_markup=reply_markup).wait() dataLoadDelta = (datetime.now() - datetime.strptime( res['UpdateTime'], '%a %b %d %H:%M:%S %Y')) dataLoadTimeHours = dataLoadDelta.seconds / 3600 maxHours = 3 if (dataLoadTimeHours >= maxHours): msg = "Carga de Datos igual a " + str( dataLoadDelta ) + " horas. Revisar BD desactualizada" self.Telegram.send_message(self.adminChatId, msg).wait() msg = "Última actualización mayor a 02:30 horas. BD desactualizada, contactar a Administrador" self.Telegram.send_message( updates[0].message.chat.id, msg).wait() logging.info('Nuevo mensaje: ' + updates[0].message.text) last_updateId = updates[0].update_id except Exception as ex: template = "Un error del tipo {0} ha ocurrido, por favor contactar Administrador. Detalles:\n{1!r}" excepMsg = template.format(type(ex).__name__, ex.args) logging.error("Error generado en el Bot") logging.error(excepMsg) if ( type(ex).__name__ == "FileNotFoundError" ): #Error no se ha encontrado el archivo, contestar con el error self.Telegram.send_message(updates[0].message.chat.id, excepMsg).wait() self.Telegram.send_message(self.adminChatId, excepMsg).wait() last_updateId = updates[0].update_id time.sleep(10)
nse = Nse() q = nse.get_quote('infy') #pprint(q) str1 = str(q) r = api.request('statuses/update', {'status': TWEET_TEXT}) print('SUCCESS' if r.status_code == 200 else 'FAILURE') """ Setup the bot """ bot = TelegramBot('332101015:AAFy9vC_d4Dj5GK7bkIQa5kETnudMqZWUhY') bot.update_bot_info().wait() print(bot.username) """ Send a message to a user """ user_id = int(185350524) result = bot.send_message(user_id, str1).wait() print(result) """ Get updates sent to the bot """ updates = bot.get_updates().wait() for update in updates: print(update) """
class specsBot(): numbers = ["\u0030\u20E3", "\u0031\u20E3", "\u0032\u20E3", "\u0033\u20E3", "\u0034\u20E3", "\u0035\u20E3", "\u0036\u20E3", "\u0037\u20E3", "\u0038\u20E3", "\u0039\u20E3", "\N{keycap ten}"] replykeyboard = ReplyKeyboardMarkup.create( [[numbers[1], numbers[2], numbers[3]], [numbers[4], numbers[5], numbers[6]], [numbers[7], numbers[8], numbers[9]]], one_time_keyboard=True ) def handleUpdate(self, update): logging.debug("received msg " + update.message.text) msg = update.message if (msg): if (msg.text): if (msg.chat in self.db): logging.debug("response") try: choice = specsBot.numbers.index(msg.text) product = self.db[msg.chat]["products"][choice - 1] text = "" for d in product["datasheets"]: text += d["description"] + "\n" + d["url"] + "\n\n" self.bot.send_message( msg.chat, text, reply_to_message_id=msg.message_id ) del self.db[msg.chat] except (ValueError, IndexError) as e: self.bot.send_message( msg.chat, "invalid choice " + str(e), reply_markup=specsBot.replykeyboard, reply_to_message_id=msg.message_id ) else: # TODO: check injection vulnerability products = self.dsf.searchForProducts(msg.text) text = "found %d products\n\n" % len(products) for i, p in enumerate(products): text += "%s %s\n\n" % (specsBot.numbers[i + 1], p["displayName"]) if len(products) > 0: self.db[msg.chat] = {"state": "choosing product", "products": products} self.bot.send_message( msg.chat, text, reply_markup=specsBot.replykeyboard, reply_to_message_id=msg.message_id ) else: self.bot.send_message( msg.chat, text, reply_to_message_id=msg.message_id ) def get_updates_cont(self): """ Get updates sent to the bot """ currentUpdateId = 0 while True: updates = self.bot.get_updates(offset=currentUpdateId).wait() for update in updates: print(update) if update: currentUpdateId = update.update_id + 1 yield update time.sleep(0.5) def run(self): try: json_data = open("settings.json").read() self.settings = json.loads(json_data) """ Setup the bot """ self.bot = TelegramBot(self.settings["tg-apiKey"]) self.dsf = DatasheetFinder(self.settings["el14-apiKey"]) self.bot.update_bot_info().wait() self.db = {} logging.info("username is %s" % self.bot.username) for update in self.get_updates_cont(): self.handleUpdate(update) except KeyboardInterrupt: logging.info("halting due to KeyboardInterrupt")
from time import sleep from twx.botapi import TelegramBot, ReplyKeyboardMarkup #Telegram BotAPI import traceback from pyowm import OWM #Weather API from config import Config """ Setup the bot and the Weather API """ c = Config() TOKEN = c.getToken() OWMKEY = c.getOWMKEY() bot = TelegramBot(TOKEN) bot.update_bot_info().wait() #wait for a message print bot.username last_update_id = 0 def process_message(bot, u): #This is what we'll do when we get a message #Use a custom keyboard keyboard = [['Get Weather']] #Setting a Button to Get the Weather reply_markup = ReplyKeyboardMarkup.create(keyboard) #And create the keyboard if u.message.sender and u.message.text and u.message.chat: #if it is a text message then get it chat_id = u.message.chat.id user = u.message.sender.username message = u.message.text print chat_id print message if message == 'Get Weather': #if the user is asking for the weather then we ask the location bot.send_message(chat_id, 'please send me your location') else:
class DevopsBot: authenticated = False auth_token = None MESSAGE_TYPE_START = "/start" def __init__(self): self.bot = None self.conn = None self.c = None self.mem_alert = False self.disk_alert = False # Initialize DB self.conn = sqlite3.connect('telegram.db') self.c = self.conn.cursor() # Create tables self.c.execute( '''create table if not exists Telegram (name STRING, last_name STRING, userid STRING UNIQUE)''' ) # Initialize bot self.bot = TelegramBot('TELEGRAM_BOT_UNIQUE_ID_GOES_HERE') self.bot.update_bot_info().wait() def new_user(self, name, lastname, userid): # Insert a row of data print "DEBUG: %s , %s , %s " % (name, lastname, userid) strr = "INSERT INTO Telegram VALUES (\"" + name + "\",\"" + lastname + "\",\"" + str( userid) + "\")" print(strr) # Save (commit) the changes try: self.c.execute(strr) self.conn.commit() self._send_message(userid, "Welcome, " + name + " " + lastname) except: # sqlite3.IntegrityError: self._send_message( userid, "Thanks, " + name + " " + lastname + ". No need to reregister") def _subproc_run(self, cmd, decode=True): print(cmd) log = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) if not decode: return log.communicate()[0] return log.communicate()[0].strip() def _handle_message(self, message): print(str(message.text)) if message.text == self.MESSAGE_TYPE_START: from random import randint rand_seed = randint(1000, 1999) send_factor.two_factor_authenticate(rand_seed, str(message.sender.id)) self._send_message( message.sender.id, "Please enter the number token your received via SMS") self.auth_token = str(rand_seed) return if not self.authenticated and message.text.isdigit(): if self.auth_token == message.text: self.new_user(message.sender.first_name, message.sender.last_name, message.sender.id) self.authenticated = True return else: self._send_message(message.sender.id, 'Wrong token, try again.') return if not self.authenticated: if message.sender.id in self._get_users_list(): self.authenticated = True else: self._send_message(message.sender.id, "Please authenticate using /start first.") return res = "Command not understood" try: cmd_list = message.text.split() print(cmd_list) print(cmd_list[0]) print(commands.allowable_commands) cmd = commands.allowable_commands[cmd_list[0]] cmd_list[0] = cmd print "DEBUG: %s" % cmd print("FINAL:" + cmd + "END") res = self._subproc_run(cmd_list) self._send_message(message.sender.id, res) except: self._send_message(message.sender.id, res) def _send_message(self, uid, message): self.bot.send_message(int(uid), message) def operation_loop(self): offset = 0 while (True): print(offset) updates = self.bot.get_updates(offset).wait() for cnt, update in enumerate(updates): self._handle_message(update.message) offset = update.update_id + 1 self._fire_alert() def _get_users_list(self): userslist = [] self.c.execute("SELECT userid FROM Telegram") for row in self.c.fetchall(): userslist.append(row[0]) return userslist def _fire_alert(self): self.userlist = self._get_users_list() self.memory = os.path.isfile("/tmp/memfile") if self.memory is True and self.mem_alert is False: self.mem_alert = True for user in self.userlist: self._send_message( int(user), "Your system is unstable, check out Memory by typing /mem -m" ) if self.memory is False and self.mem_alert is True: for user in self.userlist: self._send_message(int(user), "Your system is now OK, Memory-wise") self.mem_alert = False self.disk_space = os.path.isfile("/tmp/diskfile") if self.disk_space is True and self.disk_alert is False: self.disk_alert = True for user in self.userlist: self._send_message( int(user), "Your system is unstable, check out disk_space by typing /df -h" ) if self.disk_space is False and self.disk_alert is True: for user in self.userlist: self._send_message(int(user), "Your system is now OK, Disk-wise") self.disk_alert = False