async def showing_orders(call: CallbackQuery):
await call.answer()
products = await db.select_all_products()
for order in product_list:
await order.delete()
product_list.clear()
if products == []:
msg = await call.message.answer("Нет товаров")
product_list.append(msg)
for product in products:
print(product)
type = product[5]
if type == "photo":
product = await bot.send_photo(
chat_id=call.from_user.id,
photo=product[3],
caption=hcode("id: {id}\n"
"Название: {name}\n"
"Код товара: {code}\n"
"Балл товара: {point}".format(**product)),
reply_markup=product_delete)
else:
product = await bot.send_video(
chat_id=call.from_user.id,
video=product[3],
caption=hcode("id: {id}\n"
"Название: {name}\n"
"Код товара: {code}\n"
"Балл товара: {point}".format(**product)),
reply_markup=product_delete)
product_list.append(product)
def format_enquiry_for_paying(enquiry):
"""
Formatted message about inquiry
:param enquiry: enquiry
:return: formatted message
"""
if len(enquiry) == 0:
return "Данных нет"
formatted_enquiry_for_paying = [
'<code>Заявка со статусом:</code> <i>{}</i>'.format(enquiry['f78321']),
'', '<i>Номер заявки: {}</i>'.format(enquiry["id"]),
'Клиент: <b>{}</b>'.format(enquiry['f78201']),
'Адрес: {}'.format(enquiry['f78211']),
'Дата исполнения: {}'.format(hcode(enquiry['f78311'])),
'Срок установки: {}'.format(hcode(enquiry['f81181'])),
"Пробег: {} км".format(enquiry["f78361"]), "Акт по заявке: {}".format(
"Да" if len(str(enquiry["f81381"]).strip()) > 0 else "Нет"),
"УПД по заявке: {}".format(
"Да" if len(str(enquiry["f81301"]).strip()) > 0 else "Нет"),
"Заявка оплачена: {}".format(enquiry["f81311"]),
"Вознаграждение по заявке: {} руб".format(enquiry["f81291"])
# 'Телефон: {}'.format(enquiry['f78341']),
# 'Доставка: {}'.format(enquiry['f79841'])
]
return '\n'.join(formatted_enquiry_for_paying)
async def help_message(message: types.Message):
await message.answer(
text(hbold('1️⃣ Test yaratish uchun\n'),
hcode("+test*Fan nomi*to'g'ri javoblar\n"),
"ko`rinishida yuboring\n",
hbold("Misol:"),
hcode("+test*Kimyo*abbccabd...\n"),
hbold('2️⃣ Test javoblarini yuborish uchun\n'),
hcode("test kodi*abbcbccdd...\n"),
"kabi ko`rinishlarda yuboring.\n",
hbold("Misol:"),
hcode("1234*abbcabcdd...\n"),
sep='\n'))
async def projects_cursus_saver(self, message: Message) -> str:
downloaded = await bot.download_file_by_id(message.document.file_id)
try:
data = self._projects_parser(downloaded=downloaded)
except Exception as e:
self._logger.error('Unknown projects parser error | %s ', e)
return hcode(str(e))
if not data:
return 'Информация не обновлена, ничего не удалось спарсить'
for cursus_id in data:
project_ids = []
self._logger.info('Get projects from cursus | %s | %s ', cursus_id,
data[cursus_id])
projects = await self._config.intra.get_projects(
cursus_id=cursus_id, project_names=data[cursus_id])
for project in projects:
await Project.create_project(project_id=project['id'],
name=project['name'],
cursus_id=cursus_id,
from_intra=True)
project_ids.append(project['id'])
self._logger.info('Save project | %s | %s | %s', cursus_id,
project['id'], project['name'])
await Project.delete_projects_from_cursus(cursus_id=cursus_id,
project_ids=project_ids)
self._logger.info('Delete projects from cursus | %s | %s ',
cursus_id, data[cursus_id])
return 'Готово!'
async def variants_formatting(message: types.Message):
await message.answer(hbold('hbold'))
await message.answer(hcode('hcode'))
await message.answer(hitalic('hitalic'))
await message.answer(hunderline('hunderline'))
await message.answer(hstrikethrough('hstrikethrough'))
await message.answer(hpre('hpre'))
async def enter_username(message: types.Message, state: FSMContext):
await db.update_user_username(username=message.text, telegram_id=message.from_user.id)
user = await db.select_user(telegram_id=message.from_user.id)
user = dict(user)
await message.answer("Данные обновлены. Запись в БД:\n" +
hcode(f"{user=}"))
await state.reset_state()
async def show_menu_parcel_size(message: types.Message, state: FSMContext):
chat_id = message.from_user.id
res_phone = message.text
if res_phone == '0501111111':
return await message.answer(
hbold("Ви ввели номер телефону из прикладу\n"
"будь ласка введіть номер телефону отримувача👇"))
if not re.match(r'^[0]{1}[0-9]{9}$', res_phone):
await bot.send_sticker(
chat_id,
r"CAACAgIAAxkBAAEBV_hfY3oxV-wJjpmg-gY-tQ8vKTEPHgACCwADnP4yMPctMM3hxWgtGwQ"
)
return await bot.send_message(
chat_id,
hbold("Введений номер телефону: ") + hcode(res_phone) +
hbold("не відповідає формату\nСпробуйте ще раз"),
parse_mode=types.ParseMode.HTML)
res_phone = "38" + res_phone
print(res_phone)
await state.update_data(res_phone=res_phone)
# data = await state.get_data()
# message_id = data['message_id1']
# print(data)
# await bot.delete_message(chat_id,message_id)
await message.answer(hbold("Чи бажаєте вказати суму післяплати?"),
reply_markup=cod_kb,
parse_mode=types.ParseMode.HTML)
await ParcelCreate.get_res_cod.set()
async def filter_message_handler(message: types.Message, state: FSMContext):
user_data = await state.get_data()
param = user_data.get("input_value_await")
no_such_text = ""
value = None
if param == "location_cache":
for i in dp.bot.locations:
if i.button_text == message.text:
value = i.id
break
if not value:
no_such_text = dp.bot.texts["messages"][
"no_such_location"].format(hcode(message.text))
await dp.bot.safe_delete_message(chat_id=message.chat.id,
message_id=message.message_id)
if not value:
msg = await dp.bot.safe_send_message(chat_id=message.chat.id,
text=no_such_text)
if msg:
await asyncio.sleep(3)
await dp.bot.safe_delete_message(chat_id=msg.chat.id,
message_id=msg.message_id)
else:
await apply_filter(message, state, param, value)
async def pay_checkout_query(call: CallbackQuery, state: FSMContext):
# await call.answer(cache_time=30)
data = await state.get_data()
parcel_id = data['parcel_id_in']
parcel_res = my_parcel_debt(parcel_id)
res_amount = parcel_res['Total']
print(parcel_res)
# await call.message.answer(f"РЕЗУЛЬТАТ{parcel_res}")
pay_link = data['pay_link_in'] # раскоментить
if res_amount == 0:
await call.message.delete()
await call.answer(call.from_user.first_name +
hcode(", Ваша посилка оплачена"),
show_alert=True)
token_sender = get_token_sender(parcel_id)
await state.update_data(token_sender=token_sender)
await call.message.answer(hbold(
"На Ваш мобільний телефон буде відправлено СMC з кодом варіфікації введіть його в телеграм"
),
parse_mode=types.ParseMode.HTML)
await ParcelInsert.Insert3.set()
if res_amount != 0:
pay_button = types.InlineKeyboardMarkup(row_width=2)
pay_button.add(
types.InlineKeyboardButton(text=f"💸 Оплатити {res_amount} грн",
callback_data="pay",
url=pay_link))
pay_button.add(
types.InlineKeyboardButton(text="Підтверджую оплату",
callback_data="payment_confirm"))
await call.answer(call.from_user.first_name +
", Ваша посилка ще не оплачена",
show_alert=True)
# pay_button.add(types.InlineKeyboardButton(text="До головного меню", callback_data="Cancel3"))
return await call.message.edit_reply_markup(reply_markup=pay_button)
async def send_like(query: types.CallbackQuery, user):
db.add_like(query.from_user.id, user)
await query.answer('Вы лайкнули этого человека!')
if db.is_fake(user):
return
is_free_profile = free_profile(query.from_user.id, user)
if db.liked(user, query.from_user.id): # if he liked me
markup = chat_and_more_kb(parse_chat(query.from_user.id),
parse_profile(query.from_user.id),
free_profile=is_free_profile)
else:
markup = like_and_more_kb(parse_like(query.from_user.id),
parse_profile(query.from_user.id),
free_profile=is_free_profile)
me = db.get_user_name(query.from_user.id)
try:
await Bot.get_current().send_message(
user,
hcode(f'Вас лайкнул пользователь {me}'),
parse_mode=ParseMode.HTML,
reply_markup=markup)
except BotBlocked:
log.warning(
f"{me} could not send like to {user}, user blocked the bot")
async def my_info(message: types.Message):
user = db.get_user(message.from_user.id)
await message.answer(text(
hbold("Sizning ma'lumotlaringiz:\n"),
'👤 Ism familiya:',
hcode(f'{user[1]}\n'),
f'Sana, vaqt: {datetime.strptime(user[2], "%Y-%m-%d %H:%M:%S.%f")}',
sep='\n'
))
await message.answer(text(
hbold("Agar Ism familiyangizni o'zgartirishni xoxlasangiz\n"),
hcode('fio*ism familiya\n'),
"👆 ko'rinishda yozib yuboring.\n",
hbold('Misol:'),
hcode('fio*Valijon Alijonov'),
sep='\n'
))
async def choose_in(call: CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
data = await state.get_data()
# print(data)
user_phone = data.get("user_phone") # берем номер телефона
# user_phone = "380507723091" # тест отправки
poshtomat_num = data.get("poshtomat_num")
# poshtomat_num = "6077" # тест отправки
poshtomat_id_ref = poshtomat_info(poshtomat_num)
await state.update_data(poshtomatIDRef=poshtomat_id_ref)
print(user_phone)
print(poshtomat_num) # берем номер почтомата
print("Это Хендлер словил нажататие in")
result = parcels_list(poshtomat_num, user_phone)
if result is False:
keyboard = types.InlineKeyboardMarkup(row_width=2)
keyboard.row(
types.InlineKeyboardButton(text="Так", callback_data="parcel_cre"))
keyboard.row(
types.InlineKeyboardButton(text="Ні", callback_data="Cancel3"))
await call.message.edit_text(call.from_user.first_name + hbold(
", у Вас не має створених посилок для вкладення у поштомат №:") +
hcode(poshtomat_num) +
hbold("\nБажаєте створити?"),
reply_markup=keyboard)
return await NewParcel.PL1.set() # Разобраться со стейтом
else:
await state.update_data(choose_in_result=result)
await call.message.answer(
hcode('Оберіть Ваше відправлення для вкладення у поштомат'))
for i in result:
keyboard = types.InlineKeyboardMarkup()
keyboard.add(
types.InlineKeyboardButton(text="Відправити",
callback_data=i['id']))
await call.message.answer(i['text'],
parse_mode=types.ParseMode.HTML,
reply_markup=keyboard)
main_menu = types.InlineKeyboardMarkup()
main_menu.add(
types.InlineKeyboardButton(text="До головного меню",
callback_data="Cancel3"))
await call.message.answer("Для повернення у головне меню",
reply_markup=main_menu)
await ParcelInsert.Insert1.set()
def format_enquiry(enquiry):
"""
Formatted message about inquiry
:param enquiry: enquiry
:return: formatted message
"""
if len(enquiry) == 0:
return "Данных нет"
formatted_enquiry = [
'<code>Заявка со статусом:</code> <i>{}</i>'.format(enquiry['f78321']),
'', '<i>Номер заявки: {}</i>'.format(enquiry["id"]),
'Клиент: <b>{}</b>'.format(enquiry['f78201']), 'Адрес: {}'.format(
enquiry['f78211']), 'Телефон: {}'.format(enquiry['f78341']),
'Дата исполнения: {}'.format(hcode(enquiry['f78311'])),
'Срок установки: {}'.format(hcode(enquiry['f81181'])),
'Доставка: {}'.format(enquiry['f79841'])
]
return '\n'.join(formatted_enquiry)
async def enter_email(message: types.Message, state: FSMContext):
email = message.text
await commands.update_user_email(email=email, id=message.from_user.id)
user = await commands.select_user(id=message.from_user.id)
await message.answer("Данные обновлены. Запись в БД: \n" +
hcode(f"id={user.id}\n"
f"name={user.name}\n"
f"email={user.email}"))
await state.finish()
async def enter_email(message: types.Message, state: FSMContext):
# contact = message.contact
tel = message.contact
# await message.answer(text=f"{tel.phone_number}, {tel.user_id}", reply_markup=ReplyKeyboardRemove())
await commands.update_user_email(tel=tel.phone_number,
id=message.from_user.id)
user = await commands.select_user(id=message.from_user.id)
await message.answer("Данные обновлены. Запись в БД: \n" +
hcode(f"id={user.id}\n"
f"name={user.name}\n"
f"tel={user.tel}"),
reply_markup=ReplyKeyboardRemove())
await dp.bot.send_message(
"54309418",
"В базу добавлен новый ползователь: \n" + hcode(f"id={user.id}\n"
f"name={user.name}\n"
f"tel={user.tel}"))
await state.finish()
async def enter_email(message: types.Message, state: FSMContext):
email = message.text
await db.update_user_email(email, message.from_user.id)
user = await db.select_user(id=message.from_user.id)
await message.answer("Данные обновлены. Запись в БД: \n" +
hcode("id={id}\n"
"name={name}\n"
"email={email}".format(**user)))
await state.finish()
async def start_dialog(message: types.Message):
await message.answer(
hcode(
"""Для створення посилки Вам потрібно вказати формат вантажу, поштомат для відправлення та поштомат отримання,ім'я отримувача і телефон."""
))
size = open('data/img/sizes.png', 'rb')
await bot.send_photo(message.from_user.id,
size,
reply_markup=create_parcel_kb)
async def creat_parcel(call: CallbackQuery, state: FSMContext):
size = open('data/img/sizes.png', 'rb')
await call.message.edit_text(hcode(
"Для створення посилки Вам потрібно вказати формат вантажу, поштомат для відправлення та поштомат отримання,ім'я отримувача і телефон."
),
parse_mode=types.ParseMode.HTML)
await bot.send_photo(call.from_user.id,
size,
reply_markup=create_parcel_kb)
await state.finish()
async def check_test(message: types.Message):
# Extract test info
test_info = message.text.split('*')
test_code = test_info[0]
answers = test_info[1].lower()
test = db.get_test(test_code)
if not test:
await message.answer(
'Xatolik!\nTest bazadan topilmadi.\nTest kodini noto`g`ri yuborgan bo`lishingiz mumkin, iltimos tekshirib '
'qaytadan yuboring. '
)
return
if test[5]:
await message.answer(
'Xatolik!\nTest yakunlangan!'
)
return
if db.user_passed_test(message.from_user.id, test_code):
await message.answer(
'❗️❗️❗Siz oldinroq bu testga javob yuborgansiz.\nBitta testga faqat bir marta javob yuborish mumkin!'
)
return
if test[4] != len(answers):
await message.answer(f"Xatolik! Testlar soni {test[4]} ta bo'lishi kerak!")
return
correct_answers = calc_correct_answers(answers, test[2])
ratio = correct_answers / test[4]
db.add_test_result(test_code, message.from_user.id, answers, correct_answers)
user = db.get_user(message.from_user.id)
await message.answer(text(
text(hbold(f'👤Foydalanuvchi: '), hcode(f'{user[1]}\n')),
f'📚 Fan: {test[1]}',
text(f'📖 Test kodi: ', hbold(test_code)),
f'✏ Jami savollar soni: {test[4]} ta',
f"✅ To'g'ri javoblar soni: {correct_answers} ta",
f'🔣 Foiz: {ratio:.1%}\n',
f'🕐 Sana, vaqt: {datetime.now().strftime(config.DATETIME_FORMAT)}',
sep='\n'
))
# Notify test author about passage of his test
test_author = test[3]
markup = InlineKeyboardMarkup()
markup.add(InlineKeyboardButton('Joriy holat', callback_data=f'status*{test[1]}*{test_code}*{test[4]}'))
markup.add(InlineKeyboardButton('Yakunlash', callback_data=f'finish*{test[1]}*{test_code}*{test[4]}*{test[2]}'))
await bot.send_message(
test_author, f'{user[1]} {test[1]} fanidan {test_code} kodli testning javoblarini yubordi',
reply_markup=markup
)
async def update_info_gps(message: types.Message, state: FSMContext):
location = message.location
lat = location.latitude
lon = location.longitude
msg = await message.answer(text="text", reply_markup=ReplyKeyboardRemove())
await msg.delete()
await db.update_data_gps(lat, lon, int(ADMINS[0]))
info = await db.select_data(id=int(ADMINS[0]))
await message.answer(
hcode("latitude={latitude}\n"
"longitude={longitude}".format(**info)))
await state.finish()
async def send_start_msg(trade_mgr: TradeExchangeManager, trigger_mgr: TriggerExchangeManager):
msg = ''
msg += 'Bot started.\n\n'
enabled_phone_accounts = [c.name for c in trade_mgr.caller._accounts]
msg += text(hbold('Enabled phone accounts: '), ', '.join(enabled_phone_accounts), '\n')
msg += '\n'
msg += hbold('Enabled trade accounts:')
msg += '\n'
for e in trade_mgr.exchanges:
msg += hcode(f' {e.name.title()}: ')
msg += ', '.join(a._credential.owner for a in e.accounts)
msg += '\n'
msg += '\n'
msg += hbold('Enabled trigger parts:')
msg += '\n'
for e in trigger_mgr.exchanges:
amounts = ', '.join(f'{k}: {v}%' for k, v in e._buy_amounts.items())
msg += hcode(f' {e.name.title()}({amounts}): ')
msg += ', '.join(type(p).__name__ for p in e._parts)
msg += '\n'
msg += '\n'
msg += hbold('Ignored coins: ')
msg += ', '.join(BaseTriggerExchange.EXCLUDED_COINS) + f', \'{BaseTriggerExchange.EXCLUDED_COINS_REGEX.pattern}\''
msg += '\n'
msg += '\n'
msg += text(hbold('Limit order markup:'), f'{settings.LIMIT_ORDER_MARKUP}%')
msg += '\n'
msg += '\n'
msg += text(hbold('Order cancel delay:'), f'{settings.ORDER_CANCEL_DELAY} seconds')
msg += '\n'
await tg_log.log(msg, True, False)
async def create_test(message: types.Message):
parts = message.text.split('*')
subject = parts[1].title()
answers = parts[2].lower()
tests_num = len(answers)
test_code = db.add_test(subject, answers, message.from_user.id, tests_num)
await message.answer(text(
hbold('✅Test bazaga qo`shildi!'),
f'Test kodi: {test_code}\nFan: {subject}\nSavollar soni: {tests_num} ta',
'Testda qatnashuvchilar quyidagi ko`rinishda javob yuborishlari mumkin:',
hcode(f'{test_code}*abcdab... ({tests_num} ta)'),
sep='\n\n'
))
async def send_invoice(message, state: FSMContext):
payment = Payment(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Оплатите не менее {amount:.2f} по номеру телефона или по адресу", "",
hlink(config.WALLET_QIWI, url=payment.invoice),
"И обязательно укажите ID платежа:",
hcode(payment.id)
]),
reply_markup=paid_keyboard)
await state.set_state("qiwi")
await state.update_data(payment=payment)
async def show_info(call: CallbackQuery):
user = await db.select_user(id=int(call.from_user.id))
if user == None:
await call.message.edit_text("Вас нет в базе данных\n"
"Сначла мы должны добавить вас в базу данных\n"
"Для этого нажмите на кнопку Добавить меня")
await call.message.edit_reply_markup(back_to_employee_menu)
else:
await call.message.edit_text(hcode("Имя: {name}\n"
"Штрафы: {fine}\n"
"Кол-во опоздавших дней: {charge}\n"
"Отмечался: {was_noted}\n"
"День: {day}".format(**user)))
await call.message.edit_reply_markup(back_to_employee_menu)
async def show_menu_parcel_size(message: types.Message, state: FSMContext):
chat_id = message.from_user.id
res_full_name = message.text
# print(len(res_full_name))
# if not re.match(r"([А-ЯЁ][а-яё]+[\-\s]?){3,}", res_full_name):
# await bot.send_sticker(chat_id, r"CAACAgIAAxkBAAEBV_hfY3oxV-wJjpmg-gY-tQ8vKTEPHgACCwADnP4yMPctMM3hxWgtGwQ")
# return await bot.send_message(chat_id,
# f"У ПІБ не може бути числових значень, або мати не коректний формат вводу\n"
# "Спробуйте ще раз 👇")
await state.update_data(res_full_name=res_full_name)
await message.answer(
hbold("Введіть номер телефону отримувача у форматі:") +
hcode("0501111111"),
parse_mode=types.ParseMode.HTML)
# await state.update_data(message_id1=mess_to_del['message_id'])
# print(mess_to_del)
await ParcelCreate.get_res_phone.set()
async def create_invoice_qiwi(call: CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
item_id = call.data.split(':')[-1]
item_id = int(item_id) - 1
item = items[item_id]
amount = item.price
payment = Payment(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Pay {amount:.2f} by phone number or address", "",
hlink(config.QIWI_WALLET, url=payment.invoice), "Your payment ID",
hcode(payment.id)
]),
reply_markup=paid_button)
await state.set_state("q_pay")
await state.update_data(payment=payment)
async def get_info(call: CallbackQuery):
info = await db.select_data(id=int(ADMINS[0]))
url = show(lat=info[1], lon=info[2])
await call.message.edit_text(
hcode("Начало работы: {start_time}\n"
"Допустимая минута: {allowed_time} мин\n"
"Штраф: {fine} сом\n"
"Увеличенный штрф: {increased_fine} сом\n"
"Кол-во дней: {charge}\n"
"Пароль = {password}".format(**info)))
location = await call.message.answer_location(info[1], info[2])
google_location = await call.message.answer(
"Мы на Google карте\n"
f"<a href='{url}'>Google</a>",
disable_web_page_preview=True)
await call.message.edit_reply_markup(back_to_manager_menu)
database_list.append(location)
database_list.append(google_location)
async def create_invoice(call: CallbackQuery, state: FSMContext):
await call.answer(cache_time=60)
item_id = int(call.data.split(":")[-1]) - 1
item = Maps[0]
amount = item.price
payment = PaymentForQiwi(amount=amount)
payment.create()
await call.message.answer("\n".join([
f"Оплатите не менее {amount:.1f} по номеру телефона или по адресу",
hlink(WALLET_QIWI, url=payment.invoice),
"Обязательно укажите ID платежа",
hcode(payment.id)
]),
reply_markup=paid_keyboard)
await state.set_state("qiwi")
await state.update_data(payment=payment)
async def process_start(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data["start_bitcart"] = core.defaults["start_bitcart"] if message.text == "default" else message.text
try:
await bot.send_message(message.chat.id, "Starting installation, please wait...")
kwargs = {key: data[key] for key in core.texts if key in data}
kwargs["print_func"] = functools.partial(print, file=open(os.devnull, "w"))
kwargs.pop("onedomain_mode", None)
core.connect(**kwargs)
if core.verify_install_bitcart(data["start_bitcart"]):
await bot.send_message(message.chat.id, "Successfully started bitcart!")
else:
await bot.send_message(message.chat.id, "Successfully installed bitcart!")
except Exception:
await bot.send_message(
message.chat.id,
"Error connecting to server/installing.\n" + hcode(traceback.format_exc().splitlines()[-1]),
)
data.state = None
async def confirm_handler(call: CallbackQuery, state: FSMContext):
await call.message.delete()
data = await state.get_data()
token_sender = data['token_sender']
poshtomat_id_ref = data['poshtomatIDRef']
parcel_id_in = data['parcel_id_in']
parcel_num = data['parcel_num']
trans_id = data['trans_id']
result = customer_insert_conform(
token_sender, poshtomat_id_ref, parcel_id_in,
trans_id) # Функция подтверждения вложения
print(result)
await call.message.answer(call.from_user.first_name + hbold(
",Ваше відправлення номер: "
) + hcode(parcel_num) + hbold(
"відправлене!\nДякуємо Вам за користування послугами компанії Meest"),
reply_markup=menu_uk_kb_show)
print("ПОСЫЛКА УСПЕШНО ОТПРАВЛЕНА!!")
await state.finish()
