def __load_feds_subscriber():
global FEDS_SUBSCRIBER
global MYFEDS_SUBSCRIBER
try:
feds = SESSION.query(FedSubs.fed_id).distinct().all()
for (fed_id, ) in feds: # remove tuple by ( ,)
FEDS_SUBSCRIBER[fed_id] = []
MYFEDS_SUBSCRIBER[fed_id] = []
all_fedsubs = SESSION.query(FedSubs).all()
for x in all_fedsubs:
FEDS_SUBSCRIBER[x.fed_id] += [x.fed_subs]
try:
MYFEDS_SUBSCRIBER[x.fed_subs] += [x.fed_id]
except KeyError:
getsubs = SESSION.query(FedSubs).get((x.fed_id, x.fed_subs))
if getsubs:
SESSION.delete(getsubs)
SESSION.commit()
FEDS_SUBSCRIBER = {x: set(y) for x, y in FEDS_SUBSCRIBER.items()}
MYFEDS_SUBSCRIBER = {x: set(y) for x, y in MYFEDS_SUBSCRIBER.items()}
finally:
SESSION.close()
def del_fed(fed_id):
with FEDS_LOCK:
global FEDERATION_BYOWNER, FEDERATION_BYFEDID, FEDERATION_BYNAME, FEDERATION_CHATS, FEDERATION_CHATS_BYID, FEDERATION_BANNED_USERID, FEDERATION_BANNED_FULL
getcache = FEDERATION_BYFEDID.get(fed_id)
if getcache is None:
return False
# Variables
getfed = FEDERATION_BYFEDID.get(fed_id)
owner_id = getfed["owner"]
fed_name = getfed["fname"]
# Delete from cache
FEDERATION_BYOWNER.pop(owner_id)
FEDERATION_BYFEDID.pop(fed_id)
FEDERATION_BYNAME.pop(fed_name)
if FEDERATION_CHATS_BYID.get(fed_id):
for x in FEDERATION_CHATS_BYID[fed_id]:
delchats = SESSION.query(ChatF).get(str(x))
if delchats:
SESSION.delete(delchats)
SESSION.commit()
FEDERATION_CHATS.pop(x)
FEDERATION_CHATS_BYID.pop(fed_id)
# Delete fedban users
getall = FEDERATION_BANNED_USERID.get(fed_id)
if getall:
for x in getall:
banlist = SESSION.query(BansF).get((fed_id, str(x)))
if banlist:
SESSION.delete(banlist)
SESSION.commit()
if FEDERATION_BANNED_USERID.get(fed_id):
FEDERATION_BANNED_USERID.pop(fed_id)
if FEDERATION_BANNED_FULL.get(fed_id):
FEDERATION_BANNED_FULL.pop(fed_id)
# Delete fedsubs
getall = MYFEDS_SUBSCRIBER.get(fed_id)
if getall:
for x in getall:
getsubs = SESSION.query(FedSubs).get((fed_id, str(x)))
if getsubs:
SESSION.delete(getsubs)
SESSION.commit()
if FEDS_SUBSCRIBER.get(fed_id):
FEDS_SUBSCRIBER.pop(fed_id)
if MYFEDS_SUBSCRIBER.get(fed_id):
MYFEDS_SUBSCRIBER.pop(fed_id)
# Delete from database
curr = SESSION.query(Federations).get(fed_id)
if curr:
SESSION.delete(curr)
SESSION.commit()
return True
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 is_gmuted(sender_id):
try:
return SESSION.query(GMute).all()
except:
return None
finally:
SESSION.close()
def get_filter(chat_id, keyword):
try:
return SESSION.query(Filters).get((str(chat_id), keyword))
except:
return None
finally:
SESSION.close()
def is_echo(user_id, chat_id):
try:
return SESSION.query(ECHOSQL).get((str(user_id), str(chat_id)))
except BaseException:
return None
finally:
SESSION.close()
def is_gbanned(chat_id):
try:
return SESSION.query(GBan).filter(GBan.chat_id == str(chat_id)).one()
except:
return None
finally:
SESSION.close()
def addgvar(variable, value):
if SESSION.query(Globals).filter(
Globals.variable == str(variable)).one_or_none():
delgvar(variable)
adder = Globals(str(variable), value)
SESSION.add(adder)
SESSION.commit()
def get_all_echos():
try:
return SESSION.query(ECHOSQL).all()
except BaseException:
return None
finally:
SESSION.close()
def already_added(chat_id):
try:
return SESSION.query(Moidata).filter(Moidata.chat_id == str(chat_id)).one()
except:
return None
finally:
SESSION.close()
def is_he_added(chat_id):
try:
return SESSION.query(Blockedid).filter(
Blockedid.chat_id == str(chat_id)).one()
except:
return None
finally:
SESSION.close()
def is_approved(chat_id):
try:
return SESSION.query(PMPermit).filter(
PMPermit.chat_id == str(chat_id)).one()
except BaseException:
return None
finally:
SESSION.close()
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()
return CHAT_FLOOD
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 __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 gvarstatus(variable):
try:
return SESSION.query(Globals).filter(
Globals.variable == str(variable)).first().value
except BaseException:
return None
finally:
SESSION.close()
def delglobal(variable):
rem = (
SESSION.query(Global)
.filter(Global.variable == str(variable))
.delete(synchronize_session="fetch")
)
if rem:
SESSION.commit()
def get_current_welcome_settings(chat_id):
try:
return SESSION.query(Welcome).filter(
Welcome.chat_id == str(chat_id)).one()
except:
return None
finally:
SESSION.close()
def is_approved(chat_id):
try:
return SESSION.query(NOLogPMs).filter(
NOLogPMs.chat_id == chat_id).one()
except:
return None
finally:
SESSION.close()
def get_all_filters(chat_id):
try:
return SESSION.query(Filters).filter(
Filters.chat_id == str(chat_id)).all()
except:
return None
finally:
SESSION.close()
def fs_settings(chat_id):
try:
return (SESSION.query(forceSubscribe).filter(
forceSubscribe.chat_id == chat_id).one())
except:
return None
finally:
SESSION.close()
def rmwafu_setting(chat_id):
try:
rem = SESSION.query(Joinwafu).get(str(chat_id))
if rem:
SESSION.delete(rem)
SESSION.commit()
return True
except BaseException:
return False
def getcurrent_wafu_settings(chat_id):
try:
return (
SESSION.query(Joinwafu).filter(Joinwafu.chat_id == str(chat_id)).one()
)
except BaseException:
return None
finally:
SESSION.close()
def migrate_chat(old_chat_id, new_chat_id):
with INSERTION_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 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 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 getglobal(variable):
try:
return (
SESSION.query(Global)
.filter(Global.variable == str(variable))
.first()
.value
)
except BaseException:
return None
finally:
SESSION.close()
def set_flood(chat_id, amount):
with INSERTION_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 addwafu_setting(chat_id, previous_wafu, reply, f_mesg_id):
to_check = getwafu(chat_id)
if not to_check:
adder = Joinwafu(chat_id, previous_wafu, reply, f_mesg_id)
SESSION.add(adder)
SESSION.commit()
return True
rem = SESSION.query(Joinwafu).get(str(chat_id))
SESSION.delete(rem)
SESSION.commit()
adder = Joinwafu(chat_id, previous_wafu, reply, f_mesg_id)
SESSION.commit()
return False
def rem_sub(my_fed, fed_id):
sox = SESSION.query(FedSubs).get((my_fed, fed_id))
if sox:
if fed_id in MYFEDS_SUBSCRIBER.get(my_fed, set()): # sanity check
MYFEDS_SUBSCRIBER.get(my_fed, set()).remove(fed_id)
SESSION.delete(sox)
SESSION.commit()
return True
SESSION.close()
return False
