def target_content_type(cls):
if cls._target_content_type is None:
if cls.page_type:
target_models = []
for page_type in cls.page_type:
try:
target_models.append(resolve_model_string(page_type))
except LookupError:
raise ImproperlyConfigured(
"{0}.page_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, page_type
)
)
except ValueError:
raise ImproperlyConfigured(
"{0}.page_type refers to model {1!r} that has not been installed".format(
cls.__name__, page_type
)
)
cls._target_content_type = list(ContentType.objects.get_for_models(*target_models).values())
else:
target_model = cls.model._meta.get_field(cls.field_name).rel.to
cls._target_content_type = [ContentType.objects.get_for_model(target_model)]
return cls._target_content_type
def page_model_from_string(string):
page_model = resolve_model_string(string)
if not issubclass(page_model, Page):
raise ValueError("Model is not a page")
return page_model
def get_invoice_model(cls):
if isinstance(cls.invoice_model, models.Model):
return cls.invoice_model
elif isinstance(cls.invoice_model, string_types):
return resolve_model_string(cls.invoice_model, cls._meta.app_label)
else:
raise ValueError('Can not resolve {0}.invoice_model in to a model: {1!r}'.format(
cls.__name__, cls.invoice_model))
def get_model(self, request):
if 'type' not in request.GET:
return Page
model_name = request.GET['type']
try:
return resolve_model_string(model_name)
except LookupError:
raise self.BadRequestError("type doesn't exist")
def target_models(self):
target_models = []
for target_model in self._target_models:
target_models.append(
resolve_model_string(target_model)
)
return target_models
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 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_allowed_subpage_types(self):
"""
Returns the list of manually selected subpage types, normalised as model classes.
"""
if self.allowed_subpage_types is None or len(
self.allowed_subpage_types) == 0:
return []
return [
resolve_model_string(model_string)
for model_string in self.allowed_subpage_types
]
def alter_can_exist_under(self, child_page_class, can_exist):
"""
Alter what pages may appear as children for Static Pages.
"""
if len(self.allowed_subpage_types) > 0:
allowed_subpage_type_models = [
resolve_model_string(model_string)
for model_string in self.allowed_subpage_types
]
return child_page_class in allowed_subpage_type_models
return can_exist
def get_model(self, request):
if 'type' not in request.GET:
return Page
model_name = request.GET['type']
try:
model = resolve_model_string(model_name)
if not issubclass(model, Page):
raise BadRequestError("type doesn't exist")
return model
except LookupError:
raise BadRequestError("type doesn't exist")
def target_model(cls):
if cls._target_model is None:
if cls.snippet_type:
try:
cls._target_model = resolve_model_string(cls.snippet_type)
except LookupError:
raise ImproperlyConfigured("{0}.snippet_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, cls.snippet_type))
except ValueError:
raise ImproperlyConfigured("{0}.snippet_type refers to model {1!r} that has not been installed".format(
cls.__name__, cls.snippet_type))
else:
cls._target_model = cls.model._meta.get_field(cls.field_name).rel.to
return cls._target_model
def target_content_type(cls):
if cls._target_content_type is None:
if cls.page_type:
try:
model = resolve_model_string(cls.page_type)
except LookupError:
raise ImproperlyConfigured("{0}.page_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, cls.page_type))
except ValueError:
raise ImproperlyConfigured("{0}.page_type refers to model {1!r} that has not been installed".format(
cls.__name__, cls.page_type))
cls._target_content_type = ContentType.objects.get_for_model(model)
else:
# TODO: infer the content type by introspection on the foreign key
cls._target_content_type = ContentType.objects.get_by_natural_key('wagtailcore', 'page')
return cls._target_content_type
def target_model(cls):
if cls._target_model is None:
if cls.snippet_type:
try:
cls._target_model = resolve_model_string(cls.snippet_type)
except LookupError:
raise ImproperlyConfigured(
"{0}.snippet_type must be of the form 'app_label.model_name', given {1!r}"
.format(cls.__name__, cls.snippet_type))
except ValueError:
raise ImproperlyConfigured(
"{0}.snippet_type refers to model {1!r} that has not been installed"
.format(cls.__name__, cls.snippet_type))
else:
cls._target_model = cls.model._meta.get_field(
cls.field_name).rel.to
return cls._target_model
def target_content_type(cls):
if cls._target_content_type is None:
if cls.page_type:
try:
model = resolve_model_string(cls.page_type)
except LookupError:
raise ImproperlyConfigured("{0}.page_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, cls.page_type))
except ValueError:
raise ImproperlyConfigured("{0}.page_type refers to model {1!r} that has not been installed".format(
cls.__name__, cls.page_type))
cls._target_content_type = ContentType.objects.get_for_model(model)
else:
# TODO: infer the content type by introspection on the foreign key
cls._target_content_type = ContentType.objects.get_by_natural_key('wagtailcore', 'page')
return cls._target_content_type
def target_content_type(cls):
if cls._target_content_type is None:
if cls.page_type:
try:
model = resolve_model_string(cls.page_type)
except LookupError:
raise ImproperlyConfigured("{0}.page_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, cls.page_type))
except ValueError:
raise ImproperlyConfigured("{0}.page_type refers to model {1!r} that has not been installed".format(
cls.__name__, cls.page_type))
cls._target_content_type = ContentType.objects.get_for_model(model)
else:
target_model = cls.model._meta.get_field(cls.field_name).rel.to
cls._target_content_type = ContentType.objects.get_for_model(target_model)
return cls._target_content_type
def target_models(cls):
if cls.page_type:
target_models = []
for page_type in cls.page_type:
try:
target_models.append(resolve_model_string(page_type))
except LookupError:
raise ImproperlyConfigured(
"{0}.page_type must be of the form 'app_label.model_name', given {1!r}"
.format(cls.__name__, page_type))
except ValueError:
raise ImproperlyConfigured(
"{0}.page_type refers to model {1!r} that has not been installed"
.format(cls.__name__, page_type))
return target_models
else:
return [cls.model._meta.get_field(cls.field_name).rel.to]
def search(request, parent_page_id=None):
page_types = request.GET.get('page_types')
content_types = []
# Convert page_types string into list of ContentType objects
if page_types:
try:
content_types = ContentType.objects.get_for_models(*[
resolve_model_string(page_type) for page_type in page_types.split(',')])
except LookupError:
raise Http404
search_form = SearchForm(request.GET)
if search_form.is_valid() and search_form.cleaned_data['q']:
pages = Page.objects.exclude(
depth=1 # never include root
)
# Restrict content types
if content_types:
pages = pages.filter(content_type__in=content_types)
# Do search
pages = pages.filter(title__icontains=search_form.cleaned_data['q'])
# Truncate results
pages = pages[:10]
else:
pages = Page.objects.none()
shown_pages = []
for page in pages:
page.can_choose = True
shown_pages.append(page)
return render(
request, 'wagtailadmin/chooser/_search_results.html',
shared_context(request, {
'searchform': search_form,
'pages': shown_pages,
})
)
def target_model(cls):
if cls._target_model is None:
if cls.snippet_type:
# RemovedInWagtail16Warning: The target_model is automatically
# detected from the relation, so snippet_type is deprecated.
try:
cls._target_model = resolve_model_string(cls.snippet_type)
except LookupError:
raise ImproperlyConfigured(
"{0}.snippet_type must be of the form 'app_label.model_name', given {1!r}"
.format(cls.__name__, cls.snippet_type))
except ValueError:
raise ImproperlyConfigured(
"{0}.snippet_type refers to model {1!r} that has not been installed"
.format(cls.__name__, cls.snippet_type))
else:
cls._target_model = cls.model._meta.get_field(
cls.field_name).rel.to
return cls._target_model
def target_model(cls):
if cls._target_model is None:
if cls.snippet_type:
# RemovedInWagtail16Warning: The target_model is automatically
# detected from the relation, so snippet_type is deprecated.
try:
cls._target_model = resolve_model_string(cls.snippet_type)
except LookupError:
raise ImproperlyConfigured(
"{0}.snippet_type must be of the form 'app_label.model_name', given {1!r}"
.format(cls.__name__, cls.snippet_type)
)
except ValueError:
raise ImproperlyConfigured(
"{0}.snippet_type refers to model {1!r} that has not been installed"
.format(cls.__name__, cls.snippet_type)
)
else:
cls._target_model = cls.model._meta.get_field(cls.field_name).rel.to
return cls._target_model
def get_queryset(self):
request = self.request
# Allow pages to be filtered to a specific type
if 'type' not in request.GET:
model = Page
else:
model_name = request.GET['type']
try:
model = resolve_model_string(model_name)
except LookupError:
raise BadRequestError("type doesn't exist")
if not issubclass(model, Page):
raise BadRequestError("type doesn't exist")
# Get live pages that are not in a private section
queryset = model.objects.public().live()
# Filter by site
queryset = queryset.descendant_of(request.site.root_page, inclusive=True)
return queryset
def clean_parent_page_types(cls):
"""
Returns the list of parent page types, with strings converted to class
objects where required
"""
if cls._clean_parent_page_types is None:
parent_page_types = getattr(cls, 'parent_page_types', None)
if parent_page_types is None:
# if parent_page_types is not specified on the Page class, allow all page types as subpages
res = get_page_types()
else:
try:
models = [resolve_model_string(model_string, cls._meta.app_label)
for model_string in parent_page_types]
except LookupError as err:
raise ImproperlyConfigured("{0}.parent_page_types must be a list of 'app_label.model_name' strings, given {1!r}".format(
cls.__name__, err.args[1]))
res = list(map(ContentType.objects.get_for_model, models))
cls._clean_parent_page_types = res
return cls._clean_parent_page_types
def clean_parent_page_types(cls):
"""
Returns the list of parent page types, with strings converted to class
objects where required
"""
if cls._clean_parent_page_types is None:
parent_page_types = getattr(cls, 'parent_page_types', None)
if parent_page_types is None:
# if parent_page_types is not specified on the Page class, allow all page types as subpages
res = get_page_types()
else:
try:
models = [resolve_model_string(model_string, cls._meta.app_label)
for model_string in parent_page_types]
except LookupError as err:
raise ImproperlyConfigured("{0}.parent_page_types must be a list of 'app_label.model_name' strings, given {1!r}".format(
cls.__name__, err.args[1]))
res = list(map(ContentType.objects.get_for_model, models))
cls._clean_parent_page_types = res
return cls._clean_parent_page_types
def target_models(cls):
if cls.page_type:
target_models = []
for page_type in cls.page_type:
try:
target_models.append(resolve_model_string(page_type))
except LookupError:
raise ImproperlyConfigured(
"{0}.page_type must be of the form 'app_label.model_name', given {1!r}".format(
cls.__name__, page_type
)
)
except ValueError:
raise ImproperlyConfigured(
"{0}.page_type refers to model {1!r} that has not been installed".format(
cls.__name__, page_type
)
)
return target_models
else:
return [cls.model._meta.get_field(cls.field_name).rel.to]
def test_resolve_from_string(self):
model = resolve_model_string('wagtailcore.Page')
self.assertEqual(model, Page)
def test_resolve_from_string_with_default_app(self):
model = resolve_model_string("Page", default_app="wagtailcore")
self.assertEqual(model, Page)
def get_newsitem_model(cls):
return resolve_model_string(cls.newsitem_model, cls._meta.app_label)
def test_resolve_from_string_with_different_default_app(self):
model = resolve_model_string('wagtailcore.Page',
default_app='wagtailadmin')
self.assertEqual(model, Page)
def get_post_model(cls):
if not cls.post_model:
return
return resolve_model_string(cls.post_model)
def test_resolve_from_class(self):
model = resolve_model_string(Page)
self.assertEqual(model, Page)
def target_model(self):
return resolve_model_string(self._target_model)
def get_post_model(cls):
if not cls.post_model:
return
return resolve_model_string(cls.post_model)
def browse(request, parent_page_id=None):
ITEMS_PER_PAGE = 25
page_types = request.GET.get('page_types', 'wagtailcore.page').split(',')
desired_classes = []
for page_type in page_types:
try:
content_type = resolve_model_string(page_type)
except LookupError:
raise Http404
desired_classes.append(content_type)
if parent_page_id:
parent_page = get_object_or_404(Page, id=parent_page_id)
else:
parent_page = Page.get_first_root_node()
parent_page.can_choose = issubclass(parent_page.specific_class, tuple(desired_classes))
search_form = SearchForm()
pages = parent_page.get_children()
if desired_classes == [Page]:
# apply pagination first, since we know that the page listing won't
# have to be filtered, and that saves us walking the entire list
p = request.GET.get('p', 1)
paginator = Paginator(pages, ITEMS_PER_PAGE)
try:
pages = paginator.page(p)
except PageNotAnInteger:
pages = paginator.page(1)
except EmptyPage:
pages = paginator.page(paginator.num_pages)
for page in pages:
page.can_choose = True
page.can_descend = page.get_children_count()
else:
# restrict the page listing to just those pages that:
# - are of the given content type (taking into account class inheritance)
# - or can be navigated into (i.e. have children)
shown_pages = []
for page in pages:
page.can_choose = issubclass(page.specific_class or Page, tuple(desired_classes))
page.can_descend = page.get_children_count()
if page.can_choose or page.can_descend:
shown_pages.append(page)
# Apply pagination
p = request.GET.get('p', 1)
paginator = Paginator(shown_pages, ITEMS_PER_PAGE)
try:
pages = paginator.page(p)
except PageNotAnInteger:
pages = paginator.page(1)
except EmptyPage:
pages = paginator.page(paginator.num_pages)
return render_modal_workflow(
request,
'wagtailadmin/chooser/browse.html', 'wagtailadmin/chooser/browse.js',
shared_context(request, {
'parent_page': parent_page,
'pages': pages,
'search_form': search_form,
'page_type_string': ','.join(page_types),
'page_type_names': [desired_class.get_verbose_name() for desired_class in desired_classes],
'page_types_restricted': (page_type != 'wagtailcore.page')
})
)
def target_model(self):
return resolve_model_string(self._target_model)
def test_resolve_from_string(self):
model = resolve_model_string('wagtailcore.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_class(self):
model = resolve_model_string(Page)
self.assertEqual(model, Page)