Minidodo
2d7ecf4883
Timer messages ("Timer XX has yyy left") now get resumed after a bot restart
Alliance relay is discord compatible now. [Orgbot]
180 lines
8.5 KiB
Python
180 lines
8.5 KiB
Python
import re
|
|
import time
|
|
from threading import Thread
|
|
|
|
from core.bot_status import BotStatus
|
|
from core.buddy_service import BuddyService
|
|
from core.command_alias_service import CommandAliasService
|
|
from core.command_param_types import Int, Any, Const, Options
|
|
from core.db import DB
|
|
from core.decorators import instance, event, command
|
|
from core.dict_object import DictObject
|
|
from core.fifo_queue import FifoQueue
|
|
from core.logger import Logger
|
|
from core.lookup.character_service import CharacterService
|
|
from core.private_channel_service import PrivateChannelService
|
|
from core.public_channel_service import PublicChannelService
|
|
from core.setting_service import SettingService
|
|
from core.text import Text
|
|
from core.igncore import IgnCore
|
|
from core.util import Util
|
|
from modules.core.accounting.services.account_service import AccountService
|
|
from modules.standard.online.online_display import OnlineDisplay
|
|
|
|
|
|
class User:
|
|
def __init__(self, char_id, loggedin=True):
|
|
self.char_id = char_id
|
|
self.logged = loggedin
|
|
|
|
|
|
@instance()
|
|
class OnlineController:
|
|
def __init__(self):
|
|
self.afk_list = {}
|
|
self.afk_regex = re.compile("^(afk|brb) ?(.*)$", re.IGNORECASE)
|
|
self.awaiting_data = FifoQueue()
|
|
|
|
def inject(self, registry):
|
|
self.logger = Logger(__name__)
|
|
self.bot: IgnCore = registry.get_instance("bot")
|
|
self.db: DB = registry.get_instance("db")
|
|
self.text: Text = registry.get_instance("text")
|
|
self.util: Util = registry.get_instance("util")
|
|
self.command_alias_service: CommandAliasService = registry.get_instance("command_alias_service")
|
|
self.buddy_service: BuddyService = registry.get_instance("buddy_service")
|
|
self.setting_service: SettingService = registry.get_instance("setting_service")
|
|
self.priv: PrivateChannelService = registry.get_instance("private_channel_service")
|
|
self.online_display: OnlineDisplay = OnlineDisplay(self.text, self.util, self.db, self.afk_list)
|
|
self.account_service: AccountService = registry.get_instance("account_service")
|
|
self.character_service: CharacterService = registry.get_instance("character_service")
|
|
|
|
def pre_start(self):
|
|
self.db.exec("DROP TABLE IF EXISTS online")
|
|
self.db.shared.exec(
|
|
"CREATE TABLE IF NOT EXISTS online (char_id BIGINT NOT NULL primary key, "
|
|
"channel varchar(32) not null default 'notify', "
|
|
"bot BIGINT not null, "
|
|
"index bot(bot)) ENGINE MEMORY")
|
|
self.db.create_view("online")
|
|
self.command_alias_service.add_alias("o", "online")
|
|
|
|
@event(event_type="connect", description="Start online watcher")
|
|
def startup(self, _, _1):
|
|
self.db.exec("DELETE from online where bot=?", [self.bot.get_char_id()])
|
|
|
|
self.watchdog = Thread(name="watchdog", target=self.buddy_handler, daemon=True)
|
|
self.watchdog.start()
|
|
|
|
@event(event_type="private_channel_joined", description="Change online channel", is_hidden=True)
|
|
def priv_join(self, _, event_data):
|
|
self.db.exec("insert ignore into online(channel, char_id, bot) VALUES (?, ?, ?)",
|
|
[self.bot.name, event_data.char_id, self.bot.get_char_id()])
|
|
|
|
@event(event_type="private_channel_left", description="Change online channel", is_hidden=True)
|
|
def priv_leave(self, _, event_data):
|
|
self.db.exec("delete from online where char_id = ? and bot = ? and channel=?",
|
|
[event_data.char_id, self.bot.get_char_id(), self.bot.name])
|
|
for alt in self.account_service.get_alts(event_data.char_id):
|
|
self.afk_list.pop(alt.char_id, None)
|
|
|
|
@event(event_type="member_logon", description="declare players as online")
|
|
def logon(self, _, event_data):
|
|
self.awaiting_data.put([event_data, 'notify', True])
|
|
|
|
@event(event_type="member_logoff", description="declare players as offline")
|
|
def logoff(self, _, event_data):
|
|
if self.bot.is_ready():
|
|
self.awaiting_data.put([event_data, 'notify', False])
|
|
|
|
def buddy_handler(self):
|
|
while self.bot.status != BotStatus.SHUTDOWN:
|
|
data, channel, logged = self.awaiting_data.get()
|
|
buddy = (self.buddy_service.get_buddy(data.packet.char_id) or {}).get("types", [])
|
|
if ("org_member" in buddy) or ("member" in buddy):
|
|
if logged:
|
|
self.db.exec("INSERT IGNORE INTO online VALUES(?, ?, ?)",
|
|
[data.packet.char_id, channel, self.bot.get_char_id()])
|
|
self.db.exec("UPDATE account set last_seen=? where char_id=?", [time.time(), data.packet.char_id])
|
|
else:
|
|
self.db.exec("DELETE FROM online where char_id=? and bot=?",
|
|
[data.packet.char_id, self.bot.get_char_id()])
|
|
self.db.exec("UPDATE account set last_seen=? where char_id=?", [time.time(), data.packet.char_id])
|
|
for alt in self.account_service.get_alts(data.packet.char_id):
|
|
self.afk_list.pop(alt.char_id, None)
|
|
|
|
@command(command="online", params=[Const('all', is_optional=True),
|
|
Int("min_level", is_optional=True),
|
|
Any("profession", is_optional=True)],
|
|
description="shows online players",
|
|
access_level="member")
|
|
def online_all_cmd(self, _, const_all, min_level, profession):
|
|
query = ""
|
|
params = [self.bot.name, self.bot.get_char_id()]
|
|
if const_all:
|
|
query += "and channel_id IN (1, 2, 3) "
|
|
else:
|
|
query += "and channel_id IN (1, 2) "
|
|
if min_level:
|
|
query += "and p.level >= ? "
|
|
params.append(min_level)
|
|
if profession:
|
|
query += "and p.profession = ? "
|
|
params.append(self.util.get_profession(profession))
|
|
blob = self.online_display.format_by_channel_main(query, params)
|
|
_.reply(self.online_display.format_blob(blob))
|
|
|
|
@command(command="count",
|
|
params=[Options(["org", "prof", "tl"], is_optional=True), Any("filter", is_optional=True)],
|
|
description="Counts online players",
|
|
access_level="member")
|
|
def count(self, _, option, filters):
|
|
query = "and channel_id IN (1, 2) "
|
|
params = [self.bot.name, self.bot.get_char_id()]
|
|
if not option:
|
|
option = "prof"
|
|
output = ""
|
|
if option == "prof":
|
|
output = self.online_display.count_prof(query, params, filters)
|
|
elif option == "org":
|
|
output = self.online_display.count_org(query, params, filters)
|
|
elif option == "tl":
|
|
if filters:
|
|
try:
|
|
filters = int(filters)
|
|
except ValueError:
|
|
return f"Invalid Title level: {filters}"
|
|
output = self.online_display.count_tl(query, params, filters)
|
|
return output if output != "" else "Nobody is in my private channel, sorry..."
|
|
|
|
@event(PrivateChannelService.PRIVATE_CHANNEL_MESSAGE_EVENT, "Check for afk messages in private channel")
|
|
def afk_check_private_channel_event(self, event_type, event_data):
|
|
self.afk_check(event_data.char_id, event_data.message, lambda msg: self.bot.send_private_channel_message(msg))
|
|
|
|
@event(PublicChannelService.ORG_CHANNEL_MESSAGE_EVENT, "Check for afk messages in org channel")
|
|
def afk_check_org_channel_event(self, event_type, event_data):
|
|
self.afk_check(event_data.char_id, event_data.message, lambda msg: self.bot.send_org_message(msg))
|
|
|
|
def afk_check(self, char_id, message, channel_reply):
|
|
matches = self.afk_regex.search(message)
|
|
if matches:
|
|
char_name = self.character_service.resolve_char_to_name(char_id)
|
|
channel_reply(f"<highlight>{char_name}</highlight> is now afk.")
|
|
alts = self.account_service.get_alts(char_id)
|
|
for alt in alts:
|
|
self.afk_list[alt.char_id] = DictObject({"message": message, "time": time.time()})
|
|
elif char_id in self.afk_list.keys():
|
|
# TODO handle multiple rows
|
|
|
|
alts = self.account_service.get_alts(char_id)
|
|
data = None
|
|
for alt in alts:
|
|
out = self.afk_list.pop(alt.char_id)
|
|
if data:
|
|
continue
|
|
data = out
|
|
char_name = self.character_service.resolve_char_to_name(char_id)
|
|
time_string = self.util.time_to_readable(int(time.time()) - data.time)
|
|
channel_reply(f"<highlight>{char_name}</highlight> is back after {time_string}.")
|
|
|