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 battle_reports_show(bot: Bot, update: Update, session):
admin = session.query(Admin, Squad).filter(
Admin.user_id == update.message.from_user.id,
Squad.chat_id == Admin.admin_group).all()
group_admin = []
for adm, squad in admin:
if squad is not None:
group_admin.append([adm, squad])
for adm, squad in group_admin:
now = datetime.now()
time_from = datetime(now.year, now.month, now.day,
int(now.hour / 4) * 4, 0, 0)
reports = session.query(User, Report) \
.join(SquadMember) \
.outerjoin(Report, and_(User.id == Report.user_id, Report.date > time_from)) \
.filter(SquadMember.squad_id == adm.admin_group).order_by(Report.date.desc()).all()
text = ''
full_def = 0
full_atk = 0
full_exp = 0
full_gold = 0
full_stock = 0
total_reports = 0
total_members = 0
for user, report in reports:
total_members += 1
if report:
text += MSG_REPORT_SUMMARY_ROW.format(
report.name, user.username, report.attack, report.defence,
report.earned_exp, report.earned_gold, report.earned_stock)
full_atk += report.attack
full_def += report.defence
full_exp += report.earned_exp
full_gold += report.earned_gold
full_stock += report.earned_stock
total_reports += 1
else:
text += MSG_REPORT_SUMMARY_ROW_EMPTY.format(
user.character.name, user.username)
text = MSG_REPORT_SUMMARY_HEADER.format(
squad.squad_name, time_from.strftime('%d-%m-%Y %H:%M'),
total_reports, total_members, full_atk, full_def, full_exp,
full_gold, full_stock) + text
markup = generate_other_reports(time_from, squad.chat_id)
send_async(bot,
chat_id=update.message.chat.id,
text=text,
parse_mode=ParseMode.HTML,
reply_markup=markup)
def del_adm(bot, chat_id, user, session):
adm = session.query(Admin).filter_by(user_id=user.id,
admin_group=chat_id).first()
if adm is None:
send_async(bot,
chat_id=chat_id,
text=MSG_DEL_GROUP_ADMIN_NOT_EXIST.format(user.username))
else:
session.delete(adm)
session.commit()
send_async(bot,
chat_id=chat_id,
text=MSG_DEL_GROUP_ADMIN.format(user.username))
def newbie(bot: Bot, update: Update, session):
if ACADEM_CHAT_ID and CASTLE_CHAT_ID:
if update.message.chat.id in [CASTLE_CHAT_ID]:
if update.message.new_chat_member is not None:
user = session.query(User).filter(
User.id == update.message.new_chat_member.id).first()
if user is None:
group = session.query(Group).filter(
Group.id == ACADEM_CHAT_ID).first()
if group is not None:
send_async(bot,
chat_id=group.id,
text=fill_template(
MSG_NEWBIE,
update.message.new_chat_member))
def admin_panel(bot: Bot, update: Update, session):
if update.message.chat.type == 'private':
admin = session.query(Admin).filter_by(
user_id=update.message.from_user.id).all()
full_adm = False
grp_adm = False
for adm in admin:
if adm.admin_type <= AdminType.FULL.value:
full_adm = True
else:
grp_adm = True
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_ADMIN_WELCOME,
reply_markup=generate_admin_markup(full_adm, grp_adm))
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 web_auth(bot: Bot, update: Update, session):
user = add_user(update.message.from_user, session)
auth = session.query(Auth).filter_by(user_id=user.id).first()
if auth is None:
auth = Auth()
auth.id = uuid.uuid4().hex
auth.user_id = user.id
session.add(auth)
session.commit()
link = WEB_LINK.format(auth.id)
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_PERSONAL_SITE_LINK.format(link),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
def admins_for_users(bot: Bot, update: Update, session):
admins = session.query(Admin).filter(Admin.admin_group == update.message.chat.id).all()
users = []
for admin_user in admins:
users.append(session.query(User).filter_by(id=admin_user.user_id).first())
msg = MSG_LIST_ADMINS_HEADER
if users is None:
msg += MSG_EMPTY
else:
for user in users:
msg += MSG_LIST_ADMINS_USER_FORMAT.format(user.username or '',
user.first_name or '',
user.last_name or '')
send_async(bot, chat_id=update.message.chat.id, text=msg)
def user_panel(bot: Bot, update: Update, session):
if update.message.chat.type == 'private':
admin = session.query(Admin).filter_by(
user_id=update.message.from_user.id).all()
is_admin = False
for _ in admin:
is_admin = True
break
squad_member = session.query(SquadMember).filter_by(
user_id=update.message.from_user.id).first()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_START_WELCOME,
parse_mode=ParseMode.HTML,
reply_markup=generate_user_markup(
is_admin, True if squad_member else False))
def stock_compare(bot: Bot, update: Update, session, chat_data: dict):
old_stock = session.query(Stock).filter_by(
user_id=update.message.from_user.id,
stock_type=StockType.Stock.value).order_by(Stock.date.desc()).first()
new_stock = Stock()
new_stock.stock = update.message.text
new_stock.stock_type = StockType.Stock.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:
resources_old = {}
resources_new = {}
strings = old_stock.stock.splitlines()
for string in strings[1:]:
resource = string.split(' (')
resource[1] = resource[1][:-1]
resources_old[resource[0]] = int(resource[1])
strings = new_stock.stock.splitlines()
for string in strings[1:]:
resource = string.split(' (')
resource[1] = resource[1][:-1]
resources_new[resource[0]] = int(resource[1])
resource_diff_add, resource_diff_del = get_diff(
resources_new, resources_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,
parse_mode=ParseMode.HTML)
def ready_to_battle_result(bot: Bot, job_queue):
session = Session()
try:
group = session.query(Squad).all()
full_attack = 0
full_defence = 0
full_text = ''
full_count = 0
for item in group:
ready_order = session.query(Order).filter_by(
chat_id=item.chat_id, text=MSG_MAIN_READY_TO_BATTLE).order_by(
Order.date.desc()).first()
if ready_order is not None:
attack = 0
defence = 0
for clear in ready_order.cleared:
if clear.user.character:
attack += clear.user.character.attack
defence += clear.user.character.defence
text = MSG_SQUAD_READY.format(len(ready_order.cleared),
item.squad_name, attack, defence)
send_async(bot,
chat_id=item.chat_id,
text=text,
parse_mode=ParseMode.HTML)
full_attack += attack
full_defence += defence
full_count += len(ready_order.cleared)
full_text += MSG_FULL_TEXT_LINE.format(
item.squad_name, len(ready_order.cleared), attack, defence)
full_text += MSG_FULL_TEXT_TOTAL.format(full_count, full_attack,
full_defence)
send_async(bot,
chat_id=GOVERNMENT_CHAT,
text=full_text,
parse_mode=ParseMode.HTML)
except SQLAlchemyError as err:
bot.logger.error(str(err))
Session.rollback()
def list_admins(bot: Bot, update: Update):
session = Session()
try:
admins = session.query(Admin).filter(
Admin.admin_group == update.message.chat.id).all()
users = []
for admin_user in admins:
users.append(
session.query(User).filter_by(id=admin_user.user_id).first())
msg = MSG_LIST_ADMINS_HEADER
for user in users:
msg += MSG_LIST_ADMINS_FORMAT.format(user.id, user.username,
user.first_name,
user.last_name)
send_async(bot, chat_id=update.message.chat.id, text=msg)
except:
session.rollback()
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 remove_from_squad(bot: Bot, update: Update, session):
admin = session.query(Admin).filter_by(
user_id=update.message.from_user.id).all()
group_admin = []
for adm in admin:
squad = session.query(Squad).filter_by(chat_id=adm.admin_group).first()
if squad is not None:
group_admin.append(adm)
for adm in group_admin:
members = session.query(SquadMember).filter_by(
squad_id=adm.admin_group, approved=True).all()
markup = generate_fire_up(members)
squad = session.query(Squad).filter_by(chat_id=adm.admin_group).first()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_CLEAN.format(squad.squad_name),
reply_markup=markup,
parse_mode=ParseMode.HTML)
def send_status(bot: Bot, update: Update, session):
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])
send_async(bot,
chat_id=update.message.chat.id,
text=msg,
reply_markup=inline_markup)
def fresh_profiles(bot: Bot, job_queue):
session = Session()
try:
actual_profiles = session.query(Character.user_id, func.max(Character.date)). \
group_by(Character.user_id)
actual_profiles = actual_profiles.all()
characters = session.query(Character).filter(
tuple_(Character.user_id,
Character.date).in_([(a[0], a[1])
for a in actual_profiles]),
datetime.now() - timedelta(days=DAYS_PROFILE_REMIND) >
Character.date, Character.date >
datetime.now() - timedelta(days=DAYS_OLD_PROFILE_KICK))
if CASTLE:
characters = characters.filter_by(castle=CASTLE)
characters = characters.all()
for character in characters:
send_async(bot,
chat_id=character.user_id,
text=MSG_UPDATE_PROFILE,
parse_mode=ParseMode.HTML)
characters = session.query(Character).filter(
tuple_(Character.user_id, Character.date).in_([
(a[0], a[1]) for a in actual_profiles
]), Character.date <
datetime.now() - timedelta(days=DAYS_OLD_PROFILE_KICK)).all()
members = session.query(SquadMember, User).filter(SquadMember.user_id
.in_([character.user_id for character in characters])) \
.join(User, User.id == SquadMember.user_id).all()
for member, user in members:
session.delete(member)
admins = session.query(Admin).filter_by(
admin_group=member.squad_id).all()
for adm in admins:
send_async(bot,
chat_id=adm.user_id,
text=MSG_SQUAD_DELETE_OUTDATED_EXT.format(
member.user.character.name,
member.user.username, member.squad.squad_name),
parse_mode=ParseMode.HTML)
send_async(bot,
chat_id=member.squad_id,
text=MSG_SQUAD_DELETE_OUTDATED_EXT.format(
member.user.character.name, member.user.username,
member.squad.squad_name),
parse_mode=ParseMode.HTML)
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_DELETE_OUTDATED,
parse_mode=ParseMode.HTML)
session.commit()
except SQLAlchemyError as err:
bot.logger.error(str(err))
Session.rollback()
def trigger_show(bot: Bot, update: Update, session):
trigger = session.query(LocalTrigger).filter_by(
chat_id=update.message.chat.id, trigger=update.message.text).first()
if trigger is None:
trigger = session.query(Trigger).filter_by(
trigger=update.message.text).first()
if trigger is not None:
if trigger.message_type == MessageType.AUDIO.value:
bot.send_audio(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.DOCUMENT.value:
bot.send_document(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.VOICE.value:
bot.send_voice(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.STICKER.value:
bot.send_sticker(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.CONTACT.value:
msg = trigger.message.replace('\'', '"')
contact = loads(msg)
if 'phone_number' not in contact.keys():
contact['phone_number'] = None
if 'first_name' not in contact.keys():
contact['first_name'] = None
if 'last_name' not in contact.keys():
contact['last_name'] = None
bot.send_contact(update.message.chat.id, contact['phone_number'],
contact['first_name'], contact['last_name'])
elif trigger.message_type == MessageType.VIDEO.value:
bot.send_video(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.VIDEO_NOTE.value:
bot.send_video_note(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.LOCATION.value:
msg = trigger.message.replace('\'', '"')
location = loads(msg)
bot.send_location(update.message.chat.id, location['latitude'],
location['longitude'])
elif trigger.message_type == MessageType.PHOTO.value:
bot.send_photo(update.message.chat.id, trigger.message)
elif trigger.message_type == MessageType.ANIMATION.value:
bot.send_animation(update.message.chat.id, trigger.message)
else:
send_async(bot,
chat_id=update.message.chat.id,
text=trigger.message,
disable_web_page_preview=True)
def leave_squad_request(bot: Bot, update: Update, session):
member = session.query(SquadMember).filter_by(
user_id=update.message.from_user.id).first()
user = session.query(User).filter_by(
id=update.message.from_user.id).first()
if member:
squad = member.squad
markup = generate_yes_no(user_id=user.id)
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_LEAVE_ASK.format(user.character.name,
squad.squad_name),
parse_mode=ParseMode.HTML,
reply_markup=markup)
else:
send_async(bot,
chat_id=user.id,
text=MSG_SQUAD_NONE,
parse_mode=ParseMode.HTML)
def find_by_username(bot: Bot, update: Update, session):
if update.message.chat.type == 'private':
msg = update.message.text.split(' ', 1)[1]
msg = msg.replace('@', '')
if msg != '':
user = session.query(User).filter_by(username=msg).first()
if user is not None and user.character:
char = user.character
text = fill_char_template(MSG_PROFILE_SHOW_FORMAT, user, char)
btns = generate_profile_buttons(user)
send_async(bot,
chat_id=update.message.chat.id,
text=text,
reply_markup=btns)
else:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_PROFILE_NOT_FOUND,
parse_mode=ParseMode.HTML)
def order(bot: Bot, update: Update, chat_data):
session = Session()
admin_user = session.query(Admin).filter(
Admin.user_id == update.message.from_user.id).all()
markup = generate_order_groups_markup(
bot, admin_user, chat_data['pin'] if 'pin' in chat_data else True)
msg = update.message
if msg.audio:
chat_data['order'] = msg.audio.file_id
chat_data['order_type'] = MessageType.AUDIO.value
elif msg.document:
chat_data['order'] = msg.document.file_id
chat_data['order_type'] = MessageType.DOCUMENT.value
elif msg.voice:
chat_data['order'] = msg.voice.file_id
chat_data['order_type'] = MessageType.VOICE.value
elif msg.sticker:
chat_data['order'] = msg.sticker.file_id
chat_data['order_type'] = MessageType.STICKER.value
elif msg.contact:
chat_data['order'] = str(msg.contact)
chat_data['order_type'] = MessageType.CONTACT.value
elif msg.video:
chat_data['order'] = msg.video.file_id
chat_data['order_type'] = MessageType.VIDEO.value
elif msg.video_note:
chat_data['order'] = msg.video_note.file_id
chat_data['order_type'] = MessageType.VIDEO_NOTE.value
elif msg.location:
chat_data['order'] = str(msg.location)
chat_data['order_type'] = MessageType.LOCATION.value
elif msg.photo:
chat_data['order'] = msg.photo[-1].file_id
chat_data['order_type'] = MessageType.PHOTO.value
else:
chat_data['order'] = msg.text
chat_data['order_type'] = MessageType.TEXT.value
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_ORDER_SEND_HEADER,
reply_markup=markup)
def add_squad(bot: Bot, update: Update, session):
if update.message.chat.type == 'supergroup':
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),
parse_mode=ParseMode.HTML)
def squad_list(bot: Bot, update: Update, session):
admin = session.query(Admin).filter_by(
user_id=update.message.from_user.id).all()
global_adm = False
for adm in admin:
if adm.admin_type <= AdminType.FULL.value:
global_adm = True
break
if global_adm:
squads = session.query(Squad).all()
else:
group_ids = []
for adm in admin:
group_ids.append(adm.admin_group)
squads = session.query(Squad).filter(
Squad.chat_id.in_(group_ids)).all()
markup = generate_squad_list(squads, session)
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_LIST,
reply_markup=markup)
def set_admin(bot: Bot, update: Update, session):
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:
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))
def set_global_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:
adm = session.query(Admin).filter_by(
user_id=user.id, admin_type=AdminType.FULL.value).first()
if adm is None:
new_group_admin = Admin(user_id=user.id,
admin_type=AdminType.FULL.value,
admin_group=0)
session.add(new_group_admin)
session.commit()
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_GLOBAL_ADMIN.format(user.username))
else:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_NEW_GLOBAL_ADMIN_EXISTS.format(
user.username))
except:
session.rollback()
def repair_report_received(bot: Bot, update: Update, session):
if datetime.now() - update.message.forward_date > timedelta(minutes=10):
send_async(bot,
chat_id=update.message.from_user.id,
text=MSG_BUILD_REPORT_TOO_OLD)
return
report = re.search(REPAIR_REPORT, update.message.text)
user = session.query(User).filter_by(
id=update.message.from_user.id).first()
if report and user.character:
old_report = session.query(BuildReport) \
.filter(BuildReport.user_id == user.id,
BuildReport.date > update.message.forward_date - timedelta(minutes=5),
BuildReport.date < update.message.forward_date + timedelta(minutes=5)).first()
if old_report is None:
parse_repair_reports(update.message.text,
update.message.from_user.id,
update.message.forward_date, session)
user_builds = session.query(BuildReport).filter_by(
user_id=user.id).count()
send_async(bot,
chat_id=update.message.from_user.id,
text=MSG_BUILD_REPORT_OK.format(user_builds))
else:
send_async(bot,
chat_id=update.message.from_user.id,
text=MSG_BUILD_REPORT_EXISTS)
def leave_squad(bot: Bot, user: User, member: SquadMember, message, session):
if member:
squad = session.query(Squad).filter(
Squad.chat_id == member.squad_id).first()
member_user = session.query(User).filter(
User.id == member.user_id).first()
session.delete(member)
session.commit()
if member.approved:
admins = session.query(Admin).filter_by(
admin_group=squad.chat_id).all()
for adm in admins:
if adm.user_id != user.id:
send_async(bot,
chat_id=adm.user_id,
text=MSG_SQUAD_LEAVED.format(
member_user.character.name,
squad.squad_name),
parse_mode=ParseMode.HTML)
send_async(bot,
chat_id=member.squad_id,
text=MSG_SQUAD_LEAVED.format(member_user.character.name,
squad.squad_name),
parse_mode=ParseMode.HTML)
try:
bot.kick_chat_member(squad.chat_id, member.user_id)
except TelegramError as err:
bot.logger.error(err.message)
if member.user_id == user.id:
bot.editMessageText(MSG_SQUAD_LEAVED.format(
member_user.character.name, squad.squad_name),
message.chat.id,
message.message_id,
parse_mode=ParseMode.HTML)
else:
send_async(bot,
chat_id=member.user_id,
text=MSG_SQUAD_LEAVED.format(member_user.character.name,
squad.squad_name),
parse_mode=ParseMode.HTML)
members = session.query(SquadMember).filter_by(
squad_id=member.squad_id, approved=True).all()
bot.editMessageText(message.text,
message.chat.id,
message.message_id,
reply_markup=generate_fire_up(members))
else:
send_async(bot, chat_id=user.id, text=MSG_SQUAD_ALREADY_DELETED)
def squad_list(bot: Bot, update: Update):
session = scoped_session(Session)()
admin = session.query(Admin).filter_by(
user_id=update.message.from_user.id).all()
global_adm = False
for adm in admin:
if adm.admin_type <= AdminType.FULL.value:
global_adm = True
break
squads = []
if global_adm:
squads = session.query(Squad).all()
else:
for adm in admin:
group = session.query(Group).filter_by(id=adm.admin_group).first()
if len(group.squad) and group.squad[0]:
squads.append(group.squad[0])
markup = generate_squad_list(squads)
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_SQUAD_LIST,
reply_markup=markup)
def del_admin(bot: Bot, update: Update, session):
msg = update.message.text.split(' ', 1)[1]
if msg.find('@') != -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:
del_adm(bot, update.message.chat.id, user, session)
else:
user = session.query(User).filter_by(id=msg).first()
if user is None:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_USER_UNKNOWN)
else:
del_adm(bot, update.message.chat.id, user, session)
def ban(bot: Bot, update: Update, session):
username, reason = update.message.text.split(' ', 2)[1:]
username = username.replace('@', '')
user = session.query(User).filter_by(username=username).first()
if user:
banned = session.query(Ban).filter_by(user_id=user.id).first()
if banned:
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_ALREADY_BANNED.format(banned.to_date,
banned.reason))
else:
banned = Ban()
banned.user_id = user.id
banned.from_date = datetime.now()
banned.to_date = datetime.max
banned.reason = reason or MSG_NO_REASON
member = session.query(SquadMember).filter_by(
user_id=user.id).first()
if member:
session.delete(member)
admins = session.query(Admin).filter_by(user_id=user.id).all()
for admin in admins:
session.delete(admin)
session.add(banned)
session.commit()
squads = session.query(Squad).all()
for squad in squads:
send_async(bot,
chat_id=squad.chat_id,
text=MSG_USER_BANNED.format('@' + username))
send_async(bot,
chat_id=user.id,
text=MSG_YOU_BANNED.format(banned.reason))
send_async(bot,
chat_id=update.message.chat.id,
text=MSG_BAN_COMPLETE)
else:
send_async(bot, chat_id=update.message.chat.id, text=MSG_USER_UNKNOWN)
def char_show(bot: Bot, update: Update, session):
if update.message.chat.type == 'private':
user = session.query(User).filter_by(
id=update.message.from_user.id).first()
if user is not None and user.character is not None:
char = user.character
if CASTLE:
if char.castle == CASTLE:
text = fill_char_template(MSG_PROFILE_SHOW_FORMAT, user,
char)
btns = generate_profile_buttons(user)
send_async(bot,
chat_id=update.message.chat.id,
text=text,
reply_markup=btns)
else:
text = fill_char_template(MSG_PROFILE_SHOW_FORMAT, user, char)
btns = generate_profile_buttons(user)
send_async(bot,
chat_id=update.message.chat.id,
text=text,
reply_markup=btns)
