rewrite export coursebook

Author: tobi-werner

content/models.py

@@ -2,10 +2,9 @@
 from django.utils.translation import gettext_lazy as _
 
 from base.models import Content
-from export.mixins import ExportCoursebookMixin
 
 
-class YTVideoContent(models.Model, ExportCoursebookMixin):
+class YTVideoContent(models.Model):
     TYPE = "YouTubeVideo"
     DESC = _("YouTube Video")
 
@@ -23,14 +22,8 @@ def id(self):
     def __str__(self):
         return f"{self.DESC}: {self.url}"
 
-    def generate_latex_template(self):
-        return r"""
-        \href{""" + str(self.url) + """}{""" + str(self.url) + """}
-        \\newline
-        """
 
-
-class ImageContent(models.Model, ExportCoursebookMixin):
+class ImageContent(models.Model):
     TYPE = "Image"
     DESC = _("Single Image")
 
@@ -46,15 +39,6 @@ class Meta:
     def __str__(self):
         return f"{self.content}: {self.image}"
 
-    def generate_latex_template(self):
-        return r"""
-        \begin{figure}[H]
-        \centering
-        \includegraphics[width=\textwidth]{""" + str(self.image.path) + r"""}
-        \caption{""" + str(self.content.description) + r"""}
-        \end{figure}
-        """
-
 
 CONTENT_TYPES = {
     YTVideoContent.TYPE: YTVideoContent,

content/templates/content/export/Image.tex

@@ -0,0 +1,2 @@
+\textbf{This is an image}
+{{content.description}}

content/templates/content/export/YouTubeVideo.tex

@@ -0,0 +1 @@
+\textbf{This is a YouTube video}

content/templates/content/export/base.tex

@@ -0,0 +1,23 @@
+{% load cc_export_tags %}
+{% autoescape off %}
+
+\documentclass[a4paper]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[ngerman]{babel}
+\usepackage[left=1cm, right=1cm, top=2cm, bottom=2cm]{geometry}
+
+\begin{document}
+
+    \title{ {{ course.title|tex_escape }} }
+    \author{ {{user|tex_escape}} }
+    \maketitle
+
+    {% for content in contents %}
+        \input{ {{ content.type|export_template }} }
+    {% endfor %}
+
+\end{document}
+
+{% endautoescape %}

content/templates/content/export/invalid.tex

@@ -0,0 +1 @@
+\textit{This content type is supported at the moment.}

export/helper_functions.py

@@ -1,91 +1,31 @@
 import os
-from django.conf import settings
-from base.models.coursebook import Favorite
-from content.models import CONTENT_TYPES
+import shutil
+import tempfile
+from subprocess import Popen, PIPE
 
+from django.template.loader import get_template
 
-def generate_coursebook_for(user, course):
-    """
-    Generates a pdf file of a coursebook
-    :param user: the user which exports the coursebook
-    :param course: the course containing the coursebook
-    :return: filepath of the generated pdf file
-    """
-    file_directory = os.path.join(settings.BASE_DIR, "media", "coursebooks")
-    filename = "Coursebook_" + str(user) + "_" + str(course)
-    file_path = os.path.join(file_directory, filename)
-
-    if not os.path.exists(file_directory):
-        os.makedirs(file_directory)
-
-    latex_document_string = generate_latex_head(course.title, user)
-
-    # sort contents by topic
-    contents = [favorite.content for favorite in Favorite.objects.filter(user=user.profile, course=course)]
-    contents = sorted(contents, key=lambda c: c.topic.title)
-
-    # save the last topic to generate a new section for each topic
-    last_topic = None
-    for content in contents:
-        content_type = content.type
-        if last_topic != content.topic:
-            last_topic = content.topic
-            latex_document_string += generate_latex_section(content.topic.title)
-
-        if content_type in CONTENT_TYPES:
-            content_type_object = CONTENT_TYPES.get(content_type).objects.get(pk=content.pk)
-            latex_document_string += content_type_object.generate_latex_template()
-        else:
-            latex_document_string += generate_latex_invalid_content_type(content_type)
-
-    latex_document_string += generate_latex_end()
-
-    # write data into tex file
-    with open(file_path + '.tex', 'w+') as file:
-        file.write(latex_document_string)
-        file.close()
-
-    # convert tex file into pdf
-    bash_convert = "pdflatex -no-file-line-error -halt-on-error -output-directory='" + \
-                   file_directory + "' " \
-                   + file_path + ".tex"
-    bash_quiet = " > /dev/null"  # Quiet output in the shell
-    os.system(bash_convert + bash_quiet)  # run as shell command
-
-    # remove unnecessary files to save space
-    os.remove(file_path + ".tex")
-    os.remove(file_path + ".aux")
-    os.remove(file_path + ".log")
-    os.remove(file_path + ".out")
 
-    return file_path
-
-
-def generate_latex_head(title, author):
-    return r"""\documentclass{article}
-    \usepackage[T1]{fontenc}
-    \usepackage[utf8]{inputenc}
-    \usepackage{graphicx}
-    \usepackage{float}
-    \usepackage{grffile}
-    \usepackage{hyperref}
-
-    \title{""" + str(title) + r""" - Coursebook}
-    \author{""" + str(author) + r"""}
-    \date{\today}
-
-    \begin{document}
-    \maketitle
+class LaTeX:
     """
-
-
-def generate_latex_end():
-    return r"""\end{document}"""
-
-
-def generate_latex_invalid_content_type(content_type):
-    return r"""\textit{This type of content is not supported and cannot be displayed: """ + str(content_type) + """}"""
-
-
-def generate_latex_section(title):
-    return r"\section{" + str(title) + "}"
+    https://github.com/d120/pyophase/blob/master/ophasebase/helper.py
+    Retrieved 10.08.2020
+    """
+    @staticmethod
+    def render(context, template_name, assets, app='export', external_assets=None):
+        template = get_template(template_name)
+        rendered_tpl = template.render(context).encode('utf-8')
+        with tempfile.TemporaryDirectory() as tempdir:
+            # for asset in assets:
+            #     shutil.copy(os.path.dirname(os.path.realpath(__file__)) + '/../' + app + '/assets/' + asset, tempdir)
+            # if external_assets is not None:
+            #     for asset in external_assets:
+            #         shutil.copy(asset, tempdir)
+            process = Popen(['pdflatex'], stdin=PIPE, stdout=PIPE, cwd=tempdir, )
+            pdflatex_output = process.communicate(rendered_tpl)
+            try:
+                with open(os.path.join(tempdir, 'texput.pdf'), 'rb') as f:
+                    pdf = f.read()
+            except FileNotFoundError:
+                pdf = None
+        return pdf, pdflatex_output

export/mixins.py

@@ -0,0 +1,43 @@
+import os
+import re
+
+from django import template
+from django.template.defaultfilters import stringfilter
+from content.models import CONTENT_TYPES
+import content
+
+register = template.Library()
+
+
+@register.filter
+def export_template(type):
+    base_path = os.path.dirname(content.__file__)
+    path = base_path + f"/templates/content/export"
+    if type in CONTENT_TYPES.keys():
+        return path + f"/{type}.tex"
+    return path + "/invalid.tex"
+
+
+@register.filter
+@stringfilter
+def tex_escape(value):
+    """Escape characters with special meaning in LaTeX.
+    https://github.com/d120/pyophase/blob/master/ophasebase/templatetags/tex_escape.py
+    retrieved: 10.08.2020
+    """
+    replacements = {
+        '&': r'\&',
+        '%': r'\%',
+        '$': r'\$',
+        '#': r'\#',
+        '_': r'\_',
+        '{': r'\{',
+        '}': r'\}',
+        '~': r'\textasciitilde{}',
+        '^': r'\^{}',
+        '\\': r'\textbackslash{}',
+        '<': r'\textless{}',
+        '>': r'\textgreater{}',
+    }
+    regex = re.compile('|'.join(re.escape(key) for key in replacements))
+    return regex.sub(lambda match: replacements[match.group()], value)

export/templatetags/__init__.py

@@ -1,25 +1,34 @@
-from pathlib import Path
-from django.contrib import messages
-from django.http import HttpResponse, HttpResponseRedirect
-from django.urls import reverse
-from base.models import Course
-from export.helper_functions import generate_coursebook_for
-
-
-def generate_coursebook(request, *args, **kwargs):
-    """
-    Opens generated coursebook in a new tab
-    """
-    course_id = kwargs['pk']
-    course = Course.objects.get(pk=course_id)
+from django.http import HttpResponse
+from django.shortcuts import render
+
+from base.models import Course, Favorite
+from export.helper_functions import LaTeX
+
+
+def generate_coursebook(request, pk, template="content/export/base.tex", context=None):
+    """ Generates a PDF file with nametags for students in the queryset"""
+    if context is None:
+        context = {}
     user = request.user
+    course = Course.objects.get(pk=pk)
+    context['user'] = user
+    context['course'] = course
+    context['contents'] = [favorite.content for favorite in Favorite.objects.filter(user=user.profile, course=course)]
+    (pdf, pdflatex_output) = LaTeX.render(context, template, [])
+    return pdf, pdflatex_output
+
+
+def generate_coursebook_response(request, pk, filename='coursebook.pdf'):
+    """ Generates a PDF file with nametags for students in the queryset and sends it to the browser"""
+    (pdf, pdflatex_output) = generate_coursebook(request, pk)
+
+    return write_response(request, pdf, pdflatex_output, filename)
+
 
-    generated_file_path = generate_coursebook_for(user, course)
-    pdf_file_path = generated_file_path + '.pdf'
-    if Path(pdf_file_path).exists():
-        with open(pdf_file_path, 'rb') as file_handler:
-            response = HttpResponse(file_handler.read(), content_type="application/pdf")
-            file_handler.close()
-        return response
-    messages.error(request, 'There was an error while generating your coursebook.')
-    return HttpResponseRedirect(reverse('frontend:course', args=(course_id, )))
+def write_response(request, pdf, pdflatex_output, filename, content_type='application/pdf'):
+    if not pdf:
+        return render(request, "frontend/coursebook/rendering-error.html", {"content": pdflatex_output[0].decode("utf-8")})
+    response = HttpResponse(content_type=content_type)
+    response['Content-Disposition'] = 'attachment; filename=' + filename
+    response.write(pdf)
+    return response