from pyrogram import (Client, Filters, CallbackQuery, ReplyKeyboardRemove,
KeyboardButton, ReplyKeyboardMarkup)
from .start_handler import start_handler
from .utils import add_tg, get_code
from pyrogram.errors import UsernameNotOccupied, UsernameInvalid, PeerIdInvalid
@Client.on_callback_query(Filters.callback_data('group'))
async def add_bot(_client: Client,
callback: CallbackQuery,
message="What's the username of your group?"):
await callback.message.delete()
username = await _client.ask(callback.message.chat.id, message) # noqa
if str(username.text) == '/start':
return await start_handler(_client, callback.message)
try:
username = str(username.text)
if username.isdigit():
if username.isdigit():
return (await add_bot(
_client, callback,
"Do not send an ID, only username. try again.\n"
"What's the username of your channel?"))
group = await _client.get_chat(username)
except (IndexError, ValueError, KeyError, UsernameNotOccupied,
UsernameInvalid, PeerIdInvalid) as e:
return (await add_bot(
_client, callback,
("username not exist. try again.\n" if not isinstance(
e, IndexError) else 'Something went wrong, try again\n') +
f"New user detected ({message.from_user.id}), adding to database"
)
set_user(message.from_user.id, message.from_user.username)
if GREET:
send_message(
client,
True,
message.from_user.id,
GREET.format(
mention=f"[{name}](tg://user?id={message.from_user.id})",
id=message.from_user.id,
username=message.from_user.username),
reply_markup=BUTTONS)
@Client.on_callback_query(Filters.callback_data("info") & ~BANNED_USERS)
def bot_info(_, query):
buttons = InlineKeyboardMarkup(
[[InlineKeyboardButton("🔙 Back", "back_start")]])
edit_message_text(query, True, CREDITS.format(), reply_markup=buttons)
@Client.on_callback_query(Filters.callback_data("back_start") & ~BANNED_USERS)
def back_start(_, query):
if query.from_user.first_name:
name = query.from_user.first_name
elif query.from_user.username:
name = query.from_user.username
else:
name = "Anonymous"
if CACHE[query.from_user.id][0] == "AWAITING_ADMIN":
async def commands(bot, update):
await bot.edit_message_text(
chat_id=update.message.chat.id,
text=Translation.COMMAND,
parse_mode="html",
disable_web_page_preview=True,
message_id=update.message.message_id,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton("👤Private Commands",
url="https://t.me/keralasbots"),
InlineKeyboardButton("👷 Admin Commands",
url="https://docs.pyrogram.org"),
], [InlineKeyboardButton("🔙 Back", callback_data="start_back")]]))
@Client.on_callback_query(Filters.callback_data("jinja"))
async def jinja(bot, update):
jin = [[InlineKeyboardButton("★ Set Jinja", callback_data="setjinja")]]
jin += BACKKEY
jinjamark = InlineKeyboardMarkup(jin)
view = vjinja(update.from_user.id)
if view == None:
jinja = "None"
else:
jinja = str(view)
await bot.edit_message_text(chat_id=update.message.chat.id,
text=jinja,
message_id=update.message.message_id,
reply_markup=jinjamark)
import constructors
from pyrogram import Client, Filters
@Client.on_callback_query(Filters.callback_data('start'))
async def onstart(client, query, lang):
text, keyboard = constructors.start(query, lang)
await query.edit(text, reply_markup=keyboard, disable_web_page_preview=True)
await query.answer()
from pyrogram import (Client, Filters, CallbackQuery, ReplyKeyboardRemove,
KeyboardButton, ReplyKeyboardMarkup)
from .start_handler import start_handler
from .utils import add_tg, get_code
from pyrogram.errors import UsernameNotOccupied, UsernameInvalid, PeerIdInvalid
@Client.on_callback_query(Filters.callback_data('channel'))
async def add_channel(_client: Client,
callback: CallbackQuery,
message="What's the username of your channel?"):
await callback.message.delete()
username = await _client.ask(callback.message.chat.id, message) # noqa
if str(username.text) == '/start':
return await start_handler(_client, callback.message)
try:
username = str(username.text)
if username.isdigit():
return (await add_channel(
_client, callback,
"Do not send an ID, only username. try again.\n"
"What's the username of your channel?"))
group = await _client.get_chat(username)
except (IndexError, ValueError, KeyError, UsernameNotOccupied,
UsernameInvalid, PeerIdInvalid) as e:
return (await add_channel(
_client, callback,
("username not exist. try again.\n" if not isinstance(
e, IndexError) else 'Something went wrong, try again\n') +
hostname=proxy_host,
port=proxy_port,
username=proxy_username,
password=proxy_password
))
@app.on_message(Filters.command(['start', 'help']))
def start(client, message):
message.reply_text('Sendu la nomo de via stato')
@app.on_message(Filters.private)
def create_state(client, message):
message.reply_text(f'Cxu vi reale volas krei staton "{message.text}"?', reply_markup=InlineKeyboardMarkup([
[InlineKeyboardButton('Jes, kreu', 'jes')], [InlineKeyboardButton('Ne, nuligu', 'ne')]]))
@app.on_callback_query(Filters.callback_data('jes'))
def confirm(client, callback_query):
text = callback_query.message.text
userbot.create_group(text[32:-2], callback_query.from_user.id)
@app.on_callback_query(Filters.callback_data('ne'))
def confirm(client, callback_query):
pass
app.run()
new_msg(cli, m, tg_id, texts.wallet_menu(tg_id), kb.wallet_menu(), "wallet_menu_id", "wallet_menu_id",
"on_message")
if response.status_code == 404:
if len(m.command) > 1:
refcode = m.command[1]
refcodes = cache.get_refcodes()
if refcode in refcodes:
WalletAPI.registration_user(m.from_user)
m.reply('Do you want to create a wallet or add an existing one', reply_markup=kb.first_start())
cache.del_refcode(refcode)
return
m.reply("Sorry, but the entrance is by invitation only")
@Client.on_callback_query(Filters.callback_data("new_wallet"))
def new_wallet(cli, cb):
tg_id = cb.from_user.id
cache.change_user_flag(tg_id, "create_wallet", True)
cb.message.edit(cb.message.text)
try:
cli.answer_callback_query(cb.id, "Wait a moment. I'm creating a wallet for you.", show_alert=True)
except:
cb.message.reply("Wait a moment. I'm creating a wallet for you.")
wallet = WalletAPI.create_wallet(tg_id)
cb.message.reply("Welcome to UAX Wallet", reply_markup=kb.reply(tg_id))
msg = cb.message.reply(texts.wallet_menu(tg_id), reply_markup=kb.wallet_menu())
cache.write_user_cache(tg_id, "wallet_menu_id", msg.message_id)
from utils import clear_db, generate_msg, migrate_chat, callback_starts, get_switch
c = Client("bot", bot_token=TOKEN, api_id=API_ID, api_hash=API_HASH)
async def is_admin(chat_id, user_id):
res = await c.get_chat_member(chat_id, user_id)
if res.status == "administrator" or res.status == "creator":
return True
else:
return False
@c.on_message(Filters.command("start") & Filters.private)
@c.on_callback_query(Filters.callback_data("start_back"))
async def start(client, message):
if isinstance(message, CallbackQuery):
send = message.message.edit_text
else:
send = message.reply_text
kb = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton("📖 Info", callback_data="infos")] +
[InlineKeyboardButton("📮 Regras", callback_data="rules")] +
[InlineKeyboardButton("📕 Ajuda", callback_data="help")],
[
InlineKeyboardButton(
"Adicionar em um grupo",
url="https://t.me/trdgroupsbot?startgroup=new")
]
])
from pyro.bot import bot
from pyro.utils.helpers.cat import cat
from pyrogram import Message, Filters, Emoji, InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
@bot.on_message(Filters.command("facts", prefixes=['.', '/', '!']))
async def cat_facts_handler(c: bot, m: Message):
fact = await cat().cat_facts()
await m.reply_text(text=fact,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text=f"{Emoji.BOOKS} New Fact",
callback_data="new_facts")
]]))
@bot.on_callback_query(Filters.callback_data("new_facts"))
async def new_facts_callback_handler(c: bot, cb: CallbackQuery):
await cb.answer()
fact = await cat().cat_facts()
await c.edit_message_text(chat_id=cb.message.chat.id,
message_id=cb.message.message_id,
text=fact,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text=f"{Emoji.BOOKS} New Fact",
callback_data="new_facts")
]]))
from pyrogram import Client, CallbackQueryHandler, Filters
from pyromod import listen # noqa
from plugins.start_handler import start_handler
app = Client(
'rateChannels',
api_id=1,
api_hash="b6b154c3707471f5339bd661645ed3d6",
bot_token="",
plugins={'root': 'plugins'}
)
app.add_handler(CallbackQueryHandler(start_handler, Filters.callback_data('home')))
app.run()
import constructors
from pyrogram import Client, Filters
@Client.on_callback_query(Filters.callback_data('about'))
async def onabout(client, query, lang):
text, keyboard = constructors.about(query, lang)
await query.edit(text, reply_markup=keyboard, disable_web_page_preview=True)
await query.answer()
import constructors
from pyrogram import Client, Filters
@Client.on_callback_query(Filters.callback_data('help'))
async def onhelp(client, query, lang):
text, keyboard = constructors.help(query, lang)
await query.edit(text, reply_markup=keyboard, disable_web_page_preview=True)
await query.answer()
user_is_chatting, LIVE_CHAT_STATUSES, STATUS_BUSY, STATUS_FREE, SUPPORT_REQUEST_SENT, SUPPORT_NOTIFICATION, \
ADMIN_JOINS_CHAT, USER_CLOSES_CHAT, JOIN_CHAT_BUTTON, USER_INFO, USER_LEAVES_CHAT, ADMIN_MESSAGE, USER_MESSAGE, \
TOO_FAST, CHAT_BUSY, LEAVE_CURRENT_CHAT, USER_JOINS_CHAT, NAME
import time
from ..database.query import get_user
from .antiflood import BANNED_USERS
from .start import back_start
import logging
ADMINS_FILTER = Filters.user(list(ADMINS.keys()))
BUTTONS = InlineKeyboardMarkup(
[[InlineKeyboardButton("🔙 Back", "back_start")],
[InlineKeyboardButton("🔄 Update", "update_admins_list")]])
@Client.on_callback_query(Filters.callback_data("sos") & ~BANNED_USERS)
def begin_chat(client, query):
CACHE[query.from_user.id] = ["AWAITING_ADMIN", time.time()]
queue = LIVE_CHAT_STATUSES
for admin_id, admin_name in ADMINS.items():
status = CACHE[admin_id][0]
if status != "IN_CHAT":
queue += f"- {STATUS_FREE}"
else:
queue += f"- {STATUS_BUSY}"
queue += f"[{admin_name}]({NAME.format(admin_id)})\n"
msg = edit_message_text(
query,
True,
SUPPORT_REQUEST_SENT.format(queue=queue,
date=time.strftime('%d/%m/%Y %T')),
value_to_send)
threading.Thread(target=delete_message,
args=(a.chat.id, a.message_id)).start()
@app.on_message(
Filters.create(lambda _, message: filters_commands(message))
& ~Filters.private)
def del_spam(client, a):
print(a)
tg_analytic.statistics(a.chat.id, "spam", ischat=True)
threading.Thread(target=delete_message,
args=(a.chat.id, a.message_id, 0)).start()
@app.on_callback_query(Filters.callback_data("address"))
def address(client, query):
answer_data = query.data
data = db.create_user(query.from_user.id)[2]
app.send_message(query.from_user.id, f"`{data}`", parse_mode="Markdown")
@app.on_callback_query(Filters.callback_data("qr_code"))
def inline_kb_answer_callback_handlera(client, query):
global back_markup
answer_data = query.data
data = db.get_qr_code(query.from_user.id)
app.send_photo(query.from_user.id,
data,
caption="Scan this QR with camera.")
from pyrogram import Filters, ChatPermissions
from pyrogram import InlineKeyboardMarkup, InlineKeyboardButton
from pyrogram import Client as app
import pyrogram.errors
import sql_helpers.forceSubscribe_sql as sql
@app.on_callback_query(Filters.callback_data("onButtonPress"))
def onButtonPress(client, cb):
user_id = cb.from_user.id
chat_id = cb.message.chat.id
cws = sql.fs_settings(chat_id)
if cws:
CHANNEL_USERNAME = cws.channel
try:
client.get_chat_member(CHANNEL_USERNAME, user_id)
client.unban_chat_member(chat_id, user_id)
except pyrogram.errors.exceptions.bad_request_400.UserNotParticipant:
client.answer_callback_query(
cb.id, text="Join the channel and press the button again.")
@app.on_message(Filters.text & ~Filters.private, group=1)
def SendMsg(client, message):
cws = sql.fs_settings(message.chat.id)
if not cws:
return
user_id = message.from_user.id
first_name = message.from_user.first_name
CHANNEL_USERNAME = cws.channel
try:
async def cat_handler(c: bot, m: Message):
cat_file = await cat().random_cat()
await m.reply_photo(photo=cat_file,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text=f"{Emoji.CAT_FACE} New Cat",
callback_data="new_cat_callback")
]]))
try:
os.remove(cat_file)
except Exception as e:
logging.error(str(e))
@bot.on_callback_query(Filters.callback_data("new_cat_callback"))
async def new_cat_callback_handler(c: bot, cb: CallbackQuery):
await cb.answer()
cat_file = await cat().random_cat()
await c.edit_message_media(chat_id=cb.message.chat.id,
message_id=cb.message.message_id,
media=InputMediaPhoto(cat_file),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
text=f"{Emoji.CAT_FACE} New Cat",
callback_data="new_cat_callback")
]]))
try:
os.remove(cat_file)
from pyrogram import Client, CallbackQuery, Filters
from _interface.inline_markups import full_order_create_btns, cancel_order_btn, \
refresh_order_btn, refresh_main_btn
from _interface.messages import gen_err_msg, gen_main_msg, err_creds, input_api_key_msg, err
from handlers.filters import hide_filter
from helpers.bithumb import bh_publish_order, get_balance
from helpers.bithumb_api import BithumbGlobalRestAPI
from helpers.db import db_save, create_order
from helpers.orders import parse_full_order_data, refresh_order_msg
from helpers.security import decr
from helpers.telegram import edit_message
from models import User, Order
@Client.on_callback_query(~Filters.bot & Filters.callback_data('delete_order'))
def delete_order(bot: Client, q: CallbackQuery):
tg_id = q.from_user.id
user = User.get(tg_id=tg_id)
edit_message(bot, tg_id, user.temp['msg_ids'][1], '🕐 Deleting order')
time.sleep(1)
bot.delete_messages(tg_id, user.temp['msg_ids'])
@Client.on_callback_query(~Filters.bot & Filters.callback_data('publish_order')
)
def publish_order(bot: Client, q: CallbackQuery):
tg_id = q.from_user.id
user = User.get(tg_id=tg_id)
order_msg_id = user.temp['msg_ids'][1] # 0 - user, 1 - bot
