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."
