482 lines
22 KiB
Python
482 lines
22 KiB
Python
import collections
|
|
import inspect
|
|
import re
|
|
from threading import Thread
|
|
|
|
from core.aochat import server_packets
|
|
from core.chat_blob import ChatBlob
|
|
from core.command_request import CommandRequest
|
|
from core.conn import Conn
|
|
from core.decorators import instance
|
|
from core.dict_object import DictObject
|
|
from core.functions import flatmap, get_attrs
|
|
from core.logger import Logger
|
|
from core.lookup.character_service import CharacterService
|
|
from core.message_hub_service import MessageHubService
|
|
from core.registry import Registry
|
|
from core.sender_obj import SenderObj
|
|
from core.setting_service import SettingService
|
|
from modules.core.accounting.services.access_service import AccessService
|
|
|
|
|
|
# noinspection SqlResolve,PyAttributeOutsideInit,PyUnresolvedReferences,PyTypeChecker
|
|
@instance()
|
|
class CommandService:
|
|
PRIVATE_CHANNEL = "priv"
|
|
ORG_CHANNEL = "org"
|
|
PRIVATE_MESSAGE_CHANNEL = "msg"
|
|
|
|
def __init__(self):
|
|
self.ignore = []
|
|
self.handlers = collections.defaultdict(list)
|
|
self.logger = Logger(__name__)
|
|
self.channels = {}
|
|
self.pre_processors = []
|
|
self.ignore_regexes = [
|
|
re.compile(r" is AFK \(Away from keyboard\) since ", re.IGNORECASE),
|
|
re.compile(r"I am away from my keyboard right now", re.IGNORECASE),
|
|
re.compile(r"Unknown command or access denied!", re.IGNORECASE),
|
|
re.compile(r"I am responding", re.IGNORECASE),
|
|
re.compile(r"I only listen", re.IGNORECASE),
|
|
re.compile(r"Error!", re.IGNORECASE),
|
|
re.compile(r"Unknown command input", re.IGNORECASE),
|
|
re.compile(r"You have been auto invited", re.IGNORECASE),
|
|
re.compile(r"^<font")
|
|
]
|
|
|
|
def inject(self, registry):
|
|
self.db = registry.get_instance("db")
|
|
self.util = registry.get_instance("util")
|
|
self.access_service: AccessService = registry.get_instance("access_service")
|
|
self.bot = registry.get_instance("bot")
|
|
self.character_service: CharacterService = registry.get_instance("character_service")
|
|
self.setting_service: SettingService = registry.get_instance("setting_service")
|
|
self.command_alias_service = registry.get_instance("command_alias_service")
|
|
self.usage_service = registry.get_instance("usage_service")
|
|
self.public_channel_service = registry.get_instance("public_channel_service")
|
|
self.ban_service = registry.get_instance("ban_service")
|
|
self.getresp = registry.get_instance("translation_service").get_response
|
|
self.relay_hub_service: MessageHubService = registry.get_instance("message_hub_service")
|
|
|
|
def pre_start(self):
|
|
self.bot.register_packet_handler(server_packets.PrivateMessage.id, self.handle_private_message)
|
|
self.bot.register_packet_handler(server_packets.PrivateChannelMessage.id, self.handle_private_channel_message)
|
|
# Org channel is not supported
|
|
self.bot.register_packet_handler(server_packets.PublicChannelMessage.id, self.handle_public_channel_message)
|
|
self.register_command_channel("Private Message", self.PRIVATE_MESSAGE_CHANNEL)
|
|
self.register_command_channel("Org Channel", self.ORG_CHANNEL)
|
|
self.register_command_channel("Private Channel", self.PRIVATE_CHANNEL)
|
|
|
|
def start(self):
|
|
access_levels = {}
|
|
|
|
# process decorators
|
|
for _, inst in Registry.get_all_instances().items():
|
|
for name, method in get_attrs(inst).items():
|
|
if hasattr(method, "command"):
|
|
key = Registry.get_module_name(inst).split(".")
|
|
if key[0] not in self.bot.modules:
|
|
continue
|
|
cmd_name, params, access_level, description, help_file, sub_command, extended_description = getattr(
|
|
method, "command")
|
|
handler = getattr(inst, name)
|
|
help_text = self.get_help_file(inst.module_name, help_file)
|
|
|
|
command_key = self.get_command_key(cmd_name.lower(), sub_command.lower() if sub_command else "")
|
|
al = access_levels.get(command_key, None)
|
|
if al is not None and al != access_level.lower():
|
|
print(handler)
|
|
raise Exception("Different access levels specified for forms of command '%s'" % command_key)
|
|
access_levels[command_key] = access_level
|
|
|
|
self.register(handler, cmd_name, params, access_level, description, inst.module_name, help_text,
|
|
sub_command, extended_description)
|
|
|
|
def register(self, handler, command, params, access_level, description, module, help_text=None, sub_command=None,
|
|
extended_description=None, check_access=None):
|
|
"""
|
|
Call during pre_start
|
|
|
|
Args:
|
|
handler: (request, param1, param2, ...) -> str|ChatBlob|None
|
|
command: str
|
|
params: [CommandParam...]
|
|
access_level: str
|
|
description: str
|
|
module: str
|
|
help_text: str
|
|
sub_command: str
|
|
extended_description: str
|
|
check_access: (char, access_level_label) -> bool
|
|
"""
|
|
|
|
if len(inspect.signature(handler).parameters) != len(params) + 1:
|
|
raise Exception(
|
|
"Incorrect number of arguments for handler '%s.%s()'" % (handler.__module__, handler.__name__))
|
|
|
|
command = command.lower()
|
|
if sub_command:
|
|
sub_command = sub_command.lower()
|
|
else:
|
|
sub_command = ""
|
|
access_level = access_level.lower()
|
|
module = module.lower()
|
|
command_key = self.get_command_key(command, sub_command)
|
|
|
|
if help_text is None:
|
|
help_text = self.generate_help(command, description, params, extended_description)
|
|
|
|
if check_access is None:
|
|
check_access = self.access_service.check_access
|
|
|
|
if not self.access_service.get_access_level_by_label(access_level):
|
|
self.logger.error("Could not add command '%s': could not find access level '%s'" % (command, access_level))
|
|
return
|
|
|
|
for channel, label in self.channels.items():
|
|
row = self.db.query_single("SELECT access_level, module, enabled, verified "
|
|
"FROM command_config "
|
|
"WHERE command = ? AND sub_command = ? AND channel = ?",
|
|
[command, sub_command, channel])
|
|
|
|
if row is None:
|
|
# add new command
|
|
self.db.exec(
|
|
"INSERT INTO command_config "
|
|
"(command, sub_command, access_level, channel, module, enabled, verified) "
|
|
"VALUES (?, ?, ?, ?, ?, 1, 1)",
|
|
[command, sub_command, access_level, channel, module])
|
|
elif row.verified:
|
|
if row.module != module:
|
|
self.logger.warning("module different for different forms of command '%s' and sub_command '%s'" % (
|
|
command, sub_command))
|
|
else:
|
|
# mark command as verified
|
|
self.db.exec("UPDATE command_config SET verified = 1, module = ? "
|
|
"WHERE command = ? AND sub_command = ? AND channel = ?",
|
|
[module, command, sub_command, channel])
|
|
|
|
# save reference to command handler
|
|
r = re.compile(self.get_regex_from_params(params), re.IGNORECASE | re.DOTALL)
|
|
self.handlers[command_key].append(
|
|
{"regex": r, "callback": handler, "help": help_text, "description": description, "params": params,
|
|
"check_access": check_access})
|
|
|
|
def register_command_pre_processor(self, pre_processor):
|
|
"""
|
|
Call during start
|
|
|
|
Args:
|
|
pre_processor: (context) -> bool
|
|
"""
|
|
|
|
self.pre_processors.append(pre_processor)
|
|
|
|
def register_command_channel(self, label, value):
|
|
"""
|
|
Call during pre_start
|
|
|
|
Args:
|
|
label: str
|
|
value: str
|
|
"""
|
|
|
|
if value in self.channels:
|
|
self.logger.error("Could not register command channel '%s': command channel already registered" % value)
|
|
return
|
|
|
|
self.logger.debug("Registering command channel '%s'" % value)
|
|
self.channels[value] = label
|
|
|
|
def is_command_channel(self, channel):
|
|
return channel in self.channels
|
|
|
|
def process_command(self, message: str, channel: str, char_id, reply, conn, followup=True):
|
|
try:
|
|
context = DictObject({"message": message, "char_id": char_id, "channel": channel, "reply": reply})
|
|
for pre_processor in self.pre_processors:
|
|
if pre_processor(context) is False:
|
|
return
|
|
|
|
for regex in self.ignore_regexes:
|
|
if regex.search(message):
|
|
self.logger.info(f"Ignoring message from {char_id}: {message}")
|
|
return
|
|
if not followup:
|
|
if channel == "msg":
|
|
if message.lower().startswith("mail"):
|
|
self.relay_hub_service.send_message("tell_logger", char_id, "mail |usage hidden|",
|
|
"mail |usage hidden|")
|
|
else:
|
|
self.relay_hub_service.send_message("tell_logger", char_id, message, message)
|
|
else:
|
|
if message.lower().startswith("mail"):
|
|
self.relay_hub_service.send_message("dc_relay_log", char_id, "mail |usage hidden|",
|
|
"mail |usage hidden|")
|
|
else:
|
|
self.relay_hub_service.send_message("dc_relay_log", char_id, message, message)
|
|
# message = html.unescape(message)
|
|
command_str, command_args = self.get_command_parts(message)
|
|
|
|
# check for command alias
|
|
command_alias = self.command_alias_service.check_for_alias(command_str)
|
|
|
|
alias_depth_count = 0
|
|
while command_alias:
|
|
alias_depth_count += 1
|
|
command_str, command_args = self.get_command_parts(command_alias + command_args)
|
|
command_alias = self.command_alias_service.check_for_alias(command_str)
|
|
|
|
if alias_depth_count > 20:
|
|
raise Exception("Command alias infinite recursion detected for command '%s'" % message)
|
|
|
|
cmd_configs = self.get_command_configs(command_str, channel)
|
|
access_level = self.access_service.get_access_level(char_id)
|
|
sender = SenderObj(char_id, self.character_service.resolve_char_to_name(char_id, "Unknown(%d)" % char_id),
|
|
access_level)
|
|
if cmd_configs:
|
|
# given a list of cmd_configs that are enabled, see if one has regex that matches incoming command_str
|
|
cmd_config, matches, handler = self.get_matches(cmd_configs, command_args)
|
|
if matches:
|
|
if handler["check_access"](char_id, cmd_config.access_level):
|
|
try:
|
|
response = handler["callback"](CommandRequest(conn, channel, sender, reply),
|
|
*self.process_matches(matches, handler["params"]))
|
|
if response is not None:
|
|
reply(response)
|
|
except Exception as e:
|
|
self.logger.error("error processing command: %s" % message, e)
|
|
self.relay_hub_service.send_message("access_denied_logger", sender,
|
|
f"[ERROR] {sender.name}: {message}",
|
|
f"[ERROR] {sender.name}: {message}")
|
|
self.bot.send_mass_message(char_id, self.getresp("global", "error_processing"))
|
|
|
|
# record command usage
|
|
self.usage_service.add_usage(command_str, handler["callback"].__qualname__, char_id, channel)
|
|
else:
|
|
self.access_denied_response(message, sender, cmd_config, reply)
|
|
else:
|
|
# handlers were found, but no handler regex matched
|
|
help_text = self.get_help_text(char_id, command_str, channel)
|
|
if help_text:
|
|
reply(self.format_help_text(command_str, help_text))
|
|
else:
|
|
# the command is known, but no help is returned, therefore user does not have access to command
|
|
if access_level['label'] != "all":
|
|
self.relay_hub_service.send_message("access_denied_logger", sender,
|
|
f"[DENIED] {sender.name}: {message}",
|
|
f"[DENIED] {sender.name}: {message}")
|
|
self.bot.send_mass_message(char_id, self.getresp("global", "access_denied"))
|
|
else:
|
|
self.handle_unknown_command(command_str, command_args, channel, sender, reply)
|
|
except Exception as e:
|
|
self.logger.error("error processing command: %s" % message, e)
|
|
sender = SenderObj(char_id, self.character_service.resolve_char_to_name(char_id, "Unknown(%d)" % char_id),
|
|
0)
|
|
self.relay_hub_service.send_message("access_denied_logger", sender, f"[ERROR] {sender.name}: {message}",
|
|
f"[ERROR] {sender.name}: {message}")
|
|
self.bot.send_mass_message(char_id, self.getresp("global", "error_processing"))
|
|
|
|
def handle_unknown_command(self, command_str, command_args, channel, sender, reply):
|
|
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}))
|
|
|
|
def access_denied_response(self, message, sender, cmd_config, reply):
|
|
self.relay_hub_service.send_message("access_denied_logger", sender, f"[DENIED] {sender.name}: {message}",
|
|
f"[DENIED] {sender.name}: {message}")
|
|
if sender.access_level["label"] != "all":
|
|
self.bot.send_mass_message(sender.char_id, self.getresp("global", "access_denied"))
|
|
|
|
def get_command_parts(self, message):
|
|
parts = message.split(" ", 1)
|
|
if len(parts) == 2:
|
|
return parts[0].lower(), " " + parts[1]
|
|
else:
|
|
return parts[0].lower(), ""
|
|
|
|
def get_command_configs(self, command, channel=None, enabled=1, sub_command=None):
|
|
sql = "SELECT command, sub_command, access_level, channel, enabled FROM command_config WHERE command = ?"
|
|
params = [command]
|
|
if channel:
|
|
sql += " AND channel = ?"
|
|
params.append(channel)
|
|
if enabled:
|
|
sql += " AND enabled = ?"
|
|
params.append(enabled)
|
|
if sub_command:
|
|
sql += " AND sub_command = ?"
|
|
params.append(sub_command)
|
|
|
|
sql += " ORDER BY sub_command, channel"
|
|
|
|
return self.db.query(sql, params)
|
|
|
|
def get_matches(self, cmd_configs, command_args):
|
|
for row in cmd_configs:
|
|
command_key = self.get_command_key(row.command, row.sub_command)
|
|
handlers = self.handlers[command_key]
|
|
for handler in handlers:
|
|
# add leading space to search string to normalize input for command params
|
|
matches = handler["regex"].search(command_args)
|
|
if matches:
|
|
return row, matches, handler
|
|
return None, None, None
|
|
|
|
def process_matches(self, matches, params):
|
|
groups = list(matches.groups())
|
|
|
|
processed = []
|
|
for param in params:
|
|
processed.append(param.process_matches(groups))
|
|
return processed
|
|
|
|
def get_help_text(self, char, command_str, channel, show_regex=False):
|
|
data = self.db.query("SELECT command, sub_command, access_level FROM command_config "
|
|
"WHERE command = ? AND channel = ? AND enabled = 1",
|
|
[command_str, channel])
|
|
|
|
# filter out commands that character does not have access level for
|
|
data = filter(lambda row: self.access_service.check_access(char, row.access_level), data)
|
|
|
|
def get_regex(params):
|
|
if show_regex:
|
|
return "\n" + self.get_regex_from_params(params)
|
|
else:
|
|
return ""
|
|
|
|
def read_help_text(row):
|
|
command_key = self.get_command_key(row.command, row.sub_command)
|
|
return filter(lambda x: x is not None, map(lambda handler: handler["help"] + get_regex(handler["params"]),
|
|
self.handlers[command_key]))
|
|
|
|
content = "\n\n".join(flatmap(read_help_text, data))
|
|
return content if content else None
|
|
|
|
def format_help_text(self, topic, help_text):
|
|
return ChatBlob("Help (" + topic + ")", help_text)
|
|
|
|
def get_help_file(self, module, help_file):
|
|
if help_file:
|
|
try:
|
|
help_file = "./" + module.replace(".", "/") + "/" + help_file
|
|
with open(help_file, mode="r", encoding="UTF-8") as f:
|
|
return f.read().strip()
|
|
except FileNotFoundError as e:
|
|
self.logger.error("Error reading help file", e)
|
|
return None
|
|
|
|
def get_command_key(self, command, sub_command):
|
|
if sub_command:
|
|
return command + ":" + sub_command
|
|
else:
|
|
return command
|
|
|
|
def get_command_key_parts(self, command_str):
|
|
parts = command_str.split(":", 1)
|
|
if len(parts) == 2:
|
|
return parts[0], parts[1]
|
|
else:
|
|
return parts[0], ""
|
|
|
|
def get_regex_from_params(self, params):
|
|
# params must be wrapped with line-beginning and line-ending anchors in order to match
|
|
# when no params are specified (eg. "^$")
|
|
return "^" + "".join(map(lambda x: x.get_regex(), params)) + "$"
|
|
|
|
def generate_help(self, command, description, params, extended_description=None):
|
|
help_text = description + ":\n" + "<tab><symbol>" + command + " " + " ".join(
|
|
map(lambda x: x.get_name(), params))
|
|
if extended_description:
|
|
help_text += "\n" + extended_description
|
|
|
|
return help_text
|
|
|
|
def get_handlers(self, command_key):
|
|
return self.handlers.get(command_key, None)
|
|
|
|
def handle_private_message(self, conn: Conn, packet: server_packets.PrivateMessage):
|
|
if not self.bot.is_ready():
|
|
if packet.char_id not in self.ignore:
|
|
self.ignore.append(packet.char_id)
|
|
self.bot.send_mass_message(packet.char_id,
|
|
"Your command has not been proceeded, bot is still starting.")
|
|
return
|
|
if not self.setting_service.get("accept_commands_from_slave_bots").get_value() and conn.id != "main":
|
|
return
|
|
|
|
# since the command symbol is not required for private messages,
|
|
# the command_str must have length of at least 1 in order to be valid,
|
|
# otherwise it is ignored
|
|
if len(packet.message) < 1:
|
|
return
|
|
|
|
# ignore leading space
|
|
message = packet.message.lstrip()
|
|
|
|
def i():
|
|
self.process_command(
|
|
self.trim_command_symbol(message),
|
|
self.PRIVATE_MESSAGE_CHANNEL,
|
|
packet.char_id,
|
|
lambda msg: self.bot.send_private_message(packet.char_id, msg, conn_id=conn.id),
|
|
conn,
|
|
False)
|
|
|
|
t: Thread = Thread(target=i, daemon=True)
|
|
t.run()
|
|
|
|
def handle_private_channel_message(self, conn: Conn, packet: server_packets.PrivateChannelMessage):
|
|
if not self.setting_service.get("accept_commands_from_slave_bots").get_value() and conn.id != "main":
|
|
return
|
|
|
|
# since the command symbol is required in the private channel,
|
|
# the command_str must have length of at least 2 in order to be valid,
|
|
# otherwise it is ignored
|
|
if len(packet.message) < 2:
|
|
return
|
|
|
|
# ignore leading space
|
|
message = packet.message.lstrip()
|
|
if message.startswith(self.setting_service.get("symbol").get_value()) \
|
|
and packet.private_channel_id == self.bot.get_char_id():
|
|
Thread(target=self.process_command(
|
|
self.trim_command_symbol(message),
|
|
self.PRIVATE_CHANNEL,
|
|
packet.char_id,
|
|
lambda msg: self.bot.send_private_channel_message(msg, private_channel_id=conn.char_id,
|
|
conn_id=conn.id),
|
|
conn,
|
|
False), daemon=True).run()
|
|
|
|
def handle_public_channel_message(self, conn: Conn, packet: server_packets.PublicChannelMessage):
|
|
if not self.setting_service.get("accept_commands_from_slave_bots").get_value() and conn.id != "main":
|
|
return
|
|
|
|
# since the command symbol is required in the org channel,
|
|
# the command_str must have length of at least 2 in order to be valid,
|
|
# otherwise it is ignored
|
|
if len(packet.message) < 2:
|
|
return
|
|
|
|
# ignore leading space
|
|
message = packet.message.lstrip()
|
|
|
|
if message.startswith(self.setting_service.get("symbol").get_value()) \
|
|
and self.public_channel_service.is_org_channel_id(packet.channel_id):
|
|
Thread(target=self.process_command(
|
|
self.trim_command_symbol(message),
|
|
self.ORG_CHANNEL,
|
|
packet.char_id,
|
|
lambda msg: self.bot.send_org_message(msg, conn_id=conn.id),
|
|
conn,
|
|
False), daemon=True).run()
|
|
|
|
def trim_command_symbol(self, s):
|
|
symbol = self.setting_service.get("symbol").get_value()
|
|
if s.startswith(symbol):
|
|
s = s[len(symbol):]
|
|
return s
|