", [[flatatt(s)] for s in value.sources]
107 | ),
108 | )
109 |
110 |
111 | class BlogStreamPage(Page):
112 | author = models.CharField(max_length=255)
113 | date = models.DateField("Post date")
114 |
115 | body = StreamField(
116 | [
117 | ("heading", blocks.CharBlock(classname="title", icon="title")),
118 | ("paragraph", blocks.RichTextBlock(icon="pilcrow")),
119 | ("media", TestMediaBlock(icon="media")),
120 | ("video", VideoChooserBlock(icon="media")),
121 | ("audio", AudioChooserBlock(icon="media")),
122 | ],
123 | use_json_field=True,
124 | )
125 |
126 | featured_media = models.ForeignKey(
127 | "wagtailmedia.Media", on_delete=models.PROTECT, related_name="+"
128 | )
129 |
130 | content_panels = Page.content_panels + [
131 | FieldPanel("author"),
132 | FieldPanel("date"),
133 | FieldPanel("body"),
134 | MediaChooserPanel("featured_media"),
135 | # the following are left here for local testing convenience
136 | # MediaChooserPanel("featured_media", media_type="audio"),
137 | # MediaChooserPanel("featured_media", media_type="video"),
138 | ]
139 |
--------------------------------------------------------------------------------
/src/wagtailmedia/wagtail_hooks.py:
--------------------------------------------------------------------------------
1 | from django.urls import include, path, reverse
2 | from django.utils.html import format_html
3 | from django.utils.translation import gettext_lazy as _
4 | from django.utils.translation import ngettext
5 | from wagtail import hooks
6 | from wagtail.admin.admin_url_finder import (
7 | ModelAdminURLFinder,
8 | register_admin_url_finder,
9 | )
10 | from wagtail.admin.menu import MenuItem
11 | from wagtail.admin.navigation import get_site_for_user
12 | from wagtail.admin.search import SearchArea
13 | from wagtail.admin.site_summary import SummaryItem
14 | from wagtail.admin.staticfiles import versioned_static
15 |
16 | from wagtailmedia import admin_urls
17 | from wagtailmedia.forms import GroupMediaPermissionFormSet
18 | from wagtailmedia.models import get_media_model
19 | from wagtailmedia.permissions import permission_policy
20 |
21 |
22 | @hooks.register("register_admin_urls")
23 | def register_admin_urls():
24 | return [
25 | path("media/", include((admin_urls, "wagtailmedia"), namespace="wagtailmedia")),
26 | ]
27 |
28 |
29 | class MediaMenuItem(MenuItem):
30 | def is_shown(self, request):
31 | return permission_policy.user_has_any_permission(
32 | request.user, ["add", "change", "delete"]
33 | )
34 |
35 |
36 | @hooks.register("register_admin_menu_item")
37 | def register_media_menu_item():
38 | return MediaMenuItem(
39 | _("Media"),
40 | reverse("wagtailmedia:index"),
41 | name="media",
42 | icon_name="media",
43 | order=300,
44 | )
45 |
46 |
47 | class MediaSummaryItem(SummaryItem):
48 | order = 300
49 | template_name = "wagtailmedia/homepage/site_summary_media.html"
50 |
51 | def get_context_data(self, parent_context):
52 | site_name = get_site_for_user(self.request.user)["site_name"]
53 | return {
54 | "total_media": permission_policy.instances_user_has_any_permission_for(
55 | self.request.user, {"add", "change", "delete", "choose"}
56 | ).count(),
57 | "site_name": site_name,
58 | }
59 |
60 | def is_shown(self):
61 | return permission_policy.user_has_any_permission(
62 | self.request.user, ["add", "change", "delete"]
63 | )
64 |
65 |
66 | @hooks.register("construct_homepage_summary_items")
67 | def add_media_summary_item(request, items):
68 | items.append(MediaSummaryItem(request))
69 |
70 |
71 | class MediaSearchArea(SearchArea):
72 | def is_shown(self, request):
73 | return permission_policy.user_has_any_permission(
74 | request.user, ["add", "change", "delete"]
75 | )
76 |
77 |
78 | @hooks.register("register_admin_search_area")
79 | def register_media_search_area():
80 | return MediaSearchArea(
81 | _("Media"),
82 | reverse("wagtailmedia:index"),
83 | name="media",
84 | icon_name="media",
85 | order=400,
86 | )
87 |
88 |
89 | @hooks.register("register_group_permission_panel")
90 | def register_media_permissions_panel():
91 | return GroupMediaPermissionFormSet
92 |
93 |
94 | @hooks.register("describe_collection_contents")
95 | def describe_collection_media(collection):
96 | media_count = get_media_model().objects.filter(collection=collection).count()
97 | if media_count:
98 | url = reverse("wagtailmedia:index") + f"?collection_id={collection.id}"
99 | return {
100 | "count": media_count,
101 | "count_text": ngettext(
102 | "%(count)s media file", "%(count)s media files", media_count
103 | )
104 | % {"count": media_count},
105 | "url": url,
106 | }
107 |
108 |
109 | class MediaAdminURLFinder(ModelAdminURLFinder):
110 | permission_policy = permission_policy
111 | edit_url_name = "wagtailmedia:edit"
112 |
113 |
114 | register_admin_url_finder(get_media_model(), MediaAdminURLFinder)
115 |
116 |
117 | @hooks.register("insert_global_admin_css")
118 | def add_media_css_tweaks():
119 | return format_html(
120 | '\n\n'
85 | f"Your browser does not support the audio element.
\n ",
86 | )
87 |
88 | # will return an empty value if trying to render with the wrong media type
89 | self.assertEqual(block.render(self.video), "")
90 |
91 | def test_video_chooser_block_type(self):
92 | block = VideoChooserBlock()
93 | self.assertEqual(block.media_type, "video")
94 |
95 | def test_video_chooser_block_field_queryset(self):
96 | block = VideoChooserBlock()
97 | self.assertListEqual(
98 | list(block.field.queryset.values_list("pk", flat=True)),
99 | list(Media.objects.filter(type="video").values_list("pk", flat=True)),
100 | )
101 |
102 | def test_video_chooser_block_rendering(self):
103 | block = VideoChooserBlock()
104 | self.assertEqual(
105 | block.render(self.video),
106 | f'\n\n'
107 | f"Your browser does not support the video element.
\n ",
108 | )
109 |
110 | # will return an empty value if trying to render with the wrong media type
111 | self.assertEqual(block.render(self.audio), "")
112 |
113 | def test_comparison_class(self):
114 | self.assertIs(
115 | AbstractMediaChooserBlock().get_comparison_class(),
116 | MediaChooserBlockComparison,
117 | )
118 | self.assertIs(
119 | AudioChooserBlock().get_comparison_class(), MediaChooserBlockComparison
120 | )
121 | self.assertIs(
122 | VideoChooserBlock().get_comparison_class(), MediaChooserBlockComparison
123 | )
124 |
--------------------------------------------------------------------------------
/src/wagtailmedia/templates/wagtailmedia/chooser/chooser.html:
--------------------------------------------------------------------------------
1 | {% load i18n wagtailadmin_tags %}
2 | {% include "wagtailadmin/shared/header.html" with title=title icon=icon merged=1 %}
3 |
4 | {# TODO: drop data-wmtabs and the tabs.js include once we drop support for Wagtail < 7.1 #}
5 |
104 |
--------------------------------------------------------------------------------
/src/wagtailmedia/models.py:
--------------------------------------------------------------------------------
1 | import mimetypes
2 | import os.path
3 |
4 | from django.conf import settings
5 | from django.core.exceptions import ImproperlyConfigured
6 | from django.core.validators import FileExtensionValidator, MinValueValidator
7 | from django.db import models
8 | from django.dispatch import Signal
9 | from django.urls import reverse
10 | from django.utils.translation import gettext_lazy as _
11 | from taggit.managers import TaggableManager
12 | from wagtail.models import CollectionMember, ReferenceIndex
13 | from wagtail.search import index
14 | from wagtail.search.queryset import SearchableQuerySetMixin
15 |
16 | from wagtailmedia.settings import wagtailmedia_settings
17 |
18 |
19 | ALLOWED_EXTENSIONS_THUMBNAIL = ["gif", "jpg", "jpeg", "png", "webp"]
20 |
21 |
22 | class MediaType(models.TextChoices):
23 | AUDIO = "audio", _("Audio file")
24 | VIDEO = "video", _("Video file")
25 |
26 |
27 | class MediaQuerySet(SearchableQuerySetMixin, models.QuerySet):
28 | pass
29 |
30 |
31 | class AbstractMedia(CollectionMember, index.Indexed, models.Model):
32 | title = models.CharField(max_length=255, verbose_name=_("title"))
33 | file = models.FileField(upload_to="media", verbose_name=_("file"))
34 |
35 | type = models.CharField(
36 | choices=MediaType.choices, max_length=255, blank=False, null=False
37 | )
38 | duration = models.FloatField(
39 | blank=True,
40 | default=0,
41 | validators=[MinValueValidator(0)],
42 | verbose_name=_("duration"),
43 | help_text=_("Duration in seconds"),
44 | )
45 | width = models.PositiveIntegerField(null=True, blank=True, verbose_name=_("width"))
46 | height = models.PositiveIntegerField(
47 | null=True, blank=True, verbose_name=_("height")
48 | )
49 | thumbnail = models.FileField(
50 | upload_to="media_thumbnails", blank=True, verbose_name=_("thumbnail")
51 | )
52 |
53 | created_at = models.DateTimeField(verbose_name=_("created at"), auto_now_add=True)
54 | uploaded_by_user = models.ForeignKey(
55 | settings.AUTH_USER_MODEL,
56 | verbose_name=_("uploaded by user"),
57 | null=True,
58 | blank=True,
59 | editable=False,
60 | on_delete=models.SET_NULL,
61 | )
62 |
63 | tags = TaggableManager(help_text=None, blank=True, verbose_name=_("tags"))
64 |
65 | objects = MediaQuerySet.as_manager()
66 |
67 | search_fields = CollectionMember.search_fields + [
68 | index.SearchField("title", boost=10),
69 | index.AutocompleteField("title", boost=10),
70 | index.FilterField("title"),
71 | index.RelatedFields(
72 | "tags",
73 | [
74 | index.SearchField("name", boost=10),
75 | index.AutocompleteField("name", boost=10),
76 | ],
77 | ),
78 | index.FilterField("uploaded_by_user"),
79 | index.FilterField("type"),
80 | ]
81 |
82 | admin_form_fields = (
83 | "title",
84 | "file",
85 | "collection",
86 | "duration",
87 | "width",
88 | "height",
89 | "thumbnail",
90 | "tags",
91 | )
92 |
93 | def __str__(self):
94 | return self.title
95 |
96 | @property
97 | def icon(self):
98 | return f"wagtailmedia-{self.type}"
99 |
100 | @property
101 | def filename(self):
102 | return os.path.basename(self.file.name)
103 |
104 | @property
105 | def thumbnail_filename(self) -> str:
106 | return os.path.basename(self.thumbnail.name) if self.thumbnail else ""
107 |
108 | @property
109 | def file_extension(self):
110 | return os.path.splitext(self.filename)[1][1:]
111 |
112 | @property
113 | def url(self):
114 | return self.file.url
115 |
116 | @property
117 | def sources(self):
118 | return [
119 | {
120 | "src": self.url,
121 | "type": mimetypes.guess_type(self.filename)[0]
122 | or "application/octet-stream",
123 | }
124 | ]
125 |
126 | def get_usage(self):
127 | return ReferenceIndex.get_references_to(self).group_by_source_object()
128 |
129 | @property
130 | def usage_url(self):
131 | return reverse("wagtailmedia:media_usage", args=(self.id,))
132 |
133 | def is_editable_by_user(self, user):
134 | from wagtailmedia.permissions import permission_policy
135 |
136 | return permission_policy.user_has_permission_for_instance(user, "change", self)
137 |
138 | def clean(self, *args, **kwargs):
139 | super().clean(*args, **kwargs)
140 | if not self.duration:
141 | self.duration = 0
142 |
143 | if self.thumbnail:
144 | validate = FileExtensionValidator(ALLOWED_EXTENSIONS_THUMBNAIL)
145 | validate(self.thumbnail)
146 |
147 | if self.type == "audio" and wagtailmedia_settings.AUDIO_EXTENSIONS:
148 | validate = FileExtensionValidator(wagtailmedia_settings.AUDIO_EXTENSIONS)
149 | validate(self.file)
150 | elif self.type == "video" and wagtailmedia_settings.VIDEO_EXTENSIONS:
151 | validate = FileExtensionValidator(wagtailmedia_settings.VIDEO_EXTENSIONS)
152 | validate(self.file)
153 |
154 | class Meta:
155 | abstract = True
156 | verbose_name = _("media")
157 | verbose_name_plural = _("media items")
158 |
159 |
160 | class Media(AbstractMedia):
161 | pass
162 |
163 |
164 | def get_media_model():
165 | from django.apps import apps
166 |
167 | from wagtailmedia.settings import wagtailmedia_settings
168 |
169 | try:
170 | app_label, model_name = wagtailmedia_settings.MEDIA_MODEL.split(".")
171 | except AttributeError:
172 | return Media
173 | except ValueError as err:
174 | raise ImproperlyConfigured(
175 | "WAGTAILMEDIA[\"MEDIA_MODEL\"] must be of the form 'app_label.model_name'"
176 | ) from err
177 |
178 | media_model = apps.get_model(app_label, model_name)
179 | if media_model is None:
180 | raise ImproperlyConfigured(
181 | f"WAGTAILMEDIA[\"MEDIA_MODEL\"] refers to model '{wagtailmedia_settings.MEDIA_MODEL}' that has not been installed"
182 | )
183 |
184 | return media_model
185 |
186 |
187 | # Provides `request` as an argument
188 | media_served = Signal()
189 |
--------------------------------------------------------------------------------
/tests/test_compare.py:
--------------------------------------------------------------------------------
1 | from django.test import TestCase
2 | from django.utils.safestring import SafeString
3 | from testapp.models import BlogStreamPage
4 |
5 | from wagtailmedia.blocks import (
6 | AudioChooserBlock,
7 | MediaChooserBlockComparison,
8 | VideoChooserBlock,
9 | )
10 | from wagtailmedia.edit_handlers import MediaFieldComparison
11 | from wagtailmedia.models import get_media_model
12 | from wagtailmedia.utils import format_audio_html, format_video_html
13 |
14 | from .utils import create_audio, create_video
15 |
16 |
17 | Media = get_media_model()
18 |
19 |
20 | class MediaBlockComparisonTestCase(TestCase):
21 | @classmethod
22 | def setUpTestData(cls):
23 | cls.audio_a = create_audio("Test audio 1", duration=1000)
24 | cls.audio_b = create_audio("Test audio 2", duration=100)
25 | cls.video_a = create_video("Test video 1", duration=1024)
26 | cls.video_b = create_video("Test video 2", duration=1024)
27 |
28 | def tearDown(self):
29 | for m in [self.audio_a, self.audio_b, self.video_a, self.video_b]:
30 | m.delete()
31 |
32 |
33 | class MediaFieldComparisonTest(MediaBlockComparisonTestCase):
34 | comparison_class = MediaFieldComparison
35 |
36 | def test_hasnt_changed(self):
37 | comparison = self.comparison_class(
38 | BlogStreamPage._meta.get_field("featured_media"),
39 | BlogStreamPage(featured_media=self.audio_a),
40 | BlogStreamPage(featured_media=self.audio_a),
41 | )
42 |
43 | self.assertTrue(comparison.is_field)
44 | self.assertFalse(comparison.is_child_relation)
45 | self.assertEqual(comparison.field_label(), "Featured media")
46 | self.assertFalse(comparison.has_changed())
47 |
48 | diff = comparison.htmldiff()
49 | self.assertHTMLEqual(
50 | diff,
51 | f'{format_audio_html(self.audio_a)}
',
52 | )
53 | self.assertIsInstance(diff, SafeString)
54 |
55 | comparison = self.comparison_class(
56 | BlogStreamPage._meta.get_field("featured_media"),
57 | BlogStreamPage(featured_media=self.video_a),
58 | BlogStreamPage(featured_media=self.video_a),
59 | )
60 | self.assertFalse(comparison.has_changed())
61 |
62 | self.assertHTMLEqual(
63 | comparison.htmldiff(),
64 | f'{format_video_html(self.video_a)}
',
65 | )
66 |
67 | def test_has_changed(self):
68 | comparison = self.comparison_class(
69 | BlogStreamPage._meta.get_field("featured_media"),
70 | BlogStreamPage(featured_media=self.audio_a),
71 | BlogStreamPage(featured_media=self.audio_b),
72 | )
73 |
74 | self.assertTrue(comparison.has_changed())
75 | diff = comparison.htmldiff()
76 | self.assertHTMLEqual(
77 | diff,
78 | f'{format_audio_html(self.audio_a)}
'
79 | f'{format_audio_html(self.audio_b)}
',
80 | )
81 | self.assertIsInstance(diff, SafeString)
82 |
83 | comparison = self.comparison_class(
84 | BlogStreamPage._meta.get_field("featured_media"),
85 | BlogStreamPage(featured_media=self.audio_a),
86 | BlogStreamPage(featured_media=self.video_a),
87 | )
88 | self.assertTrue(comparison.has_changed())
89 | self.assertHTMLEqual(
90 | comparison.htmldiff(),
91 | f'{format_audio_html(self.audio_a)}
'
92 | f'{format_video_html(self.video_a)}
',
93 | )
94 |
95 | comparison = self.comparison_class(
96 | BlogStreamPage._meta.get_field("featured_media"),
97 | BlogStreamPage(featured_media=self.video_a),
98 | BlogStreamPage(featured_media=self.video_b),
99 | )
100 | self.assertTrue(comparison.has_changed())
101 | self.assertHTMLEqual(
102 | comparison.htmldiff(),
103 | f'{format_video_html(self.video_a)}
'
104 | f'{format_video_html(self.video_b)}
',
105 | )
106 |
107 | def test_empty_compare(self):
108 | comparison = self.comparison_class(
109 | BlogStreamPage._meta.get_field("featured_media"),
110 | BlogStreamPage(featured_media=None),
111 | BlogStreamPage(featured_media=None),
112 | )
113 |
114 | self.assertTrue(comparison.is_field)
115 | self.assertFalse(comparison.is_child_relation)
116 | self.assertEqual(comparison.field_label(), "Featured media")
117 | self.assertFalse(comparison.has_changed())
118 |
119 | self.assertHTMLEqual(comparison.htmldiff(), "")
120 |
121 | def test_our_class_in_comparison_class_registry(self):
122 | from wagtail.admin.compare import comparison_class_registry
123 |
124 | self.assertIn(Media, comparison_class_registry.values_by_fk_related_model)
125 | self.assertIs(
126 | comparison_class_registry.values_by_fk_related_model[Media],
127 | MediaFieldComparison,
128 | )
129 |
130 |
131 | class MediaBlockComparisonTest(MediaBlockComparisonTestCase):
132 | comparison_class = MediaChooserBlockComparison
133 |
134 | def test_comparison_hasnt_changed(self):
135 | comparison = self.comparison_class(
136 | AudioChooserBlock(), True, True, self.audio_a, self.audio_a
137 | )
138 | self.assertFalse(comparison.has_changed())
139 | diff = comparison.htmldiff()
140 | self.assertHTMLEqual(
141 | diff,
142 | f'{format_audio_html(self.audio_a)}
',
143 | )
144 | self.assertIsInstance(diff, SafeString)
145 |
146 | comparison = self.comparison_class(
147 | VideoChooserBlock(), True, True, self.video_a, self.video_a
148 | )
149 | self.assertFalse(comparison.has_changed())
150 | self.assertHTMLEqual(
151 | comparison.htmldiff(),
152 | f'{format_video_html(self.video_a)}
',
153 | )
154 |
155 | def test_comparison_has_changed(self):
156 | comparison = self.comparison_class(
157 | AudioChooserBlock(), True, True, self.audio_a, self.audio_b
158 | )
159 | self.assertTrue(comparison.has_changed())
160 | diff = comparison.htmldiff()
161 | self.assertHTMLEqual(
162 | diff,
163 | f'{format_audio_html(self.audio_a)}
'
164 | f'{format_audio_html(self.audio_b)}
',
165 | )
166 |
167 | comparison = self.comparison_class(
168 | VideoChooserBlock(), True, True, self.video_a, self.video_b
169 | )
170 | self.assertTrue(comparison.has_changed())
171 | self.assertHTMLEqual(
172 | comparison.htmldiff(),
173 | f'{format_video_html(self.video_a)}
'
174 | f'{format_video_html(self.video_b)}
',
175 | )
176 |
--------------------------------------------------------------------------------
/src/wagtailmedia/static/wagtailmedia/js/media-chooser-modal.js:
--------------------------------------------------------------------------------
1 | MEDIA_CHOOSER_MODAL_ONLOAD_HANDLERS = {
2 | 'chooser': function(modal, jsonData) {
3 | const searchUrl = $('form.media-search', modal.body).attr('action');
4 | const searchInput = $('#id_q', modal.body);
5 | const resultsContainer = $('#search-results', modal.body);
6 | const collectionChooser = $('#collection_chooser_collection_id', modal.body);
7 | /* save initial page browser HTML, so that we can restore it if the search box gets cleared */
8 | const initialPageResultsHtml = resultsContainer.html();
9 |
10 | /* currentTag stores the tag currently being filtered on, so that we can
11 | preserve this when paginating */
12 | let currentTag;
13 |
14 | let request;
15 |
16 | function ajaxifyLinks (context) {
17 | $('a.media-choice', context).on('click', function(e) {
18 | modal.loadUrl(this.href);
19 | e.preventDefault();
20 | });
21 |
22 | $('.pagination a', context).on('click', function(e) {
23 | let params = {
24 | collection_id: collectionChooser.val()
25 | };
26 |
27 | if (this.hasAttribute("data-page")) {
28 | params['p'] = this.getAttribute("data-page");
29 | }
30 | else if (this.parentElement.classList.contains("prev") || this.parentElement.classList.contains("next")) {
31 | const href = new URL(this.href);
32 | params = Object.fromEntries(href.searchParams.entries());
33 | }
34 |
35 | const query = searchInput.val();
36 | if (query.length) {
37 | params['q'] = query;
38 | }
39 | if (currentTag) {
40 | params['tag'] = currentTag;
41 | }
42 |
43 | request = fetchResults(params);
44 | e.preventDefault();
45 | });
46 |
47 | $('a[data-ordering]', context).on('click', function(e) {
48 | request = fetchResults({
49 | q: searchInput.val(),
50 | collection_id: collectionChooser.val(),
51 | ordering: this.dataset["ordering"]
52 | });
53 | e.preventDefault();
54 | });
55 | }
56 |
57 | function fetchResults(requestData) {
58 | return $.ajax({
59 | url: searchUrl,
60 | data: requestData,
61 | success(data) {
62 | request = null;
63 | resultsContainer.html(data);
64 | ajaxifyLinks(resultsContainer);
65 | },
66 | error() {
67 | request = null;
68 | },
69 | });
70 | }
71 |
72 | function search() {
73 | const query = searchInput.val();
74 | const collection_id = collectionChooser.val()
75 | if (query !== '' || collection_id !== '') {
76 | /* Searching causes currentTag to be cleared - otherwise there's
77 | no way to de-select a tag */
78 | currentTag = null;
79 | request = fetchResults({
80 | q: query,
81 | collection_id: collection_id
82 | });
83 | }
84 | else {
85 | /* search box is empty - restore original page browser HTML */
86 | resultsContainer.html(initialPageResultsHtml);
87 | ajaxifyLinks();
88 | }
89 | return false;
90 | }
91 |
92 | ajaxifyLinks(modal.body);
93 | if (typeof initWMTabs !== "undefined") {
94 | initWMTabs();
95 | }
96 |
97 | $('form.media-upload', modal.body).on('submit', function() {
98 | var formdata = new FormData(this);
99 |
100 | // Get the title field of the submitted form, not the first in the modal.
101 | const input = this.querySelector('#id_media-chooser-upload-title');
102 | if (!input.value) {
103 | if (!input.hasAttribute('aria-invalid')) {
104 | input.setAttribute('aria-invalid', 'true');
105 | const field = input.closest('[data-field]');
106 | field.classList.add('w-field--error');
107 | const errors = field.querySelector('[data-field-errors]');
108 | const icon = errors.querySelector('.icon');
109 | if (icon) {
110 | icon.removeAttribute('hidden');
111 | }
112 | const errorElement = document.createElement('p');
113 | errorElement.classList.add('error-message');
114 | // Global function provided by Wagtail.
115 | errorElement.innerHTML = gettext('This field is required.');
116 | errors.appendChild(errorElement);
117 | }
118 | setTimeout(cancelSpinner, 500);
119 | } else {
120 | $.ajax({
121 | url: this.action,
122 | data: formdata,
123 | processData: false,
124 | contentType: false,
125 | type: 'POST',
126 | dataType: 'text',
127 | success: modal.loadResponseText,
128 | error: function(response, textStatus, errorThrown) {
129 | message = jsonData['error_message'] + '' +
132 | '' + jsonData['error_label'] + ': ' + message + '
');
133 | }
134 | });
135 | }
136 |
137 | return false;
138 | });
139 |
140 | $('form.media-search', modal.body).on('submit', search);
141 |
142 | searchInput.on('input', function() {
143 | if (request) {
144 | request.abort();
145 | }
146 | clearTimeout($.data(this, 'timer'));
147 | var wait = setTimeout(search, 200);
148 | $(this).data('timer', wait);
149 | });
150 | collectionChooser.on('change', search);
151 | $('a.suggested-tag').on('click', function() {
152 | currentTag = $(this).text();
153 | searchInput.val('');
154 | request = fetchResults({
155 | 'tag': currentTag,
156 | collection_id: collectionChooser.val()
157 | });
158 | return false;
159 | });
160 |
161 | // Note: There are two inputs with `#id_title` on the page.
162 | // The page title and media title. Select the input inside the modal body.
163 | $('[name="media-chooser-upload-file"]', modal.body).each(function() {
164 | const fileWidget = $(this);
165 | fileWidget.on('change', function () {
166 | let titleWidget = $('#id_media-chooser-upload-title', fileWidget.closest('form'));
167 | if (titleWidget.val() === '') {
168 | // The file widget value example: `C:\fakepath\media.jpg`
169 | const parts = fileWidget.val().split('\\');
170 | const filename = parts[parts.length - 1];
171 | titleWidget.val(filename.replace(/\.[^.]+$/, ''));
172 | }
173 | });
174 | });
175 |
176 | /* Add tag entry interface (with autocompletion) to the tag field of the media upload form */
177 | $('[name="media-chooser-upload-tags"]', modal.body).each(function() {
178 | $(this).tagit({
179 | autocomplete: {source: jsonData['tag_autocomplete_url']}
180 | });
181 | });
182 | },
183 | 'media_chosen': function(modal, jsonData) {
184 | modal.respond('mediaChosen', jsonData['result']);
185 | modal.close();
186 | },
187 | 'select_format': function(modal) {
188 | $('form', modal.body).on('submit', function() {
189 | var formdata = new FormData(this);
190 |
191 | $.post(this.action, $(this).serialize(), modal.loadResponseText, 'text');
192 |
193 | return false;
194 | });
195 | }
196 | };
197 |
--------------------------------------------------------------------------------
/tests/test_permissions.py:
--------------------------------------------------------------------------------
1 | from django.contrib.auth import get_user_model
2 | from django.contrib.auth.models import Group, Permission
3 | from django.core.files.base import ContentFile
4 | from django.test import TestCase
5 | from django.urls import reverse
6 | from wagtail.models import Collection, GroupCollectionPermission
7 | from wagtail.test.utils import WagtailTestUtils
8 |
9 | from wagtailmedia import models
10 |
11 |
12 | class TestMediaPermissions(TestCase):
13 | @classmethod
14 | def setUpTestData(cls):
15 | # Create some user accounts for testing permissions
16 | User = get_user_model()
17 | cls.user = User.objects.create_user(
18 | username="user", email="user@email.com", password="password"
19 | )
20 | cls.owner = User.objects.create_user(
21 | username="owner", email="owner@email.com", password="password"
22 | )
23 | cls.editor = User.objects.create_user(
24 | username="editor", email="editor@email.com", password="password"
25 | )
26 | cls.editor.groups.add(Group.objects.get(name="Editors"))
27 | cls.administrator = User.objects.create_superuser(
28 | username="administrator",
29 | email="administrator@email.com",
30 | password="password",
31 | )
32 |
33 | # Owner user must have the add_media permission
34 | cls.adders_group = Group.objects.create(name="Media adders")
35 | GroupCollectionPermission.objects.create(
36 | group=cls.adders_group,
37 | collection=Collection.get_first_root_node(),
38 | permission=Permission.objects.get(codename="add_media"),
39 | )
40 | cls.owner.groups.add(cls.adders_group)
41 |
42 | # Create a media for running tests on
43 | cls.media = models.Media.objects.create(
44 | title="Test media", duration=100, uploaded_by_user=cls.owner
45 | )
46 |
47 | def test_administrator_can_edit(self):
48 | self.assertTrue(self.media.is_editable_by_user(self.administrator))
49 |
50 | def test_editor_can_edit(self):
51 | self.assertTrue(self.media.is_editable_by_user(self.editor))
52 |
53 | def test_owner_can_edit(self):
54 | self.assertTrue(self.media.is_editable_by_user(self.owner))
55 |
56 | def test_user_cant_edit(self):
57 | self.assertFalse(self.media.is_editable_by_user(self.user))
58 |
59 |
60 | class TestEditOnlyPermissions(TestCase, WagtailTestUtils):
61 | @classmethod
62 | def setUpTestData(cls):
63 | cls.root_collection = Collection.get_first_root_node()
64 | cls.evil_plans_collection = cls.root_collection.add_child(name="Evil plans")
65 | cls.nice_plans_collection = cls.root_collection.add_child(name="Nice plans")
66 |
67 | # Create a media to edit
68 | cls.media = models.Media.objects.create(
69 | title="Test media",
70 | file=ContentFile("A boring example song", name="song.mp3"),
71 | collection=cls.nice_plans_collection,
72 | duration=100,
73 | )
74 |
75 | # Create a user with change_media permission but not add_media
76 | cls.user = get_user_model().objects.create_user(
77 | username="changeonly", email="changeonly@example.com", password="password"
78 | )
79 | change_permission = Permission.objects.get(
80 | content_type__app_label="wagtailmedia", codename="change_media"
81 | )
82 | admin_permission = Permission.objects.get(
83 | content_type__app_label="wagtailadmin", codename="access_admin"
84 | )
85 | cls.changers_group = Group.objects.create(name="Media changers")
86 | GroupCollectionPermission.objects.create(
87 | group=cls.changers_group,
88 | collection=cls.root_collection,
89 | permission=change_permission,
90 | )
91 | cls.user.groups.add(cls.changers_group)
92 |
93 | cls.user.user_permissions.add(admin_permission)
94 |
95 | cls.collection_label_tag = ''
96 |
97 | def setUp(self):
98 | self.client.force_login(self.user)
99 |
100 | def test_get_index(self):
101 | response = self.client.get(reverse("wagtailmedia:index"))
102 | self.assertEqual(response.status_code, 200)
103 | self.assertTemplateUsed(response, "wagtailmedia/media/index.html")
104 |
105 | # user should not get an "Add audio" and "Add video" buttons
106 | self.assertNotContains(response, "Add audio")
107 | self.assertNotContains(response, "Add video")
108 |
109 | # user should be able to see media not owned by them
110 | self.assertContains(response, "Test media")
111 |
112 | def test_search(self):
113 | response = self.client.get(reverse("wagtailmedia:index"), {"q": "Hello"})
114 | self.assertEqual(response.status_code, 200)
115 | self.assertEqual(response.context["query_string"], "Hello")
116 |
117 | def test_get_add(self):
118 | response = self.client.get(reverse("wagtailmedia:add", args=("audio",)))
119 | # permission should be denied
120 | self.assertRedirects(response, reverse("wagtailadmin_home"))
121 |
122 | def test_get_edit(self):
123 | response = self.client.get(reverse("wagtailmedia:edit", args=(self.media.id,)))
124 | self.assertEqual(response.status_code, 200)
125 | self.assertTemplateUsed(response, "wagtailmedia/media/edit.html")
126 |
127 | # media can only be moved to collections you have add permission for,
128 | # so the 'collection' field is not available here
129 | self.assertNotContains(response, self.collection_label_tag)
130 |
131 | # if the user has add permission on a different collection,
132 | # they should have option to move the media
133 | add_permission = Permission.objects.get(
134 | content_type__app_label="wagtailmedia", codename="add_media"
135 | )
136 | GroupCollectionPermission.objects.create(
137 | group=self.changers_group,
138 | collection=self.evil_plans_collection,
139 | permission=add_permission,
140 | )
141 | response = self.client.get(reverse("wagtailmedia:edit", args=(self.media.id,)))
142 | self.assertEqual(response.status_code, 200)
143 | self.assertContains(response, self.collection_label_tag)
144 | self.assertContains(response, "Nice plans")
145 | self.assertContains(response, "Evil plans")
146 |
147 | def test_post_edit(self):
148 | # Submit title change
149 | response = self.client.post(
150 | reverse("wagtailmedia:edit", args=(self.media.id,)),
151 | {
152 | "title": "Test media changed!",
153 | "file": "",
154 | "duration": 100,
155 | },
156 | )
157 |
158 | # User should be redirected back to the index
159 | self.assertRedirects(response, reverse("wagtailmedia:index"))
160 |
161 | # Media title should be changed
162 | self.assertEqual(
163 | models.Media.objects.get(id=self.media.id).title, "Test media changed!"
164 | )
165 |
166 | # collection should be unchanged
167 | self.assertEqual(
168 | models.Media.objects.get(id=self.media.id).collection,
169 | self.nice_plans_collection,
170 | )
171 |
172 | # if the user has add permission on a different collection,
173 | # they should have option to move the media
174 | add_permission = Permission.objects.get(
175 | content_type__app_label="wagtailmedia", codename="add_media"
176 | )
177 | GroupCollectionPermission.objects.create(
178 | group=self.changers_group,
179 | collection=self.evil_plans_collection,
180 | permission=add_permission,
181 | )
182 |
183 | self.client.post(
184 | reverse("wagtailmedia:edit", args=(self.media.id,)),
185 | {
186 | "title": "Test media changed!",
187 | "collection": self.evil_plans_collection.id,
188 | "file": "",
189 | "duration": 100,
190 | },
191 | )
192 | self.assertEqual(
193 | models.Media.objects.get(id=self.media.id).collection,
194 | self.evil_plans_collection,
195 | )
196 |
197 | def test_get_delete(self):
198 | response = self.client.get(
199 | reverse("wagtailmedia:delete", args=(self.media.id,))
200 | )
201 | self.assertEqual(response.status_code, 200)
202 | self.assertTemplateUsed(response, "wagtailmedia/media/confirm_delete.html")
203 |
--------------------------------------------------------------------------------
/tests/test_edit_handlers.py:
--------------------------------------------------------------------------------
1 | from django.contrib.auth.models import AnonymousUser
2 | from django.test import RequestFactory, TestCase
3 | from django.urls import reverse
4 | from testapp.models import BlogStreamPage
5 | from wagtail import VERSION as WAGTAIL_VERSION
6 | from wagtail.admin.panels import FieldPanel, ObjectList
7 | from wagtail.models import Page
8 |
9 | from wagtailmedia.edit_handlers import MediaChooserPanel, MediaFieldComparison
10 | from wagtailmedia.widgets import AdminAudioChooser, AdminMediaChooser, AdminVideoChooser
11 |
12 | from .utils import create_audio, create_video
13 |
14 |
15 | class MediaChooserPanelTest(TestCase):
16 | @classmethod
17 | def setUpTestData(cls):
18 | cls.request = RequestFactory().get("/")
19 | cls.request.user = (
20 | AnonymousUser()
21 | ) # technically, Anonymous users cannot access the admin
22 |
23 | cls.audio = create_audio("Test audio", duration=1000)
24 | cls.video = create_video("Test video", duration=1024)
25 |
26 | # a MediaChooserPanel class that works on BlogStreamPage's 'video' field
27 | cls.edit_handler = ObjectList([MediaChooserPanel("featured_media")])
28 | cls.edit_handler = cls.edit_handler.bind_to_model(BlogStreamPage)
29 | cls.my_media_chooser_panel = cls.edit_handler.children[0]
30 |
31 | # build a form class containing the fields that MyPageChooserPanel wants
32 | cls.MediaChooserForm = cls.edit_handler.get_form_class()
33 |
34 | root_page = Page.objects.first()
35 | cls.test_instance = BlogStreamPage(
36 | title="Post",
37 | slug="post",
38 | author="Joe Bloggs",
39 | date="1984-01-01",
40 | featured_media=cls.video,
41 | )
42 | root_page.add_child(instance=cls.test_instance)
43 |
44 | cls.form = cls.MediaChooserForm(instance=cls.test_instance)
45 | cls.media_chooser_panel = cls.my_media_chooser_panel.get_bound_panel(
46 | instance=cls.test_instance, form=cls.form
47 | )
48 |
49 | def _init_edit_handler(self, media_type=None):
50 | my_page_object_list = ObjectList(
51 | [MediaChooserPanel("featured_media", media_type=media_type)]
52 | )
53 | my_page_object_list = my_page_object_list.bind_to_model(BlogStreamPage)
54 |
55 | my_media_chooser_panel = my_page_object_list.children[0]
56 | form = my_page_object_list.get_form_class()(instance=self.test_instance)
57 | media_chooser_panel = my_media_chooser_panel.get_bound_panel(
58 | instance=self.test_instance, form=form, request=self.request
59 | )
60 |
61 | return form, media_chooser_panel
62 |
63 | def test_panel_definition(self):
64 | self.assertIsInstance(self.my_media_chooser_panel, FieldPanel)
65 | self.assertEqual(
66 | self.my_media_chooser_panel.get_form_options()["widgets"],
67 | {"featured_media": AdminMediaChooser},
68 | )
69 |
70 | for media_type, widget_class in {
71 | "audio": AdminAudioChooser,
72 | "video": AdminVideoChooser,
73 | }.items():
74 | with self.subTest(msg=f"Testing widget overrides with {media_type}"):
75 | panel = MediaChooserPanel("fake_media_field", media_type=media_type)
76 | self.assertEqual(panel._widget_class, widget_class)
77 |
78 | def test_media_chooser_uses_correct_widget(self):
79 | self.assertEqual(
80 | type(self.form.fields["featured_media"].widget), AdminMediaChooser
81 | )
82 |
83 | form, media_chooser_panel = self._init_edit_handler(media_type="audio")
84 | self.assertEqual(type(form.fields["featured_media"].widget), AdminAudioChooser)
85 |
86 | form, media_chooser_panel = self._init_edit_handler(media_type="video")
87 | self.assertEqual(type(form.fields["featured_media"].widget), AdminVideoChooser)
88 |
89 | def test_render_js_init(self):
90 | self.assertIn(
91 | 'createMediaChooser("id_featured_media");',
92 | self.media_chooser_panel.render_html(),
93 | )
94 |
95 | def test_render_js_init_with_media_type(self):
96 | # construct an alternative page chooser panel object, with can_choose_root=True
97 |
98 | form, media_chooser_panel = self._init_edit_handler(media_type="audio")
99 | self.assertIn(
100 | 'createMediaChooser("id_featured_media")',
101 | media_chooser_panel.render_html(),
102 | )
103 |
104 | def test_get_chosen_item(self):
105 | self.assertEqual(
106 | self.media_chooser_panel.bound_field.form.initial["featured_media"],
107 | self.video.pk,
108 | )
109 |
110 | def test_render_as_field(self):
111 | result = self.media_chooser_panel.render_html()
112 |
113 | chooser_url = reverse("wagtailmedia:chooser")
114 | self.assertIn(f'data-chooser-url="{chooser_url}"', result)
115 | self.assertIn(
116 | 'Test video
',
117 | result,
118 | )
119 | edit_url = reverse("wagtailmedia:edit", args=(self.video.pk,))
120 | if WAGTAIL_VERSION >= (5, 1):
121 | self.assertIn(
122 | f'',
124 | result,
125 | )
126 | self.assertIn("Edit this media item", result)
127 | else:
128 | self.assertIn(
129 | f' Edit this media item ',
132 | result,
133 | )
134 | self.assertIn("Choose a media item", result)
135 |
136 | def test_render_as_field_with_media_type(self):
137 | form, media_chooser_panel = self._init_edit_handler(media_type="video")
138 | result = media_chooser_panel.render_html()
139 |
140 | chooser_url = reverse("wagtailmedia:chooser_typed", args=("video",))
141 | self.assertIn(f'data-chooser-url="{chooser_url}"', result)
142 | self.assertIn(
143 | 'Test video
',
144 | result,
145 | )
146 | edit_url = reverse("wagtailmedia:edit", args=(self.video.pk,))
147 | if WAGTAIL_VERSION >= (5, 1):
148 | self.assertIn(
149 | f'',
151 | result,
152 | )
153 | self.assertIn("Edit this video", result)
154 | else:
155 | self.assertIn(
156 | f' Edit this video ',
159 | result,
160 | )
161 | self.assertIn("Choose video", result)
162 |
163 | def test_render_as_empty_field(self):
164 | test_instance = BlogStreamPage()
165 | form = self.MediaChooserForm(instance=test_instance)
166 | media_chooser_panel = self.my_media_chooser_panel.get_bound_panel(
167 | instance=test_instance, form=form, request=self.request
168 | )
169 | result = media_chooser_panel.render_html()
170 |
171 | self.assertIn(
172 | '
',
173 | result,
174 | )
175 |
176 | if WAGTAIL_VERSION >= (5, 1):
177 | self.assertIn(
178 | '',
180 | result,
181 | )
182 | self.assertIn("Edit this media item", result)
183 | else:
184 | self.assertIn(
185 | ' Edit this media item ',
188 | result,
189 | )
190 | self.assertIn("Choose a media item", result)
191 |
192 | def test_render_error(self):
193 | form = self.MediaChooserForm(
194 | {"featured_media": ""}, instance=self.test_instance
195 | )
196 | self.assertFalse(form.is_valid())
197 |
198 | media_chooser_panel = self.my_media_chooser_panel.get_bound_panel(
199 | instance=self.test_instance, form=form, request=self.request
200 | )
201 |
202 | self.assertInHTML(
203 | 'This field is required.
',
204 | media_chooser_panel.render_html(),
205 | )
206 |
207 | def test_comparison_class(self):
208 | self.assertIs(
209 | self.my_media_chooser_panel.get_comparison_class(), MediaFieldComparison
210 | )
211 |
--------------------------------------------------------------------------------
/src/wagtailmedia/views/chooser.py:
--------------------------------------------------------------------------------
1 | from django.shortcuts import get_object_or_404, render
2 | from django.urls import reverse
3 | from django.utils.translation import gettext_lazy as _
4 | from wagtail import hooks
5 | from wagtail.admin.auth import PermissionPolicyChecker
6 | from wagtail.admin.forms.search import SearchForm
7 | from wagtail.admin.modal_workflow import render_modal_workflow
8 | from wagtail.admin.models import popular_tags_for_model
9 | from wagtail.models import Collection
10 | from wagtail.search.backends import get_search_backends
11 |
12 | from wagtailmedia.forms import get_media_form
13 | from wagtailmedia.models import get_media_model
14 | from wagtailmedia.permissions import permission_policy
15 | from wagtailmedia.utils import paginate
16 |
17 |
18 | permission_checker = PermissionPolicyChecker(permission_policy)
19 |
20 |
21 | def get_media_json(media):
22 | """
23 | helper function: given a media, return the json to pass back to the
24 | chooser panel
25 | """
26 |
27 | return {
28 | "id": media.id,
29 | "title": media.title,
30 | "edit_url": reverse("wagtailmedia:edit", args=(media.id,)),
31 | }
32 |
33 |
34 | def get_ordering(request):
35 | if request.GET.get("ordering") in ["title", "-title", "-created_at", "created_at"]:
36 | return request.GET["ordering"]
37 |
38 | # default to -created_at
39 | return "-created_at"
40 |
41 |
42 | def chooser(request, media_type=None):
43 | Media = get_media_model()
44 |
45 | ordering = get_ordering(request)
46 | media_files = permission_policy.instances_user_has_any_permission_for(
47 | request.user, ["change", "delete"]
48 | )
49 |
50 | # allow hooks to modify the queryset
51 | for hook in hooks.get_hooks("construct_media_chooser_queryset"):
52 | media_files = hook(media_files, request)
53 |
54 | if permission_policy.user_has_permission(request.user, "add"):
55 | MediaForm = get_media_form(Media)
56 | media_audio = Media(uploaded_by_user=request.user, type="audio")
57 | media_video = Media(uploaded_by_user=request.user, type="video")
58 |
59 | uploadforms = {
60 | "audio": MediaForm(
61 | user=request.user, prefix="media-chooser-upload", instance=media_audio
62 | ),
63 | "video": MediaForm(
64 | user=request.user, prefix="media-chooser-upload", instance=media_video
65 | ),
66 | }
67 |
68 | if media_type:
69 | uploadforms = {media_type: uploadforms[media_type]}
70 | else:
71 | uploadforms = {}
72 |
73 | if media_type:
74 | media_files = media_files.filter(type=media_type)
75 | chooser_url = reverse("wagtailmedia:chooser_typed", args=(media_type,))
76 | else:
77 | chooser_url = reverse("wagtailmedia:chooser")
78 |
79 | if (
80 | "q" in request.GET
81 | or "p" in request.GET
82 | or "tag" in request.GET
83 | or "collection_id" in request.GET
84 | ):
85 | collection_id = request.GET.get("collection_id")
86 | if collection_id:
87 | media_files = media_files.filter(collection=collection_id)
88 |
89 | searchform = SearchForm(request.GET)
90 | if searchform.is_valid() and searchform.cleaned_data["q"]:
91 | q = searchform.cleaned_data["q"]
92 |
93 | media_files = media_files.search(q)
94 | is_searching = True
95 | else:
96 | media_files = media_files.order_by(ordering)
97 | is_searching = False
98 | q = None
99 |
100 | tag_name = request.GET.get("tag")
101 | if tag_name:
102 | media_files = media_files.filter(tags__name=tag_name)
103 |
104 | # Pagination
105 | paginator, media_files = paginate(request, media_files)
106 |
107 | return render(
108 | request,
109 | "wagtailmedia/chooser/results.html",
110 | {
111 | "media_files": media_files,
112 | "query_string": q,
113 | "is_searching": is_searching,
114 | "media_type": media_type,
115 | "ordering": ordering,
116 | "chooser_url": chooser_url,
117 | "elided_page_range": paginator.get_elided_page_range(
118 | request.GET.get("p", 1)
119 | ),
120 | },
121 | )
122 | else:
123 | searchform = SearchForm()
124 |
125 | collections = Collection.objects.all()
126 | if len(collections) < 2:
127 | collections = None
128 |
129 | media_files = media_files.order_by(ordering)
130 | paginator, media_files = paginate(request, media_files)
131 |
132 | if media_type == "audio":
133 | title = _("Choose audio")
134 | elif media_type == "video":
135 | title = _("Choose video")
136 | else:
137 | title = _("Choose a media item")
138 |
139 | return render_modal_workflow(
140 | request,
141 | "wagtailmedia/chooser/chooser.html",
142 | None,
143 | {
144 | "media_files": media_files,
145 | "searchform": searchform,
146 | "collections": collections,
147 | "uploadforms": uploadforms,
148 | "is_searching": False,
149 | "popular_tags": popular_tags_for_model(Media),
150 | "media_type": media_type,
151 | "ordering": ordering,
152 | "title": title,
153 | "icon": f"wagtailmedia-{media_type}" if media_type is not None else "media",
154 | "chooser_url": chooser_url,
155 | "elided_page_range": paginator.get_elided_page_range(
156 | request.GET.get("p", 1)
157 | ),
158 | },
159 | json_data={
160 | "step": "chooser",
161 | "error_label": "Server Error",
162 | "error_message": "Report this error to your webmaster with the following information:",
163 | "tag_autocomplete_url": reverse("wagtailadmin_tag_autocomplete"),
164 | },
165 | )
166 |
167 |
168 | def media_chosen(request, media_id):
169 | media = get_object_or_404(get_media_model(), id=media_id)
170 |
171 | return render_modal_workflow(
172 | request,
173 | None,
174 | None,
175 | None,
176 | json_data={"step": "media_chosen", "result": get_media_json(media)},
177 | )
178 |
179 |
180 | @permission_checker.require("add")
181 | def chooser_upload(request, media_type):
182 | upload_forms = {}
183 |
184 | if (
185 | permission_policy.user_has_permission(request.user, "add")
186 | and request.method == "POST"
187 | ):
188 | Media = get_media_model()
189 | MediaForm = get_media_form(Media)
190 |
191 | media = Media(uploaded_by_user=request.user, type=media_type)
192 | uploading_form = MediaForm(
193 | request.POST,
194 | request.FILES,
195 | instance=media,
196 | user=request.user,
197 | prefix="media-chooser-upload",
198 | )
199 | if uploading_form.is_valid():
200 | uploading_form.save()
201 |
202 | # Reindex the media entry to make sure all tags are indexed
203 | for backend in get_search_backends():
204 | backend.add(media)
205 |
206 | return render_modal_workflow(
207 | request,
208 | None,
209 | None,
210 | None,
211 | json_data={"step": "media_chosen", "result": get_media_json(media)},
212 | )
213 |
214 | if media_type == "audio":
215 | video = Media(uploaded_by_user=request.user, type="video")
216 | video_form = MediaForm(
217 | instance=video, user=request.user, prefix="media-chooser-upload"
218 | )
219 | upload_forms = {"audio": uploading_form, "video": video_form}
220 | else:
221 | audio = Media(uploaded_by_user=request.user, type="audio")
222 | audio_form = MediaForm(
223 | instance=audio, user=request.user, prefix="media-chooser-upload"
224 | )
225 | upload_forms = {"audio": audio_form, "video": uploading_form}
226 |
227 | ordering = get_ordering(request)
228 |
229 | media_files = permission_policy.instances_user_has_any_permission_for(
230 | request.user, ["change", "delete"]
231 | )
232 |
233 | # allow hooks to modify the queryset
234 | for hook in hooks.get_hooks("construct_media_chooser_queryset"):
235 | media_files = hook(media_files, request)
236 |
237 | searchform = SearchForm()
238 |
239 | collections = Collection.objects.all()
240 | if len(collections) < 2:
241 | collections = None
242 |
243 | media_files = media_files.order_by(ordering)
244 | paginator, media_files = paginate(request, media_files)
245 |
246 | context = {
247 | "media_files": media_files,
248 | "searchform": searchform,
249 | "collections": collections,
250 | "uploadforms": upload_forms,
251 | "is_searching": False,
252 | "media_type": media_type,
253 | "ordering": ordering,
254 | }
255 | return render_modal_workflow(
256 | request,
257 | "wagtailmedia/chooser/chooser.html",
258 | None,
259 | context,
260 | json_data={"step": "chooser"},
261 | )
262 |
--------------------------------------------------------------------------------
/src/wagtailmedia/views/media.py:
--------------------------------------------------------------------------------
1 | from django.core.paginator import Paginator
2 | from django.shortcuts import get_object_or_404, redirect, render
3 | from django.urls import reverse
4 | from django.utils.text import capfirst
5 | from django.utils.translation import gettext as _
6 | from django.views.decorators.vary import vary_on_headers
7 | from wagtail.admin import messages
8 | from wagtail.admin.admin_url_finder import AdminURLFinder
9 | from wagtail.admin.auth import PermissionPolicyChecker, permission_denied
10 | from wagtail.admin.forms.search import SearchForm
11 | from wagtail.admin.models import popular_tags_for_model
12 | from wagtail.models import Collection, Page
13 | from wagtail.search.backends import get_search_backends
14 |
15 | from wagtailmedia.forms import get_media_form
16 | from wagtailmedia.models import get_media_model
17 | from wagtailmedia.permissions import permission_policy
18 | from wagtailmedia.utils import paginate
19 |
20 |
21 | permission_checker = PermissionPolicyChecker(permission_policy)
22 |
23 |
24 | @permission_checker.require_any("add", "change", "delete")
25 | @vary_on_headers("X-Requested-With")
26 | def index(request):
27 | Media = get_media_model()
28 |
29 | # Get media files (filtered by user permission)
30 | media = permission_policy.instances_user_has_any_permission_for(
31 | request.user, ["change", "delete"]
32 | )
33 |
34 | # Ordering
35 | if request.GET.get("ordering") in ["title", "-title", "-created_at", "created_at"]:
36 | ordering = request.GET["ordering"]
37 | else:
38 | ordering = "-created_at"
39 | media = media.order_by(ordering)
40 |
41 | # Filter by collection
42 | current_collection = None
43 | collection_id = request.GET.get("collection_id")
44 | if collection_id:
45 | try:
46 | current_collection = Collection.objects.get(id=collection_id)
47 | media = media.filter(collection=current_collection)
48 | except (ValueError, Collection.DoesNotExist):
49 | pass
50 |
51 | # Search
52 | query_string = ""
53 | if "q" in request.GET and request.GET.get("q").strip():
54 | form = SearchForm(request.GET, placeholder=_("Search media files"))
55 | if form.is_valid():
56 | query_string = form.cleaned_data["q"]
57 | media = media.search(query_string)
58 | else:
59 | form = SearchForm(placeholder=_("Search media"))
60 |
61 | # Filter by tag
62 | if current_tag := request.GET.get("tag"):
63 | try:
64 | media = media.filter(tags__name=current_tag)
65 | except AttributeError:
66 | current_tag = None
67 |
68 | # Pagination
69 | paginator, media = paginate(request, media)
70 |
71 | collections = permission_policy.collections_user_has_any_permission_for(
72 | request.user, ["add", "change"]
73 | )
74 | if len(collections) < 2:
75 | collections = None
76 |
77 | # Create response
78 | if request.headers.get("x-requested-with") == "XMLHttpRequest":
79 | return render(
80 | request,
81 | "wagtailmedia/media/results.html",
82 | {
83 | "ordering": ordering,
84 | "media_files": media,
85 | "query_string": query_string,
86 | "is_searching": bool(query_string),
87 | "collections": collections,
88 | },
89 | )
90 | else:
91 | return render(
92 | request,
93 | "wagtailmedia/media/index.html",
94 | {
95 | "ordering": ordering,
96 | "media_files": media,
97 | "query_string": query_string,
98 | "is_searching": bool(query_string),
99 | "search_form": form,
100 | "popular_tags": popular_tags_for_model(Media),
101 | "current_tag": current_tag,
102 | "user_can_add": permission_policy.user_has_permission(
103 | request.user, "add"
104 | ),
105 | "collections": collections,
106 | "current_collection": current_collection,
107 | },
108 | )
109 |
110 |
111 | @permission_checker.require("add")
112 | def add(request, media_type):
113 | Media = get_media_model()
114 | MediaForm = get_media_form(Media)
115 |
116 | if request.method == "POST":
117 | media = Media(uploaded_by_user=request.user, type=media_type)
118 | form = MediaForm(request.POST, request.FILES, instance=media, user=request.user)
119 | if form.is_valid():
120 | form.save()
121 |
122 | # Reindex the media entry to make sure all tags are indexed
123 | for backend in get_search_backends():
124 | backend.add(media)
125 |
126 | messages.success(
127 | request,
128 | _("Media file '{0}' added.").format(media.title),
129 | buttons=[
130 | messages.button(
131 | reverse("wagtailmedia:edit", args=(media.id,)), _("Edit")
132 | )
133 | ],
134 | )
135 | return redirect("wagtailmedia:index")
136 | else:
137 | messages.error(
138 | request, _("The media file could not be saved due to errors.")
139 | )
140 | else:
141 | media = Media(uploaded_by_user=request.user, type=media_type)
142 | form = MediaForm(user=request.user, instance=media)
143 |
144 | return render(
145 | request,
146 | "wagtailmedia/media/add.html",
147 | {
148 | "form": form,
149 | "media_type": media_type,
150 | },
151 | )
152 |
153 |
154 | @permission_checker.require("change")
155 | def edit(request, media_id):
156 | Media = get_media_model()
157 | MediaForm = get_media_form(Media)
158 |
159 | media = get_object_or_404(Media, id=media_id)
160 |
161 | if not permission_policy.user_has_permission_for_instance(
162 | request.user, "change", media
163 | ):
164 | return permission_denied(request)
165 |
166 | if request.method == "POST":
167 | original_file = media.file
168 | form = MediaForm(request.POST, request.FILES, instance=media, user=request.user)
169 | if form.is_valid():
170 | if "file" in form.changed_data:
171 | # if providing a new media file, delete the old one.
172 | # NB Doing this via original_file.delete() clears the file field,
173 | # which definitely isn't what we want...
174 | original_file.storage.delete(original_file.name)
175 | media = form.save()
176 |
177 | # Reindex the media entry to make sure all tags are indexed
178 | for backend in get_search_backends():
179 | backend.add(media)
180 |
181 | messages.success(
182 | request,
183 | _("Media file '{0}' updated").format(media.title),
184 | buttons=[
185 | messages.button(
186 | reverse("wagtailmedia:edit", args=(media.id,)), _("Edit")
187 | )
188 | ],
189 | )
190 | return redirect("wagtailmedia:index")
191 | else:
192 | messages.error(request, _("The media could not be saved due to errors."))
193 | else:
194 | form = MediaForm(instance=media, user=request.user)
195 |
196 | filesize = None
197 |
198 | # Get file size when there is a file associated with the Media object
199 | if media.file:
200 | try:
201 | filesize = media.file.size
202 | except OSError:
203 | # File doesn't exist
204 | pass
205 |
206 | if not filesize:
207 | messages.error(
208 | request,
209 | _(
210 | "The file could not be found. Please change the source or delete the media file"
211 | ),
212 | buttons=[
213 | messages.button(
214 | reverse("wagtailmedia:delete", args=(media.id,)), _("Delete")
215 | )
216 | ],
217 | )
218 |
219 | return render(
220 | request,
221 | "wagtailmedia/media/edit.html",
222 | {
223 | "media": media,
224 | "filesize": filesize,
225 | "form": form,
226 | "user_can_delete": permission_policy.user_has_permission_for_instance(
227 | request.user, "delete", media
228 | ),
229 | },
230 | )
231 |
232 |
233 | @permission_checker.require("delete")
234 | def delete(request, media_id):
235 | Media = get_media_model()
236 | media = get_object_or_404(Media, id=media_id)
237 |
238 | if not permission_policy.user_has_permission_for_instance(
239 | request.user, "delete", media
240 | ):
241 | return permission_denied(request)
242 |
243 | if request.method == "POST":
244 | media.delete()
245 | messages.success(request, _("Media file '{0}' deleted.").format(media.title))
246 | return redirect("wagtailmedia:index")
247 |
248 | return render(
249 | request,
250 | "wagtailmedia/media/confirm_delete.html",
251 | {
252 | "media": media,
253 | },
254 | )
255 |
256 |
257 | @permission_checker.require_any("add", "change", "delete")
258 | def usage(request, media_id):
259 | Media = get_media_model()
260 | media_item = get_object_or_404(Media, id=media_id)
261 |
262 | paginator = Paginator(media_item.get_usage(), per_page=20)
263 | object_page = paginator.get_page(request.GET.get("p"))
264 |
265 | # Add edit URLs to each source object
266 | url_finder = AdminURLFinder(request.user)
267 | results = []
268 | for entity, references in object_page:
269 | edit_url = url_finder.get_edit_url(entity)
270 | if edit_url is None:
271 | label = _("(Private %s)") % entity._meta.verbose_name
272 | edit_link_title = None
273 | else:
274 | label = str(entity)
275 | edit_link_title = _("Edit this %s") % entity._meta.verbose_name
276 |
277 | if isinstance(entity, Page):
278 | verbose_name = capfirst(entity.specific_class._meta.verbose_name)
279 | else:
280 | verbose_name = capfirst(entity._meta.verbose_name)
281 |
282 | results.append((label, edit_url, edit_link_title, verbose_name, references))
283 |
284 | return render(
285 | request,
286 | "wagtailmedia/media/usage.html",
287 | {"media_item": media_item, "results": results, "object_page": object_page},
288 | )
289 |
--------------------------------------------------------------------------------
/tests/testapp/migrations/0001_initial.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 4.1.4 on 2023-02-15 17:47
2 |
3 | import django.core.validators
4 | import django.db.models.deletion
5 | import modelcluster.fields
6 | import taggit.managers
7 | import wagtail.blocks
8 | import wagtail.fields
9 | import wagtail.search.index
10 |
11 | from django.conf import settings
12 | from django.db import migrations, models
13 |
14 | import wagtailmedia.blocks
15 |
16 |
17 | try:
18 | import wagtail.models.media as collections
19 | except ImportError:
20 | import wagtail.models.collections as collections
21 |
22 | import testapp.models
23 |
24 |
25 | class Migration(migrations.Migration):
26 | initial = True
27 |
28 | dependencies = [
29 | ("wagtailcore", "0078_referenceindex"),
30 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
31 | ("wagtailmedia", "0004_duration_optional_floatfield"),
32 | ("taggit", "0005_auto_20220424_2025"),
33 | ]
34 |
35 | operations = [
36 | migrations.CreateModel(
37 | name="EventPage",
38 | fields=[
39 | (
40 | "page_ptr",
41 | models.OneToOneField(
42 | auto_created=True,
43 | on_delete=django.db.models.deletion.CASCADE,
44 | parent_link=True,
45 | primary_key=True,
46 | serialize=False,
47 | to="wagtailcore.page",
48 | ),
49 | ),
50 | ("date_from", models.DateField(null=True, verbose_name="Start date")),
51 | (
52 | "date_to",
53 | models.DateField(
54 | blank=True,
55 | help_text="Not required if event is on a single day",
56 | null=True,
57 | verbose_name="End date",
58 | ),
59 | ),
60 | (
61 | "time_from",
62 | models.TimeField(blank=True, null=True, verbose_name="Start time"),
63 | ),
64 | (
65 | "time_to",
66 | models.TimeField(blank=True, null=True, verbose_name="End time"),
67 | ),
68 | ("location", models.CharField(max_length=255)),
69 | ("body", wagtail.fields.RichTextField(blank=True)),
70 | ("cost", models.CharField(max_length=255)),
71 | ("signup_link", models.URLField(blank=True)),
72 | ],
73 | options={
74 | "abstract": False,
75 | },
76 | bases=("wagtailcore.page",),
77 | ),
78 | migrations.CreateModel(
79 | name="EventPageRelatedMedia",
80 | fields=[
81 | (
82 | "id",
83 | models.AutoField(
84 | auto_created=True,
85 | primary_key=True,
86 | serialize=False,
87 | verbose_name="ID",
88 | ),
89 | ),
90 | (
91 | "sort_order",
92 | models.IntegerField(blank=True, editable=False, null=True),
93 | ),
94 | ("title", models.CharField(help_text="Link title", max_length=255)),
95 | (
96 | "link_media",
97 | models.ForeignKey(
98 | blank=True,
99 | null=True,
100 | on_delete=django.db.models.deletion.CASCADE,
101 | related_name="+",
102 | to="wagtailmedia.media",
103 | ),
104 | ),
105 | (
106 | "page",
107 | modelcluster.fields.ParentalKey(
108 | on_delete=django.db.models.deletion.CASCADE,
109 | related_name="related_media",
110 | to="wagtailmedia_tests.eventpage",
111 | ),
112 | ),
113 | ],
114 | options={
115 | "ordering": ["sort_order"],
116 | "abstract": False,
117 | },
118 | ),
119 | migrations.CreateModel(
120 | name="CustomMedia",
121 | fields=[
122 | (
123 | "id",
124 | models.AutoField(
125 | auto_created=True,
126 | primary_key=True,
127 | serialize=False,
128 | verbose_name="ID",
129 | ),
130 | ),
131 | ("title", models.CharField(max_length=255, verbose_name="title")),
132 | ("file", models.FileField(upload_to="media", verbose_name="file")),
133 | (
134 | "type",
135 | models.CharField(
136 | choices=[("audio", "Audio file"), ("video", "Video file")],
137 | max_length=255,
138 | ),
139 | ),
140 | (
141 | "duration",
142 | models.FloatField(
143 | blank=True,
144 | default=0,
145 | help_text="Duration in seconds",
146 | validators=[django.core.validators.MinValueValidator(0)],
147 | verbose_name="duration",
148 | ),
149 | ),
150 | (
151 | "width",
152 | models.PositiveIntegerField(
153 | blank=True, null=True, verbose_name="width"
154 | ),
155 | ),
156 | (
157 | "height",
158 | models.PositiveIntegerField(
159 | blank=True, null=True, verbose_name="height"
160 | ),
161 | ),
162 | (
163 | "thumbnail",
164 | models.FileField(
165 | blank=True,
166 | upload_to="media_thumbnails",
167 | verbose_name="thumbnail",
168 | ),
169 | ),
170 | (
171 | "created_at",
172 | models.DateTimeField(auto_now_add=True, verbose_name="created at"),
173 | ),
174 | ("fancy_caption", wagtail.fields.RichTextField(blank=True)),
175 | (
176 | "collection",
177 | models.ForeignKey(
178 | default=collections.get_root_collection_id,
179 | on_delete=django.db.models.deletion.CASCADE,
180 | related_name="+",
181 | to="wagtailcore.collection",
182 | verbose_name="collection",
183 | ),
184 | ),
185 | (
186 | "tags",
187 | taggit.managers.TaggableManager(
188 | blank=True,
189 | help_text=None,
190 | through="taggit.TaggedItem",
191 | to="taggit.Tag",
192 | verbose_name="tags",
193 | ),
194 | ),
195 | (
196 | "uploaded_by_user",
197 | models.ForeignKey(
198 | blank=True,
199 | editable=False,
200 | null=True,
201 | on_delete=django.db.models.deletion.SET_NULL,
202 | to=settings.AUTH_USER_MODEL,
203 | verbose_name="uploaded by user",
204 | ),
205 | ),
206 | ],
207 | options={
208 | "verbose_name": "media",
209 | "verbose_name_plural": "media items",
210 | "abstract": False,
211 | },
212 | bases=(wagtail.search.index.Indexed, models.Model),
213 | ),
214 | migrations.CreateModel(
215 | name="BlogStreamPage",
216 | fields=[
217 | (
218 | "page_ptr",
219 | models.OneToOneField(
220 | auto_created=True,
221 | on_delete=django.db.models.deletion.CASCADE,
222 | parent_link=True,
223 | primary_key=True,
224 | serialize=False,
225 | to="wagtailcore.page",
226 | ),
227 | ),
228 | ("author", models.CharField(max_length=255)),
229 | ("date", models.DateField(verbose_name="Post date")),
230 | (
231 | "body",
232 | wagtail.fields.StreamField(
233 | [
234 | (
235 | "heading",
236 | wagtail.blocks.CharBlock(
237 | form_classname="title", icon="title"
238 | ),
239 | ),
240 | ("paragraph", wagtail.blocks.RichTextBlock(icon="pilcrow")),
241 | (
242 | "media",
243 | testapp.models.TestMediaBlock(icon="media"),
244 | ),
245 | (
246 | "video",
247 | wagtailmedia.blocks.VideoChooserBlock(icon="media"),
248 | ),
249 | (
250 | "audio",
251 | wagtailmedia.blocks.AudioChooserBlock(icon="media"),
252 | ),
253 | ],
254 | use_json_field=True,
255 | ),
256 | ),
257 | (
258 | "featured_media",
259 | models.ForeignKey(
260 | on_delete=django.db.models.deletion.PROTECT,
261 | related_name="+",
262 | to="wagtailmedia.media",
263 | ),
264 | ),
265 | ],
266 | options={
267 | "abstract": False,
268 | },
269 | bases=("wagtailcore.page",),
270 | ),
271 | ]
272 |
--------------------------------------------------------------------------------