Esempio n. 1
0
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}
    )
Esempio n. 2
0
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),
        })
Esempio n. 3
0
def add(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)
        if form.is_valid():
            form.save()

            # Reindex the media entry to make sure all tags are indexed
            search_index.insert_or_update_object(media)
            messages.success(request,
                             _("Media file '{0}' added.").format(media.title),
                             buttons=[
                                 messages.button(
                                     reverse('wagtailmedia:edit',
                                             args=(media.id, )), _('Edit'))
                             ])
            return redirect('wagtailmedia:index')
        else:
            messages.error(
                request, _("The media file could not be saved due to errors."))
    else:
        media = Media(uploaded_by_user=request.user, type=media_type)
        form = MediaForm(user=request.user, instance=media)

    return render(request, "wagtailmedia/media/add.html", {
        'form': form,
        'media_type': media_type,
    })
Esempio n. 4
0
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}
    )
Esempio n. 5
0
def add(request):
    ImageModel = get_image_model()
    ImageForm = get_image_form(ImageModel)

    if request.method == 'POST':
        image = ImageModel(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

            form.save()

            # Reindex the image to make sure all tags are indexed
            search_index.insert_or_update_object(image)

            messages.success(request, _("Image '{0}' added.").format(image.title), buttons=[
                messages.button(reverse('wagtailimages:edit', args=(image.id,)), _('Edit'))
            ])
            return redirect('wagtailimages:index')
        else:
            messages.error(request, _("The image could not be created due to errors."))
    else:
        form = ImageForm(user=request.user)

    return render(request, "wagtailimages/images/add.html", {
        'form': form,
    })
Esempio n. 6
0
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
                                 })
Esempio n. 7
0
def add(request):
    Document = get_document_model()
    DocumentForm = get_document_form(Document)

    if request.method == 'POST':
        doc = Document(uploaded_by_user=request.user)
        form = DocumentForm(request.POST, request.FILES, instance=doc, user=request.user)
        if form.is_valid():
            doc.file_size = doc.file.size

            form.save()

            # Reindex the document to make sure all tags are indexed
            search_index.insert_or_update_object(doc)

            messages.success(request, _("Document '{0}' added.").format(doc.title), buttons=[
                messages.button(reverse('wagtaildocs:edit', args=(doc.id,)), _('Edit'))
            ])
            return redirect('wagtaildocs:index')
        else:
            messages.error(request, _("The document could not be saved due to errors."))
    else:
        form = DocumentForm(user=request.user)

    return render(request, "wagtaildocs/documents/add.html", {
        'form': form,
    })
Esempio n. 8
0
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()
    )
Esempio n. 9
0
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
                                 })
Esempio n. 10
0
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 test_inserts_object(self, backend):
        obj = models.Book.objects.create(title="Test", publication_date=date(2017, 10, 18), number_of_pages=100)
        backend().reset_mock()

        index.insert_or_update_object(obj)

        backend().add.assert_called_with(obj)
    def test_doesnt_insert_unsaved_object(self, backend):
        obj = models.Book(title="Test", publication_date=date(2017, 10, 18), number_of_pages=100)
        backend().reset_mock()

        index.insert_or_update_object(obj)

        self.assertFalse(backend().add.mock_calls)
Esempio n. 13
0
    def handle(self, *args, **options):
        self.stdout.write(self.style.SUCCESS("Importing images"))

        if not options["from_dir"].endswith("/"):
            options["from_dir"] = options["from_dir"] + "/"

        for filepath in sorted(glob(options["from_dir"] + "*-90x90.png")):
            with open(filepath, "rb") as image_file:
                name = filepath.split("/")[-1][:-10]
                image = Image(title=name)
                image.file = ImageFile(file=image_file, name=name + ".png")
                image.file_size = image.file.size

                image.file.seek(0)
                image._set_file_hash(image.file.read())
                image.file.seek(0)

                # Reindex the image to make sure all tags are indexed
                search_index.insert_or_update_object(image)
                image.save()
                image.tags.add("illustration")

                self.stdout.write(
                    self.style.SUCCESS(f"{image.pk},{image.title}"))

        self.stdout.write(self.style.SUCCESS("Importing images finished"))
