Source code for eucrim.issue.forms

# SPDX-FileCopyrightText: 2024 Thomas Breitner <t.breitner@csl.mpg.de>
#
# SPDX-License-Identifier: EUPL-1.2

from django.core.files.base import ContentFile
from wagtail.admin.forms import WagtailAdminPageForm

from eucrim.core.utils import generate_cover_image
from .utils import (
    canonical_issue_filename,
    extract_focuses,
    generate_wordcloud,
)




class IssueForm(WagtailAdminPageForm):
    """
    Override the standard WagtailAdminPageForm for custom validation
    that appears as a non-field error
    see: http://docs.wagtail.io/en/stable/advanced_topics/customisation/page_editing_interface.html#customising-generated-forms  # noqa: E501
    """



    def clean(self):
        from .models import IssueIndexPage

        cleaned_data = super().clean()

        _slug = canonical_issue_filename(
            cleaned_data["year"],
            cleaned_data["issue_number"],
        )

        cleaned_data.update(
            {
                "_slug": _slug,
            }
        )

        if cleaned_data["pdf"]:
            try:
                cover_filename = canonical_issue_filename(
                    cleaned_data["year"],
                    cleaned_data["issue_number"],
                    "jpg",
                )

                _cover_obj = cleaned_data["pdf"]

                # TODO: Remove this call+method+model field in favor of convert_pdf2imagefile and cover_image
                # Generate bitmap cover file from uploaded pdf:
                # cover_bitmap_obj = convert_pdf2bitmap(_cover_obj)

                # Extract cover bitmap from pdf file:
                _cover_obj.seek(0)
                cover_image = generate_cover_image(_cover_obj, cover_filename)

                # Generate wordcloud for issue:
                _cover_obj.seek(0)
                _pdf_contentfile = ContentFile(_cover_obj.file.read())

                stopwords = IssueIndexPage.objects.live().first().wordcloud_stopwords
                stopwords = stopwords.splitlines()
                stopwords = [stopword.strip() for stopword in stopwords]
                stopwords = list(filter(bool, stopwords))
                stopwords = set(stopwords)
                # Case sensitivity?

                _pdf_contentfile.seek(0)
                generate_wordcloud(_pdf_contentfile, _slug, custom_stopwords=stopwords)

                # Extract focuses/titles/toc from uploaded pdf:
                _pdf_contentfile.seek(0)
                (
                    focus_en,
                    focus_fr,
                    focus_ge,
                    _unused_legacy_toc,
                    error_focuses,
                ) = extract_focuses(_pdf_contentfile)

                if error_focuses:
                    self.add_error("pdf", error_focuses)

            except KeyError:
                pass

            else:
                cleaned_data.update(
                    {
                        # "cover_bitmap_obj": cover_bitmap_obj,
                        # "cover_filename": cover_filename,
                        "focus_en": focus_en,
                        "focus_fr": focus_fr,
                        "focus_ge": focus_ge,
                        "cover_image": cover_image,
                    }
                )

        return cleaned_data




    def save(self, commit=True):
        page = super().save(commit=False)

        # Save data to instance:
        page.title = self.cleaned_data["_slug"]
        page.slug = self.cleaned_data["_slug"]

        try:
            page.focus_en = self.cleaned_data["focus_en"]
            page.focus_fr = self.cleaned_data["focus_fr"]
            page.focus_ge = self.cleaned_data["focus_ge"]
            page.cover_image = self.cleaned_data["cover_image"]
        except KeyError:
            # These attributes/keys do not exist if a IssuePage without
            # a PDF file is saved.
            pass

        # TODO: Delete page.cover.save block when page.cover_image is final
        # I don't know why, but I need `save=False` - otherwise a new instance
        # will not get saved...
        # page.cover.save(
        #     self.cleaned_data["cover_filename"],
        #     self.cleaned_data["cover_bitmap_obj"],
        #     save=False,
        # )

        if commit:
            page.save()
            page.save_revision().publish()

        return page