def ShowCart(bot, update, self):
try:
if self.cart_message:
try:
bot.delete_message(chat_id=self.cart_message.chat_id,
message_id=self.cart_message.message_id)
except:
doNothing = 0
if not self.cart:
bot.send_message(chat_id=update.message.chat_id,
text='Корзина пуста.',
parse_mode=ParseMode.HTML)
else:
buttons = []
total = 0
for g in self.cart:
buttons.append([
InlineKeyboardButton(
g, callback_data='cartremove-{}'.format(g))
])
total = total + float(g.split(' ')[2])
buttons.append(
[InlineKeyboardButton('Оплатить', callback_data='pay')])
self.cart_message = bot.send_message(
chat_id=update.message.chat_id,
text='Сумма: {} UAH'.format(total),
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(buttons))
except Exception as e:
print(e)
def photo_reciever(bot, update):
photo_dict = get_votes()
file_id = update.message.photo[0].file_id
if not isinstance(photo_dict, list): photo_dict = [photo_dict]
if file_id in [elem["file_id"] for elem in photo_dict]:
update.message.reply_text("Questa foto è gia stata caricata")
return
print(f"Recieved photo with {file_id} id")
inline = InlineKeyboardMarkup([
[
InlineKeyboardButton("👍", callback_data="/vote y " + file_id),
InlineKeyboardButton("👎", callback_data="/vote n " + file_id)
],
])
insert_fileid(file_id, [], [])
bot.sendPhoto(photo=file_id, chat_id=channel_id, reply_markup=inline)
update.message.reply_text(
"Vota la foto che hai mandato sul canale https://t.me/fancaPhoto")
def get_saved(bot, update):
""" Gets a word from the user's list of words to learn. """
global store_helper
user_id = update.effective_user.id
word = store_helper.get_word(user_id)
if word is not None:
button_list = [
InlineKeyboardButton(text="Explain",
callback_data=json.dumps(
create_callback_word_dict(
CALLBACK_TYPE_EXPLAIN, word))),
InlineKeyboardButton(text="Translate",
callback_data=json.dumps(
create_callback_word_dict(
CALLBACK_TYPE_TRANSLATE, word))),
InlineKeyboardButton(text="Remove",
callback_data=json.dumps(
create_callback_word_dict(
CALLBACK_TYPE_REMOVE, word)))
]
reply_markup = InlineKeyboardMarkup(build_menu(button_list, n_cols=3))
bot.sendMessage(chat_id=get_chat_id(update),
text=word,
reply_markup=reply_markup)
else:
error(bot, update, "No saved words found.")
def awrapper(update: Update, context: CallbackContext, *args,
**kwargs):
nonlocal permission
if update.effective_chat.type == 'private':
return func(update, context, *args, **kwargs)
message = update.effective_message
is_anon = bool(update.effective_message.sender_chat)
if is_anon:
callback_id = f'anoncb/{message.chat.id}/{message.message_id}/{permission.value}'
anon_callbacks[(message.chat.id,
message.message_id)] = ((update, context),
func)
anon_callback_messages[(
message.chat.id, message.message_id
)] = (message.reply_text(
"Seems like you're anonymous, click the button below to prove your identity",
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text='Prove identity',
callback_data=callback_id)
]]))).message_id
# send message with callback f'anoncb{callback_id}'
else:
user_id = message.from_user.id
chat_id = message.chat.id
mem = context.bot.get_chat_member(chat_id=chat_id,
user_id=user_id)
if getattr(
mem, permission.value
) is True or mem.status == "creator" or user_id in SUDO_USERS:
return func(update, context, *args, **kwargs)
else:
return message.reply_text(
f"You lack the permission: `{permission.name}`",
parse_mode=ParseMode.MARKDOWN)
def aboutUs(update, context):
"""
Read more about Algorand and how you can build on Algorand
:param update:
:param context:
:return: None
"""
keyboard = [[
InlineKeyboardButton("Website",
'https://algorand.com',
callback_data='1'),
InlineKeyboardButton("Developer'site",
'https://developer.algorand.org',
callback_data='2')
],
[
InlineKeyboardButton("Community",
'https://community.algorand.com',
callback_data='3')
]]
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text('Learn more about Algorand:',
reply_markup=reply_markup)
def get_markup(self):
likes = ArticleMark.objects.filter(article=self, mark=1).count()
dislikes = ArticleMark.objects.filter(article=self, mark=-1).count()
return InlineKeyboardMarkup([[
InlineKeyboardButton(text=f'👍{likes}', callback_data=f'{self.get_callback_data()} like'),
InlineKeyboardButton(text=f'👎{dislikes}', callback_data=f'{self.get_callback_data()} dislike'),
]])
def check_scrape_job(scrape_id: str, scraper: Scraper):
from karim import telegram_bot as bot
failed = FailedJobRegistry(queue=queue)
if scrape_id in failed.get_job_ids():
# job failed
bot.send_message(scraper.get_user_id(), failed_scraping_ig_text)
sheet.log(datetime.utcnow(),
scraper.get_user_id(),
action='FAILED SCRAPE')
return False
else:
redis_url = os.getenv('REDISTOGO_URL', 'redis://localhost:6379')
conn = redis.from_url(redis_url)
job = Job.fetch(scrape_id, connection=conn)
result = job.result
# Save result in sheets
sheet.add_scrape(scraper.get_target(),
name=scraper.get_name(),
scraped=result)
sheet.log(datetime.utcnow(),
scraper.get_user_id(),
action='SUCCESSFUL SCRAPE')
# Update user
markup = InlineKeyboardMarkup([[
InlineKeyboardButton(text='Google Sheets',
url=sheet.get_sheet_url(1))
]])
bot.send_message(scraper.get_user_id(),
finished_scrape_text,
reply_markup=markup)
return True
def selecting_buro(update, context):
buttons = []
deps = termin.Buro.__subclasses__()
for dep in deps:
buttons.append(
InlineKeyboardButton(text=dep.get_name(),
callback_data=dep.__name__))
custom_keyboard = [buttons]
if 'buro' in context.user_data and 'termin_type' in context.user_data:
custom_keyboard.append([
InlineKeyboardButton(text='Reuse last selection',
callback_data='_REUSE')
])
if update.message:
msg = update.message
else:
msg = update.callback_query.message
msg.reply_text('Hi! Here are available departments. Please select one:',
reply_markup=InlineKeyboardMarkup(custom_keyboard,
one_time_keyboard=True))
return SELECTING_TERMIN_TYPE
def create_account(update, context):
"""
Create new public/private key pair
Returns the result of generating an account to user:
:param update:
:param context:
:return: 1). An Algorand address, 2). A mnemonic seed phrase
"""
update.message.reply_text("Hang on while I get you an account ...")
time.sleep(1)
try:
sk, pk = account.generate_account()
mn = mnemonic.from_private_key(sk)
if not (pk and sk is None):
update.message.reply_text("Account creation success.\nAddress: {}\n\n"
"Private Key: {}\n\n"
"Mnemonic:\n {}\n\n"
"I do not hold or manage your keys."
"".format(pk, sk, mn)
)
context.user_data['default_pk'] = pk
update.message.reply_text('To test if your address works fine, copy your address, and visit:\n ')
keyboard = [[InlineKeyboardButton(
"DISPENSER", 'https://bank.testnet.algorand.network/', callback_data='1')]]
dispenser = InlineKeyboardMarkup(keyboard)
update.message.reply_text('the dispenser to get some Algos\nSession ended.'
'Click /start to begin.', reply_markup=dispenser)
except Exception as e:
update.message.reply_text('Account creation error.')
return e
def select_termin_type(update, context):
if update.callback_query and update.callback_query.data == '_REUSE':
# All data already stored in user_data and user asked to repeat
return quering_termins(update, context, True)
elif not update.callback_query:
# We returned from previous step, but buro is already known
department = context.user_data['buro']
msg = update.message
else:
msg = update.callback_query.message
try:
department = getattr(termin, update.callback_query.data)
except AttributeError:
return SELECTING_TERMIN_TYPE
context.user_data['buro'] = department
buttons = []
for i, x in department.get_typical_appointments():
buttons.append([InlineKeyboardButton(text=x, callback_data=i)])
if department.get_typical_appointments():
buttons.append(
[InlineKeyboardButton(text='--------------', callback_data='-1')])
for i, x in enumerate(department.get_available_appointment_types()):
buttons.append([InlineKeyboardButton(text=x, callback_data=i)])
msg.reply_text(
'There are several appointment types available. Most used types are on top. Please select one',
reply_markup=InlineKeyboardMarkup(buttons, one_time_keyboard=True))
return QUERING_TERMINS
def start_over(update: Update, context: CallbackContext) -> int:
query = update.callback_query
query.answer()
Logger.getInstance().info("L'utente " + context.user_data["username"] +
" ha ricominciato la conversazione.")
keyboard = [[
InlineKeyboardButton(
"LINK", url="http://web.dmi.unict.it/corsi/l-31/programmi"),
InlineKeyboardButton("Iniziamo!", callback_data=str(0))
]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.user_data["index_list_subject_length"] = 4
context.user_data["ratings"] = []
context.user_data["subject_names"] = []
Subjects.getInstance().init_array(context.user_data["ratings"],
context.user_data["subject_names"])
query.edit_message_text(
text=
"Prima di iniziare è necessario che tu legga i programmi delle varie materie del 3° anno.\n"
+
"Questo è un passo fondamentale perché dopo ti verrà chiesto di valutarne alcuni!\n"
+
"Puoi cliccare nel bottone sottostante per raggiungere la pagina dei programmi.\n"
+
"Dopo aver letto tutto attentamente clicca su \"Iniziamo!\", ricorda che il range dei voti va da 1 (pessimo) a 5 (fantastico).",
reply_markup=reply_markup)
return 0
def estrato(update, context):
query = update.callback_query
query.edit_message_text(text="You selected {} garages.".format(query.data))
context.user_data['garages'] = query.data
lang_1 = InlineKeyboardButton(text="One \U00000031\U000020E3",
callback_data='One')
lang_2 = InlineKeyboardButton(text="Two \U00000032\U000020E3",
callback_data="Two")
lang_3 = InlineKeyboardButton(text="Three \U00000033\U000020E3",
callback_data="Three")
lang_4 = InlineKeyboardButton(text="Four \U00000034\U000020E3",
callback_data="Four")
lang_5 = InlineKeyboardButton(text="Five \U00000033\U000020E3",
callback_data="Five")
lang_6 = InlineKeyboardButton(text="Six \U00000034\U000020E3",
callback_data="Six")
lang_keyboard = InlineKeyboardMarkup([[lang_1, lang_2], [lang_3, lang_4],
[lang_5, lang_6]])
context.bot.send_message(chat_id=update.effective_chat.id,
text='Which stratum do you prefer?',
reply_markup=lang_keyboard)
return SIXTH
def tipo(update, context):
query = update.callback_query
query.edit_message_text(
text="You selected the stratum {}.".format(query.data))
context.user_data['estrato'] = query.data
names = df['tipo_inmueble'].unique()
lan = []
lan_group = []
count = 0
for i in names:
lan.append(InlineKeyboardButton(text=i, callback_data=i))
count = count + 1
if count == 2:
lan_group.append(lan)
lan = []
count = 0
lang_keyboard = InlineKeyboardMarkup(lan_group)
context.bot.send_message(chat_id=update.effective_chat.id,
text='What type of property do you prefer?',
reply_markup=lang_keyboard)
return SEVEN
def stratum(update, context):
query = update.callback_query
query.edit_message_text(
text="You selected the locality: {}".format(query.data))
context.user_data['localidad'] = query.data
names = df[df['LocNombre'] == '{}'.format(
query.data)]['sector_catastral'].unique()
lan = []
lan_group = []
count = 0
for i in names:
lan.append(InlineKeyboardButton(text=i, callback_data=i))
count = count + 1
if count == 2:
lan_group.append(lan)
lan = []
count = 0
lang_keyboard = InlineKeyboardMarkup(lan_group)
context.bot.send_message(chat_id=update.effective_chat.id,
text='What sector do you want your new house?',
reply_markup=lang_keyboard)
return SECOND
def get_state(update: Update, _: CallbackContext) -> int:
temp_user = {}
temp_user['_id'] = update.callback_query.from_user.id
query = update.callback_query
state_id = update.callback_query.data[1:]
temp_user['state'] = int(state_id)
coll_users.update_one({'_id': temp_user['_id']}, {'$set': {'state': int(state_id)}}, upsert=True)
state = coll_states.find_one({'_id': int(state_id)})
keyboard = []
keyboard_row = []
districts_list = state['districts']
for indx, district in enumerate(districts_list):
district_id = district['district_id']
keyboard_row.append(
InlineKeyboardButton(district['district_name'], callback_data=f'd{district_id}')
)
if indx == 0:
continue
if (indx+1) % 2 == 0:
keyboard.append(copy.deepcopy(keyboard_row))
keyboard_row.clear()
reply_markup = InlineKeyboardMarkup(keyboard)
query.answer()
query.edit_message_text('Please choose a district:', reply_markup=reply_markup)
def setup(update: Update, _: CallbackContext) -> None:
temp_user = {}
temp_user['_id'] = update.message.chat.id
coll_users.update_one({'_id': temp_user['_id']}, {'$set': {'_id': temp_user['_id']}}, upsert=True)
states_list = coll_states.find({})
# show states inline
keyboard = []
keyboard_row = []
for indx, state in enumerate(states_list):
state_id = state['_id']
keyboard_row.append(
InlineKeyboardButton(state['state_name'], callback_data=f's{state_id}')
)
if indx == 0:
continue
if (indx+1) % 3 == 0:
keyboard.append(copy.deepcopy(keyboard_row))
keyboard_row.clear()
if indx == 36:
keyboard.append(copy.deepcopy(keyboard_row))
keyboard_row.clear()
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text(text='Please choose a state:', reply_markup=reply_markup)
def command_deleteop(self, bot: Bot, update: Update, groups, user_data):
opportunity_id = groups[0]
opportunity = Opportunity.find(opportunity_id)
if not opportunity:
update.message.reply_text("Es gibt keine Reise mit dieser ID.")
return self.END
user_data["delete_opportunity_id"] = opportunity_id
text = "Bist du dir sicher, dass du deine Reise am %s nach <strong>%s</strong> absagen möchtest?" % (
opportunity.date_readable(),
opportunity.city
)
reply = update.message.reply_text(text,
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(
[[InlineKeyboardButton("Ja, sage die Reise ab",
callback_data="deleteop_confirm")],
[InlineKeyboardButton("Nein", callback_data="deleteop_cancel")]])
)
user_data["message_id"] = reply.message_id
return self.CONFIRM_DELETION
def comment_cmd(bot, update, args):
user_id = update.message.from_user.id
chat_id = update.message.chat_id
first_name = update.message.from_user.first_name
last_name = update.message.from_user.last_name
username = update.message.from_user.username
db = DBwrapper.get_instance()
lang_id = db.get_lang_id(user_id)
state_handler = StateHandler.get_instance()
user = state_handler.get_user(user_id)
if user.get_state() == UserState.IDLE:
if len(args) > 1:
text = " ".join(args)
logger.debug("New comment! {}!".format(user_id))
bot.sendMessage(chat_id=chat_id, text=translate("userComment", lang_id))
for admin_id in db.get_admins():
bot.sendMessage(admin_id,
"New comment:\n\n{}\n\n{} | {} | {} | @{} | {}".format(text, user_id, first_name,
last_name, username,
lang_id))
user.set_state(UserState.IDLE)
else:
# The user just wrote "/comment" -> Ask him to send a message
logger.debug("Add {} to comment_list!".format(user_id))
keyboard = [[InlineKeyboardButton(text=translate("cancel", lang_id), callback_data="cancel_comment")]]
reply_markup = InlineKeyboardMarkup(keyboard)
bot.sendMessage(chat_id=chat_id, text=translate("sendCommentNow", lang_id), reply_markup=reply_markup)
user.set_state(UserState.COMMENTING)
def ask_age() -> InlineKeyboardMarkup:
keyboard = [
[
InlineKeyboardButton("45+", callback_data='a45'),
InlineKeyboardButton("18+", callback_data='a18')
]
]
return InlineKeyboardMarkup(keyboard)
def on_style(bot, update: Update, user_data):
msg: Message = update.message
user_data.setdefault('style', Style())
msg.reply_text(COVER + str(user_data['style']),
reply_markup=InlineKeyboardMarkup(keyboard))
return State.choice
def assemble_inline_keyboard(self, poll, include_publish_button=False):
inline_keyboard_items = self.get_inline_keyboard_items(poll)
if include_publish_button:
publish_button = InlineKeyboardButton(
"Publish!", switch_inline_query=poll['poll_id'])
inline_keyboard_items.append([publish_button])
return InlineKeyboardMarkup(inline_keyboard_items)
def get_markup(self):
article = [InlineKeyboardButton(
text=i.title,
callback_data=f'{i.get_callback_data()} send'
) for i in self.articles.all()]
grouped_article = [article[i:i + 2] for i in range(0, len(article), 2)]
return InlineKeyboardMarkup(grouped_article)
def ask_notify() -> InlineKeyboardMarkup:
keyboard = [
[
InlineKeyboardButton("Yes", callback_data='n1'),
InlineKeyboardButton("No", callback_data='n0')
]
]
return InlineKeyboardMarkup(keyboard)
def shift_menu_right(update: Update, context: CallbackContext) -> int:
query = update.callback_query
query.answer()
reply_markup = InlineKeyboardMarkup(
create_keyboard(context, 1,
Subjects.getInstance().get_subjects()))
query.edit_message_text(text=query.message.text, reply_markup=reply_markup)
return 0
def SayAboutUs(bot, update, self):
buttons = [[
InlineKeyboardButton("К скульптурам", callback_data='Magazine'),
InlineKeyboardButton("Назад", callback_data='MainMenu')
]]
bot.send_message(chat_id=update.message.chat_id,
text=GetSettingsValue(bot_settings.about_us),
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(buttons))
def _show_language_selection(bot, update, lang_type, page=0):
if lang_type == SOURCE_LANGUAGE:
lang_str = 'source'
callback_select_type = CALLBACK_TYPE_SOURCE_LANG
callback_page_type = CALLBACK_TYPE_SOURCE_LANG_PAGE
elif lang_type == TARGET_LANGUAGE:
lang_str = 'target'
callback_select_type = CALLBACK_TYPE_TARGET_LANG
callback_page_type = CALLBACK_TYPE_TARGET_LANG_PAGE
else:
error(bot, update, "Unknown language type: " + str(type))
return
global store_helper
user_id = update.effective_user.id
src = store_helper.get_src_lang(user_id)
trg = store_helper.get_trg_lang(user_id)
src_str = LANGUAGES[
src] if src in LANGUAGES else src if not None else "not set"
trg_str = LANGUAGES[
trg] if trg in LANGUAGES else trg if not None else "not set"
text = "Your current source language: <b>" + str(src_str) + "</b>, target language: <b>" + str(trg_str) + \
"</b>.\nPlease chose new <b>" + lang_str + "</b> language: "
button_list = list(
map(
lambda x: InlineKeyboardButton(
text=x[1],
callback_data=json.dumps(
create_callback_word_dict(callback_select_type, x[0]))),
list(LANGUAGES.items())[page * LANG_BUTTONS_PER_REPLY:(page + 1) *
LANG_BUTTONS_PER_REPLY]))
pages_number = math.ceil(len(LANGUAGES) / LANG_BUTTONS_PER_REPLY)
if pages_number > 1:
if page > 0:
button_list.append(
InlineKeyboardButton(text="Previous page",
callback_data=json.dumps(
create_callback_word_dict(
callback_page_type, page - 1))))
if page < pages_number - 1:
button_list.append(
InlineKeyboardButton(text="Next page",
callback_data=json.dumps(
create_callback_word_dict(
callback_page_type, page + 1))))
reply_markup = InlineKeyboardMarkup(build_menu(button_list, n_cols=4))
bot.sendMessage(chat_id=get_chat_id(update),
text=text,
reply_markup=reply_markup,
parse_mode=ParseMode.HTML)
def AskAboutRealeseSquare(bot, update, self):
button_list = [[
InlineKeyboardButton("Да", callback_data="RealiseSquare-Yes"),
InlineKeyboardButton("Нет", callback_data="RealiseSquare-No")
]]
reply_markup = InlineKeyboardMarkup(button_list)
bot.send_message(chat_id=update.message.chat_id,
text='Есть ли у тебя действующий магазин/ площадка....?',
parse_mode=ParseMode.HTML,
reply_markup=reply_markup)
self.SetMyState(states.AskRealeseSquare)
def __get_keyboard(self, buttons):
keyboard = []
if "link" in buttons:
keyboard.append([
InlineKeyboardButton("Artikel lesen ↗️", url=buttons["link"])
])
if "magazine" in buttons:
keyboard.append([
InlineKeyboardButton("Ausgabe lesen ↗️",
url=buttons["magazine"])
])
return InlineKeyboardMarkup(keyboard)
def get_reply_markup(publication_id):
def get_star_button(starts):
text = '⭐️' * starts
callback = {'publication_id': publication_id, 'points': starts}
return InlineKeyboardButton(text=text,
callback_data=json.dumps(callback))
buttons = [[get_star_button(5), get_star_button(4)],
[get_star_button(3),
get_star_button(2),
get_star_button(1)]]
return InlineKeyboardMarkup(buttons)
def SayHowToFindUs(bot, update, self):
buttons = [[
InlineKeyboardButton(text='🌐 Сайт', url="https://www.vase-head.com/"),
InlineKeyboardButton("📱 Телефон", callback_data="Phone"),
InlineKeyboardButton("📧 Эл.почта", url="*****@*****.**")
]]
bot.send_message(
chat_id=update.message.chat_id,
text=
'Вы можете :\n📰 Познакомиться с нашим сайтом.\n📞 Связаться с менеджером.\n📬 Написать нам на почту.',
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(buttons))
SayShowRoomList(bot, update, self)