Esempio n. 14
0
def add(request):
    Document = get_document_model()
    DocumentForm = get_document_form(Document)

    if request.method == 'POST':
        doc = Document(uploaded_by_user=request.user)
        form = DocumentForm(request.POST, request.FILES, instance=doc, user=request.user)
        if form.is_valid():
            doc.file_size = doc.file.size

            # Set new document file hash
            doc.file.seek(0)
            doc._set_file_hash(doc.file.read())
            doc.file.seek(0)

            form.save()

            # Reindex the document to make sure all tags are indexed
            search_index.insert_or_update_object(doc)

            messages.success(request, _("Document '{0}' added.").format(doc.title), buttons=[
                messages.button(reverse('wagtaildocs:edit', args=(doc.id,)), _('Edit'))
            ])
            return redirect('wagtaildocs:index')
        else:
            messages.error(request, _("The document could not be saved due to errors."))
    else:
        form = DocumentForm(user=request.user)

    return render(request, "wagtaildocs/documents/add.html", {
        'form': form,
    })
Esempio n. 15
0
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}
    )
Esempio n. 16
0
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()
    )
Esempio n. 17
0
def add(request):
    ImageModel = get_image_model()
    ImageForm = get_image_form(ImageModel)

    if request.method == 'POST':
        image = ImageModel(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())
            image.file.seek(0)

            form.save()

            # Reindex the image to make sure all tags are indexed
            search_index.insert_or_update_object(image)

            messages.success(request, _("Image '{0}' added.").format(image.title), buttons=[
                messages.button(reverse('wagtailimages:edit', args=(image.id,)), _('Edit'))
            ])
            return redirect('wagtailimages:index')
        else:
            messages.error(request, _("The image could not be created due to errors."))
    else:
        form = ImageForm(user=request.user)

    return TemplateResponse(request, "wagtailimages/images/add.html", {
        'form': form,
    })
Esempio n. 18
0
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()
    )
Esempio n. 19
0
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()
    )
Esempio n. 20
0
def post_save_signal_handler(instance, update_fields=None, **kwargs):
    if update_fields is not None:
        # fetch a fresh copy of instance from the database to ensure
        # that we're not indexing any of the unsaved data contained in
        # the fields that were not passed in update_fields
        instance = type(instance).objects.get(pk=instance.pk)

    index.insert_or_update_object(instance)
Esempio n. 21
0
    def test_doesnt_insert_unsaved_object(self, backend):
        obj = models.Book(title="Test",
                          publication_date=date(2017, 10, 18),
                          number_of_pages=100)
        backend().reset_mock()

        index.insert_or_update_object(obj)

        self.assertFalse(backend().add.mock_calls)
