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): 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 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, } )