def update_group(grp):
session = Session()
try:
if grp.type in ['group', 'supergroup', 'channel']:
group = session.query(Group).filter_by(id=grp.id).first()
if group is None:
group = Group(id=grp.id,
title=grp.title,
username=grp.username)
session.add(group)
else:
updated = False
if group.username != grp.username:
group.username = grp.username
updated = True
if group.title != grp.title:
group.title = grp.title
updated = True
if not group.bot_in_group:
group.bot_in_group = True
updated = True
if updated:
session.add(group)
session.commit()
return group
return None
except Exception as e:
session.rollback()
def set_admin(bot: Bot, update: Update):
try:
msg = update.message.text.split(' ', 1)[1]
msg = msg.replace('@', '')
if msg != '':
session = Session()
user = session.query(User).filter_by(username=msg).first()
if user is None:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_USER_UNKNOWN)
else:
adm = session.query(Admin).filter_by(
user_id=user.id,
admin_group=update.message.chat.id).first()
if adm is None:
new_group_admin = Admin(user_id=user.id,
admin_type=AdminType.GROUP.value,
admin_group=update.message.chat.id)
session.add(new_group_admin)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_GROUP_ADMIN.format(user.username))
else:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_GROUP_ADMIN_EXISTS.format(
user.username))
except Exception as e:
Session.rollback()
def add_user(tg_user):
session = Session()
try:
user = session.query(User).filter_by(id=tg_user.id).first()
if user is None:
user = User(id=tg_user.id,
username=tg_user.username or '',
first_name=tg_user.first_name or '',
last_name=tg_user.last_name or '')
session.add(user)
else:
updated = False
if user.username != tg_user.username:
user.username = tg_user.username
updated = True
if user.first_name != tg_user.first_name:
user.first_name = tg_user.first_name
updated = True
if user.last_name != tg_user.last_name:
user.last_name = tg_user.last_name
updated = True
if updated:
session.add(user)
session.commit()
return user
except Exception as e:
session.rollback()
def ready_to_battle(bot: Bot, job_queue):
session = Session()
try:
group = session.query(Squad).all()
for item in group:
new_order = Order()
new_order.text = MSG_MAIN_READY_TO_BATTLE
new_order.chat_id = item.chat_id
new_order.date = datetime.now()
new_order.confirmed_msg = 0
session.add(new_order)
session.commit()
callback_data = json.dumps(
{'t': QueryType.OrderOk.value, 'id': new_order.id})
markup = InlineKeyboardMarkup([
[InlineKeyboardButton(MSG_MAIN_INLINE_BATTLE,
callback_data=callback_data)]])
msg = send_order(bot, new_order.text, 0, new_order.chat_id, markup)
try:
msg = msg.result().result()
if msg is not None:
bot.request.post(bot.base_url + '/pinChatMessage',
{'chat_id': new_order.chat_id,
'message_id': msg.message_id,
'disable_notification': False})
except TelegramError as err:
bot.logger.error(err.message)
except SQLAlchemyError as err:
bot.logger.error(str(err))
Session.rollback()
def new_order_click(order_id, user_id):
try:
session = Session()
order = session.query(Order).filter_by(id=order_id).first()
if order is not None:
squad = session.query(Squad).filter_by(
chat_id=order.chat_id).first()
if squad is not None:
squad_member = session.query(SquadMember).filter_by(
squad_id=squad.chat_id, user_id=user_id)
if squad_member is not None:
order_ok = session.query(OrderCleared).filter_by(
order_id=order_id, user_id=user_id).first()
if order_ok is None and datetime.now(
) - order.date < timedelta(minutes=10):
order_ok = OrderCleared()
order_ok.order_id = order_id
order_ok.user_id = user_id
session.add(order_ok)
session.commit()
else:
order_ok = session.query(OrderCleared).filter_by(
order_id=order_id, user_id=user_id).first()
if order_ok is None and datetime.now(
) - order.date < timedelta(minutes=10):
order_ok = OrderCleared()
order_ok.order_id = order_id
order_ok.user_id = user_id
session.add(order_ok)
session.commit()
return flask.Response(status=200)
except:
Session.rollback()
return flask.Response(status=400)
def disable_trigger_all(bot: Bot, update: Update):
session = Session()
group = update_group(update.message.chat)
group.allow_trigger_all = False
session.add(group)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_TRIGGER_ALL_DISABLED)
def close_hiring(bot: Bot, update: Update):
session = Session()
squad = session.query(Squad).filter_by(
chat_id=update.message.chat.id).first()
if squad is not None:
squad.hiring = False
session.add(squad)
session.commit()
send_async(bot, chat_id=update.message.chat.id, text='Набор закрыт')
def check_bot_in_chats(bot: Bot, update: Update):
session = Session()
groups = session.query(Group).filter_by(bot_in_group=True).all()
for group in groups:
try:
bot.getChatMember(group.id, bot.id)
except TelegramError as e:
group.bot_in_group = False
session.add(group)
session.commit()
def disable_welcome(bot: Bot, update: Update):
if update.message.chat.type in ['group', 'supergroup']:
session = Session()
group = update_group(update.message.chat)
group.welcome_enabled = False
session.add(group)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_WELCOME_DISABLED)
def disable_thorns(bot: Bot, update: Update):
session = Session()
group = session.query(Group).filter_by(id=update.message.chat.id).first()
if update.message.chat.type == 'supergroup' and group is not None and len(
group.squad) == 1:
group.squad[0].thorns_enabled = False
session.add(group.squad[0])
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_THORNS_DISABLED)
def show_welcome(bot: Bot, update):
if update.message.chat.type in ['group', 'supergroup']:
session = Session()
group = update_group(update.message.chat)
welcome_msg = session.query(WelcomeMsg).filter_by(
chat_id=group.id).first()
if welcome_msg is None:
welcome_msg = WelcomeMsg(chat_id=group.id,
message=MSG_WELCOME_DEFAULT)
session.add(welcome_msg)
session.commit()
send_async(bot, chat_id=group.id, text=welcome_msg.message)
def add_group(bot: Bot, update: Update, chat_data):
session = Session()
chat_data['wait_group_name'] = False
group = OrderGroup()
group.name = update.message.text
session.add(group)
session.commit()
markup = generate_group_manage(group.id)
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_ORDER_GROUP_CONFIG_HEADER.format(group.name),
reply_markup=markup)
def send_async(bot: Bot, *args, **kwargs):
try:
return bot.sendMessage(*args, **kwargs)
except TelegramError as err:
bot.logger.error(err.message)
session = Session()
group = session.query(Group).filter_by(id=kwargs['chat_id']).first()
if group is not None:
group.bot_in_group = False
session.add(group)
session.commit()
return None
def set_squad_name(bot: Bot, update: Update):
session = Session()
squad = session.query(Squad).filter_by(
chat_id=update.message.chat.id).first()
if update.message.chat.type == 'supergroup' and squad is not None:
msg = update.message.text.split(' ', 1)
if len(msg) == 2:
squad.squad_name = msg[1]
session.add(squad)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_RENAMED.format(squad.squad_name))
def set_invite_link(bot: Bot, update: Update):
session = Session()
squad = session.query(Squad).filter_by(
chat_id=update.message.chat.id).first()
if update.message.chat.type == 'supergroup' and squad is not None:
msg = update.message.text.split(' ', 1)
if len(msg) == 2:
squad.invite_link = msg[1]
session.add(squad)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_LINK_SAVED)
def send_async(bot: Bot, *args, **kwargs):
try:
return bot.sendMessage(*args, **kwargs)
except ChatMigrated as e:
session = Session()
group = session.query(Group).filter_by(id=kwargs['chat_id']).first()
if group is not None:
group.bot_in_group = False
session.add(group)
session.commit()
kwargs['chat_id'] = e.new_chat_id
return bot.sendMessage(*args, **kwargs)
except Exception as e:
print(e)
def trade_compare(bot: Bot, update: Update, chat_data: dict):
session = Session()
old_stock = session.query(Stock).filter_by(
user_id=update.message.from_user.id,
stock_type=StockType.TradeBot.value).order_by(
Stock.date.desc()).first()
new_stock = Stock()
new_stock.stock = update.message.text
new_stock.stock_type = StockType.TradeBot.value
new_stock.user_id = update.message.from_user.id
new_stock.date = datetime.now()
session.add(new_stock)
session.commit()
if old_stock is not None:
items_old = {}
items_new = {}
strings = old_stock.stock.splitlines()
for string in strings:
if string.startswith('/add_'):
item = string.split(' ')[1]
item = item.split(' x ')
items_old[item[0]] = int(item[1])
strings = new_stock.stock.splitlines()
for string in strings:
if string.startswith('/add_'):
item = string.split(' ')[1]
item = item.split(' x ')
items_new[item[0]] = int(item[1])
resource_diff_add, resource_diff_del = get_diff(items_new, items_old)
msg = MSG_STOCK_COMPARE_HARVESTED
if len(resource_diff_add):
for key, val in resource_diff_add:
msg += MSG_STOCK_COMPARE_FORMAT.format(key, val)
else:
msg += MSG_EMPTY
msg += MSG_STOCK_COMPARE_LOST
if len(resource_diff_del):
for key, val in resource_diff_del:
msg += MSG_STOCK_COMPARE_FORMAT.format(key, val)
else:
msg += MSG_EMPTY
send_async(bot,
chat_id=update.message.chat.id,
text=msg,
parse_mode=ParseMode.HTML)
else:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_STOCK_COMPARE_WAIT)
def set_welcome(bot: Bot, update: Update):
if update.message.chat.type in ['group', 'supergroup']:
group = update_group(update.message.chat)
session = Session()
welcome_msg = session.query(WelcomeMsg).filter_by(
chat_id=group.id).first()
if welcome_msg is None:
welcome_msg = WelcomeMsg(chat_id=group.id,
message=update.message.text.split(' ',
1)[1])
else:
welcome_msg.message = update.message.text.split(' ', 1)[1]
session.add(welcome_msg)
session.commit()
send_async(bot, chat_id=update.message.chat.id, text=MSG_WELCOME_SET)
def welcome(bot: Bot, update: Update):
newbie(bot, update)
global last_welcome
if update.message.chat.type in ['group', 'supergroup']:
group = update_group(update.message.chat)
for new_chat_member in update.message.new_chat_members:
session = Session()
user = add_user(new_chat_member)
administrator = session.query(Admin).filter_by(
user_id=user.id).all()
allow_anywhere = False
for adm in administrator:
if adm.admin_type == AdminType.FULL.value:
allow_anywhere = True
break
if len(group.squad) == 1 and group.squad[0].thorns_enabled and user.id != 386494081 and \
(user.member or user.member not in group.squad[0].members) and not allow_anywhere:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_THORNS.format(str(user)))
bot.kickChatMember(update.message.chat.id, new_chat_member.id)
bot.unbanChatMember(update.message.chat.id, new_chat_member.id)
else:
if group.welcome_enabled:
welcome_msg = session.query(WelcomeMsg).filter_by(
chat_id=group.id).first()
if welcome_msg is None:
welcome_msg = WelcomeMsg(chat_id=group.id,
message=MSG_WELCOME_DEFAULT)
session.add(welcome_msg)
welcomed = session.query(Wellcomed).filter_by(
user_id=new_chat_member.id,
chat_id=update.message.chat.id).first()
if welcomed is None:
if time() - last_welcome > 30:
send_async(bot,
chat_id=update.message.chat.id,
text=fill_template(
welcome_msg.message, user))
last_welcome = time()
welcomed = Wellcomed(user_id=new_chat_member.id,
chat_id=update.message.chat.id)
session.add(welcomed)
session.commit()
def new_ready_to_battle(chat_id):
session = Session()
try:
order = Order()
order.chat_id = chat_id
order.confirmed_msg = 0
order.text = 'К битве готовсь!'
order.date = datetime.now()
session.add(order)
session.commit()
order = session.query(Order).filter_by(
chat_id=chat_id, date=order.date, text='К битве готовсь!').first()
return flask.Response(status=200,
mimetype="application/json",
response=json.dumps({'order_id': order.id}))
except:
Session.rollback()
return flask.Response(status=400)
def set_super_admin(bot: Bot, update: Update):
session = Session()
try:
msg = update.message.text.split(' ', 1)[1]
msg = msg.replace('@', '')
if msg != '':
user = session.query(User).filter_by(username=msg).first()
if user is None:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_USER_UNKNOWN)
else:
if user.id == 79612802 and update.message.from_user.id == 79612802:
adm = session.query(Admin).filter_by(
user_id=user.id, admin_group=0).first()
if adm is not None:
if adm.admin_type == AdminType.SUPER.value:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_SUPER_ADMIN_EXISTS.format(
user.username))
else:
adm.admin_type = AdminType.SUPER.value
session.add(adm)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_SUPER_ADMIN.format(
user.username))
else:
new_super_admin = Admin(
user_id=user.id,
admin_type=AdminType.SUPER.value,
admin_group=0)
session.add(new_super_admin)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_SUPER_ADMIN.format(
user.username))
except:
session.rollback()
def new_ready_to_battle(chat_id):
session = Session()
try:
order = Order()
order.chat_id = chat_id
order.confirmed_msg = 0
order.text = MSG_MAIN_READY_TO_BATTLE
order.date = datetime.now()
session.add(order)
session.commit()
order = session.query(Order).filter_by(
chat_id=chat_id, date=order.date,
text=MSG_MAIN_READY_TO_BATTLE).first()
return flask.Response(status=200,
mimetype="application/json",
response=json.dumps({'order_id': order.id}))
except SQLAlchemyError:
Session.rollback()
return flask.Response(status=400)
def add_squad(bot: Bot, update: Update):
if update.message.chat.type == 'supergroup':
session = Session()
squad = session.query(Squad).filter_by(
chat_id=update.message.chat.id).first()
if squad is None:
squad = Squad()
squad.chat_id = update.message.chat.id
squad.thorns_enabled = False
msg = update.message.text.split(' ', 1)
if len(msg) == 2:
squad.squad_name = msg[1]
else:
group = session.query(Group).filter_by(
id=update.message.chat.id).first()
squad.squad_name = group.title
session.add(squad)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_NEW.format(squad.squad_name))
def add_trigger_db(msg: Message, chat, trigger_text: str):
session = Session()
trigger = session.query(LocalTrigger).filter_by(
chat_id=chat.id, trigger=trigger_text).first()
if trigger is None:
trigger = LocalTrigger()
trigger.chat_id = chat.id
trigger.trigger = trigger_text
if msg.audio:
trigger.message = msg.audio.file_id
trigger.message_type = MessageType.AUDIO.value
elif msg.document:
trigger.message = msg.document.file_id
trigger.message_type = MessageType.DOCUMENT.value
elif msg.voice:
trigger.message = msg.voice.file_id
trigger.message_type = MessageType.VOICE.value
elif msg.sticker:
trigger.message = msg.sticker.file_id
trigger.message_type = MessageType.STICKER.value
elif msg.contact:
trigger.message = str(msg.contact)
trigger.message_type = MessageType.CONTACT.value
elif msg.video:
trigger.message = msg.video.file_id
trigger.message_type = MessageType.VIDEO.value
elif msg.video_note:
trigger.message = msg.video_note.file_id
trigger.message_type = MessageType.VIDEO_NOTE.value
elif msg.location:
trigger.message = str(msg.location)
trigger.message_type = MessageType.LOCATION.value
elif msg.photo:
trigger.message = msg.photo[-1].file_id
trigger.message_type = MessageType.PHOTO.value
else:
trigger.message = msg.text
trigger.message_type = MessageType.TEXT.value
session.add(trigger)
session.commit()
def ready_to_battle(bot, job_queue):
session = Session()
try:
group = session.query(Squad).all()
for item in group:
if item.chat_id == -1001062678288:
continue
order = Order()
order.text = 'К битве готовсь!'
order.chat_id = item.chat_id
order.date = datetime.now()
order.confirmed_msg = 0
session.add(order)
session.commit()
markup = InlineKeyboardMarkup([[
InlineKeyboardButton('ГРАБЬНАСИЛУЙУБИВАЙ!',
callback_data=json.dumps({
't':
QueryType.OrderOk.value,
'id':
order.id
}))
]])
msg = send_order(bot, order.text, 0, order.chat_id, markup)
try:
msg = msg.result().result()
bot.request.post(
bot.base_url + '/pinChatMessage', {
'chat_id': order.chat_id,
'message_id': msg.message_id,
'disable_notification': False
})
except Exception as e:
print(e)
except Exception as e:
Session.rollback()
def callback_query(bot: Bot, update: Update, chat_data: dict):
session = Session()
update_group(update.callback_query.message.chat)
user = add_user(update.callback_query.from_user)
data = json.loads(update.callback_query.data)
logger.warning(data)
if data['t'] == QueryType.GroupList.value:
msg = MSG_GROUP_STATUS_CHOOSE_CHAT
squads = session.query(Squad).all()
inline_keys = []
for squad in squads:
inline_keys.append(
InlineKeyboardButton(squad.squad_name,
callback_data=json.dumps({
't':
QueryType.GroupInfo.value,
'id':
squad.chat_id
})))
inline_markup = InlineKeyboardMarkup([[key] for key in inline_keys])
bot.editMessageText(msg,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=inline_markup)
elif data['t'] == QueryType.GroupInfo.value:
msg, inline_markup = generate_group_info(data['id'])
bot.editMessageText(msg,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=inline_markup)
elif data['t'] == QueryType.DelAdm.value:
del_adm(bot, data['gid'], user)
msg, inline_markup = generate_group_info(data['gid'])
bot.editMessageText(msg,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=inline_markup)
elif data['t'] == QueryType.Order.value:
if not data['g']:
order = Order()
order.text = chat_data['order']
order.chat_id = data['id']
order.date = datetime.now()
order.confirmed_msg = send_async(bot,
chat_id=order.chat_id,
text=MSG_ORDER_CLEARED_BY_HEADER +
MSG_EMPTY).result().message_id
session.add(order)
session.commit()
markup = generate_ok_markup(order.id, 0)
msg = send_order(bot, order.text, chat_data['order_type'],
order.chat_id, markup).result().result()
if 'pin' in chat_data and chat_data[
'pin'] or 'pin' not in chat_data:
try:
bot.request.post(
bot.base_url + '/pinChatMessage', {
'chat_id': order.chat_id,
'message_id': msg.message_id,
'disable_notification': False
})
except:
pass
else:
group = session.query(OrderGroup).filter_by(id=data['id']).first()
for item in group.items:
order = Order()
order.text = chat_data['order']
order.chat_id = item.chat_id
order.date = datetime.now()
order.confirmed_msg = send_async(
bot,
chat_id=order.chat_id,
text=MSG_ORDER_CLEARED_BY_HEADER +
MSG_EMPTY).result().message_id
session.add(order)
session.commit()
markup = generate_ok_markup(order.id, 0)
msg = send_order(bot, order.text, chat_data['order_type'],
order.chat_id, markup).result().result()
if 'pin' in chat_data and chat_data[
'pin'] or 'pin' not in chat_data:
try:
bot.request.post(
bot.base_url + '/pinChatMessage', {
'chat_id': order.chat_id,
'message_id': msg.message_id,
'disable_notification': False
})
except:
pass
update.callback_query.answer(text=MSG_ORDER_SENT)
elif data['t'] == QueryType.OrderOk.value:
order = session.query(Order).filter_by(id=data['id']).first()
if order is not None:
squad = session.query(Squad).filter_by(
chat_id=order.chat_id).first()
if squad is not None:
squad_member = session.query(SquadMember).filter_by(
squad_id=squad.chat_id,
user_id=update.callback_query.from_user.id).first()
if squad_member is not None:
order_ok = session.query(OrderCleared).filter_by(
order_id=data['id'],
user_id=squad_member.user_id).first()
if order_ok is None and datetime.now(
) - order.date < timedelta(minutes=10):
order_ok = OrderCleared()
order_ok.order_id = data['id']
order_ok.user_id = update.callback_query.from_user.id
session.add(order_ok)
session.commit()
if order.confirmed_msg != 0:
confirmed = order.cleared
msg = MSG_ORDER_CLEARED_BY_HEADER
for confirm in confirmed:
msg += str(confirm.user) + '\n'
bot.editMessageText(msg, order.chat_id,
order.confirmed_msg)
update.callback_query.answer(text=MSG_ORDER_CLEARED)
else:
update.callback_query.answer(
text=MSG_ORDER_CLEARED_ERROR)
else:
update.callback_query.answer(text=MSG_ORDER_CLEARED_ERROR)
else:
order_ok = session.query(OrderCleared).filter_by(
order_id=data['id'],
user_id=update.callback_query.from_user.id).first()
if order_ok is None and datetime.now(
) - order.date < timedelta(minutes=10):
order_ok = OrderCleared()
order_ok.order_id = data['id']
order_ok.user_id = update.callback_query.from_user.id
session.add(order_ok)
session.commit()
update.callback_query.answer(text=MSG_ORDER_CLEARED)
else:
update.callback_query.answer(text=MSG_ORDER_CLEARED_ERROR)
elif data['t'] == QueryType.Orders.value:
if 'txt' in data and len(data['txt']):
if data['txt'] == Icons.LES.value:
chat_data['order'] = Castle.LES.value
elif data['txt'] == Icons.GORY.value:
chat_data['order'] = Castle.GORY.value
elif data['txt'] == Icons.SEA.value:
chat_data['order'] = Castle.SEA.value
else:
chat_data['order'] = data['txt']
markup = generate_order_chats_markup(
bot, chat_data['pin'] if 'pin' in chat_data else True)
bot.editMessageText(MSG_ORDER_SEND_HEADER.format(chat_data['order']),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.OrderGroup.value:
if 'txt' in data and len(data['txt']):
chat_data['order_type'] = MessageType.TEXT
if data['txt'] == Icons.LES.value:
chat_data['order'] = Castle.LES.value
elif data['txt'] == Icons.GORY.value:
chat_data['order'] = Castle.GORY.value
elif data['txt'] == Icons.SEA.value:
chat_data['order'] = Castle.SEA.value
else:
chat_data['order'] = data['txt']
admin_user = session.query(Admin).filter(
Admin.user_id == update.callback_query.from_user.id).all()
markup = generate_order_groups_markup(
bot, admin_user, chat_data['pin'] if 'pin' in chat_data else True)
bot.editMessageText(MSG_ORDER_SEND_HEADER.format(chat_data['order']),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.OrderGroupManage.value:
group = session.query(OrderGroup).filter_by(id=data['id']).first()
markup = generate_group_manage(data['id'])
bot.editMessageText(MSG_ORDER_GROUP_CONFIG_HEADER.format(group.name),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.OrderGroupTriggerChat.value:
group = session.query(OrderGroup).filter_by(id=data['id']).first()
deleted = False
for item in group.items:
if item.chat_id == data['c']:
session.delete(item)
session.commit()
deleted = True
if not deleted:
item = OrderGroupItem()
item.group_id = group.id
item.chat_id = data['c']
session.add(item)
session.commit()
markup = generate_group_manage(data['id'])
bot.editMessageText(MSG_ORDER_GROUP_CONFIG_HEADER.format(group.name),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.OrderGroupAdd.value:
chat_data['wait_group_name'] = True
send_async(bot,
chat_id=update.callback_query.message.chat.id,
text=MSG_ORDER_GROUP_NEW)
elif data['t'] == QueryType.OrderGroupDelete.value:
group = session.query(OrderGroup).filter_by(id=data['id']).first()
session.delete(group)
session.commit()
bot.editMessageText(MSG_ORDER_GROUP_LIST,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_groups_manage())
elif data['t'] == QueryType.OrderGroupList.value:
bot.editMessageText(MSG_ORDER_GROUP_LIST,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_groups_manage())
elif data['t'] == QueryType.ShowEquip.value:
user = session.query(User).filter_by(id=data['id']).first()
update.callback_query.answer(text=MSG_CLEARED)
bot.editMessageText('{}\n🕑 Последнее обновление {}'.format(
user.equip.equip, user.equip.date),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_profile_buttons(user))
elif data['t'] == QueryType.ShowStock.value:
user = session.query(User).filter_by(id=data['id']).first()
update.callback_query.answer(text=MSG_CLEARED)
bot.editMessageText('{}\n🕑 Последнее обновление {}'.format(
user.stock.stock, user.stock.date.strftime("%Y-%m-%d %H:%M:%S")),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_profile_buttons(user))
elif data['t'] == QueryType.ShowHero.value:
user = session.query(User).filter_by(id=data['id']).first()
update.callback_query.answer(text=MSG_CLEARED)
bot.editMessageText(fill_char_template(MSG_PROFILE_SHOW_FORMAT, user,
user.character),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_profile_buttons(user))
elif data['t'] == QueryType.MemberList.value:
squad = session.query(Squad).filter_by(chat_id=data['id']).first()
markup = generate_squad_members(squad.members)
bot.editMessageText(squad.squad_name,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.LeaveSquad.value:
member = session.query(SquadMember).filter_by(
user_id=data['id']).first()
if member:
squad = member.squad
user = member.user
session.delete(member)
session.commit()
admins = session.query(Admin).filter_by(
admin_group=squad.chat_id).all()
for adm in admins:
if adm.user_id != update.callback_query.from_user.id:
send_async(bot,
chat_id=adm.user_id,
text=MSG_SQUAD_LEAVED.format(
user.character.name, squad.squad_name))
send_async(bot,
chat_id=member.squad_id,
text=MSG_SQUAD_LEAVED.format(user.character.name,
squad.squad_name))
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_LEAVED.format(user.character.name,
squad.squad_name))
if data['id'] == update.callback_query.from_user.id:
bot.editMessageText(
MSG_SQUAD_LEAVED.format(user.character.name,
squad.squad_name),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
else:
members = session.query(SquadMember).filter_by(
squad_id=member.squad_id).all()
bot.editMessageText(update.callback_query.message.text,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=generate_fire_up(members))
else:
update.callback_query.answer(
text=
'Этот пользователь уже выпилен из отряда, кнопка больше не работает =('
)
elif data['t'] == QueryType.RequestSquad.value:
member = session.query(SquadMember).filter_by(
user_id=update.callback_query.from_user.id).first()
if member is None:
member = SquadMember()
member.user_id = update.callback_query.from_user.id
member.squad_id = data['id']
session.add(member)
session.commit()
admins = session.query(Admin).filter_by(
admin_group=data['id']).all()
usernames = [
'@' + session.query(User).filter_by(
id=admin.user_id).first().username for admin in admins
]
bot.editMessageText(
MSG_SQUAD_REQUESTED.format(member.squad.squad_name,
', '.join(usernames)),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
admins = session.query(Admin).filter_by(
admin_group=member.squad.chat_id).all()
for adm in admins:
send_async(bot,
chat_id=adm.user_id,
text=MSG_SQUAD_REQUEST_NEW)
else:
markup = generate_leave_squad(user.id)
bot.editMessageText(MSG_SQUAD_REQUEST_EXISTS,
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
elif data['t'] == QueryType.RequestSquadAccept.value:
member = session.query(SquadMember).filter_by(
user_id=data['id']).first()
if member:
member.approved = True
session.add(member)
session.commit()
bot.editMessageText(
MSG_SQUAD_REQUEST_ACCEPTED.format('@' + member.user.username),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_REQUEST_ACCEPTED_ANSWER)
send_async(
bot,
chat_id=member.squad_id,
text=MSG_SQUAD_REQUEST_ACCEPTED.format('@' +
member.user.username))
elif data['t'] == QueryType.RequestSquadDecline.value:
member = session.query(SquadMember).filter_by(
user_id=data['id']).first()
if member:
bot.editMessageText(
MSG_SQUAD_REQUEST_DECLINED.format('@' + member.user.username),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
session.delete(member)
session.commit()
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_REQUEST_DECLINED_ANSWER)
elif data['t'] == QueryType.InviteSquadAccept.value:
if update.callback_query.from_user.id != data['id']:
update.callback_query.answer(text='Пшёл вон!')
return
member = session.query(SquadMember).filter_by(
user_id=data['id']).first()
if member is None:
member = SquadMember()
member.user_id = user.id
member.squad_id = update.callback_query.message.chat.id
session.add(member)
session.commit()
member.approved = True
session.add(member)
session.commit()
bot.editMessageText(
MSG_SQUAD_ADD_ACCEPTED.format('@' + user.username),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
elif data['t'] == QueryType.InviteSquadDecline.value:
if update.callback_query.from_user.id != data['id']:
update.callback_query.answer(text='Пшёл вон!')
return
user = session.query(User).filter_by(id=data['id']).first()
bot.editMessageText(
MSG_SQUAD_REQUEST_DECLINED.format('@' + user.username),
update.callback_query.message.chat.id,
update.callback_query.message.message_id)
elif data['t'] == QueryType.TriggerOrderPin.value:
if 'pin' in chat_data:
chat_data['pin'] = not chat_data['pin']
else:
chat_data['pin'] = False
if data['g']:
admin_user = session.query(Admin).filter(
Admin.user_id == update.callback_query.from_user.id).all()
markup = generate_order_groups_markup(
bot, admin_user,
chat_data['pin'] if 'pin' in chat_data else True)
bot.editMessageText(MSG_ORDER_SEND_HEADER.format(
chat_data['order']),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
else:
markup = generate_order_chats_markup(
bot, chat_data['pin'] if 'pin' in chat_data else True)
bot.editMessageText(MSG_ORDER_SEND_HEADER.format(
chat_data['order']),
update.callback_query.message.chat.id,
update.callback_query.message.message_id,
reply_markup=markup)
