django-orchestra/orchestra/plugins/options.py

143 lines
4.3 KiB
Python
Raw Normal View History

2023-07-09 07:51:51 +00:00
from django.core.exceptions import ValidationError
class Plugin(object):
verbose_name = None
# Used on select plugin view
class_verbose_name = None
icon = None
change_form = None
form = None
serializer = None
change_readonly_fields = ()
plugin_field = None
def __init__(self, instance=None):
# Related model instance of this plugin
self.instance = instance
if self.form is None:
from .forms import PluginForm
self.form = PluginForm
super().__init__()
@classmethod
def get_name(cls):
return getattr(cls, 'name', cls.__name__)
@classmethod
def get_plugins(cls):
return cls.plugins
@classmethod
def get(cls, name):
if not hasattr(cls, '_registry'):
cls._registry = {
plugin.get_name(): plugin for plugin in cls.get_plugins()
}
return cls._registry[name]
@classmethod
def get_verbose_name(cls):
# don't evaluate p.verbose_name gettext_lazy
verbose = getattr(cls.verbose_name, '_proxy____args', [cls.verbose_name])
if verbose[0]:
return cls.verbose_name
else:
return cls.get_name()
@classmethod
def get_choices(cls):
choices = []
for plugin in cls.get_plugins():
verbose = plugin.get_verbose_name()
choices.append(
(plugin.get_name(), verbose)
)
return sorted(choices, key=lambda e: e[1])
@classmethod
def get_change_readonly_fields(cls):
return cls.change_readonly_fields
@classmethod
def get_class_path(cls):
return '.'.join((cls.__module__, cls.__name__))
def clean_data(self):
""" model clean, uses cls.serizlier by default """
if self.serializer:
serializer = self.serializer(data=self.instance.data)
if not serializer.is_valid():
raise ValidationError(serializer.errors)
return serializer.data
return {}
def get_directive(self):
raise NotImplementedError
def get_form(self):
self.form.plugin = self
self.form.plugin_field = self.plugin_field
return self.form
def get_change_form(self):
form = self.change_form or self.form
form.plugin = self
form.plugin_field = self.plugin_field
return form
def get_serializer(self):
self.serializer.plugin = self
return self.serializer
class PluginModelAdapter(Plugin):
""" Adapter class for using model classes as plugins """
model = None
name_field = None
form = None
def __init__(self, instance=None):
if self.form is None:
from .forms import PluginModelAdapterForm
self.form = PluginModelAdapterForm
super().__init__(instance)
@classmethod
def get_plugins(cls):
plugins = []
for related_instance in cls.model.objects.filter(is_active=True):
attributes = {
'related_instance': related_instance,
'verbose_name': related_instance.verbose_name
}
plugins.append(type('PluginAdapter', (cls,), attributes))
return plugins
@classmethod
def get(cls, name):
# don't cache, since models can change
for plugin in cls.get_plugins():
if name == plugin.get_name():
return plugin
@classmethod
def get_name(cls):
return getattr(cls.related_instance, cls.name_field)
class PluginMount(type):
def __init__(cls, name, bases, attrs):
if not attrs.get('abstract', False):
if not hasattr(cls, 'plugins'):
# This branch only executes when processing the mount point itself.
# So, since this is a new plugin type, not an implementation, this
# class shouldn't be registered as a plugin. Instead, it sets up a
# list where plugins can be registered later.
cls.plugins = []
else:
# This must be a plugin implementation, which should be registered.
# Simply appending it to the list is all that's needed to keep
# track of it later.
cls.plugins.append(cls)