def edit(request, document_id):
    Document = get_document_model()
    DocumentForm = get_document_form(Document)

    doc = get_object_or_404(Document, id=document_id)

    if not permission_policy.user_has_permission_for_instance(request.user, 'change', doc):
        return permission_denied(request)

    if request.method == 'POST':
        original_file = doc.file
        form = DocumentForm(request.POST, request.FILES, instance=doc, user=request.user)
        if form.is_valid():
            doc = form.save()
            if 'file' in form.changed_data:
                # if providing a new document file, delete the old one.
                # NB Doing this via original_file.delete() clears the file field,
                # which definitely isn't what we want...
                original_file.storage.delete(original_file.name)

            # Reindex the document to make sure all tags are indexed
            search_index.insert_or_update_object(doc)

            messages.success(request, _("Document '{0}' updated").format(doc.title), buttons=[
                messages.button(reverse('wagtaildocs:edit', args=(doc.id,)), _('Edit'))
            ])
            return redirect('wagtaildocs:index')
        else:
            messages.error(request, _("The document could not be saved due to errors."))
    else:
        form = DocumentForm(instance=doc, user=request.user)

    filesize = None

    # Get file size when there is a file associated with the Document object
    if doc.file:
        try:
            filesize = doc.file.size
        except OSError:
            # File doesn't exist
            pass

    if not filesize:
        messages.error(
            request,
            _("The file could not be found. Please change the source or delete the document"),
            buttons=[messages.button(reverse('wagtaildocs:delete', args=(doc.id,)), _('Delete'))]
        )

    return render(request, "wagtaildocs/documents/edit.html", {
        'document': doc,
        'filesize': filesize,
        'form': form,
        'user_can_delete': permission_policy.user_has_permission_for_instance(
            request.user, 'delete', doc
        ),
    })
Esempio n. 23
0
def edit(request, document_id):
    Document = get_document_model()
    DocumentForm = get_document_form(Document)

    doc = get_object_or_404(Document, id=document_id)

    if not permission_policy.user_has_permission_for_instance(request.user, 'change', doc):
        return permission_denied(request)

    if request.method == 'POST':
        original_file = doc.file
        form = DocumentForm(request.POST, request.FILES, instance=doc, user=request.user)
        if form.is_valid():
            doc = form.save()
            if 'file' in form.changed_data:
                doc.file_size = doc.file.size

                # if providing a new document file, delete the old one.
                # NB Doing this via original_file.delete() clears the file field,
                # which definitely isn't what we want...
                original_file.storage.delete(original_file.name)

            # Reindex the document to make sure all tags are indexed
            search_index.insert_or_update_object(doc)

            messages.success(request, _("Document '{0}' updated").format(doc.title), buttons=[
                messages.button(reverse('wagtaildocs:edit', args=(doc.id,)), _('Edit'))
            ])
            return redirect('wagtaildocs:index')
        else:
            messages.error(request, _("The document could not be saved due to errors."))
    else:
        form = DocumentForm(instance=doc, user=request.user)

    try:
        local_path = doc.file.path
    except NotImplementedError:
        # Document is hosted externally (eg, S3)
        local_path = None

    if local_path:
        # Give error if document file doesn't exist
        if not os.path.isfile(local_path):
            messages.error(
                request,
                _("The file could not be found. Please change the source or delete the document"),
                buttons=[messages.button(reverse('wagtaildocs:delete', args=(doc.id,)), _('Delete'))]
            )

    return render(request, "wagtaildocs/documents/edit.html", {
        'document': doc,
        'filesize': doc.get_file_size(),
        'form': form,
        'user_can_delete': permission_policy.user_has_permission_for_instance(
            request.user, 'delete', doc
        ),
    })
Esempio n. 24
0
    def test_inserts_object(self, backend):
        obj = models.Book.objects.create(title="Test",
                                         publication_date=date(2017, 10, 18),
                                         number_of_pages=100)
        backend().reset_mock()

        index.insert_or_update_object(obj)

        backend().add.assert_called_with(obj)
Esempio n. 25
0
 def create_image(self, image_file, title, filename, tag):
     image = Image(title=title)
     image.file = ImageFile(file=image_file, name=filename)
     image.file_size = image.file.size
     image.file.seek(0)
     image._set_file_hash(image.file.read())
     image.file.seek(0)
     # Reindex the image to make sure all tags are indexed
     search_index.insert_or_update_object(image)
     image.save()
     image.tags.add(tag)
     return image
Esempio n. 26
0
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
        }
    )
