def set_rules(chat_id, rules_text):
with INSERTION_LOCK:
rules = SESSION.query(Rules).get(str(chat_id))
if not rules:
rules = Rules(str(chat_id))
rules.rules = rules_text
SESSION.add(rules)
SESSION.commit()
def disable_gmutes(chat_id):
with GMUTE_SETTING_LOCK:
chat = SESSION.query(GmuteSettings).get(str(chat_id))
if not chat:
chat = GmuteSettings(chat_id, False)
chat.setting = False
SESSION.add(chat)
SESSION.commit()
GMUTESTAT_LIST.add(str(chat_id))
def private_note(chat_id, is_private, is_delete):
with PMNOTE_INSERTION_LOCK:
curr = SESSION.query(PrivateNote).get(str(chat_id))
if curr:
SESSION.delete(curr)
curr = PrivateNote(str(chat_id), is_private, is_delete)
SESSION.add(curr)
SESSION.commit()
def disable_antispam(chat_id):
with ASPAM_SETTING_LOCK:
chat = SESSION.query(AntispamSettings).get(str(chat_id))
if not chat:
chat = AntispamSettings(chat_id, False)
chat.setting = False
SESSION.add(chat)
SESSION.commit()
GBANSTAT_LIST.add(str(chat_id))
def set_user_bio(user_id, bio):
with INSERTION_LOCK:
userbio = SESSION.query(UserBio).get(user_id)
if userbio:
userbio.bio = bio
else:
userbio = UserBio(user_id, bio)
SESSION.add(userbio)
SESSION.commit()
def set_command_reaction(chat_id: Union[int, str], setting: bool):
with CHAT_LOCK:
chat_setting = SESSION.query(CommandReactionChatSettings).get(
str(chat_id))
if not chat_setting:
chat_setting = CommandReactionChatSettings(chat_id)
chat_setting.comm_reaction = setting
SESSION.add(chat_setting)
SESSION.commit()
def chat_leave_fed(chat_id):
with FEDS_LOCK:
H = False
curr = SESSION.query(ChatF).all()
for U in curr:
if int(U.chat_id) == int(chat_id):
H = True
SESSION.delete(U)
SESSION.commit()
return H
def __load_flood_settings():
global CHAT_FLOOD
try:
all_chats = SESSION.query(FloodControl).all()
CHAT_FLOOD = {
chat.chat_id: (None, DEF_COUNT, chat.limit)
for chat in all_chats
}
finally:
SESSION.close()
def get_human_checks(user_id, chat_id):
try:
human_check = SESSION.query(WelcomeMuteUsers).get(
(user_id, str(chat_id)))
if not human_check:
return None
human_check = human_check.human_check
return human_check
finally:
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with INSERTION_LOCK:
chat = SESSION.query(Welcome).get(str(old_chat_id))
if chat:
chat.chat_id = str(new_chat_id)
with WELC_BTN_LOCK:
chat_buttons = (SESSION.query(WelcomeButtons).filter(
WelcomeButtons.chat_id == str(old_chat_id)).all())
for btn in chat_buttons:
btn.chat_id = str(new_chat_id)
with LEAVE_BTN_LOCK:
chat_buttons = (SESSION.query(GoodbyeButtons).filter(
GoodbyeButtons.chat_id == str(old_chat_id)).all())
for btn in chat_buttons:
btn.chat_id = str(new_chat_id)
SESSION.commit()
def get_warn_setting(chat_id):
try:
setting = SESSION.query(WarnSettings).get(str(chat_id))
if setting:
return setting.warn_limit, setting.soft_warn
else:
return 3, False
finally:
SESSION.close()
def set_warn_strength(chat_id, soft_warn):
with WARN_SETTINGS_LOCK:
curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
if not curr_setting:
curr_setting = WarnSettings(chat_id, soft_warn=soft_warn)
curr_setting.soft_warn = soft_warn
SESSION.add(curr_setting)
SESSION.commit()
def set_warn_limit(chat_id, warn_limit):
with WARN_SETTINGS_LOCK:
curr_setting = SESSION.query(WarnSettings).get(str(chat_id))
if not curr_setting:
curr_setting = WarnSettings(chat_id, warn_limit=warn_limit)
curr_setting.warn_limit = warn_limit
SESSION.add(curr_setting)
SESSION.commit()
def get_warns(user_id, chat_id):
try:
user = SESSION.query(Warns).get((user_id, str(chat_id)))
if not user:
return None
reasons = user.reasons
num = user.num_warns
return num, reasons
finally:
SESSION.close()
def reset_warns(user_id, chat_id):
with WARN_INSERTION_LOCK:
warned_user = SESSION.query(Warns).get((user_id, str(chat_id)))
if warned_user:
warned_user.num_warns = 0
warned_user.reasons = []
SESSION.add(warned_user)
SESSION.commit()
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with INSERTION_FLOOD_LOCK:
flood = SESSION.query(FloodControl).get(str(old_chat_id))
if flood:
CHAT_FLOOD[str(new_chat_id)] = CHAT_FLOOD.get(
str(old_chat_id), DEF_OBJ)
flood.chat_id = str(new_chat_id)
SESSION.commit()
SESSION.close()
def set_clean_welcome(chat_id, clean_welcome):
with INSERTION_LOCK:
curr = SESSION.query(Welcome).get(str(chat_id))
if not curr:
curr = Welcome(str(chat_id))
curr.clean_welcome = int(clean_welcome)
SESSION.add(curr)
SESSION.commit()
def get_flood_setting(chat_id):
try:
setting = SESSION.query(FloodSettings).get(str(chat_id))
if setting:
return setting.flood_type, setting.value
else:
return 1, "0"
finally:
SESSION.close()
def set_gdbye_preference(chat_id, should_goodbye):
with INSERTION_LOCK:
curr = SESSION.query(Welcome).get(str(chat_id))
if not curr:
curr = Welcome(str(chat_id), should_goodbye=should_goodbye)
else:
curr.should_goodbye = should_goodbye
SESSION.add(curr)
SESSION.commit()
def get_fban_user(fed_id, user_id):
r = SESSION.query(BansF).all()
h = False
for I in r:
if I.fed_id == fed_id:
if int(I.user_id) == int(user_id):
h = I.reason
SESSION.close()
return h
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 migrate_chat(old_chat_id, new_chat_id):
with LOGS_INSERTION_LOCK:
chat = SESSION.query(GroupLogs).get(str(old_chat_id))
if chat:
chat.chat_id = str(new_chat_id)
SESSION.add(chat)
if str(old_chat_id) in CHANNELS:
CHANNELS[str(new_chat_id)] = CHANNELS.get(str(old_chat_id))
SESSION.commit()
def get_ses(chat_id):
autochat = SESSION.query(ChatbotChats).get(str(chat_id))
sesh = ""
exp = ""
if autochat:
sesh = str(autochat.ses_id)
exp = str(autochat.expires)
SESSION.close()
return sesh, exp
def clear_user_bio(user_id):
with INSERTION_LOCK:
curr = SESSION.query(UserBio).get(user_id)
if curr:
SESSION.delete(curr)
SESSION.commit()
return True
SESSION.close()
return False
def disable_gbans(chat_id):
with GBAN_SETTING_LOCK:
chat = SESSION.query(GbanSettings).get(str(chat_id))
if not chat:
chat = GbanSettings(chat_id, False)
chat.setting = False
SESSION.add(chat)
SESSION.commit()
GBANSTAT_LIST.add(str(chat_id))
def __load_APPROVE_users():
global APPROVED_USERS
try:
all_APPROVE = SESSION.query(APPROVE).all()
APPROVED_USERS = {
user.user_id + " " + user.chat_id
for user in all_APPROVE if user.is_approved
}
finally:
SESSION.close()
def set_allow_connect_to_chat(chat_id: Union[int, str], setting: bool):
with CHAT_ACCESS_LOCK:
chat_setting = SESSION.query(ChatAccessConnectionSettings).get(
str(chat_id))
if not chat_setting:
chat_setting = ChatAccessConnectionSettings(chat_id, setting)
chat_setting.allow_connect_to_chat = setting
SESSION.add(chat_setting)
SESSION.commit()
def disconnect(user_id):
with CONNECTION_INSERTION_LOCK:
disconnect = SESSION.query(Connection).get((int(user_id)))
if disconnect:
SESSION.delete(disconnect)
SESSION.commit()
return True
else:
SESSION.close()
return False
def add_history_conn(user_id, chat_id, chat_name):
global HISTORY_CONNECT
with CONNECTION_HISTORY_LOCK:
conn_time = int(time.time())
if HISTORY_CONNECT.get(int(user_id)):
counting = (SESSION.query(ConnectionHistory.user_id).filter(
ConnectionHistory.user_id == str(user_id)).count())
getchat_id = {}
for x in HISTORY_CONNECT[int(user_id)]:
getchat_id[HISTORY_CONNECT[int(user_id)][x]["chat_id"]] = x
if chat_id in getchat_id:
todeltime = getchat_id[str(chat_id)]
delold = SESSION.query(ConnectionHistory).get(
(int(user_id), str(chat_id)))
if delold:
SESSION.delete(delold)
HISTORY_CONNECT[int(user_id)].pop(todeltime)
elif counting >= 5:
todel = list(HISTORY_CONNECT[int(user_id)])
todel.reverse()
todel = todel[4:]
for x in todel:
chat_old = HISTORY_CONNECT[int(user_id)][x]["chat_id"]
delold = SESSION.query(ConnectionHistory).get(
(int(user_id), str(chat_old)))
if delold:
SESSION.delete(delold)
HISTORY_CONNECT[int(user_id)].pop(x)
else:
HISTORY_CONNECT[int(user_id)] = {}
delold = SESSION.query(ConnectionHistory).get(
(int(user_id), str(chat_id)))
if delold:
SESSION.delete(delold)
history = ConnectionHistory(int(user_id), str(chat_id), chat_name,
conn_time)
SESSION.add(history)
SESSION.commit()
HISTORY_CONNECT[int(user_id)][conn_time] = {
"chat_name": chat_name,
"chat_id": str(chat_id),
}
def update_gmute_reason(user_id, name, reason=None):
with GMUTED_USERS_LOCK:
user = SESSION.query(GloballyMutedUsers).get(user_id)
if not user:
return False
user.name = name
user.reason = reason
SESSION.merge(user)
SESSION.commit()
return True
