Upgraded the Relay module - it supports multiple relays now.

modules/core/colors/color_controller.py

@@ -37,12 +37,3 @@ class ColorController(BaseModule):
                                           "Default private message color")
         self.setting_service.register_new(self.module_name, "blob_color", "#FFFFFF", ColorSettingType(),
                                           "Default blob content color")
-        if 'orgbot' in self.bot.modules:
-            self.setting_service.register_new(self.module_name, "alliance_base", "#00FF00", ColorSettingType(),
-                                              "Base color for alliance relay")
-            self.setting_service.register_new(self.module_name, "alliance_org", "#FFFF00", ColorSettingType(),
-                                              "Org color for alliance relay")
-            self.setting_service.register_new(self.module_name, "alliance_sender", "#FF8C00", ColorSettingType(),
-                                              "Name color for alliance relay")
-            self.setting_service.register_new(self.module_name, "alliance_msg", "#FF8C00", ColorSettingType(),
-                                              "Message color for alliance relay")

modules/orgbot/alliance/alliance_relay.py

@@ -0,0 +1,403 @@
+import re
+
+from core.aochat import server_packets, client_packets
+from core.aochat.client_packets import PrivateChannelLeave
+from core.chat_blob import ChatBlob
+from core.command_param_types import Const, Character, Options, Any
+from core.conn import Conn
+from core.decorators import instance, command
+from core.logger import Logger
+from core.lookup.character_service import CharacterService
+from core.setting_service import SettingService
+from core.setting_types import DictionarySettingType
+from core.text import Text
+from core.tyrbot import Tyrbot
+
+
+# noinspection DuplicatedCode
+@instance()
+class AllianceRelay:
+    MESSAGE_SOURCE = "alliance"
+
+    def __init__(self):
+        self.logger = Logger(__name__)
+        self.relay_channel = []
+
+    def inject(self, registry):
+        self.bot: Tyrbot = registry.get_instance("bot")
+        self.setting_service: SettingService = registry.get_instance("setting_service")
+        self.character_service: CharacterService = registry.get_instance("character_service")
+        self.message_hub_service = registry.get_instance("message_hub_service")
+        self.public_channel_service = registry.get_instance("public_channel_service")
+        self.text: Text = registry.get_instance("text")
+
+    def pre_start(self):
+        self.message_hub_service.register_message_source(self.MESSAGE_SOURCE)
+
+    def start(self):
+
+        self.setting_service.register_new(self.module_name, "relay_symbols", {'default': "-"}, DictionarySettingType(), "Symbol for external relay")
+        self.setting_service.register_new(self.module_name, "relay_symbol_methods", {'default': "always"}, DictionarySettingType(), "When to relay messages")
+        self.setting_service.register_new(self.module_name, "relay_bots", {}, DictionarySettingType(), "Bot for alliance relay")
+        self.setting_service.register_new(self.module_name, "relay_command", {"default": "!agcr"}, DictionarySettingType(), "Relay command for the relay")
+        self.setting_service.register_new(self.module_name, "relay_enabled", {"default": True}, DictionarySettingType(), "Enable the alliance relay")
+        self.setting_service.register_new(self.module_name, "relay_guild_abbreviations", {"default": self.public_channel_service.get_org_name()}, DictionarySettingType(), "Abbreviation to use for org name")
+        self.setting_service.register_new(self.module_name, "relay_color_base", {"default": "#00FF00"}, DictionarySettingType(), "Base color for alliance relay")
+        self.setting_service.register_new(self.module_name, "relay_color_org", {"default": "#FFFF00"}, DictionarySettingType(), "Org color for alliance relay")
+        self.setting_service.register_new(self.module_name, "relay_color_sender", {"default": "#FF8C00"}, DictionarySettingType(), "Name color for alliance relay")
+        self.setting_service.register_new(self.module_name, "relay_color_msg", {"default": "#FF8C00"}, DictionarySettingType(), "Message color for alliance relay")
+        self.message_hub_service.register_message_destination(self.MESSAGE_SOURCE,
+                                                              self.handle_relay_hub_message,
+                                                              ["org_channel"],
+                                                              [self.MESSAGE_SOURCE])
+
+        self.bot.register_packet_handler(server_packets.PrivateChannelInvited.id, self.handle_private_channel_invite,
+                                         100)
+        self.bot.register_packet_handler(server_packets.PrivateChannelMessage.id, self.handle_private_channel_message)
+
+    @command(command="mrelay", params=[], access_level="admin",
+             description="View the relay settings")
+    def mrelay(self, request):
+        def display_color(color, msg=None):
+            if not msg:
+                msg = color
+            if color:
+                return f"<font color={color}>{msg}</font>"
+            return "UNSET"
+        blob = ""
+        for bot in self.relay_bots().get_value().keys():
+            enabled = self.relay_enabled().get_value().get(bot, self.relay_enabled().get_value().get('default', 'UNSET'))
+            prefix = self.relay_symbols().get_value().get(bot, self.relay_symbols().get_value().get('default'))
+            relay_cmd = self.relay_command().get_value().get(bot, self.relay_command().get_value().get('default'))
+            base = self.relay_color_base().get_value().get(bot, self.relay_color_base().get_value().get('default', None))
+            sender = self.relay_color_sender().get_value().get(bot, self.relay_color_sender().get_value().get('default', None))
+            abbrv = self.relay_color_org().get_value().get(bot, self.relay_color_org().get_value().get('default', None))
+            msg = self.relay_color_msg().get_value().get(bot, self.relay_color_msg().get_value().get('default', None))
+            our_abbrv = self.relay_guild_abbreviations().get_value().get(bot, self.relay_guild_abbreviations().get_value().get('default', 'UNSET'))
+            example = display_color(base, f'[{display_color(abbrv, our_abbrv)}] {display_color(sender, request.sender.name)}: {display_color(msg, "And I sent you a message")}')
+            blob += f"Relay <highlight>{self.character_service.get_char_name(int(bot))}</highlight>:\n"
+            blob += f"  Enabled: {enabled} [{self.text.make_tellcmd('Toggle', f'mrelay status {bot} {not enabled}')}]\n"
+            blob += f"  Prefix: {prefix} [{self.text.make_tellcmd('Edit', f'mrelay prefix {bot}')}]\n"
+            blob += f"  Relay command: {relay_cmd} [{self.text.make_tellcmd('Edit', f'mrelay rcmd {bot}')}]\n"
+            blob += f"  Base color: {display_color(base)} [{self.text.make_tellcmd('Edit', f'mrelay color {bot} base')}]\n"
+            blob += f"  Abbrv color: {display_color(abbrv)} [{self.text.make_tellcmd('Edit', f'mrelay color {bot} org')}]\n"
+            blob += f"  Sender color: {display_color(sender)} [{self.text.make_tellcmd('Edit', f'mrelay color {bot} sender')}]\n"
+            blob += f"  Message color: {display_color(msg)} [{self.text.make_tellcmd('Edit', f'mrelay color {bot} msg')}]\n"
+            blob += f"  Abbreviation: {our_abbrv} [Use <highlight>!mrelay abbrv {bot} &lt;your Abbreviation&gt;</highlight>]\n"
+            blob += f"  Example msg: {example}"
+            blob += "\n\n"
+
+        return ChatBlob("Current Relays", blob)
+
+    @command(command="mrelay", params=[Const("create"), Character("relaybot_name")], access_level="admin",
+             description="Create a new Relay")
+    def mrelay_create(self, request, _, bot):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if bot.char_id in bots.keys():
+            return f"There's already a relay for <highlight>{bot.name}</highlight>."
+        bots[bot.char_id] = ""
+        self.relay_bots().set_value(bots)
+
+        return f"Successfully created relay <highlight>{bot.name}</highlight>. Use <symbol>mrelay to edit it."
+
+    @command(command="mrelay", params=[Const("delete"), Character("relaybot_name")], access_level="admin",
+             description="Delete a Relay")
+    def mrelay_delete(self, request, _, bot):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if str(bot.char_id) not in bots.keys():
+            return f"There's no relay for <highlight>{bot.name}</highlight>."
+        bots.pop(str(bot.char_id))
+        self.bot.send_packet(PrivateChannelLeave(bot.char_id))
+        self.relay_bots().set_value(bots)
+        user = str(bot.char_id)
+
+        cur = self.relay_enabled().get_value()
+        cur.pop(user, None)
+        self.relay_enabled().set_value(cur)
+
+        cur = self.relay_command().get_value()
+        cur.pop(user, None)
+        self.relay_command().set_value(cur)
+
+        cur = self.relay_bots().get_value()
+        cur.pop(user, None)
+        self.relay_bots().set_value(cur)
+
+        cur = self.relay_guild_abbreviations().get_value()
+        cur.pop(user, None)
+        self.relay_guild_abbreviations().set_value(cur)
+
+        cur = self.relay_color_base().get_value()
+        cur.pop(user, None)
+        self.relay_color_base().set_value(cur)
+
+        cur = self.relay_color_msg().get_value()
+        cur.pop(user, None)
+        self.relay_color_msg().set_value(cur)
+
+        cur = self.relay_color_sender().get_value()
+        cur.pop(user, None)
+        self.relay_color_sender().set_value(cur)
+
+        cur = self.relay_color_org().get_value()
+        cur.pop(user, None)
+        self.relay_color_msg().set_value(cur)
+
+        cur = self.relay_symbols().get_value()
+        cur.pop(user, None)
+        self.relay_symbols().set_value(cur)
+
+        cur = self.relay_symbol_methods().get_value()
+        cur.pop(user, None)
+        self.relay_symbol_methods().set_value(cur)
+
+        return f"Successfully deleted relay <highlight>{bot.name}</highlight>"
+
+    @command(command="mrelay",
+             params=[Const("rcmd"), Character("relaybot_name"), Any("relay_command", is_optional=True)], access_level="admin",
+             description="Change the relay command used in a relay")
+    def mrelay_rcmd(self, request, _, bot, relay_command):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if str(bot.char_id) not in bots.keys():
+            return f"There's no relay for <highlight>{bot.name}</highlight> registered. Please use <symbol>mrelay create {bot.name}"
+        bot = str(bot.char_id)
+        current = self.relay_command().get_value()
+        if not relay_command:
+            blob = f"Current relay command: {current.get(bot, current.get('default', 'UNSET'))}\n\n"
+            blob += "Here are some presets:\n"
+            for rcmd in ["!agrc", "!gcr", "agrc", "gcr"]:
+                blob += f"  {self.text.make_tellcmd(rcmd, f'mrelay rcmd {bot} {rcmd}')}\n"
+            blob += "\n"
+            blob += f"Or you can use <highlight><symbol>mrelay rcmd {self.character_service.get_char_name(int(bot))} &lt;Your Prefix&gt;</highlight> to set a custom one."
+            return ChatBlob("Pick your relay command", blob)
+
+        current[bot] = relay_command
+        self.relay_command().set_value(current)
+        return f"Successfully changed the relaying command for relaying messages to " \
+               f"<highlight>{self.character_service.get_char_name(int(bot))}</highlight>: <highlight>{relay_command}</highlight>"
+
+    @command(command="mrelay",
+             params=[Const("prefix"), Character("relaybot_name"), Any("prefix", is_optional=True)], access_level="admin",
+             description="Change the prefix setting of the relays")
+    def mrelay_prefix(self, request, _, bot, prefix):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if str(bot.char_id) not in bots.keys():
+            return f"There's no relay for <highlight>{bot.name}</highlight> registered. Please use <symbol>mrelay create {bot.name}"
+        bot = str(bot.char_id)
+        current = self.relay_symbols().get_value()
+        if not prefix:
+            blob = f"Current prefix: {current.get(bot, current.get('default', 'UNSET'))}\n\n"
+            blob += "Here are some presets:\n"
+            for prefix in ["-", "--", "+", "#", "*", "@", "$", "$$"]:
+                blob += f"  {self.text.make_tellcmd(prefix, f'mrelay prefix {bot} {prefix}')}\n"
+            blob += "\n"
+            blob += f"Or you can use <highlight><symbol>mrelay prefix {self.character_service.get_char_name(int(bot))} &lt;Your Prefix&gt;</highlight> to set a custom one."
+            return ChatBlob("Pick your prefix", blob)
+
+        current[bot] = prefix
+        self.relay_symbols().set_value(current)
+        return f"Successfully changed the symbol for relaying messages to " \
+               f"<highlight>{self.character_service.get_char_name(int(bot))}</highlight>: <highlight>{prefix}</highlight>"
+
+    @command(command="mrelay",
+             params=[Const("status"), Character("relaybot_name"), Options(["on", "off", "true", "false"])],
+             access_level="admin",
+             description="Change the enabled status of the relays")
+    def mrelay_status(self, request, _, bot, option):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if str(bot.char_id) not in bots.keys():
+            return f"There's no relay for <highlight>{bot.name}</highlight> registered. Please use <symbol>mrelay create {bot.name}"
+        bot = str(bot.char_id)
+        current = self.relay_enabled().get_value()
+        option = True if option.lower() in ["on", "true"] else False
+        if current.get(bot, None) == option:
+            return f"The relay status of {self.character_service.get_char_name(int(bot))} is already {option}"
+        current[bot] = option
+        self.relay_enabled().set_value(current)
+        return f"Successfully changed the symbol for relaying messages to " \
+               f"<highlight>{self.character_service.get_char_name(int(bot))}</highlight>: <highlight>{option}</highlight>"
+
+    @command(command="mrelay", params=[Const("color"), Character("relaybot_name"), Options(["base", "sender", "org", "msg"]), Any("color_code", is_optional=True)], access_level="admin",
+             description="Change the color settings of the relays")
+    def mrelay_color(self, request, _, bot, option, color):
+        bots: dict = self.relay_bots().get_value()
+        if not bot.char_id:
+            return f"The character <highlight>{bot.name}</highlight> does not exist."
+        if str(bot.char_id) not in bots.keys():
+            return f"There's no relay for <highlight>{bot.name}</highlight> registered. Please use <symbol>mrelay create {bot.name}"
+        bot = str(bot.char_id)
+        if option == "base":
+            current = self.relay_color_base().get_value()
+            if color is None:
+                return ChatBlob("Pick a color", self.color_template(bot, option, current))
+            if self.check_color(color):
+                current[bot] = color
+                self.relay_color_base().set_value(current)
+            else:
+                return f"Your color is not valid: {color}. Syntax: #000000 or #000"
+        elif option == "sender":
+            current = self.relay_color_sender().get_value()
+            if color is None:
+                return ChatBlob("Pick a color", self.color_template(bot, option, current))
+            if self.check_color(color):
+                current[bot] = color
+                self.relay_color_sender().set_value(current)
+            else:
+                return f"Your color is not valid: {color}. Syntax: #000000 or #000"
+        elif option == "org":
+            current = self.relay_color_org().get_value()
+            if color is None:
+                return ChatBlob("Pick a color", self.color_template(bot, option, current))
+            if self.check_color(color):
+                current[bot] = color
+                self.relay_color_org().set_value(current)
+            else:
+                return f"Your color is not valid: {color}. Syntax: #000000 or #000"
+        elif option == "msg":
+            current = self.relay_color_msg().get_value()
+            if color is None:
+                return ChatBlob("Pick a color", self.color_template(bot, option, current))
+            if self.check_color(color):
+                current[bot] = color
+                self.relay_color_msg().set_value(current)
+            else:
+                return f"Your color is not valid: {color}. Syntax: #000000 or #000"
+        return f"Successfully set the <highlight>{option}</highlight> color to <font color={color}>{color}</font>" \
+               f" for relay <highlight>{self.character_service.get_char_name(int(bot))}</highlight>"
+
+    def color_template(self, bot, option, current):
+        def display(color, msg):
+            return f"<font color={color}>{msg}</font> (<a href='chatcmd:///tell <myname> mrelay color {bot} {option} {color}'>Save it</a>)"
+        blob = f"Current color: <font color={current.get(bot, current.get('default', '#00ff00'))}>" \
+               f"{current.get(bot, current.get('default', '#00ff00'))}</font>\n\n"
+        blob += f"{display('#FF0000', 'Red')}\n"
+        blob += f"{display('#FFFFFF', 'White')}\n"
+        blob += f"{display('#808080', 'Grey')}\n"
+        blob += f"{display('#DDDDDD', 'Light Grey')}\n"
+        blob += f"{display('#9CC6E7', 'Dark Grey')}\n"
+        blob += f"{display('#000000', 'Black')}\n"
+        blob += f"{display('#FFFF00', 'Yellow')}\n"
+        blob += f"{display('#8CB5FF', 'Blue')}\n"
+        blob += f"{display('#00BFFF', 'Deep Sky Blue')}\n"
+        blob += f"{display('#00DE42', 'Green')}\n"
+        blob += f"{display('#FCA712', 'Orange')}\n"
+        blob += f"{display('#FFD700', 'Gold')}\n"
+        blob += f"{display('#FF1493', 'Deep Pink')}\n"
+        blob += f"{display('#EE82EE', 'Violet')}\n"
+        blob += f"{display('#8B7355', 'Brown')}\n"
+        blob += f"{display('#00FFFF', 'Cyan')}\n"
+        blob += f"{display('#000080', 'Navy Blue')}\n"
+        blob += f"{display('#FF8C00', 'Dark Orange')}\n"
+        return blob
+
+    def handle_private_channel_invite(self, conn: Conn, packet: server_packets.PrivateChannelInvited):
+        if conn.id != "main":
+            return
+        if str(packet.private_channel_id) not in self.relay_bots().get_value().keys():
+            return
+        if not self.relay_enabled().get_value().get(str(packet.private_channel_id), self.relay_enabled().get_value().get('default', False)):
+            return
+        self.bot.send_packet(client_packets.PrivateChannelJoin(packet.private_channel_id))
+        self.logger.info(f"Joined private channel {self.character_service.get_char_name(packet.private_channel_id)}")
+        self.relay_channel.append(str(packet.private_channel_id))
+
+    def handle_private_channel_message(self, conn: Conn, packet: server_packets.PrivateChannelMessage):
+        if conn.id != "main":
+            return
+        if packet.private_channel_id == self.bot.get_char_id():
+            return
+        if packet.char_id == self.bot.get_char_id():
+            return
+        if not self.relay_enabled().get_value().get(str(packet.private_channel_id), self.relay_enabled().get_value().get('default', False)):
+            return
+        priv = str(packet.private_channel_id)
+        message = packet.message.lstrip()
+        rcmd = self.relay_command().get_value().get(priv, self.relay_command().get_value().get('default', "UNSET"))
+        if rcmd == "UNSET":
+            self.logger.warning("##FIX ME## No relay command set!")
+        if message[:len(rcmd)] != rcmd:
+            return
+        message = re.match(f"{rcmd} \[(.+?)\] (.+?): (.+)", message)
+        if not message:
+            return
+        org, name, text = message.groups()
+        plain = f"[{org}] {name}: {text}"
+        org = self.format_text(self.relay_color_org().get_value().get(priv, self.relay_color_org().get_value().get("default")), org)
+        name = self.format_text(self.relay_color_sender().get_value().get(priv, self.relay_color_sender().get_value().get("default")), name)
+        text = self.format_text(self.relay_color_msg().get_value().get(priv, self.relay_color_msg().get_value().get("default")), text)
+        formatted = self.format_text(self.relay_color_base().get_value().get(priv, self.relay_color_base().get_value().get("default")), f"[{org}] {name}: {text}")
+        self.message_hub_service.send_message(self.MESSAGE_SOURCE, None, plain, formatted)
+
+    def handle_relay_hub_message(self, ctx):
+        enabled = lambda x: self.relay_enabled().get_value().get(x, self.relay_enabled().get_value().get('default', False))
+        for key in self.relay_bots().get_value().keys():
+            if key not in self.relay_channel:
+                continue
+            if not enabled(key):
+                continue
+            prefix = self.relay_symbols().get_value().get(key, self.relay_symbols().get_value().get('default', False))
+            if not ctx.message.startswith(prefix):
+                continue
+
+            message = ctx.message[len(prefix):].strip()
+            if len(message) < 1:
+                continue
+            sender = ctx.sender.name
+            abbrv = self.relay_guild_abbreviations().get_value().get(key, self.relay_guild_abbreviations().get_value().get("default"))
+            cmd = self.relay_command().get_value().get(key, self.relay_command().get_value().get("default"))
+            msg = f"{cmd} [{abbrv}] {sender}: {message}"
+            self.send_message_to_alliance(key, msg)
+
+    def send_message_to_alliance(self, alliance, msg):
+        packet = client_packets.PrivateChannelMessage(int(alliance), self.text.format_message(msg, False), "\0")
+        self.bot.conns["main"].send_packet(packet)
+
+    def relay_symbols(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_symbols")
+
+    def relay_symbol_methods(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_symbol_methods")
+
+    def relay_bots(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_bots")
+
+    def relay_enabled(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_enabled")
+
+    def relay_guild_abbreviations(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_guild_abbreviations")
+
+    def relay_color_base(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_color_base")
+
+    def relay_color_org(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_color_org")
+
+    def relay_color_sender(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_color_sender")
+
+    def relay_color_msg(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_color_msg")
+
+    def relay_command(self) -> DictionarySettingType:
+        return self.setting_service.get("relay_command")
+
+    def check_color(self, msg: str):
+        if not msg.startswith('#'):
+            return False
+        if len(msg) not in [4, 7]:
+            return False
+        return True
+
+    def format_text(self, color, message):
+        return f"<font color={color}>{message}</font>"

modules/orgbot/alliance/alliance_relay_controller.py

@@ -1,135 +0,0 @@
-import re
-
-from core.aochat import server_packets, client_packets
-from core.conn import Conn
-from core.decorators import instance
-from core.logger import Logger
-from core.lookup.character_service import CharacterService
-from core.setting_service import SettingService
-from core.setting_types import TextSettingType, BooleanSettingType
-from core.text import Text
-from core.tyrbot import Tyrbot
-
-
-# noinspection DuplicatedCode
-@instance("AllianceRelayController")
-class AllianceRelayController:
-    relay_channel_id = None
-    MESSAGE_SOURCE = "alliance"
-
-    def __init__(self):
-        self.logger = Logger(__name__)
-
-    def inject(self, registry):
-        self.bot: Tyrbot = registry.get_instance("bot")
-        self.setting_service: SettingService = registry.get_instance("setting_service")
-        self.character_service: CharacterService = registry.get_instance("character_service")
-        self.message_hub_service = registry.get_instance("message_hub_service")
-        self.public_channel_service = registry.get_instance("public_channel_service")
-        self.text: Text = registry.get_instance("text")
-
-    def pre_start(self):
-        self.message_hub_service.register_message_source(self.MESSAGE_SOURCE)
-
-    def start(self):
-        self.setting_service.register_new(self.module_name, "arelay_symbol", "#",
-                                          TextSettingType(["!", "#", "*", "@", "$", "+", "-"]),
-                                          "Symbol for external relay")
-
-        self.setting_service.register_new(self.module_name, "arelay_symbol_method", "with_symbol",
-                                          TextSettingType(["Always", "with_symbol", "unless_symbol"]),
-                                          "When to relay messages")
-
-        self.setting_service.register_new(self.module_name, "arelaybot", "",
-                                          TextSettingType(allow_empty=True),
-                                          "Bot for alliance relay")
-
-        self.setting_service.register_new(self.module_name, "arelay_enabled", False,
-                                          BooleanSettingType(),
-                                          "Enable the alliance relay")
-
-        self.setting_service.register_new(self.module_name, "arelay_guild_abbreviation", "",
-                                          TextSettingType(allow_empty=True),
-                                          "Abbreviation to use for org name")
-
-        self.message_hub_service.register_message_destination(self.MESSAGE_SOURCE,
-                                                              self.handle_relay_hub_message,
-                                                              ["org_channel"],
-                                                              [self.MESSAGE_SOURCE])
-
-        self.bot.register_packet_handler(server_packets.PrivateChannelInvited.id, self.handle_private_channel_invite,
-                                         100)
-        self.bot.register_packet_handler(server_packets.PrivateChannelMessage.id, self.handle_private_channel_message)
-
-    def handle_private_channel_invite(self, conn: Conn, packet: server_packets.PrivateChannelInvited):
-        if conn.id != "main":
-            return
-
-        if not self.setting_service.get("arelay_enabled").get_value():
-            return
-
-        channel_name = self.character_service.get_char_name(packet.private_channel_id)
-        if self.setting_service.get_value("arelaybot").lower() == channel_name.lower():
-            self.bot.send_packet(client_packets.PrivateChannelJoin(packet.private_channel_id))
-            self.logger.info("Joined private channel {channel}".format(channel=channel_name))
-            self.relay_channel_id = packet.private_channel_id
-
-    def handle_private_channel_message(self, conn: Conn, packet: server_packets.PrivateChannelMessage):
-        if conn.id != "main":
-            return
-
-        if not self.setting_service.get("arelay_enabled").get_value():
-            return
-
-        # ignore packets from the bot's own private channel and from the bot itself
-        if packet.private_channel_id == self.bot.get_char_id() or packet.char_id == self.bot.get_char_id():
-            return
-
-        message = packet.message.lstrip()
-        if message[:6] != "!agcr ":
-            return
-        formatted_message = None
-        message = re.match("!agcr \[(.+)] (.+): (.+)", message)
-        if message:
-            org, name, text = message.groups()
-            formatted_message = self.setting_service.get('alliance_base').format_text(
-                f"[{self.setting_service.get('alliance_org').format_text(org)}] "
-                f"{self.setting_service.get('alliance_sender').format_text(name)}: "
-                f"{self.setting_service.get('alliance_msg').format_text(text)}")
-            # sender is not the bot that sent it, but rather the original char that sent the message
-            # given the format of !agcr messages, it could be possible to parse the sender for the message
-            # but currently this is not done
-            sender = None
-
-            self.message_hub_service.send_message(self.MESSAGE_SOURCE,
-                                                  sender, None,
-                                                  formatted_message or packet.message.lstrip)
-
-    def handle_relay_hub_message(self, ctx):
-        if not self.setting_service.get("arelay_enabled").get_value():
-            return
-        method = self.setting_service.get_value("arelay_symbol_method")
-        symbol = self.setting_service.get_value("arelay_symbol")
-        plain_msg = ctx.message or ctx.formatted_message
-
-        if method == "unless_symbol" and len(plain_msg) > len(symbol) and plain_msg[:len(symbol)] == symbol:
-            return
-        elif method == "with_symbol":
-            if len(plain_msg) < len(symbol) or plain_msg[:len(symbol)] != symbol:
-                return
-            else:
-                # trim symbol from message
-                plain_msg = plain_msg[len(symbol):]
-
-        org = self.setting_service.get_value("arelay_guild_abbreviation") or \
-              self.public_channel_service.get_org_name() or \
-              self.bot.get_char_name()
-        msg = f"[{org + (' - Priv' if ctx.source == 'private_channel' else '')}] {ctx.sender.name}: {plain_msg}"
-
-        self.send_message_to_alliance(msg)
-
-    def send_message_to_alliance(self, msg):
-        if self.relay_channel_id:
-            packet = client_packets.PrivateChannelMessage(self.relay_channel_id,
-                                                          "!agcr " + self.text.format_message(msg, False), "\0")
-            self.bot.conns["main"].send_packet(packet)

modules/relaybot/online/command_controller.py

@@ -8,12 +8,4 @@ class CustomCommandService(CommandService):
         super().inject(registry)
 
     def handle_unknown_command(self, command_str: str, command_args, channel, sender, reply):
-        if command_str.startswith('agcr'):
-            return
-        else:
-            self.relay_hub_service.send_message("access_denied_logger", sender,
-                                                f"[UNKNOWN] {sender.name}: {command_str} {command_args}",
-                                                f"[UNKNOWN] {sender.name}: {command_str} {command_args}")
-            if sender.access_level["label"] != "all":
-                self.bot.send_mass_message(sender.char_id,
-                                           self.getresp("global", "unknown_command", {"cmd": command_str}))
+        pass

modules/standard/news/worldboss_controller.py

@@ -67,7 +67,7 @@ class WorldBossController:
         elif timer.name == "The Hollow Reaper":
             data = self.calc_spawn_mortal(timer.time, 9 * 60 * 60, 15 * 60)
         elif timer.name == "Vizaresh":
-            data = self.calc_spawn_mortal(timer.time, 17 * 60 * 60, 6 * 60 + 20)
+            data = self.calc_spawn_mortal(timer.time, 17 * 60 * 60, 6 * 60)
         else:
             return None
         if not data: