def set_feds_setting(user_id: int, setting: bool):
with FEDS_SETTINGS_LOCK:
global FEDERATION_NOTIFICATION
user_setting = SESSION.query(FedsUserSettings).get(user_id)
if not user_setting:
user_setting = FedsUserSettings(user_id)
user_setting.should_report = setting
FEDERATION_NOTIFICATION[str(user_id)] = setting
SESSION.add(user_setting)
SESSION.commit()
def del_user(user_id):
with INSERTION_LOCK:
curr = SESSION.query(Users).get(user_id)
if curr:
SESSION.delete(curr)
SESSION.commit()
return True
ChatMembers.query.filter(ChatMembers.user == user_id).delete()
SESSION.commit()
SESSION.close()
return False
def get_welc_pref(chat_id):
welc = SESSION.query(Welcome).get(str(chat_id))
SESSION.close()
if welc:
return (
welc.should_welcome,
welc.custom_welcome,
welc.custom_content,
welc.welcome_type,
)
# Welcome by default.
return True, DEFAULT_WELCOME, None, Types.TEXT
def gban_user(user_id, name, reason=None):
with GBANNED_USERS_LOCK:
user = SESSION.query(GloballyBannedUsers).get(user_id)
if not user:
user = GloballyBannedUsers(user_id, name, reason)
else:
user.name = name
user.reason = reason
SESSION.merge(user)
SESSION.commit()
__load_gbanned_userid_list()
def __load_chat_settings_blacklists():
global CHAT_SETTINGS_BLACKLISTS
try:
chats_settings = SESSION.query(BlacklistSettings).all()
for x in chats_settings: # remove tuple by ( ,)
CHAT_SETTINGS_BLACKLISTS[x.chat_id] = {
"blacklist_type": x.blacklist_type,
"value": x.value,
}
finally:
SESSION.close()
def remove_warn_filter(chat_id, keyword):
with WARN_FILTER_INSERTION_LOCK:
warn_filt = SESSION.query(WarnFilters).get((str(chat_id), keyword))
if warn_filt:
if keyword in WARN_FILTERS.get(str(chat_id), []): # sanity check
WARN_FILTERS.get(str(chat_id), []).remove(keyword)
SESSION.delete(warn_filt)
SESSION.commit()
return True
SESSION.close()
return False
def set_afk(user_id, reason="", start_time=""):
with INSERTION_LOCK:
curr = SESSION.query(AFK).get(user_id)
if not curr:
curr = AFK(user_id, reason, True, start_time)
else:
curr.is_afk = True
curr.start_time = time.time()
AFK_USERS[user_id] = reason
AFK_USERSS[user_id] = start_time
SESSION.add(curr)
SESSION.commit()
def update_gban_reason(user_id, name, reason=None):
with GBANNED_USERS_LOCK:
user = SESSION.query(GloballyBannedUsers).get(user_id)
if not user:
return None
old_reason = user.reason
user.name = name
user.reason = reason
SESSION.merge(user)
SESSION.commit()
return old_reason
def user_demote_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
try:
members = eval(eval(getfed['fusers'])['members'])
except ValueError:
return False
members.remove(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()
return True
curr = SESSION.query(UserF).all()
result = False
for r in curr:
if int(r.user_id) == int(user_id):
if r.fed_id == fed_id:
SESSION.delete(r)
SESSION.commit()
result = True
SESSION.close()
return result
def unsubs_fed(fed_id, my_fed):
with FEDS_SUBSCRIBER_LOCK:
getsubs = SESSION.query(FedSubs).get((fed_id, my_fed))
if getsubs:
if my_fed in FEDS_SUBSCRIBER.get(fed_id, set()): # sanity check
FEDS_SUBSCRIBER.get(fed_id, set()).remove(my_fed)
SESSION.delete(getsubs)
SESSION.commit()
return True
SESSION.close()
return False
def rm_afk(user_id):
with INSERTION_LOCK:
curr = SESSION.query(AFK).get(user_id)
if curr:
if user_id in AFK_USERS: # sanity check
del AFK_USERS[user_id]
del AFK_USERSS[user_id]
SESSION.delete(curr)
SESSION.commit()
return True
SESSION.close()
return False
def rm_url_from_blacklist(chat_id, domain):
with URL_BLACKLIST_FILTER_INSERTION_LOCK:
domain_filt = SESSION.query(URLBlackListFilters).get(
(str(chat_id), domain))
if domain_filt:
if domain in CHAT_URL_BLACKLISTS.get(str(chat_id), set()):
CHAT_URL_BLACKLISTS.get(str(chat_id), set()).remove(domain)
SESSION.delete(domain_filt)
SESSION.commit()
return True
SESSION.close()
return False
def set_flood(chat_id, amount):
with INSERTION_FLOOD_LOCK:
flood = SESSION.query(FloodControl).get(str(chat_id))
if not flood:
flood = FloodControl(str(chat_id))
flood.user_id = None
flood.limit = amount
CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, amount)
SESSION.add(flood)
SESSION.commit()
def add_note(chat_id, keyword, reply):
adder = SESSION.query(NOTES).get((str(chat_id), keyword))
if adder:
adder.reply = reply
else:
adder = NOTES(chat_id, keyword, reply)
adder = NOTES(
chat_id,
keyword,
reply,
)
SESSION.add(adder)
SESSION.commit()
def multi_fban_user(
multi_fed_id,
multi_user_id,
multi_first_name,
multi_last_name,
multi_user_name,
multi_reason,
):
if True: # with FEDS_LOCK:
counter = 0
time = 0
for x in range(len(multi_fed_id)):
fed_id = multi_fed_id[x]
user_id = multi_user_id[x]
first_name = multi_first_name[x]
last_name = multi_last_name[x]
user_name = multi_user_name[x]
reason = multi_reason[x]
r = SESSION.query(BansF).all()
for I in r:
if I.fed_id == fed_id:
if int(I.user_id) == int(user_id):
SESSION.delete(I)
r = BansF(
str(fed_id),
str(user_id),
first_name,
last_name,
user_name,
reason,
time,
)
SESSION.add(r)
counter += 1
if str(str(counter)[-2:]) == "00":
print(user_id)
print(first_name)
print(reason)
print(counter)
try:
SESSION.commit()
except:
SESSION.rollback()
return False
finally:
SESSION.commit()
__load_all_feds_banned()
print("Done")
return counter
def remove_warn(user_id, chat_id):
with WARN_INSERTION_LOCK:
removed = False
warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
if warned_user and warned_user.num_warns > 0:
warned_user.num_warns -= 1
SESSION.add(warned_user)
SESSION.commit()
removed = True
SESSION.close()
return removed
def set_human_checks(user_id, chat_id):
with INSERTION_LOCK:
human_check = SESSION.query(WelcomeMuteUsers).get(
(user_id, str(chat_id)))
if not human_check:
human_check = WelcomeMuteUsers(user_id, str(chat_id), True)
else:
human_check.human_check = True
SESSION.add(human_check)
SESSION.commit()
return human_check
def get_fban_user(fed_id, user_id):
list_fbanned = FEDERATION_BANNED_USERID.get(fed_id)
if list_fbanned is None:
FEDERATION_BANNED_USERID[fed_id] = []
if user_id in FEDERATION_BANNED_USERID[fed_id]:
r = SESSION.query(BansF).all()
reason = None
for I in r:
if I.fed_id == fed_id:
if int(I.user_id) == int(user_id):
reason = I.reason
time = I.time
return True, reason, time
return False, None, None
def migrate_chat(old_chat_id, new_chat_id):
with WARN_INSERTION_LOCK:
chat_notes = (SESSION.query(Warns).filter(
Warns.chat_id == str(old_chat_id)).all())
for note in chat_notes:
note.chat_id = str(new_chat_id)
SESSION.commit()
with WARN_FILTER_INSERTION_LOCK:
chat_filters = (SESSION.query(WarnFilters).filter(
WarnFilters.chat_id == str(old_chat_id)).all())
for filt in chat_filters:
filt.chat_id = str(new_chat_id)
SESSION.commit()
WARN_FILTERS[str(new_chat_id)] = WARN_FILTERS[str(old_chat_id)]
del WARN_FILTERS[str(old_chat_id)]
with WARN_SETTINGS_LOCK:
chat_settings = (SESSION.query(WarnSettings).filter(
WarnSettings.chat_id == str(old_chat_id)).all())
for setting in chat_settings:
setting.chat_id = str(new_chat_id)
SESSION.commit()
def rm_from_blacklist(chat_id, trigger):
with BLACKLIST_FILTER_INSERTION_LOCK:
blacklist_filt = SESSION.query(BlackListFilters).get((str(chat_id), trigger))
if blacklist_filt:
# sanity check
if trigger in CHAT_BLACKLISTS.get(str(chat_id), set()):
CHAT_BLACKLISTS.get(str(chat_id), set()).remove(trigger)
SESSION.delete(blacklist_filt)
SESSION.commit()
return True
SESSION.close()
return False
def __load_cleaner_list():
global GLOBAL_IGNORE_COMMANDS
global CLEANER_CHATS
try:
GLOBAL_IGNORE_COMMANDS = {
int(x.command) for x in SESSION.query(CleanerBlueTextGlobal).all()
}
finally:
SESSION.close()
try:
for x in SESSION.query(CleanerBlueTextChatSettings).all():
CLEANER_CHATS.setdefault(x.chat_id, {"setting": False, "commands": set()})
CLEANER_CHATS[x.chat_id]["setting"] = x.is_enable
finally:
SESSION.close()
try:
for x in SESSION.query(CleanerBlueTextChat).all():
CLEANER_CHATS.setdefault(x.chat_id, {"setting": False, "commands": set()})
CLEANER_CHATS[x.chat_id]["commands"].add(x.command)
finally:
SESSION.close()
def __load_afk_users():
global AFK_USERS
global AFK_USERSS
try:
all_afk = SESSION.query(AFK).all()
AFK_USERS = {
user.user_id: user.reason
for user in all_afk if user.is_afk
}
AFK_USERSS = {
user.user_id: user.start_time
for user in all_afk if user.is_afk
}
finally:
SESSION.close()
def global_unignore_command(command):
command = command.lower()
with CLEANER_GLOBAL_LOCK:
unignored = SESSION.query(CleanerBlueTextGlobal).get(str(command))
if unignored:
if command in GLOBAL_IGNORE_COMMANDS:
GLOBAL_IGNORE_COMMANDS.remove(command)
SESSION.delete(command)
SESSION.commit()
return True
SESSION.close()
return False
def global_ignore_command(command):
command = command.lower()
with CLEANER_GLOBAL_LOCK:
ignored = SESSION.query(CleanerBlueTextGlobal).get(str(command))
if not ignored:
GLOBAL_IGNORE_COMMANDS.add(command)
ignored = CleanerBlueTextGlobal(str(command))
SESSION.add(ignored)
SESSION.commit()
return True
SESSION.close()
return False
def un_fban_user(fed_id, user_id):
with FEDS_LOCK:
r = SESSION.query(BansF).all()
for I in r:
if I.fed_id == fed_id:
if int(I.user_id) == int(user_id):
SESSION.delete(I)
try:
SESSION.commit()
except:
SESSION.rollback()
return False
finally:
SESSION.commit()
__load_all_feds_banned()
return I
def warn_user(user_id, chat_id, reason=None):
with WARN_INSERTION_LOCK:
warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
if not warned_user:
warned_user = Warns(user_id, str(chat_id))
warned_user.num_warns += 1
if reason:
warned_user.reasons = (warned_user.reasons + "\r\n\r\n" + reason
) # TODO:: double check this wizardry
reasons = warned_user.reasons
num = warned_user.num_warns
SESSION.add(warned_user)
SESSION.commit()
return num, reasons
def set_cleanbt(chat_id, is_enable):
with CLEANER_CHAT_SETTINGS:
curr = SESSION.query(CleanerBlueTextChatSettings).get(str(chat_id))
if not curr:
curr = CleanerBlueTextChatSettings(str(chat_id), is_enable)
else:
curr.is_enabled = is_enable
if str(chat_id) not in CLEANER_CHATS:
CLEANER_CHATS.setdefault(
str(chat_id), {"setting": False, "commands": set()}
)
CLEANER_CHATS[str(chat_id)]["setting"] = is_enable
SESSION.add(curr)
SESSION.commit()
def chat_leave_fed(chat_id):
with FEDS_LOCK:
global FEDERATION_CHATS, FEDERATION_CHATS_BYID
# Set variables
fed_info = FEDERATION_CHATS.get(str(chat_id))
if fed_info is None:
return False
fed_id = fed_info["fid"]
# Delete from cache
FEDERATION_CHATS.pop(str(chat_id))
FEDERATION_CHATS_BYID[str(fed_id)].remove(str(chat_id))
# Delete from db
curr = SESSION.query(ChatF).all()
for U in curr:
if int(U.chat_id) == int(chat_id):
SESSION.delete(U)
SESSION.commit()
return True
def is_restr_locked(chat_id, lock_type):
curr_restr = SESSION.query(Restrictions).get(str(chat_id))
SESSION.close()
if not curr_restr:
return False
if lock_type == "messages":
return curr_restr.messages
if lock_type == "media":
return curr_restr.media
if lock_type == "other":
return curr_restr.other
if lock_type == "previews":
return curr_restr.preview
if lock_type == "all":
return (curr_restr.messages and curr_restr.media and curr_restr.other
and curr_restr.preview)
def rename_fed(fed_id, owner_id, newname):
with FEDS_LOCK:
global FEDERATION_BYFEDID, FEDERATION_BYOWNER, FEDERATION_BYNAME
fed = SESSION.query(Federations).get(fed_id)
if not fed:
return False
fed.fed_name = newname
SESSION.commit()
# Update the dicts
oldname = FEDERATION_BYFEDID[str(fed_id)]["fname"]
tempdata = FEDERATION_BYNAME[oldname]
FEDERATION_BYNAME.pop(oldname)
FEDERATION_BYOWNER[str(owner_id)]["fname"] = newname
FEDERATION_BYFEDID[str(fed_id)]["fname"] = newname
FEDERATION_BYNAME[newname] = tempdata
return True
