🗃️(backend) export to docx

We can now export our document to a docx file. This is done by converting the html to a docx file using the pypandoc and pandoc library. We added the "format" param to the generate-document endpoint, "format" accept "pdf" or "docx" as value.
2024-08-07 14:44:18 +02:00
parent ffaccad014
commit 4280f0779e
10 changed files with 147 additions and 32 deletions
--- a/src/backend/core/models.py
+++ b/src/backend/core/models.py
@@ -2,10 +2,13 @@
 Declare and configure the models for the impress core application
 """
 import hashlib
+import os
 import smtplib
+import tempfile
 import textwrap
 import uuid
 from datetime import timedelta
+from io import BytesIO
 from logging import getLogger

 from django.conf import settings
@@ -16,6 +19,7 @@ from django.core import exceptions, mail, validators
 from django.core.files.base import ContentFile
 from django.core.files.storage import default_storage
 from django.db import models
+from django.http import FileResponse
 from django.template.base import Template as DjangoTemplate
 from django.template.context import Context
 from django.template.loader import render_to_string
@@ -26,10 +30,10 @@ from django.utils.translation import override

 import frontmatter
 import markdown
+import pypandoc
+import weasyprint
 from botocore.exceptions import ClientError
 from timezone_field import TimeZoneField
-from weasyprint import CSS, HTML
-from weasyprint.text.fonts import FontConfiguration

 logger = getLogger(__name__)

@@ -564,10 +568,90 @@ class Template(BaseModel):
            "retrieve": can_get,
        }

-    def generate_document(self, body, body_type):
+    def generate_pdf(self, body_html, metadata):
        """
-        Generate and return a PDF document for this template around the
+        Generate and return a pdf document wrapped around the current template
+        """
+        document_html = weasyprint.HTML(
+            string=DjangoTemplate(self.code).render(
+                Context({"body": html.format_html(body_html), **metadata})
+            )
+        )
+        css = weasyprint.CSS(
+            string=self.css,
+            font_config=weasyprint.text.fonts.FontConfiguration(),
+        )
+
+        pdf_content = document_html.write_pdf(stylesheets=[css], zoom=1)
+        response = FileResponse(BytesIO(pdf_content), content_type="application/pdf")
+        response["Content-Disposition"] = f"attachment; filename={self.title}.pdf"
+
+        return response
+
+    def generate_word(self, body_html, metadata):
+        """
+        Generate and return a docx document wrapped around the current template
+        """
+        template_string = DjangoTemplate(self.code).render(
+            Context({"body": html.format_html(body_html), **metadata})
+        )
+
+        html_string = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <style>
+                {self.css}
+            </style>
+        </head>
+        <body>
+            {template_string}
+        </body>
+        </html>
+        """
+
+        reference_docx = "core/static/reference.docx"
+
+        # Convert the HTML to a temporary docx file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp_file:
+            output_path = tmp_file.name
+
+        pypandoc.convert_text(
+            html_string,
+            "docx",
+            format="html",
+            outputfile=output_path,
+            extra_args=["--reference-doc", reference_docx],
+        )
+
+        # Create a BytesIO object to store the output of the temporary docx file
+        with open(output_path, "rb") as f:
+            output = BytesIO(f.read())
+
+        # Remove the temporary docx file
+        os.remove(output_path)
+
+        output.seek(0)
+
+        response = FileResponse(
+            output,
+            content_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        )
+        response["Content-Disposition"] = f"attachment; filename={self.title}.docx"
+        return response
+
+    def generate_document(self, body, body_type, export_format):
+        """
+        Generate and return a document for this template around the
        body passed as argument.
+
+        2 types of body are accepted:
+        - HTML: body_type = "html"
+        - Markdown: body_type = "markdown"
+
+        2 types of documents can be generated:
+        - PDF: export_format = "pdf"
+        - Docx: export_format = "docx"
        """
        document = frontmatter.loads(body)
        metadata = document.metadata
@@ -580,16 +664,10 @@ class Template(BaseModel):
                markdown.markdown(textwrap.dedent(strip_body)) if strip_body else ""
            )

-        document_html = HTML(
-            string=DjangoTemplate(self.code).render(
-                Context({"body": html.format_html(body_html), **metadata})
-            )
-        )
-        css = CSS(
-            string=self.css,
-            font_config=FontConfiguration(),
-        )
-        return document_html.write_pdf(stylesheets=[css], zoom=1)
+        if export_format == "pdf":
+            return self.generate_pdf(body_html, metadata)
+
+        return self.generate_word(body_html, metadata)


 class TemplateAccess(BaseAccess):