def add_note_to_db(chat_id,
note_name,
note_data,
msgtype,
buttons=None,
file=None):
if not buttons:
buttons = []
with NOTES_INSERTION_LOCK:
prev = SESSION.query(Notes).get((str(chat_id), note_name))
if prev:
with BUTTONS_INSERTION_LOCK:
prev_buttons = SESSION.query(Buttons).filter(
Buttons.chat_id == str(chat_id),
Buttons.note_name == note_name).all()
for btn in prev_buttons:
SESSION.delete(btn)
SESSION.delete(prev)
note = Notes(str(chat_id),
note_name,
note_data or "",
msgtype=msgtype.value,
file=file)
SESSION.add(note)
SESSION.commit()
for b_name, url, same_line in buttons:
add_note_button_to_db(chat_id, note_name, b_name, url, same_line)
def update_user(user_id, username, chat_id=None, chat_name=None):
with INSERTION_LOCK:
user = SESSION.query(Users).get(user_id)
if not user:
user = Users(user_id, username)
SESSION.add(user)
SESSION.flush()
else:
user.username = username
if not chat_id or not chat_name:
SESSION.commit()
return
chat = SESSION.query(Chats).get(str(chat_id))
if not chat:
chat = Chats(str(chat_id), chat_name)
SESSION.add(chat)
SESSION.flush()
else:
chat.chat_name = chat_name
member = SESSION.query(ChatMembers).filter(
ChatMembers.chat == chat.chat_id,
ChatMembers.user == user.user_id).first()
if not member:
chat_member = ChatMembers(chat.chat_id, user.user_id)
SESSION.add(chat_member)
SESSION.commit()
def set_custom_gdbye(chat_id,
custom_content_leave,
custom_goodbye,
goodbye_type,
buttons=None):
if buttons is None:
buttons = []
with INSERTION_LOCK:
welcome_settings = SESSION.query(Welcome).get(str(chat_id))
if not welcome_settings:
welcome_settings = Welcome(str(chat_id), True)
if custom_goodbye:
welcome_settings.custom_content_leave = custom_content_leave
welcome_settings.custom_leave = custom_goodbye
welcome_settings.leave_type = goodbye_type.value
else:
welcome_settings.custom_leave = DEFAULT_GOODBYE
welcome_settings.leave_type = Types.TEXT.value
SESSION.add(welcome_settings)
with LEAVE_BTN_LOCK:
prev_buttons = SESSION.query(GoodbyeButtons).filter(
GoodbyeButtons.chat_id == str(chat_id)).all()
for btn in prev_buttons:
SESSION.delete(btn)
for b_name, url, same_line in buttons:
button = GoodbyeButtons(chat_id, b_name, url, same_line)
SESSION.add(button)
SESSION.commit()
def set_custom_welcome(chat_id,
custom_content,
custom_welcome,
welcome_type,
buttons=None):
if buttons is None:
buttons = []
with INSERTION_LOCK:
welcome_settings = SESSION.query(Welcome).get(str(chat_id))
if not welcome_settings:
welcome_settings = Welcome(str(chat_id), True)
if custom_welcome or custom_content:
welcome_settings.custom_content = custom_content
welcome_settings.custom_welcome = custom_welcome
welcome_settings.welcome_type = welcome_type.value
else:
welcome_settings.custom_welcome = DEFAULT_WELCOME
welcome_settings.welcome_type = Types.TEXT.value
SESSION.add(welcome_settings)
with WELC_BTN_LOCK:
prev_buttons = SESSION.query(WelcomeButtons).filter(
WelcomeButtons.chat_id == str(chat_id)).all()
for btn in prev_buttons:
SESSION.delete(btn)
for b_name, url, same_line in buttons:
button = WelcomeButtons(chat_id, b_name, url, same_line)
SESSION.add(button)
SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id):
with PERM_LOCK:
perms = SESSION.query(Permissions).get(str(old_chat_id))
if perms:
perms.chat_id = str(new_chat_id)
SESSION.commit()
with RESTR_LOCK:
rest = SESSION.query(Restrictions).get(str(old_chat_id))
if rest:
rest.chat_id = str(new_chat_id)
SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id):
with ASPAM_SETTING_LOCK:
gban = SESSION.query(AntispamSettings).get(str(old_chat_id))
if gban:
gban.chat_id = new_chat_id
SESSION.add(gban)
gmute = SESSION.query(AntispamSettings).get(str(old_chat_id))
if gmute:
gmute.chat_id = new_chat_id
SESSION.add(gmute)
SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id):
with NOTES_INSERTION_LOCK:
chat_notes = SESSION.query(Notes).filter(
Notes.chat_id == str(old_chat_id)).all()
for note in chat_notes:
note.chat_id = str(new_chat_id)
with BUTTONS_INSERTION_LOCK:
chat_buttons = SESSION.query(Buttons).filter(
Buttons.chat_id == str(old_chat_id)).all()
for btn in chat_buttons:
btn.chat_id = str(new_chat_id)
SESSION.commit()
def __load_chat_blacklists():
global CHAT_BLACKLISTS
try:
chats = SESSION.query(BlackListFilters.chat_id).distinct().all()
for (chat_id, ) in chats: # remove tuple by ( ,)
CHAT_BLACKLISTS[chat_id] = []
all_filters = SESSION.query(BlackListFilters).all()
for x in all_filters:
CHAT_BLACKLISTS[x.chat_id] += [x.trigger]
CHAT_BLACKLISTS = {x: set(y) for x, y in CHAT_BLACKLISTS.items()}
finally:
SESSION.close()
def __load_chat_userrestirect():
global CHAT_USERRESTIRECT
try:
chats = SESSION.query(UserRestirect.chat_id).distinct().all()
for (chat_id, ) in chats: # remove tuple by ( ,)
CHAT_USERRESTIRECT[chat_id] = []
all_filters = SESSION.query(UserRestirect).all()
for x in all_filters:
CHAT_USERRESTIRECT[x.chat_id] += [x.user_id]
CHAT_USERRESTIRECT = {x: set(y) for x, y in CHAT_USERRESTIRECT.items()}
finally:
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with CUST_FILT_LOCK:
chat_filters = SESSION.query(CustomFilters).filter(
CustomFilters.chat_id == str(old_chat_id)).all()
for filt in chat_filters:
filt.chat_id = str(new_chat_id)
SESSION.commit()
CHAT_FILTERS[str(new_chat_id)] = CHAT_FILTERS[str(old_chat_id)]
del CHAT_FILTERS[str(old_chat_id)]
with BUTTON_LOCK:
chat_buttons = SESSION.query(Buttons).filter(
Buttons.chat_id == str(old_chat_id)).all()
for btn in chat_buttons:
btn.chat_id = str(new_chat_id)
SESSION.commit()
def get_buttons(chat_id, keyword):
try:
return SESSION.query(Buttons).filter(
Buttons.chat_id == str(chat_id),
Buttons.keyword == keyword).order_by(Buttons.id).all()
finally:
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with CHAT_LOCK:
chat_notes = SESSION.query(ReportingChatSettings).filter(
ReportingChatSettings.chat_id == str(old_chat_id)).all()
for note in chat_notes:
note.chat_id = str(new_chat_id)
SESSION.commit()
def is_locked(chat_id, lock_type):
curr_perm = SESSION.query(Permissions).get(str(chat_id))
SESSION.close()
if not curr_perm:
return False
elif lock_type == "sticker":
return curr_perm.sticker
elif lock_type == "photo":
return curr_perm.photo
elif lock_type == "audio":
return curr_perm.audio
elif lock_type == "voice":
return curr_perm.voice
elif lock_type == "contact":
return curr_perm.contact
elif lock_type == "video":
return curr_perm.video
elif lock_type == "videonote":
return curr_perm.videonote
elif lock_type == "document":
return curr_perm.document
elif lock_type == "gif":
return curr_perm.gif
elif lock_type == "url":
return curr_perm.url
elif lock_type == "bots":
return curr_perm.bots
elif lock_type == "forward":
return curr_perm.forward
elif lock_type == "game":
return curr_perm.game
elif lock_type == "location":
return curr_perm.location
def get_welc_buttons(chat_id):
try:
return SESSION.query(WelcomeButtons).filter(
WelcomeButtons.chat_id == str(chat_id)).order_by(
WelcomeButtons.id).all()
finally:
SESSION.close()
def get_gdbye_buttons(chat_id):
try:
return SESSION.query(GoodbyeButtons).filter(
GoodbyeButtons.chat_id == str(chat_id)).order_by(
GoodbyeButtons.id).all()
finally:
SESSION.close()
def _load_chat_blacklist():
global CHAT_URL_BLACKLISTS
try:
chats = SESSION.query(URLBlackListFilters.chat_id).distinct().all()
for (chat_id, ) in chats:
CHAT_URL_BLACKLISTS[chat_id] = []
all_urls = SESSION.query(URLBlackListFilters).all()
for url in all_urls:
CHAT_URL_BLACKLISTS[url.chat_id] += [url.domain]
CHAT_URL_BLACKLISTS = {
k: set(v)
for k, v in CHAT_URL_BLACKLISTS.items()
}
finally:
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with BLACKLIST_FILTER_INSERTION_LOCK:
chat_filters = SESSION.query(BlackListFilters).filter(
BlackListFilters.chat_id == str(old_chat_id)).all()
for filt in chat_filters:
filt.chat_id = str(new_chat_id)
SESSION.commit()
def migrate_chat(old_chat_id, new_chat_id):
with INSERTION_LOCK:
chat = SESSION.query(Chats).get(str(old_chat_id))
if chat:
chat.chat_id = str(new_chat_id)
SESSION.add(chat)
SESSION.flush()
chat_members = SESSION.query(ChatMembers).filter(
ChatMembers.chat == str(old_chat_id)).all()
for member in chat_members:
member.chat = str(new_chat_id)
SESSION.add(member)
SESSION.commit()
def get_buttons(chat_id, note_name):
try:
return SESSION.query(Buttons).filter(
Buttons.chat_id == str(chat_id),
Buttons.note_name == note_name).order_by(Buttons.id).all()
finally:
SESSION.close()
def chat_should_report(chat_id: Union[str, int]) -> bool:
try:
chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id))
if chat_setting:
return chat_setting.should_report
return False
finally:
SESSION.close()
def ungmute_user(user_id):
with GMUTED_USERS_LOCK:
user = SESSION.query(GloballyMutedUsers).get(user_id)
if user:
SESSION.delete(user)
SESSION.commit()
__load_gmuted_userid_list()
def allow_connect_to_chat(chat_id: Union[str, int]) -> bool:
try:
chat_setting = SESSION.query(ChatAccessConnectionSettings).get(str(chat_id))
if chat_setting:
return chat_setting.allow_connect_to_chat
return False
finally:
SESSION.close()
def get_rules(chat_id):
rules = SESSION.query(Rules).get(str(chat_id))
ret = ""
if rules:
ret = rules.rules
SESSION.close()
return ret
def get_chat_filters(chat_id):
try:
return SESSION.query(CustomFilters).filter(
CustomFilters.chat_id == str(chat_id)).order_by(
func.length(CustomFilters.keyword).desc()).order_by(
CustomFilters.keyword.asc()).all()
finally:
SESSION.close()
def command_reaction(chat_id: Union[str, int]) -> bool:
try:
chat_setting = SESSION.query(CommandReactionChatSettings).get(str(chat_id))
if chat_setting:
return chat_setting.comm_reaction
return False
finally:
SESSION.close()
def switch_to_locale(chat_id, locale_name):
with LOCALES_INSERTION_LOCK:
prev = SESSION.query(Locales).get((str(chat_id)))
if prev:
SESSION.delete(prev)
switch_locale = Locales(str(chat_id), locale_name)
SESSION.add(switch_locale)
SESSION.commit()
def user_should_report(user_id: int) -> bool:
try:
user_setting = SESSION.query(ReportingUserSettings).get(user_id)
if user_setting:
return user_setting.should_report
return True
finally:
SESSION.close()
def ungban_user(user_id):
with GBANNED_USERS_LOCK:
user = SESSION.query(GloballyBannedUsers).get(user_id)
if user:
SESSION.delete(user)
SESSION.commit()
__load_gbanned_userid_list()
def migrate_chat(old_chat_id, new_chat_id):
with GMUTE_SETTING_LOCK:
chat = SESSION.query(GmuteSettings).get(str(old_chat_id))
if chat:
chat.chat_id = new_chat_id
SESSION.add(chat)
SESSION.commit()
def add_history(user_id, chat_id1, chat_id2, chat_id3, updated):
with HISTORY_LOCK:
prev = SESSION.query(ConnectionHistory).get((int(user_id)))
if prev:
SESSION.delete(prev)
history = ConnectionHistory(user_id, chat_id1, chat_id2, chat_id3, updated)
SESSION.add(history)
SESSION.commit()
