def add_filter(
chat_id,
keyword,
reply,
snip_type,
media_id,
media_access_hash,
media_file_reference,
):
adder = SESSION.query(Filters).get((str(chat_id), keyword))
if adder:
adder.reply = reply
adder.snip_type = snip_type
adder.media_id = media_id
adder.media_access_hash = media_access_hash
adder.media_file_reference = media_file_reference
else:
adder = Filters(
chat_id,
keyword,
reply,
snip_type,
media_id,
media_access_hash,
media_file_reference,
)
SESSION.add(adder)
SESSION.commit()
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 set_chat_setting(chat_id: Union[int, str], setting: bool):
with CHAT_LOCK:
chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id))
if not chat_setting:
chat_setting = ReportingChatSettings(chat_id)
chat_setting.should_report = setting
SESSION.add(chat_setting)
SESSION.commit()
def set_user_setting(user_id: int, setting: bool):
with USER_LOCK:
user_setting = SESSION.query(ReportingUserSettings).get(user_id)
if not user_setting:
user_setting = ReportingUserSettings(user_id)
user_setting.should_report = setting
SESSION.add(user_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 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 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 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 set_ses(chat_id, ses_id, expires):
with INSERTION_LOCK:
autochat = SESSION.query(aiChats).get(str(chat_id))
if not autochat:
autochat = aiChats(str(chat_id), str(ses_id), str(expires))
else:
autochat.ses_id = str(ses_id)
autochat.expires = str(expires)
SESSION.add(autochat)
SESSION.commit()
def set_bio(user_id, fname):
with INSERTION_LOCK:
curr = SESSION.query(BIO).get(user_id)
if not curr:
curr = BIO(user_id, fname, True)
else:
curr.is_sudo = True
curr.fname = fname
SUDO_USERS[user_id] = fname
SUDO_USERSS[user_id] = fname
SESSION.add(curr)
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 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.reason = reason
curr.start_time = start_time
AFK_USERS[user_id] = reason
AFK_USERSS[user_id] = start_time
SESSION.add(curr)
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 chat_join_fed(fed_id, chat_name, chat_id):
with FEDS_LOCK:
global FEDERATION_CHATS, FEDERATION_CHATS_BYID
r = ChatF(chat_id, chat_name, fed_id)
SESSION.add(r)
FEDERATION_CHATS[str(chat_id)] = {
"chat_name": chat_name,
"fid": fed_id
}
checkid = FEDERATION_CHATS_BYID.get(fed_id)
if checkid is None:
FEDERATION_CHATS_BYID[fed_id] = []
FEDERATION_CHATS_BYID[fed_id].append(str(chat_id))
SESSION.commit()
return r
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 add_goodbye_setting(
chat_id,
custom_goodbye_message,
should_clean_goodbye,
previous_goodbye,
media_file_id,
):
# adder = SESSION.query(Goodbye).get(chat_id)
adder = Goodbye(
chat_id,
custom_goodbye_message,
should_clean_goodbye,
previous_goodbye,
media_file_id,
)
SESSION.add(adder)
SESSION.commit()
def add_welcome_setting(
chat_id,
custom_welcome_message,
should_clean_welcome,
previous_welcome,
media_file_id,
):
# adder = SESSION.query(Welcome).get(chat_id)
adder = Welcome(
chat_id,
custom_welcome_message,
should_clean_welcome,
previous_welcome,
media_file_id,
)
SESSION.add(adder)
SESSION.commit()
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 + "\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_captcha(chat_id, style):
with C_LOCK:
global CAPTCHA_CHAT
captcha = Captcha(
chat_id,
"on",
0,
style,
)
SESSION.add(captcha)
SESSION.commit()
CAPTCHA_CHAT = {
"chat_id": chat_id,
"mode": "on",
"time": 0,
"style": style,
}
return captcha
def fban_user(fed_id, user_id, first_name, last_name, user_name, reason, time):
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)
r = BansF(str(fed_id), str(user_id), first_name, last_name, user_name,
reason, time)
SESSION.add(r)
try:
SESSION.commit()
except:
SESSION.rollback()
return False
finally:
SESSION.commit()
__load_all_feds_banned()
return r
def add_usersid_in_db(chat_id: int):
id_user = Moidata(str(chat_id))
SESSION.add(id_user)
SESSION.commit()
def add_talkmode(chat_id: str):
talkmoddy = Talkmode(str(chat_id))
SESSION.add(talkmoddy)
SESSION.commit()
def add_pin(chat_id: str):
nightmoddy = Cleaned(str(chat_id))
SESSION.add(nightmoddy)
SESSION.commit()
def add_chat(chat_id: str):
nightmoddy = Nightmode(str(chat_id))
SESSION.add(nightmoddy)
SESSION.commit()
