def add(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)
messages.success(request, _("Video file '{0}' added.").format(video.title), buttons=[
messages.button(reverse('wagtail_video:edit', args=(video.id,)), _('Edit'))
])
return redirect('wagtail_video:index')
else:
messages.error(request, _("The video file could not be saved due to errors."))
else:
video = Video(uploaded_by_user=request.user)
form = VideoForm(user=request.user, instance=video)
return render(request, "wagtail_video/video/add.html", {
'form': form,
})
def usage(request, video_id):
Video = get_video_model()
video = get_object_or_404(Video, id=video_id)
paginator, used_by = paginate(request, video.get_usage())
return render(request, "wagtail_video/video/usage.html", {
'video': video,
'used_by': used_by
})
def video_chosen(request, video_id):
video = get_object_or_404(get_video_model(), id=video_id)
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'video_chosen',
'result': get_video_result_data(video)
})
def usage(request, video_id):
Video = get_video_model()
video = get_object_or_404(Video, id=video_id)
paginator = Paginator(video.get_usage(), per_page=25)
used_by = paginator.get_page(request.GET.get('p'))
return render(request, "wagtail_video/video/usage.html", {
'video': video,
'used_by': used_by
})
def describe_collection_video(collection):
video_count = get_video_model().objects.filter(
collection=collection).count()
if video_count:
url = reverse('wagtail_video:index') + ('?collection_id=%d' %
collection.id)
return {
'count': video_count,
'count_text': ungettext("%(count)s video file",
"%(count)s video files", video_count) % {
'count': video_count
},
'url': url,
}
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 delete(request, video_id):
Video = get_video_model()
video = get_object_or_404(Video, id=video_id)
if not permission_policy.user_has_permission_for_instance(request.user, 'delete', video):
return permission_denied(request)
if request.POST:
video.delete()
messages.success(request, _("Video file '{0}' deleted.").format(video.title))
return redirect('wagtail_video:index')
return render(request, "wagtail_video/video/confirm_delete.html", {
'video': video,
})
def target_model(self):
from wagtail_video.models import get_video_model
return get_video_model()
from wagtail.core.permission_policies.collections import CollectionOwnershipPermissionPolicy
from wagtail_video.models import Video, get_video_model
permission_policy = CollectionOwnershipPermissionPolicy(
get_video_model(), auth_model=Video, owner_field_name='uploaded_by_user')
def chooser(request):
Video = get_video_model()
video_files = []
if request.user.has_perm('wagtail_video.add_video'):
can_add = True
else:
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, video_files = paginate(request, video_files, per_page=10)
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, video_files = paginate(request, video_files, per_page=10)
# 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={
'video_files': video_files,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags':
popular_tags_for_model(Video),
},
json_data={
'step': 'chooser',
})
def get_context(self):
return {
'total_video': get_video_model().objects.count(),
}
def __init__(self, **kwargs):
super(AdminVideoChooser, self).__init__(**kwargs)
self.video_model = get_video_model()
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,
})
def edit(request, video_id):
Video = get_video_model()
VideoForm = get_video_form(Video)
video = get_object_or_404(Video, id=video_id)
if not permission_policy.user_has_permission_for_instance(request.user, 'change', video):
return permission_denied(request)
if request.POST:
original_file = video.mp4
form = VideoForm(request.POST, request.FILES, instance=video, user=request.user)
if form.is_valid():
if 'file' in form.changed_data:
# if providing a new video file, delete the old one.
# NB Doing this via original_file.delete() clears the file field,
# which definitely isn't what we want...
original_file.storage.delete(original_file.name)
video = form.save()
# Reindex the video entry to make sure all tags are indexed
for backend in get_search_backends():
backend.add(video)
messages.success(request, _("Video file '{0}' updated").format(video.title), buttons=[
messages.button(reverse('wagtail_video:edit', args=(video.id,)), _('Edit'))
])
return redirect('wagtail_video:index')
else:
messages.error(request, _("The video could not be saved due to errors."))
else:
form = VideoForm(instance=video, user=request.user)
filesize = None
# Get file size when there is a file associated with the Video object
if video.mp4:
try:
filesize = video.mp4.size
except OSError:
# File doesn't exist
pass
if video.ogg:
try:
filesize = video.ogg.size
except OSError:
# File doesn't exist
pass
if video.webm:
try:
filesize = video.webm.size
except OSError:
# File doesn't exist
pass
if not filesize:
messages.error(
request,
_("The file could not be found. Please change the source or delete the video file"),
buttons=[messages.button(reverse('wagtail_video:delete', args=(video.id,)), _('Delete'))]
)
return render(request, "wagtail_video/video/edit.html", {
'video': video,
'filesize': filesize,
'form': form,
'user_can_delete': permission_policy.user_has_permission_for_instance(
request.user, 'delete', video
),
})
