async def photo_message(message: types.Message):
photo_path = 'photos/' + str(message.message_id) + '.jpg'
await message.photo[-1].download(photo_path)
await message.reply('Wait a sec...')
embedding = get_face_descriptor(photo_path)
if embedding is None:
await bot.delete_message(message.chat.id, message.message_id + 1)
await message.reply(
"I can't find a face in this photo, try to send another")
# Перемещаем фотографии без лица в отдельную папку
os.rename(photo_path, f'photos/withoutface/{message.message_id}.jpg')
return
ids, _ = index.knnQuery(embedding, k=3)
urls = [
get_url_of_face_with_id(ids[0]),
get_url_of_face_with_id(ids[1]),
get_url_of_face_with_id(ids[2])
]
url_names = []
for url in urls:
url_names.append(get_name_for_url(url))
await bot.delete_message(message.chat.id, message.message_id + 1)
await message.reply('Most similar people\'s:\n\n'+ link(url_names[0],urls[0]) + '\n\n' \
+ link(url_names[1],urls[1]) + '\n\n' + link(url_names[2],urls[2]), \
parse_mode = ParseMode.MARKDOWN)
await message.reply('If you wanna try again, just send me a photo')
async def full_card_number_sent(call: types.CallbackQuery, offer: EscrowOffer):
"""Confirm that full card number is sent and ask for first and last 4 digits."""
await offer.update_document(
{"$set": {
"pending_input_from": call.from_user.id
}})
await call.answer()
if call.from_user.id == offer.init["id"]:
counter = offer.counter
await tg.send_message(
counter["id"],
i18n("ask_address {currency}").format(currency=offer.buy))
await tg.send_message(
call.message.chat.id,
i18n("exchange_continued {user}").format(
user=markdown.link(counter["mention"],
User(id=counter["id"]).url)),
parse_mode=ParseMode.MARKDOWN,
)
await offer.update_document(
{"$set": {
"pending_input_from": counter["id"]
}})
counter_state = FSMContext(dp.storage, counter["id"], counter["id"])
await counter_state.set_state(states.Escrow.receive_address.state)
await states.Escrow.receive_card_number.set()
else:
await tg.send_message(
call.message.chat.id,
i18n("send_first_and_last_4_digits_of_card_number {currency}").
format(currency=offer.sell if offer.type == "buy" else offer.buy),
)
await states.Escrow.receive_card_number.set()
async def start_cmd_handler(message: types.Message):
support_chat_url = link("сюда", "https://t.me/miptonelove")
welcome_message = f"Приветик\!\nПросто выбери семестр и набери номер задачи\.\nЕсли вам есть что сказать \- пишите {support_chat_url}\."
message_to_pin = await bot.send_message(
message.from_user.id,
welcome_message,
reply_markup=change_sem_keyboard(),
parse_mode="MarkdownV2",
)
await bot.pin_chat_message(chat_id=message_to_pin.chat.id,
message_id=message_to_pin.message_id)
async def cmd_about(message: types.Message):
# In this function markdown utils are userd for formatting message text
return SendMessage(message.chat.id,
text(bold('Hi! I\'m just a simple telegram bot.'),
'',
text(
'With',
link(text,
'https://github.com/aiogram/aiogram')),
sep='\n'),
parse_mode=ParseMode.MARKDOWN)
async def full_card_number_message(message: types.Message, offer: EscrowOffer):
"""React to sent message while sending full card number to fiat sender."""
if message.from_user.id == offer.init["id"]:
user = offer.counter
else:
user = offer.init
mention = markdown.link(user["mention"], User(id=user["id"]).url)
await tg.send_message(
message.chat.id,
i18n("wrong_full_card_number_receiver {user}").format(user=mention),
parse_mode=ParseMode.MARKDOWN,
)
def get_user_link(user_id: Union[str, int], text: Optional[str] = None) -> str:
"""
Get markdown link on a user
Used in the admin's block commands
:param user_id: user's id
:param text: text of the link
:returns: link
"""
if not text:
text = user_id
return link(str(text), f"tg://user?id={user_id}")
def _status_to_md_row(status_record):
status_emoji = replace_emoji(status_record['status'])
name = escape_md(status_record['name'])
timestamp = escape_md(status_record['timestamp'])
url = status_record['details_url']
if url:
timestamp = link(timestamp, url)
else:
timestamp = f'`{timestamp or "n/a"}`'
if 'error' in status_record:
details = f'{name}\n{escape_md(status_record["error"])}'
else:
details = rf'{name} \({timestamp}\)'
return f'{status_emoji} — {details}'
async def cmd_about(message: types.Message):
# In this function markdown utils are userd for formatting message text
return SendMessage(message.chat.id,
text(bold('Hi! I\'m just a simple telegram bot.'),
'',
text('I\'m powered by',
bold('Python',
Version(*sys.version_info[:]))),
text(
'With',
link(text('aiogram', aiogram.VERSION),
'https://github.com/aiogram/aiogram')),
sep='\n'),
parse_mode=ParseMode.MARKDOWN)
async def cmd_about(message: types.Message):
# In this function used markdown utils for formatting message text
return SendMessage(message.chat.id,
text(
bold('Hi! I\'m simple telegram bot.'),
'',
text('I\'m worked on',
bold('Python', Version(*sys.version_info[:]))),
text(
'With',
link(text('aiogram', aiogram.VERSION),
'https://bitbucket.org/illemius/aiogram')),
sep='\n'),
parse_mode=ParseMode.MARKDOWN)
async def validate_offer(call: types.CallbackQuery, offer: EscrowOffer):
"""Ask support for manual verification of exchange."""
if offer.type == "buy":
sender = offer.counter
receiver = offer.init
currency = offer.sell
elif offer.type == "sell":
sender = offer.init
receiver = offer.counter
currency = offer.buy
escrow_instance = get_escrow_instance(offer.escrow)
answer = "{0}\n{1} sender: {2}{3}\n{1} receiver: {4}{5}\nBank: {6}\nMemo: {7}"
answer = answer.format(
markdown.link("Unconfirmed escrow.",
escrow_instance.trx_url(offer.trx_id)),
currency,
markdown.link(sender["mention"],
User(id=sender["id"]).url),
" ({})".format(sender["name"]) if "name" in sender else "",
markdown.link(receiver["mention"],
User(id=receiver["id"]).url),
" ({})".format(receiver["name"]) if "name" in receiver else "",
offer.bank,
markdown.code(offer.memo),
)
await tg.send_message(config.SUPPORT_CHAT_ID,
answer,
parse_mode=ParseMode.MARKDOWN)
await offer.delete_document()
await call.answer()
await tg.send_message(
call.message.chat.id,
i18n("request_validation_promise"),
reply_markup=start_keyboard(),
)
async def send_new_post(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
data = json_methods.read(DB_PATH)
message_text = data['user_id'][str(
callback_query.from_user.id)]['head'] + '\n\n' + data['user_id'][str(
callback_query.from_user.id)]['body']
await bot.send_photo(config.CHANEL_ID,
data['user_id'][str(
callback_query.from_user.id)]['photo_id'],
caption=message_text)
message_text = text('Готово, ваш пост был отправлен в ' +
link('канал', config.CHANEL_URL) +
'Хотите создать еще один пост?')
await bot.send_message(callback_query.from_user.id,
message_text,
reply_markup=keyboards.creation_agreement_kb,
parse_mode=ParseMode.MARKDOWN)
async def complete_offer(call: types.CallbackQuery, offer: EscrowOffer):
"""Release escrow asset and finish exchange."""
if offer.type == "buy":
recipient_user = offer.counter
sender_user = offer.init
amount = offer.sum_buy.to_decimal() # type: ignore
elif offer.type == "sell":
recipient_user = offer.init
sender_user = offer.counter
amount = offer.sum_sell.to_decimal() # type: ignore
sum_fee_up = offer.sum_fee_up.to_decimal() # type: ignore
sum_fee_down = offer.sum_fee_down.to_decimal() # type: ignore
await call.answer(i18n("escrow_completing"))
escrow_instance = get_escrow_instance(offer.escrow)
trx_url = await escrow_instance.transfer(
recipient_user["receive_address"],
sum_fee_down,
offer.escrow,
memo=create_memo(offer, transfer=True),
)
if sender_user["send_address"] != recipient_user["receive_address"]:
add_cashback(offer.escrow, amount, sum_fee_up, sum_fee_down,
sender_user, recipient_user)
answer = i18n("escrow_completed", locale=sender_user["locale"])
recipient_answer = i18n("escrow_completed",
locale=recipient_user["locale"])
recipient_answer += " " + markdown.link(
i18n("escrow_sent {amount} {currency}",
locale=recipient_user["locale"]).format(amount=amount,
currency=offer.escrow),
trx_url,
)
await offer.delete_document()
await tg.send_message(
recipient_user["id"],
recipient_answer,
reply_markup=start_keyboard(),
parse_mode=ParseMode.MARKDOWN,
)
await tg.send_message(sender_user["id"],
answer,
reply_markup=start_keyboard())
async def claim_transfer_custom_address(message: types.Message,
state: FSMContext):
"""Transfer cashback to custom address."""
data = await state.get_data()
await tg.send_message(message.chat.id, i18n("claim_transfer_wait"))
try:
trx_url = await transfer_cashback(message.from_user.id,
data["currency"], message.text)
except TransferError:
await tg.send_message(message.chat.id, i18n("cashback_transfer_error"))
else:
await tg.send_message(
message.chat.id,
markdown.link(i18n("cashback_transferred"), trx_url),
parse_mode=ParseMode.MARKDOWN,
reply_markup=start_keyboard(),
)
async def errors_handler(update: types.Update, exception: Exception):
"""Handle exceptions when calling handlers.
Send error notification to special chat and warn user about the error.
"""
if isinstance(exception, MessageNotModified):
return True
log.error("Error handling request {}".format(update.update_id),
exc_info=True)
chat_id = None
if update.message:
update_type = "message"
from_user = update.message.from_user
chat_id = update.message.chat.id
if update.callback_query:
update_type = "callback query"
from_user = update.callback_query.from_user
chat_id = update.callback_query.message.chat.id
if chat_id is not None:
try:
exceptions_chat_id = config.EXCEPTIONS_CHAT_ID
except AttributeError:
pass
else:
await tg.send_message(
exceptions_chat_id,
"Error handling {} {} from {} ({}) in chat {}\n{}".format(
update_type,
update.update_id,
markdown.link(from_user.mention, from_user.url),
from_user.id,
chat_id,
markdown.code(traceback.format_exc(limit=-3)),
),
parse_mode=types.ParseMode.MARKDOWN,
)
await tg.send_message(
chat_id,
i18n("unexpected_error"),
reply_markup=start_keyboard(),
)
return True
async def claim_transfer(call: types.CallbackQuery):
"""Transfer cashback to suggested address."""
_, currency, address = call.data.split()
await call.answer(i18n("claim_transfer_wait"), show_alert=True)
try:
trx_url = await transfer_cashback(call.from_user.id, currency, address)
except TransferError:
await tg.send_message(
call.message.chat.id,
i18n("cashback_transfer_error"),
reply_markup=start_keyboard(),
)
else:
await tg.send_message(
call.message.chat.id,
markdown.link(i18n("cashback_transferred"), trx_url),
reply_markup=start_keyboard(),
parse_mode=ParseMode.MARKDOWN,
)
async def send_message_to_support(message: types.Message):
"""Format message and send it to support.
Envelope emoji at the beginning is the mark of support ticket.
"""
if message.from_user.username:
username = "******" + message.from_user.username
else:
username = markdown.link(message.from_user.full_name,
message.from_user.url)
await tg.send_message(
config.SUPPORT_CHAT_ID,
emojize(":envelope:") +
f" #chat\\_{message.chat.id} {message.message_id}\n{username}:\n" +
markdown.escape_md(message.text),
parse_mode=types.ParseMode.MARKDOWN,
)
await tg.send_message(
message.chat.id,
i18n("support_response_promise"),
reply_markup=start_keyboard(),
)
async def set_init_send_address(address: str, message: types.Message,
offer: EscrowOffer):
"""Set ``address`` as sender's address of initiator.
Send offer to counteragent.
"""
locale = offer.counter["locale"]
buy_keyboard = InlineKeyboardMarkup()
buy_keyboard.row(
InlineKeyboardButton(i18n("show_order", locale=locale),
callback_data=f"get_order {offer.order}"))
buy_keyboard.add(
InlineKeyboardButton(i18n("accept", locale=locale),
callback_data=f"accept {offer._id}"),
InlineKeyboardButton(i18n("decline", locale=locale),
callback_data=f"decline {offer._id}"),
)
mention = markdown.link(offer.init["mention"],
User(id=offer.init["id"]).url)
answer = i18n(
"escrow_offer_notification {user} {sell_amount} {sell_currency} "
"for {buy_amount} {buy_currency}",
locale=locale,
).format(
user=mention,
sell_amount=offer.sum_sell,
sell_currency=offer.sell,
buy_amount=offer.sum_buy,
buy_currency=offer.buy,
)
if offer.bank:
answer += " " + i18n("using {bank}",
locale=locale).format(bank=offer.bank)
answer += "."
update_dict = {"init.send_address": address}
if offer.type == "sell":
insured = await get_insurance(offer)
update_dict["insured"] = Decimal128(insured)
if offer[f"sum_{offer.type}"].to_decimal() > insured:
answer += "\n" + i18n(
"exceeded_insurance {amount} {currency}").format(
amount=insured, currency=offer.escrow)
await offer.update_document({
"$set": update_dict,
"$unset": {
"pending_input_from": True
}
})
await tg.send_message(
offer.counter["id"],
answer,
reply_markup=buy_keyboard,
parse_mode=ParseMode.MARKDOWN,
)
sell_keyboard = InlineKeyboardMarkup()
sell_keyboard.add(
InlineKeyboardButton(i18n("cancel"),
callback_data=f"escrow_cancel {offer._id}"))
await tg.send_message(message.from_user.id,
i18n("offer_sent"),
reply_markup=sell_keyboard)
await dp.current_state().finish()
async def ask_credentials(
call: types.CallbackQuery,
offer: EscrowOffer,
):
"""Update offer with ``update_dict`` and start asking transfer information.
Ask to choose bank if user is initiator and there is a fiat
currency. Otherwise ask receive address.
"""
await call.answer()
is_user_init = call.from_user.id == offer.init["id"]
has_fiat_currency = "RUB" in {offer.buy, offer.sell}
if has_fiat_currency:
if is_user_init:
keyboard = InlineKeyboardMarkup()
for bank in SUPPORTED_BANKS:
keyboard.row(
InlineKeyboardButton(
bank, callback_data=f"bank {offer._id} {bank}"))
await tg.send_message(call.message.chat.id,
i18n("choose_bank"),
reply_markup=keyboard)
await states.Escrow.bank.set()
else:
if offer.type == "buy":
request_user = offer.init
answer_user = offer.counter
currency = offer.sell
else:
request_user = offer.counter
answer_user = offer.init
currency = offer.buy
keyboard = InlineKeyboardMarkup()
keyboard.add(
InlineKeyboardButton(i18n("sent"),
callback_data=f"card_sent {offer._id}"))
mention = markdown.link(answer_user["mention"],
User(id=answer_user["id"]).url)
await tg.send_message(
request_user["id"],
i18n(
"request_full_card_number {currency} {user}",
locale=request_user["locale"],
).format(currency=currency, user=mention),
reply_markup=keyboard,
parse_mode=ParseMode.MARKDOWN,
)
state = FSMContext(dp.storage, request_user["id"],
request_user["id"])
await state.set_state(states.Escrow.full_card.state)
answer = i18n(
"asked_full_card_number {user}",
locale=answer_user["locale"]).format(
user=markdown.link(request_user["mention"],
User(id=request_user["id"]).url))
await tg.send_message(
answer_user["id"],
answer,
parse_mode=ParseMode.MARKDOWN,
)
return
await tg.send_message(
call.message.chat.id,
i18n("ask_address {currency}").format(
currency=offer.sell if is_user_init else offer.buy),
)
await offer.update_document(
{"$set": {
"pending_input_from": call.from_user.id
}})
await states.Escrow.receive_address.set()
async def _refund_callback(
self,
reasons: typing.FrozenSet[str],
offer_id: ObjectId,
op: typing.Mapping[str, typing.Any],
from_address: str,
amount: Decimal,
asset: str,
block_num: int,
) -> None:
"""Refund transaction after confirmation because of mistakes in it.
:param reasons: Frozen set of mistakes in transaction.
The only allowed elements are ``asset``, ``amount`` and ``memo``.
:param offer_id: ``_id`` of escrow offer.
:param op: Operation object to confirm.
:param from_address: Address which sent assets.
:param amount: Amount of transferred asset.
:param asset: Transferred asset.
"""
offer = await database.escrow.find_one({"_id": offer_id})
if not offer:
return
user = offer["init"] if offer["type"] == "buy" else offer["counter"]
answer = i18n("transfer_mistakes", locale=user["locale"])
points = []
for reason in reasons:
if reason == "asset":
memo_point = i18n("wrong_asset", locale="en")
message_point = i18n("wrong_asset", locale=user["locale"])
elif reason == "amount":
memo_point = i18n("wrong_amount", locale="en")
message_point = i18n("wrong_amount", locale=user["locale"])
elif reason == "memo":
memo_point = i18n("wrong_memo", locale="en")
message_point = i18n("wrong_memo", locale=user["locale"])
else:
continue
points.append(memo_point)
answer += f"\n• {message_point}"
answer += "\n\n" + i18n("refund_promise", locale=user["locale"])
await tg.send_message(user["id"],
answer,
parse_mode=ParseMode.MARKDOWN)
is_confirmed = await create_task(self.is_block_confirmed(
block_num, op))
await database.escrow.update_one(
{"_id": offer["_id"]}, {"$set": {
"transaction_time": time()
}})
if is_confirmed:
trx_url = await self.transfer(
from_address,
amount,
asset,
memo="reason of refund: " + ", ".join(points),
)
answer = markdown.link(
i18n("transaction_refunded", locale=user["locale"]), trx_url)
else:
answer = i18n("transaction_not_confirmed", locale=user["locale"])
answer += " " + i18n("try_again", locale=user["locale"])
await tg.send_message(user["id"],
answer,
parse_mode=ParseMode.MARKDOWN)
async def _confirmation_callback(
self,
offer_id: ObjectId,
op: typing.Mapping[str, typing.Any],
trx_id: str,
block_num: int,
) -> bool:
"""Confirm found block with transaction.
Notify escrow asset sender and check if block is confirmed.
If it is, continue exchange. If it is not, send warning and
update ``transaction_time`` of escrow offer.
:param offer_id: ``_id`` of escrow offer.
:param op: Operation object to confirm.
:param trx_id: ID of transaction with desired operation.
:param block_num: Number of block to confirm.
:return: True if transaction was confirmed and False otherwise.
"""
offer = await database.escrow.find_one({"_id": offer_id})
if not offer:
return False
if offer["type"] == "buy":
new_currency = "sell"
escrow_user = offer["init"]
other_user = offer["counter"]
elif offer["type"] == "sell":
new_currency = "buy"
escrow_user = offer["counter"]
other_user = offer["init"]
answer = i18n(
"transaction_passed {currency}",
locale=escrow_user["locale"]).format(currency=offer[new_currency])
await tg.send_message(escrow_user["id"], answer)
is_confirmed = await create_task(self.is_block_confirmed(
block_num, op))
if is_confirmed:
await database.escrow.update_one(
{"_id": offer["_id"]},
{"$set": {
"trx_id": trx_id,
"unsent": True
}})
keyboard = InlineKeyboardMarkup()
keyboard.add(
InlineKeyboardButton(
i18n("sent", locale=other_user["locale"]),
callback_data="tokens_sent {}".format(offer["_id"]),
))
answer = markdown.link(
i18n("transaction_confirmed", locale=other_user["locale"]),
self.trx_url(trx_id),
)
answer += "\n" + i18n("send {amount} {currency} {address}",
locale=other_user["locale"]).format(
amount=offer[f"sum_{new_currency}"],
currency=offer[new_currency],
address=markdown.escape_md(
escrow_user["receive_address"]),
)
answer += "."
await tg.send_message(
other_user["id"],
answer,
reply_markup=keyboard,
parse_mode=ParseMode.MARKDOWN,
)
return True
await database.escrow.update_one(
{"_id": offer["_id"]}, {"$set": {
"transaction_time": time()
}})
answer = i18n("transaction_not_confirmed",
locale=escrow_user["locale"])
answer += " " + i18n("try_again", locale=escrow_user["locale"])
await tg.send_message(escrow_user["id"], answer)
return False
def nicer(card: Card):
return link(card.name, card.link)
from aiogram.utils.markdown import link, text
start = 'Привет, я бот, созданный для психологической помощи. Выбери действие.'
call = text(
link('Запись в службу психологической помощи\n',
'http://pozapisi.ru/day/psy/'),
'Мы располагаемся по адресу: Санкт-Петербург, Менделеевская линия, д. 5 (здание Института истории и Института философии), во внутреннем дворе.\n\n',
'Если Вы записались на консультацию к специалистам Кафедры медицинской психологии, то Ваша консультация будет проходить по адресу Наб.Макарова, д.6, каб. 109в.\n\n',
'Телефоны: 363-65-01, 328-94-17\n', 'E-mail: [email protected]')
async def show_order(
order: typing.Mapping[str, typing.Any],
chat_id: int,
user_id: int,
message_id: typing.Optional[int] = None,
location_message_id: typing.Optional[int] = None,
show_id: bool = False,
invert: typing.Optional[bool] = None,
edit: bool = False,
locale: typing.Optional[str] = None,
):
"""Send detailed order.
:param order: Order document.
:param chat_id: Telegram ID of chat to send message to.
:param user_id: Telegram user ID of message receiver.
:param message_id: Telegram ID of message to edit.
:param location_message_id: Telegram ID of message with location object.
It is deleted when **Hide** inline button is pressed.
:param show_id: Add ID of order to the top.
:param invert: Invert price.
:param edit: Enter edit mode.
:param locale: Locale of message receiver.
"""
if locale is None:
locale = i18n.ctx_locale.get()
new_edit_msg = None
if invert is None:
user = await database.users.find_one({"id": user_id})
invert = user.get("invert_order", False)
else:
user = await database.users.find_one_and_update(
{"id": user_id}, {"$set": {
"invert_order": invert
}})
if "edit" in user:
if edit:
if user["edit"]["field"] == "price":
new_edit_msg = i18n(
"new_price {of_currency} {per_currency}",
locale=locale)
if invert:
new_edit_msg = new_edit_msg.format(
of_currency=order["buy"],
per_currency=order["sell"])
else:
new_edit_msg = new_edit_msg.format(
of_currency=order["sell"],
per_currency=order["buy"])
elif user["edit"]["order_message_id"] == message_id:
await tg.delete_message(user["chat"],
user["edit"]["message_id"])
await database.users.update_one(
{"_id": user["_id"]},
{"$unset": {
"edit": True,
STATE_KEY: True
}})
if location_message_id is None:
if order.get("lat") is not None and order.get("lon") is not None:
location_message = await tg.send_location(chat_id, order["lat"],
order["lon"])
location_message_id = location_message.message_id
else:
location_message_id = -1
header = ""
if show_id:
header += "ID: {}\n".format(markdown.code(order["_id"]))
if order.get("archived"):
header += markdown.bold(i18n("archived", locale=locale)) + "\n"
creator = await database.users.find_one({"id": order["user_id"]})
header += "{} ({}) ".format(
markdown.link(creator["mention"],
types.User(id=creator["id"]).url),
markdown.code(creator["id"]),
)
if invert:
act = i18n("sells {sell_currency} {buy_currency}", locale=locale)
else:
act = i18n("buys {buy_currency} {sell_currency}", locale=locale)
header += act.format(buy_currency=order["buy"],
sell_currency=order["sell"]) + "\n"
lines = [header]
field_names = {
"sum_buy": i18n("buy_amount", locale=locale),
"sum_sell": i18n("sell_amount", locale=locale),
"price": i18n("price", locale=locale),
"payment_system": i18n("payment_system", locale=locale),
"duration": i18n("duration", locale=locale),
"comments": i18n("comments", locale=locale),
}
lines_format: typing.Dict[str, typing.Optional[str]] = {}
for name in field_names:
lines_format[name] = None
if "sum_buy" in order:
lines_format["sum_buy"] = "{} {}".format(order["sum_buy"],
order["buy"])
if "sum_sell" in order:
lines_format["sum_sell"] = "{} {}".format(order["sum_sell"],
order["sell"])
if "price_sell" in order:
if invert:
lines_format["price"] = "{} {}/{}".format(order["price_buy"],
order["buy"],
order["sell"])
else:
lines_format["price"] = "{} {}/{}".format(order["price_sell"],
order["sell"],
order["buy"])
if "payment_system" in order:
lines_format["payment_system"] = order["payment_system"]
if "duration" in order:
lines_format["duration"] = "{} - {}".format(
datetime.utcfromtimestamp(
order["start_time"]).strftime("%d.%m.%Y"),
datetime.utcfromtimestamp(
order["expiration_time"]).strftime("%d.%m.%Y"),
)
if "comments" in order:
lines_format["comments"] = "«{}»".format(order["comments"])
keyboard = types.InlineKeyboardMarkup(row_width=6)
keyboard.row(
types.InlineKeyboardButton(
i18n("invert", locale=locale),
callback_data="{} {} {} {}".format(
"revert" if invert else "invert",
order["_id"],
location_message_id,
int(edit),
),
))
if edit and creator["id"] == user_id:
buttons = []
for i, (field, value) in enumerate(lines_format.items()):
if value is not None:
lines.append(f"{i + 1}. {field_names[field]} {value}")
else:
lines.append(f"{i + 1}. {field_names[field]} -")
buttons.append(
types.InlineKeyboardButton(
f"{i + 1}",
callback_data="edit {} {} {} 0".format(
order["_id"], field, location_message_id),
))
keyboard.add(*buttons)
keyboard.row(
types.InlineKeyboardButton(
i18n("finish", locale=locale),
callback_data="{} {} {} 0".format(
"invert" if invert else "revert", order["_id"],
location_message_id),
))
else:
for field, value in lines_format.items():
if value is not None:
lines.append(field_names[field] + " " + value)
keyboard.row(
types.InlineKeyboardButton(
i18n("similar", locale=locale),
callback_data="similar {}".format(order["_id"]),
),
types.InlineKeyboardButton(
i18n("match", locale=locale),
callback_data="match {}".format(order["_id"]),
),
)
if creator["id"] == user_id:
keyboard.row(
types.InlineKeyboardButton(
i18n("edit", locale=locale),
callback_data="{} {} {} 1".format(
"invert" if invert else "revert",
order["_id"],
location_message_id,
),
),
types.InlineKeyboardButton(
i18n("delete", locale=locale),
callback_data="delete {} {}".format(
order["_id"], location_message_id),
),
)
keyboard.row(
types.InlineKeyboardButton(
i18n("unarchive", locale=locale) if order.get("archived")
else i18n("archive", locale=locale),
callback_data="archive {} {}".format(
order["_id"], location_message_id),
),
types.InlineKeyboardButton(
i18n("change_duration", locale=locale),
callback_data="edit {} duration {} 1".format(
order["_id"], location_message_id),
),
)
elif "price_sell" in order:
if (get_escrow_instance(order["buy"]) is not None
or get_escrow_instance(order["sell"]) is not None):
keyboard.row(
types.InlineKeyboardButton(
i18n("escrow", locale=locale),
callback_data="escrow {} sum_buy 0".format(
order["_id"]),
))
keyboard.row(
types.InlineKeyboardButton(
i18n("hide", locale=locale),
callback_data="hide {}".format(location_message_id),
))
answer = "\n".join(lines)
if message_id is not None:
await tg.edit_message_text(
answer,
chat_id,
message_id,
reply_markup=keyboard,
parse_mode=types.ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
if new_edit_msg is not None:
keyboard = types.InlineKeyboardMarkup()
keyboard.row(
types.InlineKeyboardButton(i18n("unset", locale=locale),
callback_data="unset"))
await tg.edit_message_text(
new_edit_msg,
chat_id,
user["edit"]["message_id"],
reply_markup=keyboard,
)
else:
await tg.send_message(
chat_id,
answer,
reply_markup=keyboard,
parse_mode=types.ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
