def set_clean_service(chat_id: Union[int, str], setting: bool): with CS_LOCK: chat_setting = SESSION.query(CleanServiceSetting).get(str(chat_id)) if not chat_setting: chat_setting = CleanServiceSetting(chat_id) chat_setting.clean_service = setting SESSION.add(chat_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 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_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 set_lockconf(chat_id, should_warn): with CONF_LOCK: lock_setting = SESSION.query(LockConfig).get(str(chat_id)) if not lock_setting: lock_setting = LockConfig(str(chat_id)) lock_setting.warn = should_warn SESSION.add(lock_setting) SESSION.commit()
def __load_gbanned_userid_list(): global GBANNED_LIST try: GBANNED_LIST = { x.user_id for x in SESSION.query(GloballyBannedUsers).all() } finally: SESSION.close()
def __load_gban_stat_list(): global GBANSTAT_LIST try: GBANSTAT_LIST = { x.chat_id for x in SESSION.query(GbanSettings).all() if not x.setting } finally: SESSION.close()
def set_permapin(chat_id, message_id): with PERMPIN_LOCK: permpin = SESSION.query(PermanentPin).get(str(chat_id)) if not permpin: permpin = PermanentPin(chat_id) permpin.message_id = int(message_id) SESSION.add(permpin) SESSION.commit()
def welcome_security(chat_id): try: security = SESSION.query(WelcomeSecurity).get(str(chat_id)) if security: return security.security, security.extra_verify, security.mute_time, security.timeout, security.timeout_mode, security.custom_text else: return False, False, "0", "0", 1, "Klik disini untuk mensuarakan" finally: SESSION.close()
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 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 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 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_warn_mode(chat_id): try: setting = SESSION.query(WarnSettings).get(str(chat_id)) if setting: return setting.warn_mode, setting.warn_mode else: return 3, False finally: SESSION.close()
def set_user(user_id, username): with INSERTION_LOCK: user = SESSION.query(LastFMUsers).get(str(user_id)) if not user: user = LastFMUsers(str(user_id), str(username)) else: user.username = str(username) SESSION.add(user) 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, setting.warn_mode else: return 3, False, 1 finally: SESSION.close()
def set_warn_mode(chat_id, warn_mode): with WARN_SETTINGS_LOCK: curr_setting = SESSION.query(WarnSettings).get(str(chat_id)) if not curr_setting: curr_setting = WarnSettings(chat_id, warn_mode=warn_mode) curr_setting.warn_mode = warn_mode SESSION.add(curr_setting) SESSION.commit()
def add_warn_filter(chat_id, keyword, reply): with WARN_FILTER_INSERTION_LOCK: warn_filt = WarnFilters(str(chat_id), keyword, reply) if keyword not in WARN_FILTERS.get(str(chat_id), []): WARN_FILTERS[str(chat_id)] = sorted(WARN_FILTERS.get(str(chat_id), []) + [keyword], key=lambda x: (-len(x), x)) SESSION.merge(warn_filt) # merge to avoid duplicate key issues 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 __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 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 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 __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 __load_disabledel(): global DISABLEDEL try: all_disabledel = SESSION.query(DisableDelete).all() for x in all_disabledel: if x.is_enable: DISABLEDEL.append(str(x.chat_id)) finally: SESSION.close()
def get_blacklist_setting(chat_id): try: setting = CHAT_BLSTICK_BLACKLISTS.get(str(chat_id)) if setting: return setting['blacklist_type'], setting['value'] else: return 1, "0" finally: SESSION.close()
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 __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 add_to_stickers(chat_id, trigger): with STICKERS_FILTER_INSERTION_LOCK: stickers_filt = StickersFilters(str(chat_id), trigger) SESSION.merge(stickers_filt) # merge to avoid duplicate key issues SESSION.commit() global CHAT_STICKERS if CHAT_STICKERS.get(str(chat_id), set()) == set(): CHAT_STICKERS[str(chat_id)] = {trigger} else: CHAT_STICKERS.get(str(chat_id), set()).add(trigger)
def add_to_userlist(chat_id, user_id, is_clicked): with UR_LOCK: user_filt = UserRestrict(str(chat_id), user_id, is_clicked) SESSION.merge(user_filt) # merge to avoid duplicate key issues SESSION.commit() global CHAT_USERRESTRICT if not CHAT_USERRESTRICT.get(str(chat_id)): CHAT_USERRESTRICT[str(chat_id)] = {user_id: is_clicked} else: CHAT_USERRESTRICT.get(str(chat_id))[user_id] = is_clicked