def cmd_toggleloginsounds(self, data): data_actor = gs.mumble_inst.users[data.actor] current_status = not self.metadata.getboolean( C_PLUGIN_SET, P_PLAY_AUDIO_CLIP_ON_USER_JOIN, fallback=False) self.metadata[C_PLUGIN_SET][ P_PLAY_AUDIO_CLIP_ON_USER_JOIN] = f"{'True' if current_status else 'False'}" try: with open( f'{dir_utils.get_core_plugin_dir()}/{self.plugin_name}/metadata.ini', 'w') as metadata_file: self.metadata.write(metadata_file) self.metadata = PluginUtilityService.process_metadata( f'plugins/core/{self.plugin_name}') log(INFO, f"{'Enabled' if current_status else 'Disabled'} user connection sounds in the server_tools metadata.ini file.", origin=L_COMMAND, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui( f"{'Enabled' if current_status else 'Disabled'} user connection sounds in " f"the server_tools metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) except IOError: log(ERROR, f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", origin=L_COMMAND, error_type=CMD_PROCESS_ERR, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui( f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) return
def cmd_toggleuserconnectionsound(self, data): data_actor = gs.mumble_inst.users[data.actor] current_status = not self.metadata.getboolean( C_PLUGIN_SET, P_PLAY_AUDIO_CLIP_ON_USER_JOIN, fallback=False) self.metadata[C_PLUGIN_SET][ P_PLAY_AUDIO_CLIP_ON_USER_JOIN] = f"{'True' if current_status else 'False'}" try: with open( f'{dir_utils.get_main_dir()}/plugins/extensions/{self.plugin_name}/metadata.ini', 'w') as metadata_file: self.metadata.write(metadata_file) self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') gs.gui_service.quick_gui( f"{'Enabled' if current_status else 'Disabled'} user connection sounds in " f"the server_tools metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) except IOError: gs.gui_service.quick_gui( f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) return
def __init__(self): super().__init__() from os import path from json import loads self.plugin_name = path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/core/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.")
def cmd_setdefaultloginsound(self, data): all_data = data.message.strip().split(' ', 1) data_actor = gs.mumble_inst.users[data.actor] if len(all_data) != 2: log(ERROR, CMD_INVALID_SET_USER_DEFAULT_CONNECTION, origin=L_COMMAND, error_type=CMD_PROCESS_ERR, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui(CMD_INVALID_SET_USER_DEFAULT_CONNECTION, text_type='header', box_align='left', user=data_actor['name']) return audio_clip_name = all_data[1] if not find_file(audio_clip_name): log(ERROR, f"{audio_clip_name} is not one of the available files in the sound board permanent directory.", origin=L_COMMAND, error_type=CMD_PROCESS_ERR, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui( f"{audio_clip_name} is not one of the available files in the sound board permanent directory.", text_type='header', box_align='left', user=data_actor['name']) return self.metadata[C_PLUGIN_SET][ P_GENERIC_CLIP_TO_PLAY_ON_USER_JOIN] = audio_clip_name try: with open( f'{dir_utils.get_core_plugin_dir()}/{self.plugin_name}/metadata.ini', 'w') as metadata_file: self.metadata.write(metadata_file) self.metadata = PluginUtilityService.process_metadata( f'plugins/core/{self.plugin_name}') log(INFO, f"Updated the default user connection sound and saved the {self.plugin_name} metadata to the metadata.ini file.", origin=L_COMMAND, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui( f"Updated the default user connection sound and saved the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) except IOError: log(ERROR, f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", origin=L_COMMAND, error_type=CMD_PROCESS_ERR, print_mode=PrintMode.VERBOSE_PRINT.value) gs.gui_service.quick_gui( f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) return
def __init__(self): super().__init__() import os import json self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = json.loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) # Add any custom initialization code here... # ... # ... rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.")
def __init__(self): super().__init__() from json import loads self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads( self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) self.is_running = True log(INFO, f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value)
def __init__(self): super().__init__() from json import loads self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads( self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) dir_utils.make_directory( f'{gs.cfg[C_MEDIA_SETTINGS][P_PERM_MEDIA_DIR]}/{self.plugin_name}/' ) rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized." )
def __init__(self): super().__init__() from os import path from json import loads self.plugin_name = path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) self.osrs_wiki_url = self.metadata[C_PLUGIN_SET][P_WIKI_URL] self.osrs_user_agent = self.metadata[C_PLUGIN_SET][P_USER_AGENT] rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.") try: self.osrs_wiki = MediaWiki(url=self.osrs_wiki_url, user_agent=self.osrs_user_agent) except Exception: rprint(f"{self.plugin_name} Plugin could not be initialized.")
def __init__(self): super().__init__() from json import loads self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) dir_utils.make_directory(f'{GS.cfg[C_MEDIA_DIR][P_TEMP_MED_DIR]}/{self.plugin_name}/') warnings.filterwarnings("ignore", category=UserWarning, module='bs4') YH.yt_metadata = self.metadata YH.volume = float(self.metadata[C_PLUGIN_SETTINGS][P_YT_DEF_VOL]) YH.max_queue_size = int(self.metadata[C_PLUGIN_SETTINGS][P_YT_MAX_QUE_LEN]) YH.max_track_duration = int(self.metadata[C_PLUGIN_SETTINGS][P_YT_MAX_VID_LEN]) YH.autoplay = self.metadata.getboolean(C_PLUGIN_SETTINGS, P_YT_AUTO_PLAY, fallback=True) YH.queue_instance = qh.QueueHandler(YH.max_queue_size) rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.")
def __init__(self): super().__init__() from json import loads self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) self.is_running = True dir_utils.make_directory(f'{gs.cfg[C_MEDIA_SETTINGS][P_TEMP_MED_DIR]}/{self.plugin_name}/') dir_utils.clear_directory(f'{dir_utils.get_temp_med_dir()}/{self.plugin_name}') warnings.filterwarnings("ignore", category=UserWarning, module='bs4') log( INFO, f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value )
def __init__(self): super().__init__() from json import loads self.plugin_name = path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) self.is_running = True dir_utils.make_directory(f'{gs.cfg[C_MEDIA_SETTINGS][P_PERM_MEDIA_DIR]}/{self.plugin_name}/') dir_utils.make_directory(f'{gs.cfg[C_MEDIA_SETTINGS][P_TEMP_MED_DIR]}/{self.plugin_name}/') sbu_settings.sound_board_metadata = self.metadata sbu_settings.plugin_name = self.plugin_name log( INFO, f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value )
def __init__(self): from json import loads super().__init__() self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads( self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) dir_utils.make_directory( f'{GS.cfg[C_MEDIA_DIR][P_PERM_MEDIA_DIR]}/{self.plugin_name}/') dir_utils.make_directory( f'{GS.cfg[C_MEDIA_DIR][P_TEMP_MED_DIR]}/{self.plugin_name}/') tts_settings.tts_metadata = self.metadata tts_settings.voice_list = loads( self.metadata.get(C_PLUGIN_SETTINGS, P_TTS_ALL_VOICE)) rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized." )
def __init__(self): super().__init__() from json import loads self.plugin_name = os.path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads( self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) dir_utils.make_directory( f'{gs.cfg[C_MEDIA_SETTINGS][P_TEMP_MED_DIR]}/{self.plugin_name}/') dir_utils.clear_directory( f'{dir_utils.get_temp_med_dir()}/{self.plugin_name}') warnings.filterwarnings("ignore", category=UserWarning, module='bs4') md_settings.youtube_metadata = self.metadata md_settings.plugin_name = self.plugin_name self.register_callbacks() rprint( f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized." )
def __init__(self): super().__init__() from json import loads self.plugin_name = path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata(f'plugins/core/{self.plugin_name}') self.plugin_cmds = loads(self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) dir_utils.make_directory(f'{gs.cfg[C_MEDIA_SETTINGS][P_PERM_MEDIA_DIR]}/{self.plugin_name}/') dir_utils.make_directory(f'{gs.cfg[C_MEDIA_SETTINGS][P_TEMP_MED_DIR]}/{self.plugin_name}/') self.is_running = True st_settings.server_tools_metadata = self.metadata st_settings.plugin_name = self.plugin_name if not st_utility.create_empty_user_connections(): self.quit() self.register_callbacks() log( INFO, f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value )
def __init__(self): super().__init__() from os import path, makedirs from json import loads import shutil import errno self.plugin_name = path.basename(__file__).rsplit('.')[0] self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') self.plugin_cmds = loads( self.metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) # Copy over monster_images directory to the permanent media directory. try: if not path.exists( path.join(dir_utils.get_perm_med_dir(), 'mhw_wiki')): makedirs(path.join(dir_utils.get_perm_med_dir(), 'mhw_wiki')) except FileExistsError: pass try: shutil.copytree( path.join(path.dirname(__file__), 'resources/monster_images'), path.join(dir_utils.get_perm_med_dir(), 'mhw_wiki')) except OSError as e: if e.errno == errno.EEXIST: from distutils.dir_util import copy_tree copy_tree( path.join(path.dirname(__file__), 'resources/monster_images'), path.join(dir_utils.get_perm_med_dir(), 'mhw_wiki')) # Initialize database definitions self.mhw_db = sqlite3.connect( path.join(path.dirname(__file__), 'resources/mhw.db')) self.img_path = path.join(path.dirname(__file__), 'resources/monster_images') self.mhw_cursor = self.mhw_db.cursor() self.monster_definitions = define_all_monsters(self.mhw_cursor, self.img_path) log(INFO, f"{self.metadata[C_PLUGIN_INFO][P_PLUGIN_NAME]} v{self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]} Plugin Initialized.", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value)
def cmd_setdefaultconnectionsound(self, data): all_data = data.message.strip().split(' ', 1) data_actor = gs.mumble_inst.users[data.actor] if len(all_data) != 2: gs.gui_service.quick_gui( f"Incorrect Formatting!" f"<br>Format: {get_command_token()}setdefaultconnectionsound 'audio_clip_name'", text_type='header', box_align='left', user=data_actor['name']) return audio_clip_name = all_data[1] if not find_file(audio_clip_name): gs.gui_service.quick_gui( f"{audio_clip_name} is not one of the available files in the sound board permanent directory.", text_type='header', box_align='left', user=data_actor['name']) return self.metadata[C_PLUGIN_SET][ P_GENERIC_CLIP_TO_PLAY_ON_USER_JOIN] = audio_clip_name try: with open( f'{dir_utils.get_main_dir()}/plugins/extensions/{self.plugin_name}/metadata.ini', 'w') as metadata_file: self.metadata.write(metadata_file) self.metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{self.plugin_name}') gs.gui_service.quick_gui( f"Updated the default user connection sound and saved the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) except IOError: gs.gui_service.quick_gui( f"There was an error saving the {self.plugin_name} metadata to the metadata.ini file.", text_type='header', box_align='left', user=data_actor['name']) return
def initialize_plugins_safe(): import sys from os import path, listdir from json import loads from JJMumbleBot.lib.resources.strings import C_PLUGIN_SETTINGS, P_PLUG_SAFE if not global_settings.cfg: from JJMumbleBot.lib.errors import ExitCodes, ConfigError from JJMumbleBot.lib.utils import runtime_utils runtime_utils.exit_bot_error(ExitCodes.CONFIG_ERROR) raise ConfigError( 'There was an error loading the global config for initializing safe mode plugins.' ) # Import global aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path=f'{dir_utils.get_main_dir()}/cfg/global_aliases.csv') global_settings.bot_plugins = {} safe_mode_plugins = loads( global_settings.cfg.get(C_PLUGIN_SETTINGS, P_PLUG_SAFE)) # Load Core Plugins rprint("######### Initializing Core Plugins - Safe Mode #########") sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/core') all_imports = [ name for name in listdir(f'{dir_utils.get_main_dir()}/plugins/core') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/core', name)) and name != "__pycache__" ] for p_file in all_imports: if p_file in safe_mode_plugins: if not path.exists( f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/metadata.ini' ): rprint( f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) log( WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/core/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) dprint( f"Registered plugin command: " f"{plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}" ) # Initialize the core plugin class instance. global_settings.bot_plugins[ p_file] = global_settings.bot_plugins[p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/help.html' ) # help_plugin = __import__('help.help') # self.bot_plugins['help'] = help_plugin.help.Plugin(self.bot_plugins) sys.path.pop(0) rprint("######### Core Plugins Initialized - Safe Mode #########") # Load Extension Plugins rprint( "######### Initializing Extension Plugins - Safe Mode #########") sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/extensions') all_imports = [ name for name in listdir( f'{dir_utils.get_main_dir()}/plugins/extensions') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/extensions', name)) and name != "__pycache__" ] for p_file in all_imports: if p_file in safe_mode_plugins: if not path.exists( path.join( f'{dir_utils.get_main_dir()}/plugins/extensions', p_file)): rprint( f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) log( WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/core/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) dprint( f"Registered plugin command: " f"{plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}" ) # Initialize the core plugin class instance. global_settings.bot_plugins[ p_file] = global_settings.bot_plugins[p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/help.html' ) save_memory_db_to_file() sys.path.pop(0) rprint("######### Extension Plugins Initialized - Safe Mode #########")
def process(self, text): message = text.message.strip() message_parse = message[1:].split(' ', 1) command = message_parse[0] if command == "sleep": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return sleep_time = float(text.message[1:].split(' ', 1)[1].strip()) RS.tick_rate = sleep_time sleep(sleep_time) RS.tick_rate = float(GS.cfg[C_MAIN_SETTINGS][P_CMD_TICK_RATE]) elif command == "version": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return GS.gui_service.quick_gui( f"{rutils.get_bot_name()} is on version {rutils.get_version()}", text_type='header', box_align='left') elif command == "about": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return GS.gui_service.quick_gui( f"{rutils.get_about()}<br>{rutils.get_bot_name()} is on version {rutils.get_version()}", text_type='header', box_align='left') elif command == "uptime": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return GS.gui_service.quick_gui( rutils.check_up_time(), text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "exit": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return dprint("Stopping all threads...") rutils.exit_bot() log(INFO, "JJ Mumble Bot is being shut down.") log(INFO, "######################################") elif command == "reboot": import os import sys if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return rutils.exit_bot() log(INFO, "JJ Mumble Bot is being rebooted.", origin=L_STARTUP) os.execv(sys.executable, ['python3'] + sys.argv) # nosec elif command == "safereboot": import os import sys if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return rutils.exit_bot() log(INFO, "JJ Mumble Bot is being rebooted in safe mode.", origin=L_STARTUP) os.execv(sys.executable, ['python3'] + sys.argv + ['-safe']) # nosec elif command == "refresh": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return rutils.refresh_plugins() elif command == "help": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return message = text.message.strip() message_parse = message[1:].split(' ', 2) if len(message_parse) < 2: return plugin_name = message_parse[1] plugin_help_data = PluginUtilityService.process_help( db_cursor=get_memory_db().cursor(), plugin_name=plugin_name) if plugin_help_data: GS.gui_service.open_box() all_help_lines = [ msg.strip() for msg in plugin_help_data.split('<br>') ] content = GS.gui_service.make_content( f'<font color="red">##### </font>' f'<b>{rutils.get_bot_name()} Help Commands - [{plugin_name}]</b>' f'<font color="red"> #####</font>') GS.gui_service.append_row(content) content = GS.gui_service.make_content( f'Plugin Version: {self.metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]}<br>', text_color='cyan') GS.gui_service.append_row(content) for i, item in enumerate(all_help_lines): item_parts = item.split(':', 1) if len(item_parts) > 1: content = GS.gui_service.make_content( f'<font color="yellow">{item_parts[0]}</font>:{item_parts[1]}', text_type='header', text_align="left") else: content = GS.gui_service.make_content( f'{item}', text_type='header', text_align="left") GS.gui_service.append_row(content) GS.gui_service.close_box() GS.gui_service.display_box(channel=rutils.get_my_channel()) dprint( f"Displayed help screen for {plugin_name} in the channel.") log(INFO, f"Displayed help screen for {plugin_name} in the channel.", origin=L_COMMAND) elif command == "alias": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return message = text.message.strip() message_parse = message[1:].split(' ', 2) if len(message_parse) < 2: return alias_name = message_parse[1] if aliases.add_to_aliases(alias_name, message_parse[2]): GS.gui_service.quick_gui( f"Registered new alias: [{alias_name}] - [{message_parse[2]}]", text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif aliases.set_alias(alias_name, message_parse[2]): GS.gui_service.quick_gui( f"Registered alias: [{alias_name}] - [{message_parse[2]}]", text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "aliases": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return aliases_list = aliases.get_all_aliases() if len(aliases_list) == 0: cur_text = f"<font color='{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}'>Registered Aliases: None</font>" else: cur_text = f"<font color='{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}'>Registered Aliases:</font>" for i, alias in enumerate(aliases_list): cur_text += f"<br><font color={GS.cfg[C_PGUI_SETTINGS][P_TXT_IND_COL]}>[{alias[0]}]</font> - " \ f"[{BeautifulSoup(alias[1], 'html.parser').get_text()}] " if i % 50 == 0 and i != 0: GS.gui_service.quick_gui( cur_text, text_type='header', box_align='left', text_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) cur_text = "" GS.gui_service.quick_gui( cur_text, text_type='header', box_align='left', text_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "removealias": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return message = text.message.strip() message_parse = message[1:].split(' ', 2) if len(message_parse) < 2: return alias_name = message_parse[1] if aliases.remove_from_aliases(alias_name): GS.gui_service.quick_gui( f'Removed [{alias_name}] from registered aliases.', text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) else: GS.gui_service.quick_gui( f'Could not remove [{alias_name}] from registered aliases.', text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "clearaliases": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return if aliases.clear_aliases(): GS.gui_service.quick_gui( 'Cleared all registered aliases.', text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) else: GS.gui_service.quick_gui( 'The registered aliases could not be cleared.', text_type='header', box_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "clearhistory": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return GS.cmd_history.queue_storage.clear() GS.gui_service.quick_gui( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}">Cleared command history.</font>', text_type='header', box_align='left', text_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) elif command == "history": if not privileges.plugin_privilege_checker(text, command, self.plugin_name): return cur_text = f"<font color='{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}'>Command History:</font>" for i, item in enumerate(GS.cmd_history.queue_storage): cur_text += f"<br><font color={GS.cfg[C_PGUI_SETTINGS][P_TXT_IND_COL]}>[{i}]</font> - {item}" if i % 50 == 0 and i != 0: GS.gui_service.quick_gui( cur_text, text_type='header', box_align='left', text_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name']) cur_text = "" GS.gui_service.quick_gui( cur_text, text_type='header', box_align='left', text_align='left', ignore_whisper=True, user=GS.mumble_inst.users[text.actor]['name'])
def initialize_plugins_safe(): import sys from os import path, listdir from json import loads from JJMumbleBot.lib.resources.strings import C_PLUGIN_SETTINGS, P_PLUG_SAFE from hashlib import md5 if not global_settings.cfg: from JJMumbleBot.lib.errors import ExitCodes, ConfigError from JJMumbleBot.lib.utils import runtime_utils runtime_utils.exit_bot_error(ExitCodes.CONFIG_ERROR) raise ConfigError( 'There was an error loading the global config for initializing safe mode plugins.' ) # Check database metadata for changes. # If the version is different, or plugin checksum is modified, # clear plugins, plugins_help, and commands tables on launch. if global_settings.cfg.getboolean(C_MAIN_SETTINGS, P_DB_INTEGRITY, fallback=True): log(INFO, "######### Checking Database Integrity", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) all_core_plugins = [ name for name in listdir(f'{dir_utils.get_main_dir()}/plugins/core') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/core', name)) and name != "__pycache__" ] all_ext_plugins = [ name for name in listdir( f'{dir_utils.get_main_dir()}/plugins/extensions') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/extensions', name)) and name != "__pycache__" ] filenames = [] for core_plugin in all_core_plugins: glob_files = glob.glob( f'{dir_utils.get_main_dir()}/plugins/core/{core_plugin}/**/*', recursive=True) glob_files = [ f for f in glob_files if path.isfile(f) and "__pycache__" not in f ] filenames.extend(glob_files) for ext_plugin in all_ext_plugins: glob_files = glob.glob( f'{dir_utils.get_main_dir()}/plugins/extensions/{ext_plugin}/**/*', recursive=True) glob_files = [ f for f in glob_files if path.isfile(f) and "__pycache__" not in f ] filenames.extend(glob_files) hash_func = md5() # nosec for fn in filenames: if path.isfile(fn): hash_func.update(open(fn, "rb").read()) plugins_checksum = hash_func.hexdigest() integrity_check = UtilityDB.check_database_metadata( db_conn=get_memory_db(), version=META_VERSION, plugins_checksum=plugins_checksum) if integrity_check is False: log(WARNING, "Database integrity mismatch identified! Creating database backup and rebuilding database...", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) db_backup = BotServiceHelper.backup_database() if db_backup: log(INFO, f"Created internal database backup @ {db_backup}", origin=L_DATABASE, print_mode=PrintMode.REG_PRINT.value) DeleteDB.delete_all_commands(db_conn=get_memory_db()) DeleteDB.delete_all_plugins_help(db_conn=get_memory_db()) DeleteDB.delete_all_plugins(db_conn=get_memory_db()) log(INFO, "######### Database Integrity Verified", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) # Import custom aliases into the database. log(INFO, "######### Importing Custom Aliases", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path=f'{dir_utils.get_main_dir()}/cfg/custom_aliases.csv', update_if_exists=False) log(INFO, "######### Imported Custom Aliases", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) # Import custom command permissions into the database. log(INFO, "######### Importing Custom Command Permissions", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path=f'{dir_utils.get_main_dir()}/cfg/custom_permissions.csv', update_if_exists=False) log(INFO, "######### Imported Custom Command Permissions", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) # Import custom user privileges into the database. log(INFO, "######### Importing Custom User Privileges", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) UtilityDB.import_user_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/cfg/custom_user_privileges.csv', update_if_exists=False) log(INFO, "######### Imported Custom User Privileges", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) global_settings.bot_plugins = {} safe_mode_plugins = loads( global_settings.cfg.get(C_PLUGIN_SETTINGS, P_PLUG_SAFE)) # Load Core Plugins log(INFO, "######### Initializing Core Plugins - Safe Mode", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/core') all_imports = [ name for name in listdir(f'{dir_utils.get_main_dir()}/plugins/core') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/core', name)) and name != "__pycache__" ] for p_file in all_imports: if p_file in safe_mode_plugins: if not path.exists( f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/metadata.ini' ): log(WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization...", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/core/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) log(INFO, f"Registered plugin command: {plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}", origin=L_STARTUP, print_mode=PrintMode.VERBOSE_PRINT.value) # Initialize the core plugin class instance. global_settings.bot_plugins[ p_file] = global_settings.bot_plugins[p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/help.html' ) # Create directory for user modifiable plugin-specific data and configs. dir_utils.make_directory( f'{dir_utils.get_plugin_data_dir()}/{p_file}') sys.path.pop(0) log(INFO, "######### Core Plugins Initialized - Safe Mode", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) # Load Extension Plugins log(INFO, "######### Initializing Extension Plugins - Safe Mode", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/extensions') all_imports = [ name for name in listdir( f'{dir_utils.get_main_dir()}/plugins/extensions') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/extensions', name)) and name != "__pycache__" ] for p_file in all_imports: if p_file in safe_mode_plugins: if not path.exists( f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/metadata.ini' ): log(WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization...", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) log(INFO, f"Registered plugin command: {plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}", origin=L_STARTUP, print_mode=PrintMode.VERBOSE_PRINT.value) # Initialize the core plugin class instance. global_settings.bot_plugins[ p_file] = global_settings.bot_plugins[p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/help.html' ) # Create directory for user modifiable plugin-specific data and configs. dir_utils.make_directory( f'{dir_utils.get_plugin_data_dir()}/{p_file}') save_memory_db_to_file() sys.path.pop(0) log(INFO, "######### Extension Plugins Initialized - Safe Mode", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value)
def cmd_help(self, data): all_data = data.message.strip().split() if len(all_data) < 2: all_plugin_names = [plugin for plugin in list(GS.bot_plugins)] all_plugin_metadata = [{ "name": plugin_name, "metadata": GS.bot_plugins[plugin_name].metadata } for plugin_name in all_plugin_names] all_core_plugin_names = [ (plugin_info["name"], plugin_info["metadata"][C_PLUGIN_INFO][P_PLUGIN_NAME]) for plugin_info in all_plugin_metadata if plugin_info["metadata"].getboolean(C_PLUGIN_TYPE, P_CORE_PLUGIN) ] all_extension_plugin_names = [ (plugin_info["name"], plugin_info["metadata"][C_PLUGIN_INFO][P_PLUGIN_NAME]) for plugin_info in all_plugin_metadata if plugin_info["metadata"].getboolean(C_PLUGIN_TYPE, P_EXT_PLUGIN) ] GS.gui_service.open_box() content = GS.gui_service.make_content( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}">##### </font>' f'<b>{rutils.get_bot_name()} General Help Commands</b>' f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}"> #####</font>' ) GS.gui_service.append_row(content) content = GS.gui_service.make_content( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}">##### </font>' f'<b>Core Plugins</b>' f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}"> #####</font>' ) GS.gui_service.append_row(content) for x, plugin_info in enumerate(all_core_plugin_names): content = GS.gui_service.make_content( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_SUBHEAD_COL]}">!help {plugin_info[0].strip()}</font> - Displays help information for the <font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_IND_COL]}">{plugin_info[1]}</font> plugin.', text_type='header', text_align="left") GS.gui_service.append_row(content) content = GS.gui_service.make_content( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}">##### </font>' f'<b>Extension Plugins</b>' f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_HEAD_COL]}"> #####</font>' ) GS.gui_service.append_row(content) for x, plugin_info in enumerate(all_extension_plugin_names): content = GS.gui_service.make_content( f'<font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_SUBHEAD_COL]}">!help {plugin_info[0].strip()}</font> - Displays help information for the <font color="{GS.cfg[C_PGUI_SETTINGS][P_TXT_IND_COL]}">{plugin_info[1].strip()}</font> plugin.', text_type='header', text_align="left") GS.gui_service.append_row(content) GS.gui_service.close_box() GS.gui_service.display_box(channel=rutils.get_my_channel()) log(INFO, f"Displayed general help screen in the channel.", origin=L_COMMAND, print_mode=PrintMode.VERBOSE_PRINT.value) return plugin_name = all_data[1] plugin_help_data = PluginUtilityService.process_help( db_cursor=get_memory_db().cursor(), plugin_name=plugin_name) if plugin_help_data: plugin_metadata = GS.bot_plugins[plugin_name].metadata GS.gui_service.open_box() all_help_lines = [ msg.strip() for msg in plugin_help_data.split('<br>') ] content = GS.gui_service.make_content( f'<font color="red">##### </font>' f'<b>{rutils.get_bot_name()} Help Commands - [{plugin_name}]</b>' f'<font color="red"> #####</font>') GS.gui_service.append_row(content) content = GS.gui_service.make_content( f'Plugin Version: {plugin_metadata[C_PLUGIN_INFO][P_PLUGIN_VERS]}<br>', text_color='cyan') GS.gui_service.append_row(content) for x, help_item in enumerate(all_help_lines): item_parts = help_item.rsplit(':', 1) if len(item_parts) > 1: content = GS.gui_service.make_content( f'<font color="yellow">{item_parts[0]}</font>:{item_parts[1]}', text_type='header', text_align="left") else: content = GS.gui_service.make_content(f'{help_item}', text_type='header', text_align="left") GS.gui_service.append_row(content) GS.gui_service.close_box() GS.gui_service.display_box(channel=rutils.get_my_channel()) log(INFO, f"Displayed help screen for {plugin_name} in the channel.", origin=L_COMMAND, print_mode=PrintMode.VERBOSE_PRINT.value)
def initialize_plugins(): import sys from os import path, listdir from json import loads # Clear plugins, plugins_help, and commands tables on launch. DeleteDB.delete_all_commands(db_conn=get_memory_db()) DeleteDB.delete_all_plugins_help(db_conn=get_memory_db()) DeleteDB.delete_all_plugins(db_conn=get_memory_db()) # Import global aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path=f'{dir_utils.get_main_dir()}/cfg/global_aliases.csv') global_settings.bot_plugins = {} # Load Core Plugins rprint("######### Initializing Core Plugins #########") sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/core') all_imports = [ name for name in listdir(f'{dir_utils.get_main_dir()}/plugins/core') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/core', name)) and name != "__pycache__" ] for p_file in all_imports: if not path.exists( f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/metadata.ini' ): rprint( f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) log( WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/core/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) dprint( f"Registered plugin command: " f"{plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}" ) # Initialize the core plugin class instance. global_settings.bot_plugins[p_file] = global_settings.bot_plugins[ p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/core/{p_file}/help.html') sys.path.pop(0) rprint("######### Core Plugins Initialized #########") # Load Extension Plugins rprint("######### Initializing Extension Plugins #########") sys.path.insert(0, f'{dir_utils.get_main_dir()}/plugins/extensions') all_imports = [ name for name in listdir( f'{dir_utils.get_main_dir()}/plugins/extensions') if path.isdir( path.join(f'{dir_utils.get_main_dir()}/plugins/extensions', name)) and name != "__pycache__" ] for p_file in all_imports: if not path.exists( f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/metadata.ini' ): rprint( f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) log( WARNING, f"{p_file} plugin does not contain a metadata.ini file. Skipping initialization..." ) continue # Import the core plugin class. global_settings.bot_plugins[p_file] = __import__( f'{p_file}.{p_file}', fromlist=['*']).Plugin # Register plugin command callbacks. plugin_metadata = PluginUtilityService.process_metadata( f'plugins/extensions/{p_file}') plugin_cmds = loads( plugin_metadata.get(C_PLUGIN_INFO, P_PLUGIN_CMDS)) for plugin_command in plugin_cmds: global_settings.cmd_callbacks.register_command( f'{plugin_command}', p_file, f'{plugin_command}_clbk') global_settings.mtd_callbacks.register_callback( f'{plugin_command}_clbk', getattr(global_settings.bot_plugins[p_file], f'cmd_{plugin_command}', None)) dprint( f"Registered plugin command: " f"{plugin_command}:{global_settings.cmd_callbacks.get_command(plugin_command)[1]}:cmd_{plugin_command}" ) # Initialize the core plugin class instance. global_settings.bot_plugins[p_file] = global_settings.bot_plugins[ p_file]() # Import core plugin into the database. InsertDB.insert_new_plugin(db_conn=get_memory_db(), plugin_name=p_file, ignore_file_save=True) # Import core plugin user privileges into the database. UtilityDB.import_privileges_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/privileges.csv' ) # Import plugin aliases into the database. UtilityDB.import_aliases_to_db( db_conn=get_memory_db(), csv_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/aliases.csv' ) # Import plugin help into the database. UtilityDB.import_help_to_db( db_conn=get_memory_db(), html_path= f'{dir_utils.get_main_dir()}/plugins/extensions/{p_file}/help.html' ) save_memory_db_to_file() sys.path.pop(0) rprint("######### Extension Plugins Initialized #########")