255 lines
15 KiB
Python
255 lines
15 KiB
Python
import time
|
|
|
|
from core.chat_blob import ChatBlob
|
|
from core.command_alias_service import CommandAliasService
|
|
from core.command_param_types import Const, Character, Any, Int
|
|
from core.db import DB
|
|
from core.decorators import instance, command
|
|
from core.event_service import EventService
|
|
from core.lookup.character_history_service import CharacterHistoryService
|
|
from core.lookup.character_service import CharacterService
|
|
from core.lookup.pork_service import PorkService
|
|
from core.message_hub_service import MessageHubService
|
|
from core.setting_service import SettingService
|
|
from core.text import Text
|
|
from core.tyrbot import Tyrbot
|
|
from core.util import Util
|
|
from modules.core.accounting.services.account_service import AccountService
|
|
|
|
|
|
@instance()
|
|
class RegisterController:
|
|
def inject(self, registry):
|
|
self.bot: Tyrbot = registry.get_instance("bot")
|
|
self.buddy_service = registry.get_instance("buddy_service")
|
|
self.util: Util = registry.get_instance("util")
|
|
self.db: DB = registry.get_instance("db")
|
|
self.character_service: CharacterService = registry.get_instance("character_service")
|
|
self.account_service: AccountService = registry.get_instance("account_service")
|
|
self.event_service: EventService = registry.get_instance("event_service")
|
|
self.pork_service: PorkService = registry.get_instance("pork_service")
|
|
self.text: Text = registry.get_instance("text")
|
|
self.setting_service: SettingService = registry.get_instance("setting_service")
|
|
self.character_history_service: CharacterHistoryService = registry.get_instance("character_history_service")
|
|
self.command_alias_service: CommandAliasService = registry.get_instance("command_alias_service")
|
|
self.messagehub: MessageHubService = registry.get_instance("message_hub_service")
|
|
|
|
def start(self):
|
|
self.command_alias_service.add_alias("pending", "register pending")
|
|
self.command_alias_service.add_alias("recommend", "register recommend")
|
|
self.messagehub.register_message_source("registration")
|
|
|
|
@command(command="register", params=[Const("pending"), Int('count', is_optional=True)],
|
|
description="Show the latest Recommendations", sub_command="mng", access_level="admin")
|
|
def register_pending(self, _, _1, limit):
|
|
limit = limit or 25
|
|
latest = self.db.query("SELECT "
|
|
"main.char_id as main_id, "
|
|
"alt.char_id as alt_id, "
|
|
"recommender.char_id as recommender_id, "
|
|
|
|
"main.name as main_name, "
|
|
"alt.name as alt_name, "
|
|
"recommender.name as recommender_name, "
|
|
|
|
"main.faction as main_faction, "
|
|
"alt.faction as alt_faction, "
|
|
"recommender.faction as recommender_faction, "
|
|
|
|
"main.level as main_level, "
|
|
"alt.level as alt_level, "
|
|
"recommender.level as main_level, "
|
|
|
|
"alt.ai_level as alt_ai_level, "
|
|
"main.ai_level as main_ai_level, "
|
|
"recommender.ai_level as recommender_ai_level, "
|
|
|
|
"reason "
|
|
"from pending_accounts p "
|
|
"left join player alt on alt.char_id = p.alt "
|
|
"left join player main on main.char_id = p.main "
|
|
"left join player recommender on recommender.char_id = p.recommender where answered=0 "
|
|
"order by time desc limit ?", [limit])
|
|
blob = ""
|
|
for entry in latest:
|
|
blob += self.format_pending(entry, buttons=True)
|
|
|
|
return ChatBlob("Latest recommendations", blob)
|
|
|
|
@command(command="register", params=[Const("pending"), Const('latest'), Int('count', is_optional=True)],
|
|
description="Show the latest Recommendations", sub_command="mng", access_level="admin")
|
|
def register_pending_latest(self, _, _1, _2, limit):
|
|
limit = limit or 25
|
|
latest = self.db.query("SELECT "
|
|
"main.char_id as main_id, "
|
|
"alt.char_id as alt_id, "
|
|
"recommender.char_id as recommender_id, "
|
|
|
|
"main.name as main_name, "
|
|
"alt.name as alt_name, "
|
|
"recommender.name as recommender_name, "
|
|
|
|
"main.faction as main_faction, "
|
|
"alt.faction as alt_faction, "
|
|
"recommender.faction as recommender_faction, "
|
|
|
|
"main.level as main_level, "
|
|
"alt.level as alt_level, "
|
|
"recommender.level as main_level, "
|
|
|
|
"alt.ai_level as alt_ai_level, "
|
|
"main.ai_level as main_ai_level, "
|
|
"recommender.ai_level as recommender_ai_level, "
|
|
|
|
"reason "
|
|
"from pending_accounts p "
|
|
"left join player alt on alt.char_id = p.alt "
|
|
"left join player main on main.char_id = p.main "
|
|
"left join player recommender on recommender.char_id = p.recommender "
|
|
"order by time desc limit ?", [limit])
|
|
blob = ""
|
|
for entry in latest:
|
|
blob += self.format_pending(entry)
|
|
|
|
return ChatBlob("Latest recommendations", blob)
|
|
|
|
# noinspection LongLine
|
|
def format_pending(self, entry, buttons=False):
|
|
button = "[<green>" + self.text.make_tellcmd(name="APPROVE", msg=f"pending approve {entry.alt_name}",
|
|
style="style='text-decoration:none'") + "</green>] - [<red>" + self.text.make_tellcmd(
|
|
name="DENY", msg=f"pending deny {entry.alt_name}",
|
|
style="style='text-decoration:none'") + "</red>]" if buttons else ""
|
|
if entry.main_id == entry.alt_id:
|
|
text = f"[<notice>ACC</notice>] <{entry.main_faction.lower()}>{entry.main_name}</{entry.main_faction.lower()}> ({entry.main_level}/<green>{entry.main_ai_level}</green>) " \
|
|
f" [{self.text.make_tellcmd('W', f'whois {entry.main_name}')}] " \
|
|
f"[{self.text.make_tellcmd('H', f'history {entry.main_name}')}]\n" \
|
|
f"Recommender: <{entry.recommender_faction.lower()}>{entry.recommender_name}</{entry.recommender_faction.lower()}> Why: <notice>{entry.reason}</notice>\n" \
|
|
f"{button}"
|
|
else:
|
|
account = self.account_service.get_account(entry.main_id)
|
|
text = f"[<notice>ALT</notice>] <{entry.alt_faction.lower()}>{entry.alt_name}</{entry.alt_faction.lower()}> ({entry.alt_level}/<green>{entry.alt_ai_level}</green>) " \
|
|
f" [{self.text.make_tellcmd('W', f'whois {entry.alt_name}')}] " \
|
|
f"[{self.text.make_tellcmd('H', f'history {entry.alt_name}')}]\n" \
|
|
f"Main: <{entry.main_faction.lower()}>{entry.main_name}</{entry.main_faction.lower()}> ({entry.main_level}/<green>{entry.main_ai_level}</green>) [Join: {self.util.format_datetime(account.created)}]" \
|
|
f" - [{self.text.make_tellcmd('W', f'whois {entry.main_name}')}] " \
|
|
f"[{self.text.make_tellcmd('H', f'history {entry.main_name}')}]\n" \
|
|
f"{button}"
|
|
|
|
return text + "\n\n"
|
|
|
|
@command(command="register", params=[Const("pending"), Const('deny'), Character('character')],
|
|
description="Deny (and disable) a pending account", sub_command="mng", access_level="admin")
|
|
def register_pending_deny(self, request, _1, _2, user):
|
|
pending = self.account_service.is_pending(user.char_id)
|
|
if not pending:
|
|
return f"There's no pending registration for <highlight>{user.name}</highlight>."
|
|
self.account_service.create_users([(pending.alt, pending.alt, -1, time.time(), time.time())])
|
|
self.account_service.add_log(request.sender.char_id, "system",
|
|
f"Created <highlight>{user.name}</highlight>'s account.",
|
|
request.sender.char_id)
|
|
self.account_service.add_log(user.char_id, "system",
|
|
f"Account closed by <highlight>{request.sender.name}</highlight>.",
|
|
request.sender.char_id)
|
|
|
|
self.db.exec("UPDATE pending_accounts set answered = 1 where alt=?", [pending.alt])
|
|
self.account_service.account_disable(user.char_id)
|
|
self.send_notify(self.Notify.DENIED, user.name, user.name)
|
|
|
|
# noinspection LongLine
|
|
@command(command="register", params=[Const("pending"), Const('approve'), Character('character')],
|
|
description="Approve (and activate) a pending account", sub_command="mng", access_level="admin")
|
|
def register_pending_approve(self, request, _1, _2, user):
|
|
pending = self.account_service.is_pending(user.char_id)
|
|
if not pending:
|
|
return f"There's no pending registration for <highlight>{user.name}</highlight>."
|
|
self.account_service.create_users([(pending.alt, pending.alt, 0, time.time(), time.time())])
|
|
if pending.alt == pending.main:
|
|
self.db.exec("UPDATE pending_accounts set answered = 1 where alt=?", [pending.alt])
|
|
self.account_service.add_log(request.sender.char_id, "system",
|
|
f"Opened <highlight>{user.name}</highlight>'s account.",
|
|
request.sender.char_id)
|
|
self.account_service.add_log(user.char_id, "system",
|
|
f"Account opened by <highlight>{request.sender.name}</highlight>.",
|
|
request.sender.char_id)
|
|
recommender: str = self.character_service.get_char_name(pending.recommender)
|
|
self.buddy_service.add_buddy(user.char_id, "member")
|
|
self.bot.send_mass_message(user.char_id,
|
|
f"Your Account has been <green>opened</green> by "
|
|
f"<highlight>{request.sender.name}</highlight>. "
|
|
f"<highlight>{recommender.capitalize()}</highlight> has recommended you.")
|
|
self.send_notify(self.Notify.APPROVAL_MAIN, user.name, user.name)
|
|
else:
|
|
msg, typ = self.account_service.add_alt(pending.main, pending.alt, approve=True)
|
|
if msg == "success":
|
|
self.db.exec("UPDATE pending_accounts set answered = 1 where alt=?", [pending.alt])
|
|
self.account_service.add_log(request.sender.char_id, "system",
|
|
f"Added <highlight>{user.name}</highlight> as an alt of <highlight>{self.character_service.resolve_char_to_name(pending.main)}</highlight>.",
|
|
request.sender.char_id)
|
|
self.account_service.add_log(user.char_id, "system",
|
|
f"Request to add <highlight>{user.name}</highlight> as an alt "
|
|
f"has been approved by <highlight>{request.sender.name}</highlight>.",
|
|
request.sender.char_id)
|
|
self.send_notify(self.Notify.APPROVAL_ALT,
|
|
self.character_service.resolve_char_to_name(pending.main),
|
|
user.name)
|
|
else:
|
|
return "Something went wrong.."
|
|
|
|
@command(command="register", params=[Const('alt'), Character('character')],
|
|
description="Add an alt", access_level="member")
|
|
def register_alt(self, request, _, alt):
|
|
manual = self.setting_service.get_value("alt_verification") == "1"
|
|
if not alt.char_id:
|
|
return "Character does not exist"
|
|
if not manual:
|
|
return "This command is currently disabled, please use <highlight>!alts add</highlight>"
|
|
msg, _ = self.account_service.add_pending_alt(request.sender.char_id, alt.char_id)
|
|
if msg in ["another_main", "already_main"]:
|
|
return f"You cannot add <highlight>{alt.name}</highlight> as an alt, because it already has a main."
|
|
elif msg == "pending_alt":
|
|
return f"There's already a pending registration for the alt <highlight>{alt.name}</highlight>, " \
|
|
f"please wait for an admin to confirm it."
|
|
elif msg == "success":
|
|
self.send_notify(self.Notify.REQUEST_ALT, request.sender.name, alt.name)
|
|
return f"You requested to add <highlight>{alt.name}</highlight> as an alt."
|
|
|
|
@command(command="register", params=[Const('recommend'), Character('character'), Any('reason')],
|
|
description="Recommend someone as a raider", access_level="member")
|
|
def register_account(self, request, _, user, reason):
|
|
if not user.char_id:
|
|
return "Character does not exist"
|
|
if self.account_service.get_account(user.char_id):
|
|
return f"There's already an account for <highlight>{user.name}</highlight> registered."
|
|
msg, _ = self.account_service.add_pending_account(request.sender.char_id, user.char_id, reason)
|
|
if msg in ["another_main", "already_main"]:
|
|
return f"You cannot recommend <highlight>{user.name}</highlight>, " \
|
|
f"because the character is already registered."
|
|
elif msg == "pending_alt":
|
|
return f"There's already a pending registration for the character <highlight>{user.name}</highlight>, " \
|
|
f"please wait for an admin to confirm it."
|
|
elif msg == "success":
|
|
self.send_notify(self.Notify.REQUEST_MAIN, user.name, user.name)
|
|
|
|
def send_notify(self, notify_type, main, alt):
|
|
message = "[<cyan>PG</cyan>] "
|
|
if notify_type == self.Notify.APPROVAL_MAIN:
|
|
message += f"[<cyan>Main</cyan>] Approved: <highlight>{main}</highlight>'s Account has been opened."
|
|
elif notify_type == self.Notify.APPROVAL_ALT:
|
|
message += f"[<cyan>Alt</cyan>] Approved: <highlight>{alt}</highlight> " \
|
|
f"has been assigned to <highlight>{main}</highlight>."
|
|
elif notify_type == self.Notify.DENIED:
|
|
message += f"Denied: <highlight>{main}</highlight>'s Account has been closed."
|
|
elif notify_type == self.Notify.REQUEST_ALT:
|
|
message += f"[<cyan>Alt</cyan>] Request: <highlight>{alt}</highlight> => <highlight>{main}</highlight>"
|
|
elif notify_type == self.Notify.REQUEST_MAIN:
|
|
message += f"[<cyan>Main</cyan>] Request: <highlight>{main}</highlight> as a new " \
|
|
f"<highlight>raider</highlight>"
|
|
self.messagehub.send_message("registration", None, f"{message}", f"{message}")
|
|
|
|
class Notify:
|
|
APPROVAL_MAIN = "approval-main"
|
|
APPROVAL_ALT = "approval-alt"
|
|
DENIED = "denied"
|
|
REQUEST_ALT = "req-alt"
|
|
REQUEST_MAIN = "req-main"
|