Esempio n. 27
0
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 test_converts_to_specific_page(self, backend):
        root_page = Page.objects.get(id=1)
        page = root_page.add_child(instance=SimplePage(title="test", slug="test", content="test"))

        # Convert page into a generic "Page" object and add it into the index
        unspecific_page = page.page_ptr

        backend().reset_mock()

        index.insert_or_update_object(unspecific_page)

        # It should be automatically converted back to the specific version
        backend().add.assert_called_with(page)
    def test_catches_index_error(self, backend):
        obj = models.Book.objects.create(title="Test", publication_date=date(2017, 10, 18), number_of_pages=100)

        backend().add.side_effect = ValueError("Test")
        backend().reset_mock()

        with self.assertLogs('wagtail.search.index', level='ERROR') as cm:
            index.insert_or_update_object(obj)

        self.assertEqual(len(cm.output), 1)
        self.assertIn("Exception raised while adding <Book: Test> into the 'default' search backend", cm.output[0])
        self.assertIn("Traceback (most recent call last):", cm.output[0])
        self.assertIn("ValueError: Test", cm.output[0])
Esempio n. 30
0
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
                                 })
Esempio n. 31
0
    def test_converts_to_specific_page(self, backend):
        root_page = Page.objects.get(id=1)
        page = root_page.add_child(
            instance=SimplePage(title="test", slug="test", content="test"))

        # Convert page into a generic "Page" object and add it into the index
        unspecific_page = page.page_ptr

        backend().reset_mock()

        index.insert_or_update_object(unspecific_page)

        # It should be automatically converted back to the specific version
        backend().add.assert_called_with(page)
Esempio n. 32
0
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)
Esempio n. 33
0
    def save_form(self, form):
        document = form.instance
        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 document
Esempio n. 34
0
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())
Esempio n. 35
0
def update_index(arguments):
    # the spooler is forked so the db connection might be closed
    if not connection.is_usable():
        connection.close()

    category_id = arguments.get("category_id")
    product_id = arguments.get("product_id")

    if category_id is not None:
        products = ProductProxy.objects.filter(categories__id=category_id)
        for product in products:
            index.insert_or_update_object(product)

    if product_id is not None:
        product = ProductProxy.objects.get(pk=product_id)
        index.insert_or_update_object(product)
Esempio n. 36
0
    def test_catches_index_error(self, backend):
        obj = models.Book.objects.create(title="Test",
                                         publication_date=date(2017, 10, 18),
                                         number_of_pages=100)

        backend().add.side_effect = ValueError("Test")
        backend().reset_mock()

        with self.assertLogs('wagtail.search.index', level='ERROR') as cm:
            index.insert_or_update_object(obj)

        self.assertEqual(len(cm.output), 1)
        self.assertIn(
            "Exception raised while adding <Book: Test> into the 'default' search backend",
            cm.output[0])
        self.assertIn("Traceback (most recent call last):", cm.output[0])
        self.assertIn("ValueError: Test", cm.output[0])
Esempio n. 37
0
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', 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)

    images = Image.objects.order_by('-created_at')
    paginator, images = paginate(request, images, per_page=12)

    return render_modal_workflow(
        request, 'wagtailimages/chooser/chooser.html', None,
        {'images': images, 'uploadform': form, 'searchform': searchform},
        json_data=get_chooser_context()
    )
Esempio n. 38
0
def chooser_upload(request):
    Media = get_media_model()
    MediaForm = get_media_form(Media)

    if request.method == 'POST':
        media = Media(uploaded_by_user=request.user)
        form = MediaForm(request.POST,
                         request.FILES,
                         instance=media,
                         user=request.user)

        if form.is_valid():
            form.save()
            # Reindex the media to make sure all tags are indexed
            search_index.insert_or_update_object(media)

            return render_modal_workflow(request,
                                         None,
                                         None,
                                         None,
                                         json_data={
                                             'step': 'media_chosen',
                                             'result':
                                             get_media_result_data(media)
                                         })
    else:
        form = MediaForm(user=request.user)

    media_files = Media.objects.order_by('-created_at')

    # allow hooks to modify the queryset
    for hook in hooks.get_hooks('construct_media_chooser_queryset'):
        media_files = hook(media_files, request)

    paginator, media_files = paginate(request, media_files, per_page=12)

    context = get_chooser_context(request)
    context.update({
        'media_files': media_files,
        'uploadform': form,
    })
    return render_modal_workflow(request,
                                 'wagtailmedia/chooser/chooser.html',
                                 None,
                                 context,
                                 json_data=get_chooser_js_data())
