def chooser_upload(request):
VideoForm = get_video_form(Video)
searchform = SearchForm()
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST, request.FILES, instance=video)
if form.is_valid():
video.uploaded_by_user = request.user
video.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(video)
return render_modal_workflow(
request, None, 'wagtailvideos/chooser/video_chosen.js',
{'video_json': get_video_json(video)}
)
else:
form = VideoForm()
videos = Video.objects.order_by('title')
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html', 'wagtailvideos/chooser/chooser.js',
{'videos': videos, 'uploadform': form, 'searchform': searchform}
)
def chooser_upload(request):
Document = get_document_model()
DocumentForm = get_document_form(Document)
if request.method == 'POST':
document = Document(uploaded_by_user=request.user)
form = DocumentForm(request.POST, request.FILES, instance=document, user=request.user)
if form.is_valid():
form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(document)
return render_modal_workflow(
request, None, 'wagtaildocs/chooser/document_chosen.js',
{'document_json': get_document_json(document)}
)
else:
form = DocumentForm(user=request.user)
documents = Document.objects.order_by('title')
return render_modal_workflow(
request, 'wagtaildocs/chooser/chooser.html', 'wagtaildocs/chooser/chooser.js',
{'documents': documents, 'uploadform': form}
)
def chooser_upload(request):
Document = get_document_model()
DocumentForm = get_document_form(Document)
if request.method == 'POST':
document = Document(uploaded_by_user=request.user)
form = DocumentForm(request.POST, request.FILES, instance=document, user=request.user)
if form.is_valid():
document.file_size = document.file.size
# Set new document file hash
document.file.seek(0)
document._set_file_hash(document.file.read())
document.file.seek(0)
form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(document)
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'document_chosen', 'result': get_document_result_data(document)}
)
else:
form = DocumentForm(user=request.user)
documents = Document.objects.order_by('title')
return render_modal_workflow(
request, 'wagtaildocs/chooser/chooser.html', None,
{'documents': documents, 'uploadform': form},
json_data=get_chooser_context()
)
def email_link(request):
initial_data = {
'link_text': request.GET.get('link_text', ''),
'email_address': request.GET.get('link_url', ''),
}
if request.method == 'POST':
form = EmailLinkChooserForm(request.POST, initial=initial_data, prefix='email-link-chooser')
if form.is_valid():
result = {
'url': 'mailto:' + form.cleaned_data['email_address'],
'title': form.cleaned_data['link_text'].strip() or form.cleaned_data['email_address'],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
'prefer_this_title_as_link_text': ('link_text' in form.changed_data),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'external_link_chosen', 'result': result}
)
else:
form = EmailLinkChooserForm(initial=initial_data, prefix='email-link-chooser')
return render_modal_workflow(
request,
'wagtailadmin/chooser/email_link.html', None,
shared_context(request, {
'form': form,
}), json_data={'step': 'email_link'}
)
def allocate_product_to_order(request: HttpRequest,
guid: uuid.UUID) -> JsonResponse:
variant = ProductVariant.objects.prefetch_related("order_lines").get(
guid=guid)
if request.method == "POST":
form = SimpleAllocationForm(request.POST, variant=variant)
if form.is_valid():
items = form.save()
return render_modal_workflow(
request,
None,
None,
{
"obj": variant,
"assigned_to": items
},
json_data={"step": "allocated"},
)
form = SimpleAllocationForm(variant=variant, initial={"variant": variant})
return render_modal_workflow(
request,
"products/choosers/product_allocation.html",
None,
{
"obj": variant,
"form": form
},
json_data={"step": "chooser"},
)
def external_link(request):
initial_data = {
'url': request.GET.get('link_url', ''),
'link_text': request.GET.get('link_text', ''),
}
if request.method == 'POST':
form = ExternalLinkChooserForm(request.POST, initial=initial_data)
if form.is_valid():
result = {
'url': form.cleaned_data['url'],
'title': form.cleaned_data['link_text'].strip() or form.cleaned_data['url'],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
# (Normally this will match the link_text passed in the URL here anyhow,
# but that won't account for non-text content such as images.)
'prefer_this_title_as_link_text': ('link_text' in form.changed_data),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'external_link_chosen', 'result': result}
)
else:
form = ExternalLinkChooserForm(initial=initial_data)
return render_modal_workflow(
request,
'wagtailadmin/chooser/external_link.html', None,
shared_context(request, {
'form': form,
}), json_data={'step': 'external_link'}
)
def email_link(request):
initial_data = {
'link_text': request.GET.get('link_text', ''),
'email_address': request.GET.get('link_url', ''),
}
if request.method == 'POST':
form = EmailLinkChooserForm(request.POST, initial=initial_data)
if form.is_valid():
result = {
'url': 'mailto:' + form.cleaned_data['email_address'],
'title': form.cleaned_data['link_text'].strip() or form.cleaned_data['email_address'],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
'prefer_this_title_as_link_text': ('link_text' in form.changed_data),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'external_link_chosen', 'result': result}
)
else:
form = EmailLinkChooserForm(initial=initial_data)
return render_modal_workflow(
request,
'wagtailadmin/chooser/email_link.html', None,
shared_context(request, {
'form': form,
}), json_data={'step': 'email_link'}
)
def colour_chooser(request):
if request.method == 'POST':
form = ColourForm(request.POST)
if form.is_valid():
feature_name = ''
if form.cleaned_data.get('colour'):
feature_name = get_feature_name_upper(
'colour', form.cleaned_data.get('colour'))
all_features = get_feature_name_list('COLOURS', 'colour')
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'colour_chosen',
'toggled_feature': feature_name,
'all_features': all_features
})
else:
form = ColourForm()
return render_modal_workflow(request,
'colourpicker/chooser/chooser.html',
None, {'form': form},
json_data={'step': 'chooser'})
def news_templates(request, tpl_name):
# --------------------------------------------
def get_notification_tpl_form(tpl_name):
if tpl_name == 'emergency_power_test':
return EmergencyPowerNotificationForm
if tpl_name == 'air_condition_test':
return AirConditionNotificationForm
if tpl_name == 'alarm_test':
return AlarmNotificationForm
return None
# --------------------------------------------
Form = get_notification_tpl_form(tpl_name)
if Form is None:
raise Http404
if request.method == 'GET':
form = Form()
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid():
return render_modal_workflow(request, None,
'news/tpls/{}.json'.format(tpl_name),
{'data': form.cleaned_data})
return render_modal_workflow(
request, 'news/tpls/tpl_form.html', 'news/tpls/tpl_form.js', {
'form': form,
'post_url': reverse('rubionadmin:news_templates', args=[tpl_name])
})
def anchor_link(request):
initial_data = {
'link_text': request.GET.get('link_text', ''),
'url': request.GET.get('link_url', ''),
}
if request.method == 'POST':
form = AnchorLinkChooserForm(request.POST, initial=initial_data, prefix='anchor-link-chooser')
if form.is_valid():
result = {
'url': '#' + form.cleaned_data['url'],
'title': form.cleaned_data['link_text'].strip() or form.cleaned_data['url'],
'prefer_this_title_as_link_text': ('link_text' in form.changed_data),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'external_link_chosen', 'result': result}
)
else:
form = AnchorLinkChooserForm(initial=initial_data, prefix='anchor-link-chooser')
return render_modal_workflow(
request,
'wagtailadmin/chooser/anchor_link.html', None,
shared_context(request, {
'form': form,
}), json_data={'step': 'anchor_link'}
)
def chooser_select(request, image_id):
Image = get_image_model()
ImageForm = get_image_form(Image, hide_file=True)
image = get_object_or_404(Image, id=image_id)
if not request.is_ajax():
return HttpResponseBadRequest("Cannot POST to this view without AJAX")
if not image.is_editable_by_user(request.user):
raise PermissionDenied
form = ImageForm(request.POST, request.FILES, instance=image,
prefix='image-' + image_id, user=request.user)
if form.is_valid():
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
# several possibilities starting from here, based on the GET params
#
will_select_format = request.GET.get('select_format')
will_select_rendition = request.GET.get('select_rendition')
if will_select_format:
form = ImageInsertionForm(
initial={'alt_text': image.default_alt_text})
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html',
'wagtailimages/chooser/select_format.js',
{'image': image, 'form': form}
)
elif will_select_rendition:
form = ImageCropperForm(**get_cropper_settings(request, image))
return render_modal_workflow(
request, 'wagtailimages/chooser/select_rendition.html',
'wagtailimages/chooser/select_rendition.js',
{'image': image, 'form': form}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, 'wagtailimages/chooser/image_chosen.js',
{'image_json': get_image_json(image)}
)
else:
# something was wrong with the submitted data
#
return JsonResponse({
'success': False,
'image_id': int(image_id),
'form': render_to_string('wagtailimages/chooser/update.html', {
'image': image,
'form': form,
'additional_params': get_cropper_params(request),
}, request=request),
})
def chooser_upload(request):
VideoForm = get_video_form(Video)
searchform = SearchForm()
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST, request.FILES, instance=video)
if form.is_valid():
video.uploaded_by_user = request.user
video.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(video)
return render_modal_workflow(
request, None, 'wagtailvideos/chooser/video_chosen.js',
{'video_json': get_video_json(video)}
)
else:
form = VideoForm()
videos = Video.objects.order_by('title')
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html', 'wagtailvideos/chooser/chooser.js',
{'videos': videos, 'uploadform': form, 'searchform': searchform}
)
def chooser_upload(request):
FormForm = get_form_form(Form)
if request.method == 'POST':
form = Form(uploaded_by_user=request.user)
form_form = FormForm(request.POST,
request.FILES,
instance=form,
user=request.user)
if form_form.is_valid():
form_form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(form)
return render_modal_workflow(request, None,
'customforms/chooser/form_chosen.js',
{'form_json': get_form_json(form)})
else:
form_form = FormForm(user=request.user)
forms = Form.objects.order_by('title')
return render_modal_workflow(request, 'customforms/chooser/chooser.html',
'customforms/chooser/chooser.js', {
'forms': forms,
'uploadform': form
})
def external_link(request):
initial_data = {
'url': request.GET.get('link_url', ''),
'link_text': request.GET.get('link_text', ''),
}
if request.method == 'POST':
form = ExternalLinkChooserForm(request.POST, initial=initial_data, prefix='external-link-chooser')
if form.is_valid():
result = {
'url': form.cleaned_data['url'],
'title': form.cleaned_data['link_text'].strip() or form.cleaned_data['url'],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
# (Normally this will match the link_text passed in the URL here anyhow,
# but that won't account for non-text content such as images.)
'prefer_this_title_as_link_text': ('link_text' in form.changed_data),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'external_link_chosen', 'result': result}
)
else:
form = ExternalLinkChooserForm(initial=initial_data, prefix='external-link-chooser')
return render_modal_workflow(
request,
'wagtailadmin/chooser/external_link.html', None,
shared_context(request, {
'form': form,
}), json_data={'step': 'external_link'}
)
def chooser_upload(request):
Document = get_document_model()
DocumentForm = get_document_form(Document)
if request.method == 'POST':
document = Document(uploaded_by_user=request.user)
form = DocumentForm(request.POST,
request.FILES,
instance=document,
user=request.user)
if form.is_valid():
document.file_size = document.file.size
form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(document)
return render_modal_workflow(
request, None, 'wagtaildocs/chooser/document_chosen.js',
{'document_json': get_document_json(document)})
else:
form = DocumentForm(user=request.user)
documents = Document.objects.order_by('title')
return render_modal_workflow(request, 'wagtaildocs/chooser/chooser.html',
'wagtaildocs/chooser/chooser.js', {
'documents': documents,
'uploadform': form
})
def confirm_workflow_cancellation(request, page_id):
"""Provides a modal view to confirm that the user wants to publish the page even though it will cancel the current workflow"""
page = get_object_or_404(Page, id=page_id)
workflow_state = page.current_workflow_state
if (not workflow_state) or not getattr(
settings, "WAGTAIL_WORKFLOW_CANCEL_ON_PUBLISH", True):
return render_modal_workflow(
request,
"",
None, {},
json_data={"step": "no_confirmation_needed"})
return render_modal_workflow(
request,
"wagtailadmin/pages/confirm_workflow_cancellation.html",
None,
{
"needs_changes": workflow_state.status
== WorkflowState.STATUS_NEEDS_CHANGES,
"task": workflow_state.current_task_state.task.name,
"workflow": workflow_state.workflow.name,
},
json_data={"step": "confirm"},
)
def chooser_upload(request):
VideoForm = get_video_form(Video)
searchform = SearchForm()
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST, request.FILES, instance=video)
if form.is_valid():
video.uploaded_by_user = request.user
video.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(video)
return render_modal_workflow(
request, None, json_data={
'step': 'video_chosen',
'result': get_video_json(video)
}
)
else:
form = VideoForm()
videos = Video.objects.order_by('title')
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html', None,
template_vars={'videos': page, 'uploadform': form, 'searchform': searchform},
json_data=get_chooser_js_data()
)
def embed_chooser_upload(request):
if request.method == "POST":
form = EmbedForm(request.POST, request.FILES, prefix="embed-chooser")
if form.is_valid():
error = None
try:
embed_html = embed_to_editor_html(form.cleaned_data["url"])
embed_obj = embeds.get_embed(form.cleaned_data["url"])
embed_data = {
"embedType": embed_obj.type,
"url": embed_obj.url,
"providerName": embed_obj.provider_name,
"authorName": embed_obj.author_name,
"thumbnail": embed_obj.thumbnail_url,
"title": embed_obj.title,
}
return render_modal_workflow(
request,
None,
None,
None,
json_data={
"step": "embed_chosen",
"embed_html": embed_html,
"embed_data": embed_data,
},
)
except AccessDeniedEmbedlyException:
error = _(
"There seems to be a problem with your embedly API key. Please check your settings."
)
except (EmbedNotFoundException, EmbedUnsupportedProviderException):
error = _("Cannot find an embed for this URL.")
except EmbedlyException:
error = _(
"There seems to be an error with Embedly while trying to embed this URL."
" Please try again later."
)
if error:
errors = form._errors.setdefault("url", ErrorList())
errors.append(error)
return render_modal_workflow(
request,
"non_admin_draftail/embed/chooser.html",
None,
{"form": form},
json_data={"step": "chooser"},
)
else:
form = EmbedForm(prefix="embed-chooser")
return render_modal_workflow(
request,
"non_admin_draftail/embed/chooser.html",
None,
{"form": form},
json_data={"step": "chooser"},
)
def create_review(request):
ReviewForm = get_review_form_class()
if request.method == 'GET':
form = ReviewForm(prefix='create_review')
reviewer_formset = ReviewerFormSet(prefix='create_review_reviewers')
else:
form = ReviewForm(request.POST, prefix='create_review')
reviewer_formset = ReviewerFormSet(request.POST, prefix='create_review_reviewers')
form_is_valid = form.is_valid()
reviewer_formset_is_valid = reviewer_formset.is_valid()
if not (form_is_valid and reviewer_formset_is_valid):
return render_modal_workflow(
request, 'wagtail_review/create_review.html', None, {
'form': form,
'reviewer_formset': reviewer_formset,
}, json_data={'step': 'form'}
)
else:
return render_modal_workflow(
request, None, None, {}, json_data={'step': 'done'}
)
return render_modal_workflow(
request, 'wagtail_review/create_review.html', None, {
'form': form,
'reviewer_formset': reviewer_formset,
}, json_data={'step': 'form'}
)
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(
request.POST, request.FILES, instance=image, user=request.user, prefix='image-chooser-upload'
)
if form.is_valid():
# Set image file size
image.file_size = image.file.size
# Set image file hash
image.file.seek(0)
image._set_file_hash(image.file.read())
image.file.seek(0)
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(
initial={'alt_text': image.default_alt_text}, prefix='image-chooser-insertion'
)
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', None,
{'image': image, 'form': form}, json_data={'step': 'select_format'}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)}
)
else:
form = ImageForm(user=request.user, prefix='image-chooser-upload')
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
paginator = Paginator(images, per_page=CHOOSER_PAGE_SIZE)
images = paginator.get_page(request.GET.get('p'))
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': form,
})
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', None, context,
json_data=get_chooser_js_data()
)
def chooser_select_format(request, image_id):
image = get_object_or_404(get_image_model(), id=image_id)
if request.method == 'POST':
form = ImageInsertionForm(request.POST,
initial={'alt_text': image.default_alt_text},
prefix='image-chooser-insertion')
if form.is_valid():
format = get_image_format(form.cleaned_data['format'])
preview_image = image.get_rendition(format.filter_spec)
image_data = {
'id':
image.id,
'title':
image.title,
'format':
format.name,
'alt':
form.cleaned_data['alt_text'],
'class':
format.classnames,
'edit_link':
reverse('wagtailimages:edit', args=(image.id, )),
'preview': {
'url': preview_image.url,
'width': preview_image.width,
'height': preview_image.height,
},
'html':
format.image_to_editor_html(image,
form.cleaned_data['alt_text']),
}
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'image_chosen',
'result': image_data
})
else:
initial = {'alt_text': image.default_alt_text}
initial.update(request.GET.dict())
# If you edit an existing image, and there is no alt text, ensure that
# "image is decorative" is ticked when you open the form
initial['image_is_decorative'] = initial['alt_text'] == ''
form = ImageInsertionForm(initial=initial,
prefix='image-chooser-insertion')
return render_modal_workflow(request,
'wagtailimages/chooser/select_format.html',
None, {
'image': image,
'form': form
},
json_data={'step': 'select_format'})
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(
request.POST, request.FILES, instance=image, user=request.user, prefix='image-chooser-upload'
)
if form.is_valid():
# Set image file size
image.file_size = image.file.size
# Set image file hash
image.file.seek(0)
image._set_file_hash(image.file.read())
image.file.seek(0)
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(
initial={'alt_text': image.default_alt_text}, prefix='image-chooser-insertion'
)
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', None,
{'image': image, 'form': form}, json_data={'step': 'select_format'}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)}
)
else:
form = ImageForm(user=request.user, prefix='image-chooser-upload')
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
paginator = Paginator(images, per_page=12)
images = paginator.get_page(request.GET.get('p'))
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': form,
})
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', None, context,
json_data=get_chooser_js_data()
)
def chooser_upload(request, media_type):
Media = get_media_model()
MediaForm = get_media_form(Media)
if request.method == 'POST':
media = Media(uploaded_by_user=request.user, type=media_type)
form = MediaForm(request.POST,
request.FILES,
instance=media,
user=request.user,
prefix='media-chooser-upload')
if form.is_valid():
form.save()
# Reindex the media entry to make sure all tags are indexed
for backend in get_search_backends():
backend.add(media)
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'media_chosen',
'result': get_media_json(media)
})
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)
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)
context = {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'uploadform': form,
'is_searching': False,
'pagination_template': pagination_template,
'media_type': media_type,
}
return render_modal_workflow(request,
'wagtailmedia/chooser/chooser.html',
None,
context,
json_data={'step': 'chooser'})
def external_link(request):
initial_data = {
"url": request.GET.get("link_url", ""),
"link_text": request.GET.get("link_text", ""),
}
if request.method == "POST":
form = ExternalLinkChooserForm(request.POST,
initial=initial_data,
prefix="external-link-chooser")
if form.is_valid():
result = {
"url":
form.cleaned_data["url"],
"title":
form.cleaned_data["link_text"].strip()
or form.cleaned_data["url"],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
# (Normally this will match the link_text passed in the URL here anyhow,
# but that won't account for non-text content such as images.)
"prefer_this_title_as_link_text": ("link_text"
in form.changed_data),
}
return render_modal_workflow(
request,
None,
None,
None,
json_data={
"step": "external_link_chosen",
"result": result
},
)
else:
form = ExternalLinkChooserForm(initial=initial_data,
prefix="external-link-chooser")
return render_modal_workflow(
request,
"non_admin_draftail/link/external_link.html",
None,
shared_context(
request,
{
"form": form,
},
),
json_data={"step": "external_link"},
)
def chooser_select_format(request, embed_video_id):
embed_video = get_object_or_404(get_embed_video_model(), id=embed_video_id)
print(embed_video)
if request.POST:
form = EmbedVideoInsertionForm(
request.POST, initial={'alt_text': embed_video.default_alt_text})
if form.is_valid():
format = get_video_format(form.cleaned_data['format'])
preview_embed_video = detect_backend(
embed_video.url).get_thumbnail_url()
video_json = json.dumps({
'id':
embed_video.id,
'title':
embed_video.title,
'format':
format.name,
'alt':
form.cleaned_data['alt_text'],
'class':
format.classnames,
'edit_link':
reverse('wagtail_embed_videos:edit', args=(embed_video.id, )),
'preview': {
'url': preview_embed_video,
'width': embed_video.thumbnail.width,
'height': embed_video.thumbnail.height,
},
'html':
format.video_to_editor_html(embed_video,
form.cleaned_data['alt_text']),
})
print(video_json)
return render_modal_workflow(
request, None,
'wagtail_embed_videos/chooser/embed_video_chosen.js',
{'embed_video_json': video_json})
else:
initial = {'alt_text': embed_video.default_alt_text}
initial.update(request.GET.dict())
form = EmbedVideoInsertionForm(initial=initial)
return render_modal_workflow(
request, 'wagtail_embed_videos/chooser/select_format.html',
'wagtail_embed_videos/chooser/select_format.js', {
'embed_video': embed_video,
'form': form
})
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(
request.POST, request.FILES, instance=image, user=request.user, prefix='image-chooser-upload'
)
if form.is_valid():
# Set image file size
image.file_size = image.file.size
# Set image file hash
image.file.seek(0)
image._set_file_hash(image.file.read())
image.file.seek(0)
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(
initial={'alt_text': image.default_alt_text}, prefix='image-chooser-insertion'
)
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', None,
{'image': image, 'form': form}, json_data={'step': 'select_format'}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)}
)
else:
form = ImageForm(user=request.user, prefix='image-chooser-upload')
upload_form_html = render_to_string('wagtailimages/chooser/upload_form.html', {
'form': form,
'will_select_format': request.GET.get('select_format'),
}, request)
return render_modal_workflow(
request, None, None, None,
json_data={
'step': 'reshow_upload_form',
'htmlFragment': upload_form_html
}
)
def document_chooser_upload(request):
Document = get_document_model()
DocumentForm = get_document_form(Document)
if request.method == "POST":
document = Document(uploaded_by_user=request.user)
form = DocumentForm(
request.POST,
request.FILES,
instance=document,
user=request.user,
prefix="document-chooser-upload",
)
if form.is_valid():
document.file_size = document.file.size
# Set new document file hash
document.file.seek(0)
document._set_file_hash(document.file.read())
document.file.seek(0)
form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(document)
return render_modal_workflow(
request,
None,
None,
None,
json_data={
"step": "document_chosen",
"result": get_document_result_data(document),
},
)
else:
form = DocumentForm(user=request.user,
prefix="document-chooser-upload")
documents = Document.objects.order_by("title")
return render_modal_workflow(
request,
"non_admin_draftail/document/chooser.html",
None,
{
"documents": documents,
"uploadform": form
},
json_data=get_chooser_context(),
)
def chooser_upload(request):
if request.method == 'POST':
form = EmbedForm(request.POST, request.FILES, prefix='embed-chooser')
if form.is_valid():
error = None
try:
embed_html = embed_to_editor_html(form.cleaned_data['url'])
embed_obj = embeds.get_embed(form.cleaned_data['url'])
embed_data = {
'embedType': embed_obj.type,
'url': embed_obj.url,
'providerName': embed_obj.provider_name,
'authorName': embed_obj.author_name,
'thumbnail': embed_obj.thumbnail_url,
'title': embed_obj.title,
}
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'embed_chosen',
'embed_html': embed_html,
'embed_data': embed_data
})
except AccessDeniedEmbedlyException:
error = _(
"There seems to be a problem with your embedly API key. Please check your settings."
)
except (EmbedNotFoundException, EmbedUnsupportedProviderException):
error = _("Cannot find an embed for this URL.")
except EmbedlyException:
error = _(
"There seems to be an error with Embedly while trying to embed this URL."
" Please try again later.")
if error:
errors = form._errors.setdefault('url', ErrorList())
errors.append(error)
return render_modal_workflow(
request,
'wagtailembeds/chooser/chooser.html',
None, {'form': form},
json_data={'step': 'chooser'})
else:
form = EmbedForm(prefix='embed-chooser')
return render_modal_workflow(request,
'wagtailembeds/chooser/chooser.html',
None, {'form': form},
json_data={'step': 'chooser'})
def phone_link(request):
initial_data = {
"link_text": request.GET.get("link_text", ""),
"phone_number": request.GET.get("link_url", ""),
}
if request.method == "POST":
form = PhoneLinkChooserForm(request.POST,
initial=initial_data,
prefix="phone-link-chooser")
if form.is_valid():
result = {
"url":
"tel:" + form.cleaned_data["phone_number"],
"title":
form.cleaned_data["link_text"].strip()
or form.cleaned_data["phone_number"],
# If the user has explicitly entered / edited something in the link_text field,
# always use that text. If not, we should favour keeping the existing link/selection
# text, where applicable.
"prefer_this_title_as_link_text": ("link_text"
in form.changed_data),
}
return render_modal_workflow(
request,
None,
None,
None,
json_data={
"step": "external_link_chosen",
"result": result
},
)
else:
form = PhoneLinkChooserForm(initial=initial_data,
prefix="phone-link-chooser")
return render_modal_workflow(
request,
"wagtailadmin/chooser/phone_link.html",
None,
shared_context(
request,
{
"form": form,
},
),
json_data={"step": "phone_link"},
)
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 chooser_upload(request):
EmbedVideo = get_embed_video_model()
EmbedVideoForm = get_embed_video_form(EmbedVideo)
searchform = SearchForm()
if request.POST:
embed_video = EmbedVideo(uploaded_by_user=request.user)
form = EmbedVideoForm(request.POST,
request.FILES,
instance=embed_video,
user=request.user)
if form.is_valid():
form.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(embed_video)
if request.GET.get('select_format'):
form = EmbedVideoInsertionForm(
initial={'alt_text': embed_video.default_alt_text})
return render_modal_workflow(
request, 'wagtail_embed_videos/chooser/select_format.html',
'wagtail_embed_videos/chooser/select_format.js', {
'embed_video': embed_video,
'form': form
})
# not specifying a format; return the embed video details now
else:
json_data = get_embed_video_json(embed_video)
json_data['step'] = 'embed_video_chosen'
return render_modal_workflow(
request,
None,
None, #'wagtail_embed_videos/chooser/embed_video_chosen.js',
json_data=json_data)
else:
form = EmbedVideoForm(user=request.user)
embed_videos = EmbedVideo.objects.order_by('-created_at')
paginator, images = paginate(request, embed_videos, per_page=12)
return render_modal_workflow(request,
'wagtail_embed_videos/chooser/chooser.html',
None, {
'embed_videos': embed_videos,
'uploadform': form,
'searchform': searchform
})
def make_product_purchase(request: HttpRequest,
guid: uuid.UUID) -> JsonResponse:
page_query = int(request.GET.get("page", 1))
variant = ProductVariant.objects.prefetch_related("order_lines").get(
guid=guid)
purchase_orders = PurchaseOrder.objects.filter(
status=PurchaseOrder.StatusChoices.DRAFT)
paginator = Paginator(purchase_orders, 5)
qs = variant.order_lines.aggregate(total_qty=Sum("quantity"))
if request.method == "POST":
form = PurchaseOrderForm(data=request.POST, variant=variant)
if form.is_valid():
obj = form.save()
return render_modal_workflow(
request,
None,
None,
{"obj": obj},
json_data={"step": "created"},
)
return render_modal_workflow(
request,
"products/choosers/product_purchase.html",
None,
{
"obj": variant,
"page": paginator.page(page_query),
"purchase_orders": purchase_orders,
"form": form,
"form_errors": form.errors,
},
json_data={"step": "chooser"},
)
to_purchase = (variant.needed_stock["quantity"]
or 0 - variant.available_stock["quantity"]
or 0 - variant.in_purchase["quantity"] or 0)
form = PurchaseOrderForm(initial={"quantity": to_purchase},
variant=variant)
return render_modal_workflow(
request,
"products/choosers/product_purchase.html",
None,
{
"obj": variant,
"page": paginator.page(page_query),
"purchase_orders": purchase_orders,
"form": form,
},
json_data={"step": "chooser"},
)
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(request.POST,
request.FILES,
instance=image,
user=request.user)
if form.is_valid():
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(
initial={'alt_text': image.default_alt_text})
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html',
'wagtailimages/chooser/select_format.js', {
'image': image,
'form': form
})
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, 'wagtailimages/chooser/image_chosen.js',
{'image_json': get_image_json(image)})
else:
form = ImageForm(user=request.user)
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
paginator, images = paginate(request, images, per_page=12)
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': form,
})
return render_modal_workflow(request, 'wagtailimages/chooser/chooser.html',
'wagtailimages/chooser/chooser.js', context)
def receive_product_stock(request: HttpRequest,
guid: uuid.UUID) -> JsonResponse:
variant = ProductVariant.objects.get(guid=guid)
purchase_orders = PurchaseOrderItem.objects.filter(
~Q(sales_orders__order__status__in=[
PurchaseOrderItem.StatusChoices.RECEIVED,
]),
Q(sales_orders__variant=variant),
)
if request.method == "POST":
form = StockReceiveForm(
request.POST,
request.FILES,
variant=variant,
purchase_orders=purchase_orders,
)
if form.is_valid():
return render_modal_workflow(
request,
None,
None,
{"obj": variant},
json_data={"step": "received"},
)
return render_modal_workflow(
request,
None,
None,
{
"obj": variant,
"form": form
},
json_data={"step": "chooser"},
)
form = StockReceiveForm(
variant=variant,
purchase_orders=purchase_orders,
initial={"product_variant": variant},
)
return render_modal_workflow(
request,
"products/choosers/product_receive.html",
None,
{
"obj": variant,
"form": form
},
json_data={"step": "chooser"},
)
def chooser_upload(request):
Document = get_document_model()
DocumentForm = get_document_form(Document)
if request.method == 'POST':
document = Document(uploaded_by_user=request.user)
form = DocumentForm(request.POST,
request.FILES,
instance=document,
user=request.user,
prefix='document-chooser-upload')
if form.is_valid():
document.file_size = document.file.size
# Set new document file hash
document.file.seek(0)
document._set_file_hash(document.file.read())
document.file.seek(0)
form.save()
# Reindex the document to make sure all tags are indexed
search_index.insert_or_update_object(document)
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step':
'document_chosen',
'result':
get_document_result_data(document)
})
else:
form = DocumentForm(user=request.user,
prefix='document-chooser-upload')
documents = Document.objects.order_by('title')
return render_modal_workflow(request,
'wagtaildocs/chooser/chooser.html',
None, {
'documents': documents,
'uploadform': form
},
json_data=get_chooser_context())
def chooser_select_format(request, image_id):
image = get_object_or_404(get_image_model(), id=image_id)
if request.method == 'POST':
form = ImageInsertionForm(request.POST,
initial={'alt_text': image.default_alt_text})
if form.is_valid():
format = get_image_format(form.cleaned_data['format'])
preview_image = image.get_rendition(format.filter_spec)
image_json = json.dumps({
'id':
image.id,
'title':
image.title,
'format':
format.name,
'alt':
form.cleaned_data['alt_text'],
'class':
format.classnames,
'edit_link':
reverse('wagtailimages:edit', args=(image.id, )),
'preview': {
'url': preview_image.url,
'width': preview_image.width,
'height': preview_image.height,
},
'html':
format.image_to_editor_html(image,
form.cleaned_data['alt_text']),
})
return render_modal_workflow(
request, None, 'wagtailimages/chooser/image_chosen.js',
{'image_json': image_json})
else:
initial = {'alt_text': image.default_alt_text}
initial.update(request.GET.dict())
form = ImageInsertionForm(initial=initial)
return render_modal_workflow(request,
'wagtailimages/chooser/select_format.html',
'wagtailimages/chooser/select_format.js', {
'image': image,
'form': form
})
def document_chosen(request, document_id):
doc = get_object_or_404(get_document_model(), id=document_id)
Document = get_document_model()
DocumentMultiForm = get_document_multi_form(Document)
# handle some updated data if this is a POST
if request.POST:
if not request.is_ajax():
return http.HttpResponseBadRequest(
"Cannot POST to this view without AJAX")
form = DocumentMultiForm(
request.POST, request.FILES, instance=doc, prefix='doc-' + document_id, user=request.user
)
if form.is_valid():
form.save()
# Reindex the doc to make sure all tags are indexed
search_index.insert_or_update_object(doc)
return render_modal_workflow(
request, None, 'wagtaildocs/chooser/document_chosen.js',
{'document_json': get_document_json(doc)}
)
def embed_video_chosen(request, embed_video_id):
embed_video = get_object_or_404(get_embed_video_model(), id=embed_video_id)
return render_modal_workflow(
request, None, 'wagtail_embed_videos/chooser/embed_video_chosen.js',
{'embed_video_json': get_embed_video_json(embed_video)}
)
def media_chosen(request, media_id):
media = get_object_or_404(get_media_model(), id=media_id)
return render_modal_workflow(
request, None, 'wagtailmedia/chooser/media_chosen.js',
{'media_json': get_media_json(media)}
)
def video_chosen(request, video_id):
video = get_object_or_404(Video, id=video_id)
return render_modal_workflow(
request, None, 'wagtailvideos/chooser/video_chosen.js',
{'video_json': get_video_json(video)}
)
def chooser(request, get_results=False):
# Get most popular queries
queries = models.Query.get_most_popular()
# If searching, filter results by query string
query_string = None
if 'q' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
query_string = searchform.cleaned_data['q']
queries = queries.filter(query_string__icontains=normalise_query_string(query_string))
else:
searchform = SearchForm()
paginator, queries = paginate(request, queries, per_page=10)
# Render
if get_results:
return render(request, "wagtailsearch/queries/chooser/results.html", {
'queries': queries,
})
else:
return render_modal_workflow(
request, 'wagtailsearch/queries/chooser/chooser.html', None, {
'queries': queries,
'searchform': searchform,
}, json_data={'step': 'chooser'}
)
def chooser(request):
Image = get_image_model()
if permission_policy.user_has_permission(request.user, 'add'):
ImageForm = get_image_form(Image)
uploadform = ImageForm(user=request.user)
else:
uploadform = None
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
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:
images = images.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
images = images.search(q)
is_searching = True
else:
is_searching = False
q = None
tag_name = request.GET.get('tag')
if tag_name:
images = images.filter(tags__name=tag_name)
# Pagination
paginator, images = paginate(request, images, per_page=12)
return render(request, "wagtailimages/chooser/results.html", {
'images': images,
'is_searching': is_searching,
'query_string': q,
'will_select_format': request.GET.get('select_format')
})
else:
paginator, images = paginate(request, images, per_page=12)
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': uploadform,
})
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', None, context,
json_data=get_chooser_js_data()
)
def document_chosen(request, document_id):
document = get_object_or_404(get_document_model(), id=document_id)
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'document_chosen', 'result': get_document_result_data(document)}
)
def video_chosen(request, video_id):
video = get_object_or_404(Video, id=video_id)
return render_modal_workflow(
request, None, 'wagtailvideos/chooser/video_chosen.js',
{'video_json': get_video_json(video)}
)
def image_chosen(request, image_id):
image = get_object_or_404(get_image_model(), id=image_id)
return render_modal_workflow(
request, None, 'wagtailimages/chooser/image_chosen.js',
{'image_json': get_image_json(image)}
)
def document_chosen(request, document_id):
document = get_object_or_404(get_document_model(), id=document_id)
return render_modal_workflow(
request, None, 'wagtaildocs/chooser/document_chosen.js',
{'document_json': get_document_json(document)}
)
def image_chosen(request, image_id):
image = get_object_or_404(get_image_model(), id=image_id)
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)}
)
def chooser_upload(request):
if request.method == 'POST':
form = EmbedForm(request.POST, request.FILES, prefix='embed-chooser')
if form.is_valid():
error = None
try:
embed_html = embed_to_editor_html(form.cleaned_data['url'])
embed_obj = embeds.get_embed(form.cleaned_data['url'])
embed_data = {
'embedType': embed_obj.type,
'url': embed_obj.url,
'providerName': embed_obj.provider_name,
'authorName': embed_obj.author_name,
'thumbnail': embed_obj.thumbnail_url,
'title': embed_obj.title,
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'embed_chosen', 'embed_html': embed_html, 'embed_data': embed_data}
)
except AccessDeniedEmbedlyException:
error = _("There seems to be a problem with your embedly API key. Please check your settings.")
except (EmbedNotFoundException, EmbedUnsupportedProviderException):
error = _("Cannot find an embed for this URL.")
except EmbedlyException:
error = _(
"There seems to be an error with Embedly while trying to embed this URL."
" Please try again later."
)
if error:
errors = form._errors.setdefault('url', ErrorList())
errors.append(error)
return render_modal_workflow(
request, 'wagtailembeds/chooser/chooser.html', None,
{'form': form},
json_data={'step': 'chooser'}
)
else:
form = EmbedForm(prefix='embed-chooser')
return render_modal_workflow(
request, 'wagtailembeds/chooser/chooser.html', None,
{'form': form},
json_data={'step': 'chooser'}
)
def chooser(request):
form = EmbedForm(initial=request.GET.dict(), prefix='embed-chooser')
return render_modal_workflow(
request, 'wagtailembeds/chooser/chooser.html', None,
{'form': form},
json_data={'step': 'chooser'}
)
def chooser(request):
Document = get_document_model()
if permission_policy.user_has_permission(request.user, 'add'):
DocumentForm = get_document_form(Document)
uploadform = DocumentForm(user=request.user)
else:
uploadform = None
documents = Document.objects.all()
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_document_chooser_queryset'):
documents = hook(documents, request)
q = None
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
collection_id = request.GET.get('collection_id')
if collection_id:
documents = documents.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
documents = documents.search(q)
is_searching = True
else:
documents = documents.order_by('-created_at')
is_searching = False
# Pagination
paginator, documents = paginate(request, documents, per_page=10)
return render(request, "wagtaildocs/chooser/results.html", {
'documents': documents,
'query_string': q,
'is_searching': is_searching,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
documents = documents.order_by('-created_at')
paginator, documents = paginate(request, documents, per_page=10)
return render_modal_workflow(request, 'wagtaildocs/chooser/chooser.html', 'wagtaildocs/chooser/chooser.js', {
'documents': documents,
'uploadform': uploadform,
'searchform': searchform,
'collections': collections,
'is_searching': False,
'uploadid': uuid.uuid4(),
})
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
searchform = SearchForm()
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(request.POST, request.FILES, instance=image, user=request.user)
if form.is_valid():
# Set image file size
image.file_size = image.file.size
# Set image file hash
image.file.seek(0)
image._set_file_hash(image.file.read())
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(initial={'alt_text': image.default_alt_text})
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', 'wagtailimages/chooser/select_format.js',
{'image': image, 'form': form}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, 'wagtailimages/chooser/image_chosen.js',
{'image_json': get_image_json(image)}
)
else:
form = ImageForm(user=request.user)
images = Image.objects.order_by('-created_at')
paginator, images = paginate(request, images, per_page=12)
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', 'wagtailimages/chooser/chooser.js',
{'images': images, 'uploadform': form, 'searchform': searchform}
)
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, videos = paginate(request, videos, per_page=12)
return render(request, "wagtailvideos/chooser/results.html", {
'videos': videos,
'is_searching': is_searching,
'query_string': q,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(request, 'wagtailvideos/chooser/chooser.html', 'wagtailvideos/chooser/chooser.js', {
'videos': videos,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'popular_tags': popular_tags_for_model(Video),
'collections': collections,
})
def choose(request, app_label, model_name):
model = get_snippet_model_from_url_params(app_label, model_name)
items = model.objects.all()
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name
})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name
})
# Pagination
paginator = Paginator(items, per_page=25)
paginated_items = paginator.get_page(request.GET.get('p'))
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(request, "wagtailsnippets/chooser/results.html", {
'model_opts': model._meta,
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request,
'wagtailsnippets/chooser/choose.html', None,
{
'model_opts': model._meta,
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
}, json_data={'step': 'choose'}
)
def chooser_select_format(request, image_id):
image = get_object_or_404(get_image_model(), id=image_id)
if request.method == 'POST':
form = ImageInsertionForm(
request.POST, initial={'alt_text': image.default_alt_text}, prefix='image-chooser-insertion'
)
if form.is_valid():
format = get_image_format(form.cleaned_data['format'])
preview_image = image.get_rendition(format.filter_spec)
image_data = {
'id': image.id,
'title': image.title,
'format': format.name,
'alt': form.cleaned_data['alt_text'],
'class': format.classnames,
'edit_link': reverse('wagtailimages:edit', args=(image.id,)),
'preview': {
'url': preview_image.url,
'width': preview_image.width,
'height': preview_image.height,
},
'html': format.image_to_editor_html(image, form.cleaned_data['alt_text']),
}
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': image_data}
)
else:
initial = {'alt_text': image.default_alt_text}
initial.update(request.GET.dict())
form = ImageInsertionForm(initial=initial, prefix='image-chooser-insertion')
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', None,
{'image': image, 'form': form}, json_data={'step': 'select_format'}
)
def choose(request):
# TODO: Ideally this would return the endnotes for the current article.
items = EndNote.objects.all()
# Search
is_searchable = class_is_indexed(EndNote)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search End Notes"))
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(placeholder=_("Search End Notes"))
# Pagination
p = request.GET.get("p", 1)
paginator = Paginator(items, 25)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(request, "content_notes/chooser/results.html", {
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request,
'content_notes/chooser/choose.html', 'content_notes/chooser/choose.js',
{
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
}
)
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)
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)
searchform = SearchForm()
return render_modal_workflow(
request,
'wagtail_embed_videos/chooser/chooser.html',
'wagtail_embed_videos/chooser/chooser.js',
{
'embed_videos': embed_videos,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags': popular_tags_for_model(EmbedVideo),
}
)
def chosen(request, id):
item = get_object_or_404(EndNote, id=id)
end_note_json = json.dumps({
'id': item.uuid,
'string': text_type(item)
})
return render_modal_workflow(
request,
None, 'content_notes/chooser/chosen.js',
{
'endnote_json': end_note_json,
}
)
def chooser(request):
Media = get_media_model()
media_files = []
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
media_files = Media.objects.all()
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
# 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,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = Media.objects.order_by('-created_at')
paginator, media_files = paginate(request, media_files, per_page=10)
return render_modal_workflow(request, 'wagtailmedia/chooser/chooser.html', 'wagtailmedia/chooser/chooser.js', {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'is_searching': False,
})
def chosen(request, app_label, model_name, pk):
model = get_snippet_model_from_url_params(app_label, model_name)
item = get_object_or_404(model, pk=unquote(pk))
snippet_data = {
'id': str(item.pk),
'string': str(item),
'edit_link': reverse('wagtailsnippets:edit', args=(
app_label, model_name, quote(item.pk)))
}
return render_modal_workflow(
request,
None, None,
None, json_data={'step': 'chosen', 'result': snippet_data}
)
def product_chosen(request, pk):
product = get_object_or_404(Product, pk=pk)
product_json = json.dumps({
'id': product.pk,
'string': text_type(product),
'edit_link': reverse(
'dashboard:catalogue-product', kwargs={'pk': product.pk})
})
return render_modal_workflow(
request,
None, 'oscar_wagtail/chooser/product_chosen.js',
{
'product_json': product_json,
}
)
