async def send_order_button(call: types.CallbackQuery, state: FSMContext, callback_data: dict): mes = config.adminMessage["order_missing"] order = orderModel.get_order(callback_data.get("id")) keyboard = None if order and not order.active: mes = config.adminMessage["order_completed"] elif order: PRICE = types.LabeledPrice(label="Работа на заказ", amount=int(order.price / 2) * 100) secret_key = hashlib.md5("{nameProduct}{time}".format( nameProduct="Работа на заказ", time=time.time()).encode()) await bot.send_message(order.userID, config.payMessage["payment_two"]) await bot.send_invoice(chat_id=order.userID, title=config.payMessage["title"], description=config.payMessage["description"], provider_token=config.PAYMENT_TOKEN, currency=config.currency, is_flexible=False, prices=[PRICE], start_parameter='time-machine-example', payload=secret_key.hexdigest()) order.set_paymentKey_order(secret_key.hexdigest()) paymentModel.create_payment(call.from_user.id, order.description, order.document, order.separate_payment, order.price / 2, secret_key.hexdigest(), True) mes = "Отправленно" await call.message.answer(mes) await menu_info_order(callback_data.get("id"), call.message) await call.message.delete()
async def chek_shop(msg: types.Message): name = price_select.Conncet() for items in name: if msg.text == items: await bot.send_message(msg.from_user.id, conf.TestPay) select_price = price_select.Select_price(items) for sp in select_price: name = sp[0] description = sp[1] amount = sp[2] link_photo = sp[3] if conf.PAY_PROVIDER_TOKEN.split(':')[1] == 'TEST': await bot.send_invoice( msg.chat.id, title=name, description=description, provider_token=conf.PAY_PROVIDER_TOKEN, currency='rub', photo_url=link_photo, photo_height=512, # !=0/None, иначе изображение не покажется photo_width=512, photo_size=512, is_flexible= False, # True если конечная цена зависит от способа доставки prices=[types.LabeledPrice(label=name, amount=amount)], start_parameter='time-machine-example', payload='some')
async def pay(call: CallbackQuery, state: FSMContext): data = await state.get_data() if call.data == 'Наличные': await call.message.answer('С какой суммы подготовить сдачу?') await Confirm.cash.set() if call.data == 'Терминал': await call.message.answer( 'Заказ принят! Приедем к вам с терминалом.\n' 'Скоро с вами свяжемся и сообщим время доставки' ) await information_admin(state=state, chat_id=call.message.chat.id, payment_method=call.data) await state.update_data(chat_id=call.message.chat.id) if call.data == 'Онлайн': cart = data.get('cart') text = 'Ваш заказ:\n\n' prices = 0 for purchase in cart: text += f'{purchase.product.name} {purchase.quantity} шт. - {purchase.price * purchase.quantity} руб.\n' prices += purchase.price * purchase.quantity text += f'\nИтоговая стоимость заказа: {prices} руб' PRICE = types.LabeledPrice(label='Покупка', amount=prices * 100) await bot.send_invoice( call.message.chat.id, title='Ваша корзина', description=text, provider_token=settings.PAYMENTS_PROVIDER_TOKEN, currency='rub', is_flexible=False, # True если конечная цена зависит от способа доставки prices=[PRICE], start_parameter='time-machine-example', payload='some-invoice-payload-for-our-internal-use') await Confirm.payments.set()
async def subscribe_continue_pay(callback: types.CallbackQuery, state: FSMContext): """Продлить подписку после её окончания""" await callback.answer() user = DataBaseFunc.get_user(callback.from_user.id) course = DataBaseFunc.get_course(user.course_id) timestamp = get_timestamp(user) PRICE = types.LabeledPrice(label=course.name, amount=int(f"{course.cost}00")) await state.update_data(last_course_id=user.course_id) mess = await bot.send_invoice( callback.message.chat.id, title=course.name, description=course.description, provider_token=TOKEN_SHOP_YANDEX, currency="rub", is_flexible=False, prices=[PRICE], start_parameter=f"course_id_{course.id}", payload=timestamp, # reply_markup=UserGeneratorKeyboard.course_back_in_list(user) # start_parameter = f"lol-lel-cheburek", # payload = "test-payload-check" ) await DataBaseFunc.delete_messages(user) ms = Message(user_id=user.id, message_id=mess.message_id) DataBaseFunc.add(ms)
async def subscribe_menu_choose_course(callback: types.CallbackQuery, state: FSMContext): """Отправляет чек для оплаты выбраноого курса""" user = DataBaseFunc.get_user(callback.from_user.id) if (TOKEN_SHOP_YANDEX.split(':')[1] == "TEST"): await callback.message.edit_text( text=get_text(user, 'subscribe_menu_test_payments')) course = DataBaseFunc.get_course(int(callback.data[20:])) timestamp = get_timestamp(user) PRICE = types.LabeledPrice(label=course.name, amount=int(f"{course.cost}00")) await state.update_data(last_course_id=int(callback.data[20:])) await bot.send_invoice( callback.message.chat.id, title=course.name, description=course.description, provider_token=TOKEN_SHOP_YANDEX, currency="rub", is_flexible=False, prices=[PRICE], start_parameter=f"course_id_{course.id}", payload=timestamp, # reply_markup=UserGeneratorKeyboard.course_back_in_list(user) # start_parameter = f"lol-lel-cheburek", # payload = "test-payload-check" )
async def send_donate_invoice(user_id: int, amt: int) -> None: await bot.send_invoice(chat_id=user_id, title="On9 Word Chain Bot Donation", description="Support bot development", payload=f"on9wordchainbot_donation:{user_id}", provider_token=PROVIDER_TOKEN, start_parameter="donate", currency="HKD", prices=[types.LabeledPrice("Donation", amt)])
def get_basket_price(usr_id): conn = sqlite3.connect("data.db") cursor = conn.cursor() cursor.execute('''SELECT * FROM users WHERE _id = ? LIMIT 1''', (usr_id,)) products = make_dict(cursor.fetchall()[0][3]) conn.commit() names = list(products.keys()) total_price = 0 for i in range(len(products)): name = names[i] price = products[name][1] total_price += price * int(products[name][0]) total_price = types.LabeledPrice(label='корзина', amount=total_price * 100) return total_price
async def process_shipping(shipping_query: types.ShippingQuery) -> None: shipping_options = [ types.ShippingOption( id, _(title), prices=[ types.LabeledPrice(_(label), to_telegram_price(price)) for label, price in prices ], ) for id, title, prices in settings.SHIPPING_OPTIONS ] await bot.answer_shipping_query(shipping_query.id, ok=True, shipping_options=shipping_options)
async def process_key_1(message: types.Message): price = price_select.select_price() print(price['amount']) await bot.send_photo(message.from_user.id, photo=price['file']) if conf.PAY_PROVIDER_TOKEN.split(':')[1] == 'TEST': await bot.send_invoice( message.chat.id, title=price['name'], description=price['description'], provider_token=conf.PAY_PROVIDER_TOKEN, currency='rub', is_flexible= False, # True если конечная цена зависит от способа доставки prices=[ types.LabeledPrice(label=price['name'], amount=price['amount']) ], start_parameter='time-machine-example', payload='some')
async def handle_payment(callback_query: types.CallbackQuery): user_id = callback_query.message.chat.id goods_price = moltin_aps.get_cart( f'tg-{user_id}')['meta']['display_price']['with_tax']['amount'] delivery_price = callback_query.data.split(',')[1] total_price = goods_price + int(delivery_price) date = int(callback_query.message.date.timestamp()) await bot.send_invoice( user_id, title='Оплата заказа', description='Тестовая оплата заказа', provider_token=os.environ['TG_BOT_PAYMENT_TOKEN'], currency='rub', prices=[types.LabeledPrice(label='rub', amount=total_price * 100)], start_parameter=f'{user_id}-{date}', payload=f'payment-{user_id}-{date}-{total_price}') await callback_query.answer('Оплатите заказ') await callback_query.message.edit_reply_markup() return 'WAITING_ADDRESS'
async def message_send_yes(call: types.CallbackQuery, state: FSMContext): await call.answer(cache_time=2) mes = "Все пропало (((" data = await state.get_data() order = ordersProcessingModel.get_order_provisional(data.get("orderID")) if order and not order.active: mes = config.adminMessage["order_completed"] elif order: amount = int(data.get("price")) - ( int(data.get("price")) / 100 * order.discount if order.percent and order.discount != 0 else order.discount) amount = int(amount) amount = amount if order.separate_payment else int( amount - (amount / 100 * config.discount_full_payment)) if amount < 100: await state.finish() await call.message.edit_text( "Вышла сумма меньше 100р.\nОтправка отменена") return PRICE = types.LabeledPrice( label="Работа на заказ", amount=(int(amount / 2) if order.separate_payment else amount) * 100) secret_key = hashlib.md5("{nameProduct}{time}".format( nameProduct="Работа на заказ", time=time.time()).encode()) await bot.send_invoice(chat_id=order.userID, title=config.payMessage["title"], description=config.payMessage["description"], provider_token=config.PAYMENT_TOKEN, currency=config.currency, is_flexible=False, prices=[PRICE], start_parameter='time-machine-example', payload=secret_key.hexdigest()) paymentModel.create_payment(call.from_user.id, order.text, order.document, order.separate_payment, amount, secret_key.hexdigest(), False) order.updateActive_order() mes = config.adminMessage["message_yes_send"] await state.finish() await call.message.edit_text(mes)
async def play_bt(callback: types.CallbackQuery): await callback.answer() user = Datafunc.get_user(callback.from_user.id) if (user.is_payed) == True or (user.id in ADMINS_ID): await callback.message.answer( text=TEXTS["thanks"], reply_markup=UserGenerationKeyboard.game_bt()) else: if PAY_TOKEN.split(':')[1] == 'TEST': await callback.message.answer( 'Для оплаты используйте данные тестовой карты: 1111 1111 1111 1026, 12/22, CVC 000.' ) price = types.LabeledPrice(label='Malibu Party Bot', amount=20000) await bot.send_invoice(callback.message.chat.id, title='Malibu Party Bot', description='Игра остается с вами навсегда', provider_token=PAY_TOKEN, currency="rub", prices=[price], start_parameter='eto_start_parametr', payload=datetime.datetime.now().timestamp())
async def pay_finishing(q: types.CallbackQuery): if q.data == "pay_process": if config.payment_method == "Simple": for e in config.cart: e.is_ordered = True e.save() await BotStateMachine.main_menu.set() await bot.send_message(q.from_user.id, "Wait for call", reply_markup=getMainMenuKeyboard()) elif config.payment_method == "LiqPay": prices = [] uniq_id = "" getCurrentUserCart() description = "" for e in config.cart: uniq_id += str(e.id) #*100 because cost in 0.01 uah price = types.LabeledPrice(e.menu_element.name, int(e.count * e.menu_element.cost * 100)) prices.append(price) description += e.menu_element.name + "\n" await bot.send_invoice( q.message.chat.id, title="Shop payment", description=description, provider_token=config.pay_token, currency="uah", prices=prices, start_parameter="start-parameter-buy", payload=uniq_id[0:64] ) elif q.data == "pay_clear_info": config.user.phone = "" await BotStateMachine.buy_selectMethod.set() await bot.send_message(q.from_user.id, "Select payment method", reply_markup=paymentKeyboard())
async def answer_product_invoice( message: types.Message, state: FSMContext, locale: str, product_index: int, product_filters: ProductFilters, product_size_id: int, ) -> None: product = await get_product(state, product_index, product_filters) product_identifier = (CallbackForm(str(product_index)) + product_filters.as_query_string() + str(product_size_id)).callback_string payload = json.dumps( (product_index, product_filters.as_query_string(), product_size_id)) await bot.send_invoice( message.chat.id, f"{product.name} {product.code}", emojize(texts.INVOICE_DESCRIPTION.value), payload, provider_token=settings.PAYMENTS_PROVIDER_TOKEN, start_parameter=encode_parameter(product_identifier), currency=product.price_currency, prices=[ types.LabeledPrice(_("Price"), to_telegram_price(int(product.price))) ], photo_url=product.main_picture.thumbnail, photo_height=150, photo_width=200, need_name=True, need_phone_number=True, need_shipping_address=True, is_flexible=True, reply_markup=get_invoice_keyboard(product, locale), )
PAYMENTS_PROVIDER_TOKEN = os.environ['PAYMENTS_PROVIDER_TOKEN'] DATABASE_URL = os.environ['DATABASE_URL'] pool = None # Configure logging logging.basicConfig(level=logging.INFO) # Initialize bot and dispatcher bot = Bot(token=API_TOKEN) dp = Dispatcher(bot) update_time = 0 # Setup prices prices = [ types.LabeledPrice(label='Продление подписки на месяц', amount=10000), ] async def update_status(alert, status, chat_id, error=None): db = await asyncpg.connect(DATABASE_URL) await db.execute('''UPDATE ALERTS SET status=$1 WHERE id=$2''', *[ status, alert[0], ]) if error: await db.execute('''UPDATE ALERTS SET latest_error=$1 WHERE id=$2''', *[ str(error).replace('\n', ' '), alert[0], ])
def get_prices(name, amount): prices = [types.LabeledPrice(label=name, amount=amount)] return prices
from aiogram import types def get_prices(name, amount): prices = [types.LabeledPrice(label=name, amount=amount)] return prices POST_REG_SHIPPING = types.ShippingOption( id="post_reg", title="Почтой", prices=[ types.LabeledPrice("Обычная коробка", 10), types.LabeledPrice("Почтой обычной", 1000_00) ]) POST_FAST_SHIPPING = types.ShippingOption( id="post_fast", title="Почтой FAST", prices=[ types.LabeledPrice("Прочная коробка", 1000_00), types.LabeledPrice("Почтой срочной", 3000_00) ]) PICKUP_SHIPPING = types.ShippingOption( id="pickup", title="Самовывоз", prices=[types.LabeledPrice("Самовывоз", -100_00)])
def get_price(months): price = prices[months] p = [types.LabeledPrice(label=price['label'], amount=price['amount'])] return p
amount=17_00_00), LabeledPrice(label="Доставка", amount=10_00), LabeledPrice(label="Скидка", amount=-30_00), LabeledPrice(label="НДС", amount=30_00), ], need_shipping_address=True, start_parameter="create_invoice_macbook_pro_13", photo_url= "https://content2.onliner.by/catalog/device/main@2/8b2f2c3c18c6102c0537aaf5cea17561.jpeg", photo_size=600, is_flexible=True) POST_REGULAR_SHIPPING = types.ShippingOption( id='post_reg', title='Почтой', prices=[ types.LabeledPrice('Обычная коробка', 0), types.LabeledPrice('Почтой обычной', 10_00), ]) POST_FAST_SHIPPING = types.ShippingOption( id='post_fast', title='Почтой (vip)', prices=[ types.LabeledPrice('Супер прочная коробка', 10_00), types.LabeledPrice('Почтой срочной - DHL (3 дня)', 30_00), ]) PICKUP_SHIPPING = types.ShippingOption( id='pickup', title='Самовывоз', prices=[types.LabeledPrice('Самовывоз из магазина', -10_00)])
from aiogram.types.message import ContentType from messages import MESSAGES from config import BOT_TOKEN, PAYMENTS_PROVIDER_TOKEN, TIME_MACHINE_IMAGE_URL logging.basicConfig( format= u'%(filename)+13s [ LINE:%(lineno)-4s] %(levelname)-8s [%(asctime)s] %(message)s', level=logging.INFO) loop = asyncio.get_event_loop() bot = Bot(BOT_TOKEN, parse_mode=types.ParseMode.MARKDOWN) dp = Dispatcher(bot, loop=loop) # Setup prices PRICE = types.LabeledPrice(label='Настоящая Машина Времени', amount=4200000) @dp.message_handler(commands=['terms']) async def process_terms_command(message: types.Message): await message.reply(MESSAGES['terms'], reply=False) @dp.message_handler(commands=['buy']) async def process_buy_command(message: types.Message): if PAYMENTS_PROVIDER_TOKEN.split(':')[1] == 'TEST': await bot.send_message(message.chat.id, MESSAGES['pre_buy_demo_alert']) await bot.send_invoice( message.chat.id, title=MESSAGES['tm_title'],
from aiogram import types from aiogram.utils import executor from aiogram.dispatcher import Dispatcher import config BOT_TOKEN = config.telegram_token PAYMENTS_PROVIDER_TOKEN = '123456789:TEST:1234567890abcdef1234567890abcdef' loop = asyncio.get_event_loop() bot = Bot(BOT_TOKEN) dp = Dispatcher(bot, loop=loop) # Setup prices prices = [ types.LabeledPrice(label='Working Time Machine', amount=5750), types.LabeledPrice(label='Gift wrapping', amount=500) ] # Setup shipping options shipping_options = [ types.ShippingOption(id='instant', title='WorldWide Teleporter').add( types.LabeledPrice('Teleporter', 1000)), types.ShippingOption(id='pickup', title='Local pickup').add( types.LabeledPrice('Pickup', 300)) ] @dp.message_handler(commands=['start']) async def cmd_start(message: types.Message): await bot.send_message(
from messages import MESSAGES from config import BOT_TOKEN, PAYMENTS_PROVIDER_TOKEN, TIME_MACHINE_IMAGE_URL logging.basicConfig( format= u'%(filename)+13s [ LINE:%(lineno)-4s] %(levelname)-8s [%(asctime)s] %(message)s', level=logging.INFO) loop = asyncio.get_event_loop() bot = Bot(BOT_TOKEN, parse_mode=types.ParseMode.MARKDOWN) dp = Dispatcher(bot, loop=loop) # Setup prices PRICES = [ types.LabeledPrice(label='Настоящая Машина Времени', amount=4200000), types.LabeledPrice(label='Подарочная упаковка', amount=30000) ] # Setup shipping options TELEPORTER_SHIPPING_OPTION = types.ShippingOption( id='teleporter', title='Всемирный* телепорт').add(types.LabeledPrice('Телепорт', 1000000)) RUSSIAN_POST_SHIPPING_OPTION = types.ShippingOption(id='ru_post', title='Почтой России') RUSSIAN_POST_SHIPPING_OPTION.add( types.LabeledPrice('Деревянный ящик с амортизирующей подвеской внутри', 100000)) RUSSIAN_POST_SHIPPING_OPTION.add(
format= u'%(filename)+13s [ LINE:%(lineno)-4s] %(levelname)-8s [%(asctime)s] %(message)s', level=logging.INFO) # инициализируем бота bot = Bot(token=config.API_TOKEN) dp = Dispatcher(bot) # инициализируем соединение с БД db = SQLighter('db.db') # инициализируем парсер sg = lsg() all_id = sg.all_id() PRICE = types.LabeledPrice(label='Донат', amount=420) # PAY платёж ------------------------------------------------------------------ @dp.message_handler(commands=['buy']) async def process_buy_command(message: types.Message): if PAYMENTS_PROVIDER_TOKEN.split(':')[1] == 'TEST': await bot.send_message(message.chat.id, MESSAGES['pre_buy_demo_alert']) await bot.send_invoice( message.chat.id, title=MESSAGES['donat_title'], description=MESSAGES['donat_description'], provider_token=PAYMENTS_PROVIDER_TOKEN, currency='eur', photo_url=TIME_MACHINE_IMAGE_URL,
from aiogram.types.message import ContentType from aiogram.utils.markdown import text, bold, italic, code, pre from aiogram.types import ParseMode, InputMediaPhoto, InputMediaVideo, ChatActions from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.contrib.middlewares.logging import LoggingMiddleware from utils import TestStates import keyboards as kb from config import TOKEN, PAY_TOKEN loop = asyncio.get_event_loop() bot = Bot(token=TOKEN) dp = Dispatcher(bot, storage=MemoryStorage(), loop=loop) dp.middleware.setup(LoggingMiddleware()) PRICES = [ types.LabeledPrice(label='Machine time', amount=4200000), types.LabeledPrice(label='holiday packaging', amount=30000) ] TELEPORT_SHIPPING_OPTION = types.ShippingOption( id='teleporter', title='Wold teleport').add(types.LabeledPrice('teleport', 1000000)) RUSSIAN_POST_SHIPPING_OPTION = types.ShippingOption( id='ru_post', title='Russian post').add( types.LabeledPrice('Wooden box with shock absorbing suspension inside', 100000)).add( types.LabeledPrice( 'Urgent departure (5-10 days)', 500000)) PICKUP_SHIPPING_OPTION = types.ShippingOption(id='pickup', title='pickup').add(
async def shipping(shipping_query: types.ShippingQuery): await bot.answer_shipping_query(shipping_query.id, ok=True, shipping_options=[ types.ShippingOption(id='instant', title='VIP доставка').add(types.LabeledPrice('VIP', 100000)), types.ShippingOption(id='pickup', title='Стандартная доставка').add(types.LabeledPrice('classic', 30000))], error_message='Произошла ошибка')
from datetime import datetime from aiogram import types from aiogram.types import ContentType from data.config import PAYMENTS_PROVIDER_TOKEN from loader import dp, PAYMENTS_TABLE PRICES_FOR_NEW_USER = [ types.LabeledPrice(label='Подписка на месяц, как новому пользователю', amount=9900) ] PRICES = [types.LabeledPrice(label='Подписка на месяц', amount=19700)] @dp.message_handler(commands=['buy']) async def payment_process(message: types.Message): """Payment process, and send invoice""" if not PAYMENTS_TABLE.exist_user(chat_id=message.from_user.id): await dp.bot.send_invoice( message.from_user.id, title='Новому пользователю', description='Для новых пользователей первый месяц скидка', provider_token=PAYMENTS_PROVIDER_TOKEN, currency='rub', need_email=True, need_phone_number=True, is_flexible=False, prices=PRICES_FOR_NEW_USER,
from aiogram import types from typing import Union from aiogram.dispatcher import FSMContext from aiogram.types.message import ContentTypes from aiogram.types import CallbackQuery from loader import dp, db, bot import time from utils.keyboards.paymentKey import payMark, markone, markfive, markten from database.config import PAYMENTS_PROVIDER_TOKEN, admin_id from utils.files.profilePic import prof from utils.keyboards.profileKey import profMark from datetime import datetime, date, time pricesOne = [ types.LabeledPrice(label='1 прогноз', amount=15000), ] pricesFive = [ types.LabeledPrice(label='3 прогноза', amount=30000), ] pricesTen = [ types.LabeledPrice(label='5 прогнозов', amount=50000), ] @dp.callback_query_handler(text='buy_one') async def put_money1(call: types.CallbackQuery): chat, mess = call.from_user.id, call.message.message_id dt = datetime.now() tmp = 1 await db.tmpCount(tmp, chat) await bot.send_invoice(
from aiogram import Bot from aiogram import types from aiogram.dispatcher import Dispatcher from aiogram.utils import executor BOT_TOKEN = 'BOT TOKEN HERE' PAYMENTS_PROVIDER_TOKEN = '123456789:TEST:1234567890abcdef1234567890abcdef' loop = asyncio.get_event_loop() bot = Bot(BOT_TOKEN) dp = Dispatcher(bot, loop=loop) # Setup prices prices = [ types.LabeledPrice(label='Working Time Machine', amount=5750), types.LabeledPrice(label='Gift wrapping', amount=500) ] # Setup shipping options shipping_options = [ types.ShippingOption(id='instant', title='WorldWide Teleporter').add(types.LabeledPrice('Teleporter', 1000)), types.ShippingOption(id='pickup', title='Local pickup').add(types.LabeledPrice('Pickup', 300)) ] @dp.message_handler(commands=['start']) async def cmd_start(message: types.Message): await bot.send_message(message.chat.id, "Hello, I'm the demo merchant bot." " I can sell you a Time Machine."