Esempio n. 39
0
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}
    )
Esempio n. 40
0
    def save(self, commit=True):
        if "file" in self.changed_data:
            self.instance._set_image_file_metadata()

        super().save(commit=commit)

        if commit:
            if "file" in self.changed_data and self.original_file:
                # if providing a new image file, delete the old one and all renditions.
                # NB Doing this via original_file.delete() clears the file field,
                # which definitely isn't what we want...
                self.original_file.storage.delete(self.original_file.name)
                self.instance.renditions.all().delete()

            # Reindex the image to make sure all tags are indexed
            search_index.insert_or_update_object(self.instance)

        return self.instance
Esempio n. 41
0
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 get_document_chosen_response(request, document)
    else:
        form = DocumentForm(user=request.user,
                            prefix="document-chooser-upload")

    return render_modal_workflow(
        request,
        None,
        None,
        None,
        json_data={
            "step":
            "reshow_upload_form",
            "htmlFragment":
            render_to_string("wagtaildocs/chooser/upload_form.html",
                             {"form": form}, request),
        },
    )
Esempio n. 42
0
    def handle(self, *args, **options):
        self.stdout.write(self.style.SUCCESS("Importing images"))

        with open(options["speakers_csv"], "r") as file:
            for row in DictReader(file):
                if not row["filename"]:
                    self.stdout.write(
                        self.style.WARNING(
                            f"====> skipping {row['post_name']}, {row['post_title']}"
                        ))
                    continue
                image_path = os.path.join(options["from_dir"], row["filename"])
                with open(image_path, "rb") as image_file:
                    image = Image(title=row["post_title"])
                    if row["filename"].lower().endswith(".jpg") or row[
                            "filename"].lower().endswith(".jpeg"):
                        image_filename = f"{row['first_name']} {row['last_name']}.jpg"
                    elif row["filename"].lower().endswith(".png"):
                        image_filename = f"{row['first_name']} {row['last_name']}.png"
                    else:
                        raise ValueError("Unknown file format")
                    image.file = ImageFile(file=image_file,
                                           name=image_filename)
                    image.file_size = image.file.size

                    image.file.seek(0)
                    image._set_file_hash(image.file.read())
                    image.file.seek(0)

                    # Reindex the image to make sure all tags are indexed
                    search_index.insert_or_update_object(image)
                    image.save()
                    image.tags.add("speaker")

                    speaker = Speaker.objects.get(wordpress_id=row["ID"])
                    speaker.photo = image
                    speaker.save()

                    self.stdout.write(
                        self.style.SUCCESS(f"{image.pk},{image.title}"))

        self.stdout.write(self.style.SUCCESS("Importing images finished"))
