def main():
updater = ext.Updater('1267970793:AAFIiTln0imXgRAQQOk3rX-byuEmZXf7A_s', use_context=True)
dp = updater.dispatcher
dp.add_handler(ext.MessageHandler(ext.Filters.text, route))
dp.add_handler(ext.CallbackQueryHandler(call, pattern=r'[^0]'))
dp.add_handler(ext.CallbackQueryHandler(final_times, pattern=r'[0]'))
updater.start_polling()
updater.idle()
def run_tbot(ip):
updater = ext.Updater(token=token)
sounds = get_sounds()
sound_keys = sorted(list(sounds.keys()))
def generic(bot, update):
sound = sounds[update.message.text[1:]]
requests.get('http://{}:5000/play_sound/{}'.format(ip, sound))
bot.send_message(chat_id=update.message.chat_id, text='sent: {}'.format(sound))
def play(bot, update):
keyboard = [
[
InlineKeyboardButton(sound_keys[2*i], callback_data=sounds[sound_keys[2*i]]),
InlineKeyboardButton(sound_keys[2*i+1], callback_data=sounds[sound_keys[2*i+1]]) \
if 2*i+1 < len(sound_keys) else InlineKeyboardButton('', callback_data=sounds[sound_keys[2*i]]),
] for i in range((len(sound_keys) +1 ) //2)
]
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text('Buttons:', reply_markup=reply_markup)
def button(bot, update):
query = update.callback_query
requests.get('http://{}:5000/play_sound/{}'.format(ip, query.data))
bot.edit_message_text(text="sent: {}".format(query.data),
chat_id=query.message.chat_id,
message_id=query.message.message_id)
updater.dispatcher.add_handler(ext.CallbackQueryHandler(button))
updater.dispatcher.add_handler(ext.CommandHandler('play', play))
for key in sound_keys:
updater.dispatcher.add_handler(ext.CommandHandler(key, generic))
updater.start_polling()
def main():
global welcome_message
global command_list_message
try:
with open("welcome.txt", 'r', encoding='utf8') as welcome_file:
welcome_message = welcome_file.read()
except FileNotFoundError:
logger.error('failed to load welcome.txt')
try:
with open("commands.txt", 'r', encoding='utf8') as commands_file:
command_list_message = commands_file.read()
except FileNotFoundError:
logger.error('failed to load welcome.txt')
updater = ext.Updater(os.environ['TELEGRAM_BOT_KEY'])
dispatcher = updater.dispatcher
dispatcher.add_handler(ext.CommandHandler('cadastro', register))
dispatcher.add_handler(ext.CommandHandler('start', hello))
#dispatcher.add_handler(ext.CommandHandler('cadastrar', signup))
dispatcher.add_handler(ext.CommandHandler('email', update_email, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('planilha', register_spreadsheet_name, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('telegram', change_alert_telegram, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('limpar_email', clear_email))
dispatcher.add_handler(ext.CommandHandler('ajuda', help))
dispatcher.add_handler(ext.CommandHandler('dia', show_weekday_keyboard))
dispatcher.add_handler(ext.CommandHandler('teste', show_names_suggestion))
dispatcher.add_handler(ext.CallbackQueryHandler(callback_handler))
dispatcher.add_handler(ext.MessageHandler(ext.Filters.text, text_decoder))
logger.info("Starting polling")
updater.start_polling()
logger.info("Bot in idle, awaiting users messages")
updater.idle()
def setup_handlers(self):
"""
Cria os comandos do bot
"""
# Começar
self.dispatcher.add_handler(
tgm.CommandHandler(command="start", callback=self.start_handler))
# Ajuda
self.dispatcher.add_handler(
tgm.CommandHandler(command="ajuda", callback=self.help_handler))
# Informações
self.dispatcher.add_handler(
tgm.CommandHandler(command="info", callback=self.info_handler))
# Cadastrar chat
self.dispatcher.add_handler(
tgm.CommandHandler(command="cadastrar",
callback=self.subscribe_handler))
# Descadastrar chat
self.dispatcher.add_handler(
tgm.CommandHandler(command="descadastrar",
callback=self.unsubscribe_handler))
# Listar sites
self.dispatcher.add_handler(
tgm.CommandHandler(command="listar_sites",
callback=self.list_scrapers))
# Atualizar tudo
self.dispatcher.add_handler(
tgm.CommandHandler(command="atualizar_tudo",
callback=self.update_all))
# Comandos concurso
self.dispatcher.add_handler(
tgm.CallbackQueryHandler(callback=self.button_actions))
# Erro
self.dispatcher.add_error_handler(callback=self.error_handler)
def main_bot():
persistence = te.PicklePersistence(
filename=configuration["filenames"]["persistence"])
defaults = te.Defaults(parse_mode=tele.ParseMode.HTML)
token = get_secret_token()
updater = te.Updater(token=token,
use_context=True,
persistence=persistence,
defaults=defaults)
dispatcher = updater.dispatcher
dispatcher.add_handler(te.CommandHandler("start", start_callback))
dispatcher.add_handler(te.CommandHandler("help", help_callback))
dispatcher.add_handler(te.CommandHandler("aiuto", help_callback))
dispatcher.add_handler(
te.MessageHandler(te.Filters.regex(r'^/id'), id_callback))
dispatcher.add_handler(te.CommandHandler("dosi", dosi_callback))
dispatcher.add_handler(te.CommandHandler("stagione", stagione_callback))
dispatcher.add_handler(te.CommandHandler("categorie", categorie_callback))
dispatcher.add_handler(te.CommandHandler("portate", portate_callback))
dispatcher.add_handler(te.CallbackQueryHandler(portate_button_callback))
dispatcher.add_handler(te.MessageHandler(te.Filters.text, query_callback))
dispatcher.add_error_handler(error_callback)
updater.start_polling()
updater.idle()
def main(dispatcher):
get_suggestions_handler = ext.CommandHandler('get_suggestions',
__get_suggestions)
get_suggestions_callback_handler = ext.CallbackQueryHandler(
__handle_suggestion_callback, pattern=r'^[1,0],.*$')
dispatcher.add_handler(get_suggestions_handler)
dispatcher.add_handler(get_suggestions_callback_handler)
def main():
print("Connection to Telegram established; starting bot.")
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('start', start, pass_user_data=True)],
states={
CHOOSING: [
ext.RegexHandler('^(Nama|NIM_or_NIP|Email)$',
regular_choice,
pass_user_data=True),
],
TYPING_CHOICE: [
ext.MessageHandler(ext.Filters.text,
regular_choice,
pass_user_data=True),
],
TYPING_REPLY: [
ext.MessageHandler(ext.Filters.text,
received_information,
pass_user_data=True),
],
},
fallbacks=[ext.RegexHandler('^Done$', done, pass_user_data=True)])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start command
# dp.add_handler(ext.CommandHandler(
# ('start'), start))
# Home command
dp.add_handler(ext.CommandHandler(('home'), home))
# Tata Tulis PKL dan TA
dp.add_handler(ext.CommandHandler(('tatatulis'), tatatulis))
# Layanan TA
dp.add_handler(ext.CommandHandler(('layananta'), layananta))
# Layanan PKL
dp.add_handler(ext.CommandHandler(('layananpkl'), layananpkl))
# Button Handler
dp.add_handler(ext.CallbackQueryHandler(button))
# Filter Command
dp.add_handler(ext.MessageHandler((ext.Filters.command), unknowncommand))
updater.start_polling()
updater.idle()
def create_tg_conversation_handler(self):
return tg.ConversationHandler(
entry_points=[
tg.CommandHandler('track', self.start, pass_user_data=True)
],
states={
SET_SPENT_ON: [
tg.CallbackQueryHandler(self.spent_on,
pattern='^\d{4}-\d{2}-\d{2}$',
pass_user_data=True)
],
SET_ISSUE: [
tg.CallbackQueryHandler(self.issue,
pattern='^\d+$',
pass_user_data=True)
],
SET_COMMENTS: [
tg.MessageHandler(Filters.text,
self.comment,
pass_user_data=True)
],
SET_HOURS: [
tg.CallbackQueryHandler(self.add_hours,
pattern='^[\\d.]+$',
pass_user_data=True),
tg.CallbackQueryHandler(self.reset_hours,
pattern='^Reset$',
pass_user_data=True)
],
},
fallbacks=[
tg.CallbackQueryHandler(self.done,
pattern='^Done$',
pass_user_data=True),
tg.CommandHandler('cancel', self.cancel, pass_user_data=True)
],
)
def add_handlers(dispatcher: tg.ext.Dispatcher):
start_handler = tge.CommandHandler('start', start_callback)
dispatcher.add_handler(start_handler)
tree_handler = tge.CommandHandler('tree', tree_callback)
dispatcher.add_handler(tree_handler)
callback_handler = tge.CallbackQueryHandler(query_callback)
dispatcher.add_handler(callback_handler)
link_handler = tge.MessageHandler(
filters=tgFilters.text &
(tgFilters.entity(tg.MessageEntity.URL)
| tgFilters.entity(tg.MessageEntity.TEXT_LINK)),
callback=link_callback)
dispatcher.add_handler(link_handler)
def main(dispatcher):
add_word_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('add_word', __add_word)],
states={
WORD: [ext.MessageHandler(ext.Filters.text, __set_word)],
MEANING: [
ext.MessageHandler(ext.Filters.text, __set_meaning),
ext.CallbackQueryHandler(__word_meaning_verification,
pattern=r'^word_meaning:\d$')
],
MEANING_ERROR:
[ext.MessageHandler(ext.Filters.text, __handle_meaning_error)],
},
fallbacks=[ext.CommandHandler('cancel', __add_word_cancel)])
dispatcher.add_handler(add_word_handler)
def main():
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s")
updater = tex.Updater(
token='1611542237:AAGPMlkeNxp3geL0urxsSsBncnOBROjctsg')
dp = updater.dispatcher
# Handler do jogo
game_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler('start', start)],
states={'ROUND': [tex.CallbackQueryHandler(round)]},
fallbacks=[tex.CommandHandler('start', start)])
dp.add_handler(game_handler)
updater.start_polling()
logging.info("=== Bot running! ===")
updater.idle()
logging.info("=== Bot shutting down! ===")
self.comment)
elif self.mod == 'user':
self.insta.user(self.items, self.num, self.like, self.comment)
elif self.mod == 'search':
self.insta.search(self.num, self.like, self.follow,
self.comment)
self.insta.Quit()
bot.sendMessage(text='پایان کار', chat_id=chat_id)
telBot = InsTelgram()
start_command = ext.CommandHandler('start', start)
updater.dispatcher.add_handler(start_command)
clear_command = ext.CommandHandler('clear', telBot)
updater.dispatcher.add_handler(clear_command)
login_command = ext.CommandHandler('login', telBot.login, pass_args=True)
updater.dispatcher.add_handler(login_command)
login_command = ext.CommandHandler('job', telBot.job)
updater.dispatcher.add_handler(login_command)
callback1_handler = ext.CallbackQueryHandler(telBot.callback)
updater.dispatcher.add_handler(callback1_handler)
updater.start_polling()
updater.idle()
user = active_users.get_user(username)
query = update.callback_query
query.answer()
language = query.data
query.edit_message_text(text=ans.answers[ans.CHANGE_LANGUAGE][language])
user.change_language(language)
tg_help(update, context)
dispatcher.add_handler(tg_ext.CallbackQueryHandler(change_language))
# просто help нельзя потому что есть функция в builtins, поэтому tg_help
def tg_help(update: tg.Update, context: tg_ext.CallbackContext):
username = update.effective_user.username
user = active_users.get_user(username)
user.tg_user.send_message(text=ans.answers[ans.HELP][user.language])
dispatcher.add_handler(tg_ext.CommandHandler("help", tg_help))
def create_pdf(update: tg.Update, context: tg_ext.CallbackContext):
if prev_hw:
context.chat_data['hw'][args[2]] = prev_hw
else:
del context.chat_data['hw'][args[2]]
del context.chat_data['temp']['hw'][request_msgid]
update.callback_query.message.delete()
elif args[0] == 'DEL_HW':
if args[1] == 'CANCEL':
request_msgid = update.callback_query.message.reply_to_message.message_id
prev_hw = context.chat_data['temp']['hw'][request_msgid]
print(prev_hw)
context.chat_data['hw'][args[2]] = prev_hw
del context.chat_data['temp']['hw'][request_msgid]
update.callback_query.message.delete()
updater.dispatcher.add_handler(tg_ext.CallbackQueryHandler(button_callback))
if os.path.exists(os.environ['CACHE_FILENAME']):
with open(os.environ['CACHE_FILENAME']) as cache:
cache_dict = json.loads(cache.read())
if dt.datetime.now() - dt.datetime.fromisoformat(cache_dict['read_at']) > dt.timedelta(hours=1):
get_hw()
else:
get_hw()
updater.bot.send_message(chat_id=os.environ['CREATOR_ID'], text='Бот включен\nВерсия бота: '+os.environ['BOT_VERSION'])
updater.start_webhook(listen='0.0.0.0', port=int(os.environ.get('PORT', 5000)), url_path=os.environ['TOKEN'])
updater.bot.set_webhook(os.environ['HOST_URL']+os.environ['TOKEN'])
updater.idle()
def __init__(self, catalogHOST: str, catalogPORT: int, botToken: str):
print("LOG: Telegram Bot initialization BEGIN")
self.catalogEndPoint = catalogHOST + ":" + str(catalogPORT)
self.availableDevices = {}
self.availableServices = {}
self.telegramBotToken = botToken
# Get the broker from the catalog
try:
response = requests.get(self.catalogEndPoint +
"/getMQTTMessageBroker")
response.raise_for_status()
except:
raise ConnectionError("Unable to get mqtt broker from the catalog")
try:
responseDict = json.loads(response.text)
if "url" not in responseDict or "port" not in responseDict:
raise Exception()
except:
raise Exception("Response from catalog was invalid")
self.brokerHOST = responseDict["url"]
self.brokerPORT = responseDict["port"]
# Initialize the thread for registration to the catalog
self.registrationAndRetrivalThread = threading.Thread(
target=self.registerAndRetrieveRagistrationsRunner)
self.running = False
self.subscribePayload = json.dumps({
"serviceID":
"TelegramBot",
"description":
"A telegram bot that exposes the catalog to end users",
"endPoints": [{
"service": "https://t.me/tiot19ControlBot",
"type": "webService",
"webType": "producer"
}]
})
self.catalogAvailable = False
self.retrieveRegistrationsLock = threading.Lock()
# Initialize the Telegram Bot
self.botUpdater = ext.Updater(token=self.telegramBotToken,
use_context=True)
self.botDispatcher = self.botUpdater.dispatcher
self.botDispatcher.add_handler(
ext.CommandHandler(command="start", callback=self.botClbStart))
self.botDispatcher.add_handler(
ext.CallbackQueryHandler(self.botClbQueryHandler))
self.botDispatcher.add_handler(
ext.MessageHandler(ext.Filters.text, self.botMessageHandler))
# Initialize MQTT
self.mqttReceivedValues = {
} # Store, for every device/service that produces mqtt messages, a list of values (the most recent 64), so that we can then
# produce a nice chart of that data and send it as a Telegram image.
# The only drawback is that we must assume a common syntax for every mqtt resource, and that will be SenML.
self.mqttReceivedValuesThreshold = 64 # Keep only the newest 64 values and discard the rest
self.pendingAlerts = {} # For pending inputs of alert thresholds
self.mqttClient = PahoMQTT.Client("tiot19_Catalog_Telegram_Bot", True)
self.mqttClient.on_message = self.mqttOnMessage
try:
self.mqttClient.connect(self.brokerHOST, self.brokerPORT)
self.mqttClient.loop_start()
except:
raise ConnectionError(
"Unable to connect to the MQTT message broker")
print("LOG: Telegram Bot initialization END")
dispatcher.add_handler(ext.CommandHandler(["craft_reset"], functions.commands.craft_reset)) dispatcher.add_handler(ext.CommandHandler(["todo"], functions.commands.todo)) # regexp handlers dispatcher.add_handler(ext.MessageHandler(ext.Filters.regex(r'/stomp_[\w]+'), functions.regex.stomp)) dispatcher.add_handler(ext.MessageHandler(ext.Filters.regex(r'/[wrk][\d]+'), functions.regex.resource)) dispatcher.add_handler(ext.MessageHandler(ext.Filters.regex(r'/todo_[\w]+'), functions.regex.todo_edit)) # filter handlers dispatcher.add_handler(ext.MessageHandler(ext.Filters.forwarded, functions.filters.forwarded)) # message handlers dispatcher.add_handler(ext.MessageHandler(ext.Filters.text, _incomming_message)) # callback query handlers dispatcher.add_handler(ext.CallbackQueryHandler(functions.callbacks.empty, pattern=r'empty')) dispatcher.add_handler(ext.CallbackQueryHandler(functions.callbacks.craft_resume, pattern=r'craft_resume')) dispatcher.add_handler(ext.CallbackQueryHandler(functions.callbacks.craft_all, pattern=r'craft_all')) # error handlers dispatcher.add_error_handler(_error) # timing functions functions.timers.BOT=updater.bot functions.timers.start() # notify the starting _notify_start(updater.bot) # start the polling try:
]
},
fallbacks=[tex.MessageHandler(tex.Filters.all, invalid_nick)])
play_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler("play", play_command)],
states={
'CHECK_OPTION': [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
check_option)
],
'SPECIFIC_USER': [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
specific_user)
],
'ROUND': [tex.CallbackQueryHandler(gameRound)]
},
fallbacks=[tex.CommandHandler("play", play_command)])
change_nick_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler("change", change_nick)],
states={
"SET_NICK": [
tex.MessageHandler(tex.Filters.text & ~tex.Filters.command,
set_nick)
]
},
fallbacks=[tex.MessageHandler(tex.Filters.all, invalid_nick)])
users_handler = tex.CommandHandler('users', users)
people_conv()
elif querry.data == '111':
querry.edit_message_text(text="Ох, сейчас покопаюсь... \n Нужна помощь! Нажми на команду /view")
group_conv()
elif querry.data == '3' or querry.data == '4':
querry.edit_message_text(text="You selected2 {}".format(querry.data))
elif querry.data == 'закрыть':
keyboard = [
[
InlineKeyboardButton("Просмотр групп", callback_data='111'),
InlineKeyboardButton("Добавить ученика", callback_data='222'),
],
[InlineKeyboardButton("Помощь", callback_data="333"),],
]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(chat_id=update.effective_chat.id, text="Погнали к выбору!", reply_markup=reply_markup)
elif querry.data[:4] == 'ch_l':
querry.edit_message_text(text="Ок, меняем логики в группе номер: {}. \n Нажмите на команду: /change".format(querry.data[4:len(querry.data)]))
change_logiks()
else:
querry.edit_message_text(text="Ок, открываю группу номер: {}".format(querry.data[:len(querry.data)-1]))
show_group(querry.data[:len(querry.data)-1], update, context)
start_handler = ext.CommandHandler('start', start)
dispatcher.add_handler(start_handler)
updater.dispatcher.add_handler(ext.CallbackQueryHandler(button))
updater.start_polling()
logger = logging.getLogger()
updater = ext.Updater(token=config['main']['TELEGRAM_BOT_TOKEN'])
dispatcher = updater.dispatcher
admin_id = int(config['main']['ADMIN_ID'])
if not admin_id:
raise ValueError("Couldn't load without admin id")
blog_id = config['main']['BLOG_ID']
if not blog_id:
raise ValueError("Couldn't load without blog id")
message_handler = ext.MessageHandler(ext.filters.MergedFilter(base_filter=ext.Filters.user(admin_id), and_filter=ext.Filters.text), get_message)
location_handler = ext.MessageHandler(ext.filters.MergedFilter(base_filter=ext.Filters.user(admin_id), and_filter=ext.Filters.location), add_location)
delete_command_handler = ext.CommandHandler('delete', delete_post)
send_command_handler = ext.CommandHandler('send', send_post)
draft_command_handler = ext.CommandHandler('draft', draft_post)
drafted_command_handler = ext.CommandHandler('drafted', get_drafted_posts)
dispatcher.add_handler(message_handler)
dispatcher.add_handler(location_handler)
dispatcher.add_handler(delete_command_handler)
dispatcher.add_handler(send_command_handler)
dispatcher.add_handler(draft_command_handler)
dispatcher.add_handler(drafted_command_handler)
callback_handler = ext.CallbackQueryHandler(get_reaction)
dispatcher.add_handler(callback_handler)
updater.start_polling(clean=True)
updater.idle()
def registry_handlers(dispatcher):
dispatcher.add_handler(tg_ext.CommandHandler('start', start_cmd))
dispatcher.add_handler(
tg_ext.MessageHandler(tg_ext.Filters.text, message_handler))
dispatcher.add_handler(tg_ext.CallbackQueryHandler(callback_handler))
dispatcher.add_error_handler(error_handler)
