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 set_custom_gdbye(chat_id, 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_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 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_note(chat_id, note_name):
try:
return (SESSION.query(Notes).filter(
func.lower(Notes.name) == note_name,
Notes.chat_id == str(chat_id)).first())
finally:
SESSION.close()
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 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 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 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 list_approved(chat_id):
try:
return (SESSION.query(Approvals).filter(
Approvals.chat_id == str(chat_id)).order_by(
Approvals.user_id.asc()).all())
finally:
SESSION.close()
def get_user_num_chats(user_id):
try:
return (
SESSION.query(ChatMembers).filter(ChatMembers.user == int(user_id)).count()
)
finally:
SESSION.close()
def __load_afk_users():
global AFK_USERS
try:
all_afk = SESSION.query(AFK).all()
AFK_USERS = {user.user_id: user.reason for user in all_afk if user.is_afk}
finally:
SESSION.close()
def rem_chat(chat_id):
with INSERTION_LOCK:
autochat = SESSION.query(ChatbotChats).get(str(chat_id))
if autochat:
SESSION.delete(autochat)
SESSION.commit()
def set_blacklist_strength(chat_id, blacklist_type, value):
# for blacklist_type
# 0 = nothing
# 1 = delete
# 2 = warn
# 3 = mute
# 4 = kick
# 5 = ban
# 6 = tban
# 7 = tmute
with BLACKLIST_SETTINGS_INSERTION_LOCK:
global CHAT_SETTINGS_BLACKLISTS
curr_setting = SESSION.query(BlacklistSettings).get(str(chat_id))
if not curr_setting:
curr_setting = BlacklistSettings(
chat_id, blacklist_type=int(blacklist_type), value=value)
curr_setting.blacklist_type = int(blacklist_type)
curr_setting.value = str(value)
CHAT_SETTINGS_BLACKLISTS[str(chat_id)] = {
"blacklist_type": int(blacklist_type),
"value": value,
}
SESSION.add(curr_setting)
SESSION.commit()
def new_fed(owner_id, fed_name, fed_id):
with FEDS_LOCK:
global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
fed = Federations(
str(owner_id),
fed_name,
str(fed_id),
"Rules is not set in this federation.",
None,
str({"owner": str(owner_id), "members": "[]"}),
)
SESSION.add(fed)
SESSION.commit()
FEDERATION_BYOWNER[str(owner_id)] = {
"fid": str(fed_id),
"fname": fed_name,
"frules": "Rules is not set in this federation.",
"flog": None,
"fusers": str({"owner": str(owner_id), "members": "[]"}),
}
FEDERATION_BYFEDID[str(fed_id)] = {
"owner": str(owner_id),
"fname": fed_name,
"frules": "Rules is not set in this federation.",
"flog": None,
"fusers": str({"owner": str(owner_id), "members": "[]"}),
}
FEDERATION_BYNAME[fed_name] = {
"fid": str(fed_id),
"owner": str(owner_id),
"frules": "Rules is not set in this federation.",
"flog": None,
"fusers": str({"owner": str(owner_id), "members": "[]"}),
}
return fed
def user_join_fed(fed_id, user_id):
with FEDS_LOCK:
global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME
# Variables
getfed = FEDERATION_BYFEDID.get(str(fed_id))
owner_id = getfed["owner"]
fed_name = getfed["fname"]
fed_rules = getfed["frules"]
fed_log = getfed["flog"]
# Temp set
members = eval(eval(getfed["fusers"])["members"])
members.append(user_id)
# Set user
FEDERATION_BYOWNER[str(owner_id)]["fusers"] = str(
{"owner": str(owner_id), "members": str(members)}
)
FEDERATION_BYFEDID[str(fed_id)]["fusers"] = str(
{"owner": str(owner_id), "members": str(members)}
)
FEDERATION_BYNAME[fed_name]["fusers"] = str(
{"owner": str(owner_id), "members": str(members)}
)
# Set on database
fed = Federations(
str(owner_id),
fed_name,
str(fed_id),
fed_rules,
fed_log,
str({"owner": str(owner_id), "members": str(members)}),
)
SESSION.merge(fed)
SESSION.commit()
__load_all_feds_chats()
return True
def migrate_chat(old_chat_id, new_chat_id):
with STICKERS_FILTER_INSERTION_LOCK:
chat_filters = SESSION.query(StickersFilters).filter(
StickersFilters.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 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 set_blacklist_strength(chat_id, blacklist_type, value):
# for blacklist_type
# 0 = nothing
# 1 = delete
# 2 = warn
# 3 = mute
# 4 = kick
# 5 = ban
# 6 = tban
# 7 = tmute
with STICKSET_FILTER_INSERTION_LOCK:
global CHAT_BLSTICK_BLACKLISTS
curr_setting = SESSION.query(StickerSettings).get(str(chat_id))
if not curr_setting:
curr_setting = StickerSettings(chat_id,
blacklist_type=int(blacklist_type),
value=value)
curr_setting.blacklist_type = int(blacklist_type)
curr_setting.value = str(value)
CHAT_BLSTICK_BLACKLISTS[str(chat_id)] = {
'blacklist_type': int(blacklist_type),
'value': value
}
SESSION.add(curr_setting)
SESSION.commit()
def get_user_com_chats(user_id):
try:
chat_members = SESSION.query(ChatMembers).filter(
ChatMembers.user == int(user_id)).all()
return [i.chat for i in chat_members]
finally:
SESSION.close()
def __load_log_channels():
global CHANNELS
try:
all_chats = SESSION.query(GroupLogs).all()
CHANNELS = {chat.chat_id: chat.log_channel for chat in all_chats}
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 remove_url(tg_chat_id, tg_feed_link):
with INSERTION_LOCK:
# this loops to delete any possible duplicates for the same TG User ID, TG Chat ID and link
for row in check_url_availability(tg_chat_id, tg_feed_link):
# add the action to the DB query
SESSION.delete(row)
SESSION.commit()
def add_channel(chat_id, channel):
adder = SESSION.query(forceSubscribe).get(chat_id)
if adder:
adder.channel = channel
else:
adder = forceSubscribe(chat_id, channel)
SESSION.add(adder)
SESSION.commit()
def fs_settings(chat_id):
try:
return (SESSION.query(forceSubscribe).filter(
forceSubscribe.chat_id == chat_id).one())
except:
return None
finally:
SESSION.close()
def __load_all_feds_settings():
global FEDERATION_NOTIFICATION
try:
getuser = SESSION.query(FedsUserSettings).all()
for x in getuser:
FEDERATION_NOTIFICATION[str(x.user_id)] = x.should_report
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 unblacklist_user(user_id):
with BLACKLIST_LOCK:
user = SESSION.query(BlacklistUsers).get(str(user_id))
if user:
SESSION.delete(user)
SESSION.commit()
__load_blacklist_userid_list()
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 get_reason(user_id):
user = SESSION.query(BlacklistUsers).get(str(user_id))
rep = ""
if user:
rep = user.reason
SESSION.close()
return rep
def get_rules(chat_id):
rules = SESSION.query(Rules).get(str(chat_id))
ret = ""
if rules:
ret = rules.rules
SESSION.close()
return ret