Esempio n. 43
0
def edit(request, image_id):
    Image = get_image_model()
    ImageForm = get_image_form(Image)

    image = get_object_or_404(Image, id=image_id)

    if not permission_policy.user_has_permission_for_instance(
            request.user, 'change', image):
        return permission_denied(request)

    if request.method == 'POST':
        original_file = image.file
        form = ImageForm(request.POST,
                         request.FILES,
                         instance=image,
                         user=request.user)
        if form.is_valid():
            if 'file' in form.changed_data:
                # Set new image file size
                image.file_size = image.file.size

                # Set new image file hash
                image.file.seek(0)
                image._set_file_hash(image.file.read())
                image.file.seek(0)

            form.save()

            if 'file' in form.changed_data:
                # if providing a new image file, delete the old one and all renditions.
                # NB Doing this via original_file.delete() clears the file field,
                # which definitely isn't what we want...
                original_file.storage.delete(original_file.name)
                image.renditions.all().delete()

            # Reindex the image to make sure all tags are indexed
            search_index.insert_or_update_object(image)

            messages.success(request,
                             _("Image '{0}' updated.").format(image.title),
                             buttons=[
                                 messages.button(
                                     reverse('wagtailimages:edit',
                                             args=(image.id, )),
                                     _('Edit again'))
                             ])
            return redirect('wagtailimages:index')
        else:
            messages.error(request,
                           _("The image could not be saved due to errors."))
    else:
        form = ImageForm(instance=image, user=request.user)

    # Check if we should enable the frontend url generator
    try:
        reverse('wagtailimages_serve', args=('foo', '1', 'bar'))
        url_generator_enabled = True
    except NoReverseMatch:
        url_generator_enabled = False

    if image.is_stored_locally():
        # Give error if image file doesn't exist
        if not os.path.isfile(image.file.path):
            messages.error(
                request,
                _("The source image file could not be found. Please change the source or delete the image."
                  ).format(image.title),
                buttons=[
                    messages.button(
                        reverse('wagtailimages:delete', args=(image.id, )),
                        _('Delete'))
                ])

    try:
        filesize = image.get_file_size()
    except SourceImageIOError:
        filesize = None

    return render(
        request, "wagtailimages/images/edit.html", {
            'image':
            image,
            'form':
            form,
            'url_generator_enabled':
            url_generator_enabled,
            'filesize':
            filesize,
            'user_can_delete':
            permission_policy.user_has_permission_for_instance(
                request.user, 'delete', image),
        })
Esempio n. 44
0
def edit(request, image_id):
    Image = get_image_model()
    ImageForm = get_image_form(Image)

    image = get_object_or_404(Image, id=image_id)

    if not permission_policy.user_has_permission_for_instance(request.user, 'change', image):
        return permission_denied(request)

    if request.method == 'POST':
        original_file = image.file
        form = ImageForm(request.POST, request.FILES, instance=image, user=request.user)
        if form.is_valid():
            if 'file' in form.changed_data:
                # Set new image file size
                image.file_size = image.file.size

            form.save()

            if 'file' in form.changed_data:
                # if providing a new image file, delete the old one and all renditions.
                # NB Doing this via original_file.delete() clears the file field,
                # which definitely isn't what we want...
                original_file.storage.delete(original_file.name)
                image.renditions.all().delete()

            # Reindex the image to make sure all tags are indexed
            search_index.insert_or_update_object(image)

            messages.success(request, _("Image '{0}' updated.").format(image.title), buttons=[
                messages.button(reverse('wagtailimages:edit', args=(image.id,)), _('Edit again'))
            ])
            return redirect('wagtailimages:index')
        else:
            messages.error(request, _("The image could not be saved due to errors."))
    else:
        form = ImageForm(instance=image, user=request.user)

    # Check if we should enable the frontend url generator
    try:
        reverse('wagtailimages_serve', args=('foo', '1', 'bar'))
        url_generator_enabled = True
    except NoReverseMatch:
        url_generator_enabled = False

    if image.is_stored_locally():
        # Give error if image file doesn't exist
        if not os.path.isfile(image.file.path):
            messages.error(request, _(
                "The source image file could not be found. Please change the source or delete the image."
            ).format(image.title), buttons=[
                messages.button(reverse('wagtailimages:delete', args=(image.id,)), _('Delete'))
            ])

    return render(request, "wagtailimages/images/edit.html", {
        'image': image,
        'form': form,
        'url_generator_enabled': url_generator_enabled,
        'filesize': image.get_file_size(),
        'user_can_delete': permission_policy.user_has_permission_for_instance(
            request.user, 'delete', image
        ),
    })