move core modules to src/core_modules, make them uneffected by white/black list

1 files changed, 208 insertions, 0 deletions

diff --git a/src/core_modules/admin.py b/src/core_modules/admin.py
new file mode 100644
index 00000000..364380d4
--- /dev/null
+++ b/src/core_modules/admin.py
@@ -0,0 +1,208 @@
+#--depends-on commands
+#--depends-on permissions
+
+from src import IRCLine, ModuleManager, utils
+
+class Module(ModuleManager.BaseModule):
+    @utils.hook("received.command.nick", min_args=1)
+    def change_nickname(self, event):
+        """
+        :help: Change my nickname
+        :usage: <nickname>
+        :permission: changenickname
+        """
+        nickname = event["args_split"][0]
+        event["server"].send_nick(nickname)
+
+    @utils.hook("received.command.raw", min_args=1)
+    def raw(self, event):
+        """
+        :help: Send a line of raw IRC data
+        :usage: <raw line>
+        :permission: raw
+        """
+        if IRCLine.is_human(event["args"]):
+            line = IRCLine.parse_human(event["args"])
+        else:
+            line = IRCLine.parse_line(event["args"])
+        line = event["server"].send(line)
+
+        if not line == None:
+            event["stdout"].write("Sent: %s" % line.parsed_line.format())
+        else:
+            event["stderr"].write("Line was filtered")
+
+    @utils.hook("received.command.part")
+    def part(self, event):
+        """
+        :help: Part from the current or given channel
+        :usage: [channel]
+        :permission: part
+        """
+        if event["args"]:
+            target = event["args_split"][0]
+        elif event["is_channel"]:
+            target = event["target"].name
+        else:
+            event["stderr"].write("No channel provided")
+        event["server"].send_part(target)
+
+    def _id_from_alias(self, alias):
+        return self.bot.database.servers.get_by_alias(alias)
+    def _server_from_alias(self, alias):
+        id, server = self._both_from_alias(alias)
+        return server
+    def _both_from_alias(self, alias):
+        id = self._id_from_alias(alias)
+        if id == None:
+            raise utils.EventError("Unknown server alias")
+        return id, self.bot.get_server_by_id(id)
+
+    @utils.hook("received.command.reconnect")
+    def reconnect(self, event):
+        """
+        :help: Reconnect to the current network
+        :permission: reconnect
+        """
+        server = event["server"]
+        alias = str(event["server"])
+        if event["args"]:
+            alias = event["args_split"][0]
+            server = self._server_from_alias(alias)
+
+        if server:
+            line = server.send_quit("Reconnecting")
+            line.events.on("send").hook(lambda e: self.bot.reconnect(
+                server.id, server.connection_params))
+            if not server == event["server"]:
+                event["stdout"].write("Reconnecting to %s" % alias)
+        else:
+            event["stdout"].write("Not connected to %s" % alias)
+
+    @utils.hook("received.command.connect", min_args=1)
+    def connect(self, event):
+        """
+        :help: Connect to a network
+        :usage: <server id>
+        :permission: connect
+        """
+        alias = event["args_split"][0]
+        server = self._server_from_alias(alias)
+        if server:
+            raise utils.EventError("Already connected to %s" % str(server))
+
+        server = self.bot.add_server(self._id_from_alias(alias))
+        event["stdout"].write("Connecting to %s" % str(server))
+
+    @utils.hook("received.command.disconnect")
+    def disconnect(self, event):
+        """
+        :help: Disconnect from a server
+        :usage: [server id]
+        :permission: disconnect
+        """
+        server = event["server"]
+        id = -1
+        alias = str(event["server"])
+        if event["args"]:
+            alias = event["args_split"][0]
+            id, server = self._both_from_alias(alias)
+
+        if not server == None:
+            alias = str(server)
+            server.disconnect()
+            self.bot.disconnect(server)
+        elif id in self.bot.reconnections:
+            self.bot.reconnections[id].cancel()
+            del self.bot.reconnections[id]
+        else:
+            raise utils.EventError("Server not connected")
+
+        event["stdout"].write("Disconnected from %s" % alias)
+
+    @utils.hook("received.command.shutdown")
+    def shutdown(self, event):
+        """
+        :help: Shutdown bot
+        :usage: [reason]
+        :permission: shutdown
+        """
+        reason = event["args"] or ""
+        for server in self.bot.servers.values():
+            line = server.send_quit(reason)
+            line.events.on("send").hook(self._shutdown_hook(server))
+    def _shutdown_hook(self, server):
+        def shutdown(e):
+            server.disconnect()
+            self.bot.disconnect(server)
+        return shutdown
+
+    @utils.hook("received.command.addserver", min_args=3)
+    def add_server(self, event):
+        """
+        :help: Add a new server
+        :usage: <alias> <hostname>:[+]<port> <nickname>!<username>[@<bindhost>]
+        :permission: addserver
+        """
+        alias = event["args_split"][0]
+        hostname, sep, port = event["args_split"][1].partition(":")
+        tls = port.startswith("+")
+        port = port.lstrip("+")
+
+        if not hostname or not port or not port.isdigit():
+            raise utils.EventError("Please provide <hostname>:[+]<port>")
+        port = int(port)
+
+        hostmask = IRCLine.parse_hostmask(event["args_split"][2])
+        nickname = hostmask.nickname
+        username = hostmask.username or nickname
+        realname = nickname
+        bindhost = hostmask.hostname or None
+
+        try:
+            server_id = self.bot.database.servers.add(alias, hostname, port, "",
+                tls, bindhost, nickname, username, realname)
+        except Exception as e:
+            event["stderr"].write("Failed to add server")
+            self.log.error("failed to add server \"%s\"", [alias],
+                exc_info=True)
+            return
+        event["stdout"].write("Added server '%s'" % alias)
+
+    @utils.hook("received.command.editserver")
+    @utils.kwarg("min_args", 3)
+    @utils.kwarg("help", "Edit server details")
+    @utils.kwarg("usage", "<alias> <option> <value>")
+    @utils.kwarg("permission", "editserver")
+    def edit_server(self, event):
+        alias = event["args_split"][0]
+        server_id = self._id_from_alias(alias)
+        if server_id == None:
+            raise utils.EventError("Unknown server '%s'" % alias)
+
+        option = event["args_split"][1].lower()
+        value = " ".join(event["args_split"][2:])
+        value_parsed = None
+
+        if option == "hostname":
+            value_parsed = value
+        elif option == "port":
+            if not value.isdigit():
+                raise utils.EventError("Invalid port")
+            value_parsed = int(value.lstrip("0"))
+        elif option == "tls":
+            value_lower = value.lower()
+            if not value_lower in ["yes", "no"]:
+                raise utils.EventError("TLS should be either 'yes' or 'no'")
+            value_parsed = value_lower == "yes"
+        elif option == "password":
+            value_parsed = value
+        elif option == "bindhost":
+            value_parsed = value
+        elif option in ["nickname", "username", "realname"]:
+            value_parsed = value
+        else:
+            raise utils.EventError("Unknown option '%s'" % option)
+
+        self.bot.database.servers.edit(server_id, option, value_parsed)
+        event["stdout"].write("Set %s for %s" % (option, alias))