def __init__(self,
target_models=None,
can_choose_root=False,
user_perms=None,
**kwargs):
super().__init__(**kwargs)
if target_models:
if not isinstance(target_models, (set, list, tuple)):
# assume we've been passed a single instance; wrap it as a list
target_models = [target_models]
# normalise the list of target models to a list of page classes
cleaned_target_models = []
for model in target_models:
try:
cleaned_target_models.append(resolve_model_string(model))
except (ValueError, LookupError):
raise ImproperlyConfigured(
"Could not resolve %r into a model. "
"Model names should be in the form app_label.model_name"
% (model, ))
else:
cleaned_target_models = [Page]
if len(cleaned_target_models
) == 1 and cleaned_target_models[0] is not Page:
model_name = cleaned_target_models[0]._meta.verbose_name.title()
self.choose_one_text += " (" + model_name + ")"
self.user_perms = user_perms
self.target_models = cleaned_target_models
self.can_choose_root = bool(can_choose_root)
def target_models(self):
target_models = []
for target_model in self.page_type:
target_models.append(resolve_model_string(target_model))
return target_models
def register(self, field_class, to=None, value=None, exact_class=False):
if to:
if field_class == models.ForeignKey:
self.values_by_fk_related_model[resolve_model_string(to)] = value
else:
raise ImproperlyConfigured(
"The 'to' argument on ModelFieldRegistry.register is only valid for ForeignKey fields"
)
else:
super().register(field_class, value=value, exact_class=exact_class)
def target_model(self):
"""
Defines the model used by the base ChooserBlock for ID <-> instance
conversions. If a single page type is specified in target_model,
we can use that to get the more specific instance "for free"; otherwise
use the generic Page model.
"""
if len(self.target_models) == 1:
return self.target_models[0]
return resolve_model_string("wagtailcore.Page")
def page_models_from_string(string):
page_models = []
for sub_string in string.split(","):
page_model = resolve_model_string(sub_string)
if not issubclass(page_model, Page):
raise ValueError("Model is not a page")
page_models.append(page_model)
return tuple(page_models)
def get_create_model(self):
"""
To be called after dispatch(); returns the model to use for a new task if one is known
(either from being the only available task mode, or from being specified in the URL as create_model)
"""
if self.can_create:
if len(self.task_models) == 1:
return self.task_models[0]
elif "create_model" in self.request.GET:
create_model = resolve_model_string(self.request.GET["create_model"])
if create_model not in self.task_models:
raise Http404
return create_model
def model_class(self):
if self.model:
return resolve_model_string(self.model)
def model_class(self):
return resolve_model_string(self.target_model)
def target_model(self):
return resolve_model_string(self._target_model)
def test_resolve_from_class(self):
model = resolve_model_string(Page)
self.assertEqual(model, Page)
def test_resolve_from_string_with_different_default_app(self):
model = resolve_model_string("wagtailcore.Page", default_app="wagtailadmin")
self.assertEqual(model, Page)
def test_resolve_from_string(self):
model = resolve_model_string("wagtailcore.Page")
self.assertEqual(model, Page)