def delete_message(bot: TeleBot, call: CallbackQuery):
chat_id = call.message.chat_id
message_id = call.message.message_id
try:
bot.delete_message(chat_id, message_id)
except:
bot.answer_callback_query(call.id,
text="Щоб продовжити натискай на /start")
def process_tests_text(bot: TeleBot, user: User, data: Data, text: str,
user_func: Callable):
test_action = text.split("__")[1]
if test_action == "help":
bot.send_message(user.chat_id, help_msg)
elif test_action.startswith("edit"):
btn_number = int(text.split("-")[-1])
elif test_action == "update":
data.update_ejf_table()
bot.send_message(user.chat_id, text="EJF table has been updated")
elif test_action == "resetquiz":
user.additional_info = None
user.save()
bot.send_message(
user.chat_id,
text="You can now click /start and take a quiz again.")
elif test_action == "user":
user_func(user)
elif test_action == "test_blocked":
blocked_counter = 0
unblocked_counter = 0
for u in User.objects:
try:
m = bot.send_message(chat_id=u.chat_id, text="check")
bot.delete_message(chat_id=u.chat_id, message_id=m.message_id)
if u.is_blocked:
u.is_blocked = False
bot.send_message(
user.chat_id,
text=f"{u.chat_id} @{u.username} unblocked!!!!")
u.save()
unblocked_counter += 1
except Exception as e:
bot.send_message(user.chat_id,
text=f"{u.chat_id} @{u.username} {e}")
if u.is_blocked is False:
u.is_blocked = True
u.save()
blocked_counter += 1
bot.send_message(
user.chat_id,
text=
f"Заблоковано нових {blocked_counter}\nРозблоковано нових {unblocked_counter}",
)
def num_changed(bot: TeleBot, message):
chat_id = message.chat.id
lang = redis_cache.get_language(chat_id)
if lang == 'uz':
_num_changed = num_changed_uz
menu_but = menu_but_uz
else:
_num_changed = num_changed_ru
menu_but = menu_but_ru
markup = InlineKeyboardMarkup()
markup.add(InlineKeyboardButton(text=menu_but, callback_data='menu'))
bot.delete_message(chat_id=chat_id, message_id=message.message_id)
bot.send_message(chat_id=chat_id, text=_num_changed, reply_markup=markup)
def delete_message(call: CallbackQuery, admin_bot: TeleBot):
_, chat_id, message_id, op_name = call.data.split(':')
user_bot = TeleBot(USER_BOT_TOKEN)
try:
user_bot.delete_message(chat_id, message_id)
except ApiException:
resp = '`Это сообщение уже удалено!`'
else:
resp = '`Вы удалили это собщение`'
# print(resp)
admin_bot.edit_message_text(resp,
call.from_user.id,
call.message.message_id,
parse_mode='Markdown')
def self(bot: TeleBot, callback: CallbackQuery, sql):
chat_id = callback.message.chat.id
lang = redis_cache.get_language(chat_id)
info = sql.select_info_from_user(chat_id)
if lang == 'uz':
name = menu_name_uz
sex = menu_sex_uz
num = menu_num_uz
add = menu_address_uz
menu_but = menu_but_uz
change_name = change_name_uz
change_num = change_num_uz
change_sex = change_sex_uz
if int(info[2]) == 1:
sex_val = menu_sex_val_m_uz
else:
sex_val = menu_sex_val_f_uz
else:
name = menu_name_ru
sex = menu_sex_ru
num = menu_num_ru
add = menu_address_ru
menu_but = menu_but_ru
change_name = change_name_ru
change_num = change_num_ru
change_sex = change_sex_ru
if int(info[2]) == 1:
sex_val = menu_sex_val_m_ru
else:
sex_val = menu_sex_val_f_ru
self_text = f'<u>{name}</u>: <b>{info[0]}</b>\n<u>{num}</u>: <b>{info[1]}</b>\n' \
f'<u>{sex}</u>: <b>{sex_val}</b>\n<u>{add}</u>: <b>{info[3]}</b>'
markup = InlineKeyboardMarkup()
markup.add(
InlineKeyboardButton(text=change_name, callback_data='change_name'),
InlineKeyboardButton(text=change_num, callback_data='change_num'),
InlineKeyboardButton(text=change_sex, callback_data='change_sex'))
markup.add(InlineKeyboardButton(text=menu_but, callback_data='menu'))
bot.delete_message(chat_id=chat_id, message_id=callback.message.message_id)
bot.send_message(chat_id=chat_id,
text=self_text,
reply_markup=markup,
parse_mode='html')
def menu(bot: TeleBot, callback: CallbackQuery):
chat_id = callback.message.chat.id
markup = InlineKeyboardMarkup()
lang = redis_cache.get_language(chat_id)
if lang == 'uz':
_catalog = catalog_uz
self_data = self_uz
cart = cart_uz
menu_but = menu_but_uz
else:
_catalog = catalog_ru
self_data = self_ru
cart = cart_ru
menu_but = menu_but_ru
button_catalog = InlineKeyboardButton(text=f'{_catalog} 🛍',
callback_data='catalog')
button_self = InlineKeyboardButton(text=f'{self_data} 🧾',
callback_data='self')
button_cart = InlineKeyboardButton(text=f'{cart} 🛒', callback_data='cart')
markup.add(button_catalog, button_self).add(button_cart)
bot.delete_message(chat_id=chat_id, message_id=callback.message.message_id)
bot.send_message(chat_id=chat_id, text=menu_but, reply_markup=markup)
def calendar_query_handler(
bot: TeleBot,
call: CallbackQuery,
name: str,
action: str,
year: int,
month: int,
day: int,
) -> None or datetime.datetime:
"""
The method creates a new calendar if the forward or backward button is pressed
This method should be called inside CallbackQueryHandler.
:param bot: The object of the bot CallbackQueryHandler
:param call: CallbackQueryHandler data
:param day:
:param month:
:param year:
:param action:
:param name:
:return: Returns a tuple
"""
current = datetime.datetime(int(year), int(month), 1)
if action == "IGNORE":
bot.answer_callback_query(callback_query_id=call.id)
return False, None
elif action == "DAY":
bot.delete_message(chat_id=call.message.chat.id,
message_id=call.message.message_id)
return datetime.datetime(int(year), int(month), int(day))
elif action == "PREVIOUS-MONTH":
preview_month = current - datetime.timedelta(days=1)
bot.edit_message_text(
text=call.message.text,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=create_calendar(name=name,
year=int(preview_month.year),
month=int(preview_month.month)),
)
return None
elif action == "NEXT-MONTH":
next_month = current + datetime.timedelta(days=31)
bot.edit_message_text(
text=call.message.text,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=create_calendar(name=name,
year=int(next_month.year),
month=int(next_month.month)),
)
return None
elif action == "MONTHS":
bot.edit_message_text(
text=call.message.text,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=create_months_calendar(name=name, year=current.year),
)
return None
elif action == "MONTH":
bot.edit_message_text(
text=call.message.text,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=create_calendar(name=name,
year=int(year),
month=int(month)),
)
return None
elif action == "Выход":
bot.delete_message(chat_id=call.message.chat.id,
message_id=call.message.message_id)
return "Выход", None
else:
#bot.answer_callback_query(callback_query_id=call.id, text="ERROR!")
bot.delete_message(chat_id=call.message.chat.id,
message_id=call.message.message_id)
return None
def delete_message(telegram_api: telebot.TeleBot, chat_id, message_id):
return telegram_api.delete_message(chat_id, message_id)
class BOT:
index = 0
count_films = utils.STEP
config_file_name = 'config.json'
def __init__(self):
self.cfg = self.JSON()
self.construct()
def construct(self):
self.bot = TeleBot(self.cfg['token'])
self.commands = {
"List films": utils.call(self.manage),
"Unsubscribe": utils.call(self.del_user),
}
self.film_view_markup = {
"back": utils.call(self.revert),
"open": utils.call(lambda *x, **b:...),
}
self.markup = {
"1": utils.call(self.film, 0),
"2": utils.call(self.film, 1),
"3": utils.call(self.film, 2),
"4": utils.call(self.film, 3),
"5": utils.call(self.film, 4),
"6": utils.call(self.film, 5),
"7": utils.call(self.film, 6),
"8": utils.call(self.film, 7),
"9": utils.call(self.film, 8),
"10": utils.call(self.film, 9),
"prev": utils.call(self.prev),
"next": utils.call(self.next),
}
@self.bot.message_handler(
commands=['subscribe', 'unsubscribe', 'categories', 'find'])
def subscribe_detector(message):
try:
if "/subscribe" in message.text:
category = message.text.split("/subscribe")[-1].strip()
if category in list(self.cfg['categories'].keys()):
uinfo = (message.chat.id, category)
db = utils.DATABASE(self.cfg["db_name"])
db.insert(table_name="subscribe_categories",
args=uinfo)
self.bot.reply_to(
message, self.cfg["subscribe_category"].replace(
"{}", category))
else:
self.bot.send_message(message.chat.id,
self.cfg["category_not_found"])
elif "/unsubscribe" in message.text:
category = message.text.split("/unsubscribe")[-1].strip()
if category in self.cfg['categories']:
db = utils.DATABASE(self.cfg["db_name"])
db.delete(table_name="subscribe_categories",
where=" chat_id = " + str(message.chat.id))
self.bot.reply_to(
message, self.cfg["unsibscribe_category"].replace(
"{}", category))
else:
self.bot.send_message(message.chat.id,
self.cfg["category_not_found"])
elif "/find" in message.text:
film_name = message.text.split("/find")[-1].strip()
finded = utils.load_films(
db_name=self.cfg['db_name'],
find_perc=[film_name, self.cfg['film_perc']])
finded.extend(
utils.load_films(db_name=self.cfg['db_name'],
find=film_name))
message_ = ""
for i, film in enumerate(finded):
message_ += "{}. {}\n{}\n\n".format(
i + 1, film[1], film[3])
messages_ = []
if len(message_) > 2800:
count = int(len(message_) / 2800)
s = 0
for i in range(count):
ns = s + 2800
if len(message_) < ns:
ns = -1
msg = message_[s:ns]
messages_.append(msg)
s = ns
if not ns:
break
else:
messages_.append(message_)
for msg in messages_:
if len(msg) > 2:
self.bot.send_message(message.chat.id, msg)
else:
self.bot.send_message(message.chat.id,
self.cgf['no_film_error'])
elif "/categories" in message.text:
msg = ""
for i, key in enumerate(list(self.cfg["categories"])):
msg += "{} : {}\n".format(i, key)
self.bot.send_message(
message.chat.id,
self.cfg['categories_text'].replace("{}", msg))
except Exception as e:
# utils.log(e)
raise
@self.bot.callback_query_handler(func=lambda call: True)
def callback_query(call):
try:
if call.data in self.markup.keys():
self.markup[call.data](call)
elif call.data in self.film_view_markup.keys():
self.film_view_markup[call.data](call)
except Exception as e:
utils.log(e)
@self.bot.message_handler(func=lambda x: True)
def main(message):
try:
utils.add_user(message=message, db_name=self.cfg['db_name'])
if message.text in self.commands:
self.commands[message.text](message)
else:
self.bot.send_message(message.chat.id,
text=self.cfg['base_message'],
reply_markup=utils.repl_markup(
list(self.commands.keys())))
except Exception as e:
utils.log(e)
def JSON(self):
return utils.loads(open(self.config_file_name).read())
def del_user(self, message):
self.bot.send_message(message.chat.id, self.cfg["global_unsubscribe"])
utils.delete_subscriber(message.chat.id, db_name=self.cfg['db_name'])
def manage(self, message, text=None):
self.bot.send_message(
message.chat.id,
text=utils.new_message(
msg=text if text else self.cfg['default_message'],
db_name=self.cfg["db_name"],
repl=self.cfg['message_repl']),
reply_markup=utils.inline_markup(self.markup))
def revert(self, call):
id = call.message.chat.id
messages = utils.new_message(index=self.index,
msg=self.cfg['default_message'],
repl=self.cfg['message_repl'],
db_name=self.cfg["db_name"])
self.bot.delete_message(id, call.message.message_id)
self.bot.send_message(id,
text=messages,
reply_markup=utils.inline_markup(self.markup))
self.bot.answer_callback_query(call.id, "Success")
def send_all(self, msg):
mkp = utils.repl_markup(utils.START_MARKUP)
for id in utils.get_all_subscribers_id(db_name=self.cfg["db_name"]):
try:
self.bot.send_message(id, msg, reply_markup=mkp)
except Exception as e:
utils.delete_subscriber(id, db_name=self.cfg["db_name"])
def film(self, call, id=0):
id_ = call.message.chat.id
db = utils.DATABASE(self.cfg['db_name'])
film_info = db.read(table_name="films",
where=" id = '{}'".format(
utils.class_db.film_list[id][1]))[0]
db.close()
def download():
utils.image_download(film_info[2])
t = Thread(target=download)
t.start()
t.join()
self.bot.delete_message(id_, call.message.message_id)
self.bot.send_photo(
chat_id=id_,
photo=open(".image.jpg", "rb"),
reply_markup=utils.inline_markup(self.film_view_markup),
caption=utils.render_film_info(film_info[0],
db_name=self.cfg["db_name"]))
def next(self, call):
utils.class_db.index += utils.STEP
messages = utils.new_message(msg=self.cfg['default_message'],
repl=self.cfg['message_repl'],
index=utils.class_db.index,
db_name=self.cfg["db_name"])
self.bot.edit_message_text(text=messages,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=utils.inline_markup(
self.markup),
inline_message_id=call.inline_message_id)
def prev(self, call):
utils.class_db.index -= utils.STEP
if utils.class_db.index < 0:
utils.class_db.index = 0
self.bot.answer_callback_query(call.id, self.cfg['no_films_error'])
return True
message = utils.new_message(msg=self.cfg['default_message'],
repl=self.cfg['message_repl'],
index=utils.class_db.index,
db_name=self.cfg["db_name"])
self.bot.edit_message_text(text=message,
chat_id=call.message.chat.id,
message_id=call.message.message_id,
reply_markup=utils.inline_markup(
self.markup),
inline_message_id=call.inline_message_id)
def start(self, msg=True):
if msg:
self.send_all(self.cfg["start_message"])
utils.new_message(msg=self.cfg['default_message'],
repl=self.cfg['message_repl'],
db_name=self.cfg["db_name"])
self.bot.polling()
def stop(self):
self.bot.stop_polling()
class CashbackBot:
def __init__(self, token):
'''Подключение к Telegram, SQL'''
self.bot = TeleBot(token)
'''это кнопка отмены, она часто используется, поэтому я добавил ее в переменные класса'''
self.button_cancel = InlineKeyboardButton(text = "❌", callback_data = "cancel")
'''переменная для обозначения предпринимателей, которые находятся в процессе настройки процентов'''
self.users_in_process = []
def start_command(self, query, is_callback_query=False):
if not is_callback_query:
message = query
if not self.id_exists_in_table("id",message.from_user.id,"users"):
if " " in message.text:
ref_data = message.text.split()[1]
if ref_data[0] == "o":
ref_data = ref_data.split("o")[1]
inst_id = int(ref_data)
inst_name = self.sql.get_institution_info_by_id(inst_id)['institution_name']
self.bot.send_message(user_id, parse_mode = "HTML",
text = f"Теперь вы оператор <b>{inst_name}</b>!")
self.bot.send_message(message.chat.id, "Оператор приглашен.")
# тут нужен sql
elif ref_data[0] == "u"
ref_data = ref_data.split("u")
inst_id = int(ref_data[1])
user_id = int(ref_data[0])
inst_name = self.sql.get_institution_info_by_id(inst_id)['institution_name']
self.bot.send_message(user_id, parse_mode = "HTML",
text = f"У вас новый реферал на предприятие <b>{inst_name}</b>!\n Имя реферала:<b>{user_name}</b>")
self.bot.send_message(message.chat.id, f"Вы были приглашены по реферальной ссылке к предприятию <b>{inst_name}</b>",
parse_mode = "HTML")
# тут нужен sql
self.sql.create_user_as(message.from_user.id, message.from_user.first_name + " " + message.from_user.last_name, "customer")
keyboard = InlineKeyboardMarkup()
button_buy = InlineKeyboardButton(text = "Совершить покупку", callback_data = "menu|buy")
button_referal = InlineKeyboardButton(text = "Реферальная программа", callback_data = "menu|refer")
button_about = InlineKeyboardButton(text = "О боте", callback_data = "menu|about")
keyboad.add(button_buy, button_referal)
keyboard.add(button_about, self.button_cancel)
self.bot.send_message(message.chat.id, f"Здравствуйте <b>{message.from_user.first_name}</b>",
parse_mode = "HTML", reply_markup = keyboard)
else:
call = query
if call.data.startswith("menu"):
menu_type = call.data.split("|")[1]
if menu_type == "buy":
keyboard = InlineKeyboardMarkup()
button_bonus_plus = InlineKeyboardButton(text = "Начислить", callback_data = "bonus|plus")
button_bonus_mins = InlineKeyboardButton(text = "Списать", callback_data = "bonus|mins")
keyboard.add(button_bonus_plus, button_bonus_mins)
keyboard.add(self.button_cancel)
self.bot.edit_message_text(chat_id = call.message.chat.id, text = "Что вы намерены делать с бонусами?",
reply_markup = keyboard, message_id = call.message.message_id)
elif menu_type == "refer":
insts = #тут нужен sql #self.sql.get_insts(call.from_user.id)
if insts == []:
self.bot.send_message(call.message.chat.id, "Вы не работали ни с какими предприятиями 🚫")
else:
keyboard = InlineKeyboardMarkup()
for inst in insts:
name = self.sql.get_institution_info_by_id(inst)["institution_name"]
keyboard.add(InlineKeyboardButton(text=name,callback_data=f"refer|{inst}"))
keyboard.add(self.button_cancel)
self.bot.edit_message_text(chat_id = call.message.chat.id,
text = "Выберите предприятие, к которому вы хотите получить реферальную ссылку:",
reply_markup = keyboard, message_id = call.message.message_id)
elif menu_type == "about":
self.bot.send_message(call.message.chat.id,
"""
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Sed vitae ornare elit. Morbi pellentesque bibendum leo quis hendrerit.
Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
""")
elif call.data.startswith("refer"):
inst_id = call.data.split("|")[1]
link = f"http://t.me/cashtestback_bot?start=u{call.from_user.id}q{inst_id}"
self.bot.edit_message_text(chat_id = call.message.chat.id, message_id = call.message.message_id,
text = f"Используйте эту ссылку, чтобы пригласить нового пользователя\n{link}")
elif call.data.startswith("bonus"):
need_data = call.data.split("|")
bonus_type = need_data[1]
operation_id = self.sql.gen_random_id()
#тут нужен sql
self.bot.edit_message_text(chat_id = call.message.chat.id, message_id = call.message.message_id,
text = f"Ваш код: <b>{operation_id}</b>\nСообщите этот код кассиру.")
def admin_commands(self, query, is_callback_query=False):
if not is_callback_query:
message = query
if self.sql.check_user(message.from_user.id):
keyboard = InlineKeyboardMarkup()
button_settings = InlineKeyboardButton(text = "Настройки", callback_data = "settings")
button_add_operator = InlineKeyboardButton(text = "Добавить оператора", callback_data = "add_operator")
button_buy = InlineKeyboardButton(text = "Совершить продажу", callback_data = "buy")
keyboard.add(button_settings, button_add_operator)
keyboard.add(button_buy, self.button_cancel)
self.bot.send_message(message.chat.id,"Меню предприятия:",reply_markup=keyboard)
elif message.from_user.id in [process.get("user_id") for process in self.users_in_process]:
for process in self.users_in_process:
if process.get("user_id") == message.from_user.id:
theme = process.get("item")
break
theme_text = theme.replace("referal","рефералов").replace("reffer","рефферов").replace("bounus","бонусов")
if item.startswith("buy"):
if item == "buy":
if not in #тут sql:
self.bot.send_message(message.chat.id, "Данный код не найден, попробуйте ввести снова или ввести <b>Отмена</b> для отмены",
parse_mode = "HTML")
else:
self.bot.send_message(message.chat.id, "Введите сумму покупки: ")
self.users_in_process.remove(process)
self.users_in_process.append({"user_id":message.from_user.id, "item":"buy2", "code":message.text})
else:
try:
count = int(message.text)
inst_id = #тут нужен sql #self.sql.get_inst_id(message.from_user.id)
do = #тут нужн sql # self.sql.get_do(process['code'])
self.sql.bonuses_to_user(self,user_id,count,inst_id,do)
referals = #тут нужен sql
percent_for_referal = #тут нужен sql
sale = referals * percent_for_referal
count = count / 100 * sale
self.bot.send_message(message.chat.id, parse_mode = "HTML",
text = f"Операция прошла успешно! Сумма покупки равна: <b>{count}</b>, так как <b>{referals}</b> реферал")
self.users_in_process.remove(process)
except ValueError:
self.bot.send_message(message.chat.id, "Вы ввели не по формату, попробуйте еще раз или введите <b>Отмена</b>",
parse_mode = "HTML")
if message.text == "Отмена":
self.bot.delete_message(chat_id = message.chat.id, message_id = message.message_id)
self.users_in_process.remove(process)
elif message.text not in [str(i) for i in range(1,101)]:
self.bot.send_message(message.chat.id, "Вы ввели не по формату, попробуйте еще раз или введите <b>Отмена</b>",
parse_mode = "HTML")
else:
self.bot.send_message(message.chat.id, f"Ваш новый процент для <b>{theme_text}</b> -- <b>{message.text}%</b>",
parse_mode = "HTML")
#тут нужен sql
else:
call = query
if call.data == "add_operator":
inst_id = #тут нужен sql #self.sql.get_inst(call.from_user.id)
link = f"http://t.me/cashtestback_bot?start=o{inst_id}"
self.bot.send_message(call.message.chat.id, f"Используйте эту ссылку, чтобы добавить в ваше предприятие оператора:\n{link}")
elif call.data == "settings":
keyboard = InlineKeyboardMarkup()
button_referal = InlineKeyboardButton(text = "Проценты на рефералы", callback_data = "config|referal")
button_reffer = InlineKeyboardButton(text = "Проценты на рефферы", callback_data = "config|reffer")
button_bonus = InlineKeyboardButton(text = "Бонусы", callback_data = "config|bonus")
keyboard.add(button_referal, button_reffer)
keyboard.add(button_bonus, self.button_cancel)
self.bot.send_message(call.message.chat.id, "Настроить:", reply_markup = keyboard)
elif call.data == "buy":
self.users_in_process.append({"user_id":call.from_user.id, "item":"buy"})
self.bot.send_message(call.message.chat.id, "Введите код: ")
elif call.data.startswith("config"):
item = call.data.split("|")[1]
self.bot.send_message(call.message.chat.id, "Введите число от 1>100")
self.users_in_process.append({"user_id":call.from_user.id, "item":item})
def delete_msgs(bot: telebot.TeleBot, user_id: int, msg_ids: List[int]) -> None:
for msg_id in msg_ids:
bot.delete_message(user_id, message_id=msg_id)
def delete_message(bot: telebot.TeleBot, chat_id: int, message_id: int) -> Any:
return bot.delete_message(chat_id, message_id)
