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)