def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
collections = permission_policy.collections_user_has_any_permission_for(
self.request.user, ['add', 'change'])
if len(collections) < 2:
collections = None
Image = get_image_model()
context.update({
'search_form':
self.form,
'popular_tags':
popular_tags_for_model(get_image_model()),
'current_tag':
self.current_tag,
'collections':
collections,
'current_collection':
self.current_collection,
'user_can_add':
permission_policy.user_has_permission(self.request.user, 'add'),
'app_label':
Image._meta.app_label,
'model_name':
Image._meta.model_name,
})
return context
def chooser(request):
VideoForm = get_video_form(Video)
uploadform = VideoForm()
videos = Video.objects.order_by('-created_at')
q = None
if ('q' in request.GET or 'p' in request.GET or 'tag' in request.GET
or 'collection_id' in request.GET):
# this request is triggered from search, pagination or 'popular tags';
# we will just render the results.html fragment
collection_id = request.GET.get('collection_id')
if collection_id:
videos = videos.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
videos = videos.search(q)
is_searching = True
else:
is_searching = False
tag_name = request.GET.get('tag')
if tag_name:
videos = videos.filter(tags__name=tag_name)
# Pagination
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render(request, "wagtailvideos/chooser/results.html", {
'videos': page,
'is_searching': is_searching,
'query_string': q,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render_modal_workflow(
request,
'wagtailvideos/chooser/chooser.html',
None, {
'videos': page,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'popular_tags': popular_tags_for_model(Video),
'collections': collections,
},
json_data=get_chooser_js_data())
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
collections = permission_policy.collections_user_has_any_permission_for(
self.request.user, ["add", "change"])
if len(collections) < 2:
collections = None
Document = get_document_model()
context.update({
"search_form":
self.form,
"popular_tags":
popular_tags_for_model(get_document_model()),
"user_can_add":
permission_policy.user_has_permission(self.request.user, "add"),
"collections":
collections,
"current_collection":
self.current_collection,
"app_label":
Document._meta.app_label,
"model_name":
Document._meta.model_name,
})
return context
def index(request):
Image = get_image_model()
# Get images (filtered by user permission)
images = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete']
).order_by('-created_at')
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search images"))
if form.is_valid():
query_string = form.cleaned_data['q']
images = images.search(query_string)
else:
form = SearchForm(placeholder=_("Search images"))
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
images = images.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
paginator = Paginator(images, per_page=32)
images = paginator.get_page(request.GET.get('p'))
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
# Create response
if request.is_ajax():
return render(request, 'wagtailimages/images/results.html', {
'images': images,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(request, 'wagtailimages/images/index.html', {
'images': images,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Image),
'collections': collections,
'current_collection': current_collection,
'user_can_add': permission_policy.user_has_permission(request.user, 'add'),
})
def index(request):
# Get Videos (filtered by user permission)
videos = Video.objects.all()
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search videos"))
if form.is_valid():
query_string = form.cleaned_data['q']
videos = videos.search(query_string)
else:
form = SearchForm(placeholder=_("Search videos"))
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
videos = videos.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
paginator = Paginator(videos, per_page=25)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
else:
collections = Collection.order_for_display(collections)
page = paginator.get_page(request.GET.get('p'))
# Create response
if request.is_ajax():
response = render(request, 'wagtailvideos/videos/results.html', {
'videos': page,
'query_string': query_string,
'is_searching': bool(query_string),
})
return response
else:
response = render(request, 'wagtailvideos/videos/index.html', {
'videos': page,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Video),
'current_collection': current_collection,
'collections': collections,
})
return response
def chooser(request):
EmbedVideo = get_embed_video_model()
if request.user.has_perm('wagtail_embed_videos.add_embedvideo'):
can_add = True
else:
can_add = False
q = None
embed_videos = EmbedVideo.objects.order_by('-created_at')
if 'q' in request.GET or 'p' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
embed_videos = embed_videos.search(q)
is_searching = True
else:
is_searching = False
q = None
# Pagination
# paginator, embed_videos = paginate(request, embed_videos, per_page=12) DEPRECATED
paginator = Paginator(embed_videos, per_page=12)
embed_videos = paginator.get_page(request.GET.get('p'))
return render(request, "wagtail_embed_videos/chooser/results.html", {
'embed_videos': embed_videos,
'is_searching': is_searching,
'can_add': can_add,
'query_string': q,
})
else:
# paginator, embed_videos = paginate(request, embed_videos, per_page=12)
paginator = Paginator(embed_videos, per_page=12)
embed_videos = paginator.get_page(request.GET.get('p'))
searchform = SearchForm()
return render_modal_workflow(
request,
'wagtail_embed_videos/chooser/chooser.html',
None, #'wagtail_embed_videos/chooser/chooser.js',
template_vars={
'embed_videos': embed_videos,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags': popular_tags_for_model(EmbedVideo),
},
json_data={
'step': 'chooser',
}
)
def index(request):
EmbedVideo = get_embed_video_model()
# Get embed videos
embed_videos = EmbedVideo.objects.order_by('-created_at')
# Permissions
if not request.user.has_perm('wagtail_embed_videos.change_embedvideo'):
# restrict to the user's own embed videos
embed_videos = embed_videos.filter(uploaded_by_user=request.user)
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search videos"))
if form.is_valid():
query_string = form.cleaned_data['q']
if not request.user.has_perm(
'wagtail_embed_videos.change_embedvideo'):
# restrict to the user's own embed videos
embed_videos = EmbedVideo.objects.search(
query_string,
filters={'uploaded_by_user_id': request.user.id})
else:
embed_videos = EmbedVideo.objects.search(query_string)
else:
form = SearchForm(placeholder=_("Search videos"))
# Pagination
p = request.GET.get('p', 1)
paginator = Paginator(embed_videos, 20)
try:
embed_videos = paginator.page(p)
except PageNotAnInteger:
embed_videos = paginator.page(1)
except EmptyPage:
embed_videos = paginator.page(paginator.num_pages)
# Create response
if request.is_ajax():
return render(
request, 'wagtail_embed_videos/embed_videos/results.html', {
'embed_videos': embed_videos,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(
request, 'wagtail_embed_videos/embed_videos/index.html', {
'embed_videos': embed_videos,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(EmbedVideo),
})
def chooser_upload(request):
Video = get_video_model()
VideoForm = get_video_form(Video)
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST,
request.FILES,
instance=video,
user=request.user)
if form.is_valid():
form.save()
# Reindex the video entry to make sure all tags are indexed
for backend in get_search_backends():
backend.add(video)
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'video_chosen',
'result':
get_video_result_data(video)
})
else:
video = Video(uploaded_by_user=request.user)
form = VideoForm(user=request.user, instance=video)
video_files = Video.objects.order_by('-created_at')
paginator = Paginator(video_files, per_page=10)
video_files = paginator.get_page(request.GET.get('p'))
context = {
'video_files': video_files,
'searchform': SearchForm(),
'is_searching': False,
'can_add': True,
'uploadform': form,
'popular_tags': popular_tags_for_model(Video),
}
return render_modal_workflow(request,
'wagtailimages/chooser/chooser.html',
None,
context,
json_data={
'step': 'chooser',
})
def get_chooser_context(request):
"""Helper function to return common template context variables for the main chooser view"""
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
return {
'searchform': SearchForm(),
'is_searching': False,
'query_string': None,
'will_select_format': request.GET.get('select_format'),
'popular_tags': popular_tags_for_model(get_image_model()),
'collections': collections,
}
def get_context_data(self):
context = super().get_context_data()
if permission_policy.user_has_permission(self.request.user, 'add'):
ImageForm = get_image_form(self.image_model)
uploadform = ImageForm(user=self.request.user, prefix='image-chooser-upload')
else:
uploadform = None
collections = permission_policy.collections_user_has_permission_for(
self.request.user, 'choose'
)
if len(collections) < 2:
collections = None
context.update({
'searchform': self.search_form,
'popular_tags': popular_tags_for_model(self.image_model),
'collections': collections,
'uploadform': uploadform,
})
return context
def get_context_data(self):
context = super().get_context_data()
if permission_policy.user_has_permission(self.request.user, "add"):
ImageForm = get_image_form(self.image_model)
uploadform = ImageForm(user=self.request.user,
prefix="image-chooser-upload")
else:
uploadform = None
collections = permission_policy.collections_user_has_permission_for(
self.request.user, "choose")
if len(collections) < 2:
collections = None
context.update({
"searchform": self.search_form,
"popular_tags": popular_tags_for_model(self.image_model),
"collections": collections,
"uploadform": uploadform,
})
return context
def index(request):
Media = get_media_model()
# Get media files (filtered by user permission)
media = permission_policy.instances_user_has_any_permission_for(
request.user, ["change", "delete"])
# Ordering
if "ordering" in request.GET and request.GET["ordering"] in [
"title",
"-created_at",
]:
ordering = request.GET["ordering"]
else:
ordering = "-created_at"
media = media.order_by(ordering)
# Search
query_string = None
if "q" in request.GET:
form = SearchForm(request.GET, placeholder=_("Search media files"))
if form.is_valid():
query_string = form.cleaned_data["q"]
media = media.search(query_string)
else:
form = SearchForm(placeholder=_("Search media"))
# Filter by collection
current_collection = None
collection_id = request.GET.get("collection_id")
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
media = media.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Filter by tag
current_tag = request.GET.get("tag")
if current_tag:
try:
media = media.filter(tags__name=current_tag)
except (AttributeError):
current_tag = None
# Pagination
paginator, media = paginate(request, media)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ["add", "change"])
if len(collections) < 2:
collections = None
# Create response
if request.headers.get("x-requested-with") == "XMLHttpRequest":
return render(
request,
"wagtailmedia/media/results.html",
{
"ordering": ordering,
"media_files": media,
"query_string": query_string,
"is_searching": bool(query_string),
},
)
else:
return render(
request,
"wagtailmedia/media/index.html",
{
"ordering":
ordering,
"media_files":
media,
"query_string":
query_string,
"is_searching":
bool(query_string),
"search_form":
form,
"popular_tags":
popular_tags_for_model(Media),
"current_tag":
current_tag,
"user_can_add":
permission_policy.user_has_permission(request.user, "add"),
"collections":
collections,
"current_collection":
current_collection,
},
)
def index(request):
Document = get_document_model()
# Get documents (filtered by user permission)
documents = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete']
)
# Ordering
if 'ordering' in request.GET and request.GET['ordering'] in ['title', '-created_at']:
ordering = request.GET['ordering']
else:
ordering = '-created_at'
documents = documents.order_by(ordering)
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
documents = documents.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search documents"))
if form.is_valid():
query_string = form.cleaned_data['q']
documents = documents.search(query_string)
else:
form = SearchForm(placeholder=_("Search documents"))
# Pagination
paginator = Paginator(documents, per_page=20)
documents = paginator.get_page(request.GET.get('p'))
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
else:
collections = Collection.order_for_display(collections)
# Create response
if request.is_ajax():
return render(request, 'wagtaildocs/documents/results.html', {
'ordering': ordering,
'documents': documents,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(request, 'wagtaildocs/documents/index.html', {
'ordering': ordering,
'documents': documents,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Document),
'user_can_add': permission_policy.user_has_permission(request.user, 'add'),
'collections': collections,
'current_collection': current_collection,
})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["popular_tags"] = popular_tags_for_model(self.model)
return context
def chooser(request):
Video = get_video_model()
video_files = []
if request.user.has_perm('wagtail_video.add_video'):
can_add = True
VideoForm = get_video_form(Video)
video = Video(uploaded_by_user=request.user)
uploadform = VideoForm(user=request.user, instance=video)
else:
uploadform = None
can_add = False
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET:
video_files = Video.objects.all()
collection_id = request.GET.get('collection_id')
if collection_id:
video_files = video_files.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
video_files = video_files.search(q)
is_searching = True
else:
video_files = video_files.order_by('-created_at')
is_searching = False
# Pagination
paginator = Paginator(video_files, per_page=10)
video_files = paginator.get_page(request.GET.get('p'))
return render(
request, "wagtail_video/chooser/results.html", {
'video_files': video_files,
'query_string': q,
'is_searching': is_searching,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
video_files = Video.objects.order_by('-created_at')
paginator = Paginator(video_files, per_page=10)
video_files = paginator.get_page(request.GET.get('p'))
# return render_modal_workflow(request, 'wagtail_video/chooser/chooser.html', None, {
# 'video_files': video_files,
# 'searchform': searchform,
# 'collections': collections,
# 'is_searching': False,
# })
return render_modal_workflow(request,
'wagtail_video/chooser/chooser.html',
None,
template_vars={
'collections': collections,
'video_files': video_files,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'uploadform': uploadform,
'query_string': q,
'popular_tags':
popular_tags_for_model(Video),
},
json_data={
'step': 'chooser',
})
def index(request):
Media = get_media_model()
# Get media files (filtered by user permission)
media = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete'])
# Ordering
if 'ordering' in request.GET and request.GET['ordering'] in [
'title', '-created_at'
]:
ordering = request.GET['ordering']
else:
ordering = '-created_at'
media = media.order_by(ordering)
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
media = media.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search media files"))
if form.is_valid():
query_string = form.cleaned_data['q']
media = media.search(query_string)
else:
form = SearchForm(placeholder=_("Search media"))
# Pagination
paginator, media = paginate(request, media)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change'])
if len(collections) < 2:
collections = None
# Create response
if request.is_ajax():
return render(
request, 'wagtailmedia/media/results.html', {
'ordering': ordering,
'media_files': media,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(
request, 'wagtailmedia/media/index.html', {
'ordering':
ordering,
'media_files':
media,
'query_string':
query_string,
'is_searching':
bool(query_string),
'search_form':
form,
'popular_tags':
popular_tags_for_model(Media),
'user_can_add':
permission_policy.user_has_permission(request.user, 'add'),
'collections':
collections,
'current_collection':
current_collection,
})
def chooser(request, media_type=None):
Media = get_media_model()
media_files = permission_policy.instances_user_has_any_permission_for(
request.user, ["change", "delete"])
# allow hooks to modify the queryset
for hook in hooks.get_hooks("construct_media_chooser_queryset"):
media_files = hook(media_files, request)
if permission_policy.user_has_permission(request.user, "add"):
MediaForm = get_media_form(Media)
media_audio = Media(uploaded_by_user=request.user, type="audio")
media_video = Media(uploaded_by_user=request.user, type="video")
uploadforms = {
"audio":
MediaForm(user=request.user,
prefix="media-chooser-upload",
instance=media_audio),
"video":
MediaForm(user=request.user,
prefix="media-chooser-upload",
instance=media_video),
}
if media_type:
uploadforms = {media_type: uploadforms[media_type]}
else:
uploadforms = {}
if media_type:
media_files = media_files.filter(type=media_type)
if ("q" in request.GET or "p" in request.GET or "tag" in request.GET
or "collection_id" in request.GET):
collection_id = request.GET.get("collection_id")
if collection_id:
media_files = media_files.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data["q"]
media_files = media_files.search(q)
is_searching = True
else:
media_files = media_files.order_by("-created_at")
is_searching = False
q = None
tag_name = request.GET.get("tag")
if tag_name:
media_files = media_files.filter(tags__name=tag_name)
# Pagination
paginator, media_files = paginate(request, media_files, per_page=10)
return render(
request,
"wagtailmedia/chooser/results.html",
{
"media_files": media_files,
"query_string": q,
"is_searching": is_searching,
"pagination_template": pagination_template,
"media_type": media_type,
},
)
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = media_files.order_by("-created_at")
paginator, media_files = paginate(request, media_files, per_page=10)
return render_modal_workflow(
request,
"wagtailmedia/chooser/chooser.html",
None,
{
"media_files": media_files,
"searchform": searchform,
"collections": collections,
"uploadforms": uploadforms,
"is_searching": False,
"pagination_template": pagination_template,
"popular_tags": popular_tags_for_model(Media),
"media_type": media_type,
},
json_data={
"step": "chooser",
"error_label": "Server Error",
"error_message":
"Report this error to your webmaster with the following information:",
"tag_autocomplete_url": reverse("wagtailadmin_tag_autocomplete"),
},
)
def index(request):
Video = get_video_model()
# Get video files (filtered by user permission)
video = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete']
)
# Ordering
if 'ordering' in request.GET and request.GET['ordering'] in ['title', '-created_at']:
ordering = request.GET['ordering']
else:
ordering = '-created_at'
video = video.order_by(ordering)
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
# noinspection PyUnresolvedReferences
try:
current_collection = Collection.objects.get(id=collection_id)
video = video.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search video files"))
if form.is_valid():
query_string = form.cleaned_data['q']
video = video.search(query_string)
else:
form = SearchForm(placeholder=_("Search video"))
# Pagination
paginator = Paginator(video, per_page=25)
video = paginator.get_page(request.GET.get('p'))
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
# Create response
if request.is_ajax():
return render(request, 'wagtail_video/video/results.html', {
'ordering': ordering,
'video_files': video,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(request, 'wagtail_video/video/index.html', {
'ordering': ordering,
'video_files': video,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Video),
'user_can_add': permission_policy.user_has_permission(request.user, 'add'),
'collections': collections,
'current_collection': current_collection,
})
