2021-06-23 12:29:33 +02:00

252 lines
8.0 KiB
Python

from django.conf.urls import include, url
from django.template.loader import render_to_string
from django.utils.functional import cached_property
from django.conf import settings
from string import Formatter
from allianceauth.hooks import get_hooks
from .models import NameFormatConfig
def get_extension_logger(name):
"""
Takes the name of a plugin/extension and generates a child logger of the extensions logger
to be used by the extension to log events to the extensions logger.
The logging level is determined by the level defined for the parent logger.
:param: name: the name of the extension doing the logging
:return: an extensions child logger
"""
if not isinstance(name, str):
raise TypeError(f"get_extension_logger takes an argument of type string."
f"Instead received argument of type {type(name).__name__}.")
import logging
parent_logger = logging.getLogger('extensions')
logger = logging.getLogger('extensions.' + name)
logger.name = name
logger.level = parent_logger.level
return logger
class ServicesHook:
"""
Abstract base class for creating a compatible services
hook. Decorate with @register('services_hook') to have the
services module registered for callbacks. Must be in
auth_hook(.py) sub module
"""
def __init__(self):
self.name = 'Undefined'
self.urlpatterns = []
self.service_ctrl_template = 'services/services_ctrl.html'
self.access_perm = None
@property
def title(self):
"""
A nicely formatted title of the service, for client facing
display.
:return: str
"""
return self.name.title()
def delete_user(self, user, notify_user=False):
"""
Delete the users service account, optionally notify them
that the service has been disabled
:param user: Django.contrib.auth.models.User
:param notify_user: Whether the service should sent a
notification to the user about the disabling of their
service account.
:return: True if the service account has been disabled,
or False if it doesnt exist.
"""
pass
def validate_user(self, user):
pass
def sync_nickname(self, user):
"""
Sync the users nickname
:param user: Django.contrib.auth.models.User
:return: None
"""
pass
def update_groups(self, user):
"""
Update the users group membership
:param user: Django.contrib.auth.models.User
:return: None
"""
pass
def update_all_groups(self):
"""
Iterate through and update all users groups
:return: None
"""
pass
def service_active_for_user(self, user):
pass
def show_service_ctrl(self, user):
"""
Whether the service control should be displayed to the given user
who has the given service state. Usually this function wont
require overloading.
:param user: django.contrib.auth.models.User
:return: bool True if the service should be shown
"""
return self.service_active_for_user(user) or user.is_superuser
def render_services_ctrl(self, request):
"""
Render the services control template row
:param request:
:return:
"""
return ''
def __str__(self):
return self.name or 'Unknown Service Module'
class Urls:
def __init__(self):
self.auth_activate = ''
self.auth_set_password = ''
self.auth_reset_password = ''
self.auth_deactivate = ''
@staticmethod
def get_services():
for fn in get_hooks('services_hook'):
yield fn()
class MenuItemHook:
def __init__(self, text, classes, url_name, order=None, navactive=list([])):
self.text = text
self.classes = classes
self.url_name = url_name
self.template = 'public/menuitem.html'
self.order = order if order is not None else 9999
# count is an integer shown next to the menu item as badge when count != None
# apps need to set the count in their child class, e.g. in render() method
self.count = None
navactive = navactive or []
navactive.append(url_name)
self.navactive = navactive
def render(self, request):
return render_to_string(self.template,
{'item': self},
request=request)
class UrlHook:
def __init__(self, urls, namespace, base_url):
self.include_pattern = url(base_url, include(urls, namespace=namespace))
class NameFormatter:
DEFAULT_FORMAT = getattr(settings, "DEFAULT_SERVICE_NAME_FORMAT", '[{corp_ticker}] {character_name}')
def __init__(self, service, user):
"""
:param service: ServicesHook of the service to generate the name for.
:param user: django.contrib.auth.models.User to format name for
"""
self.service = service
self.user = user
def format_name(self):
"""
:return: str Generated name
"""
format_data = self.get_format_data()
return Formatter().vformat(self.string_formatter, args=[], kwargs=format_data).strip()
def get_format_data(self):
try:
character_name = self.user.profile.main_character.character_name
character_id = self.user.profile.main_character.character_id
corp_name = self.user.profile.main_character.corporation_name
corp_id = self.user.profile.main_character.corporation_id
corp_ticker = self.user.profile.main_character.corporation_ticker
alliance_name = self.user.profile.main_character.alliance_name
alliance_id = self.user.profile.main_character.alliance_id
alliance_ticker = self.user.profile.main_character.alliance_ticker
except (AttributeError, ObjectDoesNotExist):
character_name = self.user.username if self._default_to_username else ""
character_id = ""
corp_name = ""
corp_id = ""
corp_ticker = ""
alliance_name = ""
alliance_id = ""
alliance_ticker = ""
format_data = {
'character_name': character_name,
'character_id': character_id if character_id else "",
'corp_ticker': corp_ticker if corp_ticker else "",
'corp_name': corp_name if corp_name else "",
'corp_id': corp_id if corp_id else "",
'alliance_name': alliance_name if alliance_name else "",
'alliance_id': alliance_id if alliance_id else "",
'alliance_ticker': alliance_ticker if alliance_ticker else "",
'username': self.user.username,
}
format_data['alliance_or_corp_name'] = format_data['alliance_name'] or format_data['corp_name']
format_data['alliance_or_corp_ticker'] = format_data['alliance_ticker'] or format_data['corp_ticker']
return format_data
@cached_property
def formatter_config(self):
format_config = NameFormatConfig.objects.filter(service_name=self.service.name,
states__pk=self.user.profile.state.pk)
if format_config.exists():
return format_config[0]
return None
@cached_property
def string_formatter(self):
"""
Try to get the config format first
Then the service default
Before finally defaulting to global default
:return: str
"""
return getattr(self.formatter_config, 'format', self.default_formatter)
@cached_property
def default_formatter(self):
return getattr(self.service, 'name_format', self.DEFAULT_FORMAT)
@cached_property
def _default_to_username(self):
"""
Default to a users username if they have no main character.
Default is True
:return: bool
"""
return getattr(self.formatter_config, 'default_to_username', True)