blog

from django.contrib.auth.models import User  # For logging purposes

from django.utils import translation

from django.template.defaultfilters import slugify

from django.db import models

from django.conf import settings  # Necessary to get the link to the media root folder

from django.utils.translation import gettext as _

import pytz

import datetime

import os

import subprocess

from django.shortcuts import render as render_shortcut

""" New version:

- For each post, there's no longer a mandatory Dutch and English

  version. Instead, only the title needs to be in multiple languages.

- There's a new table for the links to the articles themselves. These include a

  language code and a foreign key to the post they belong to.

- If an article is available in the active language, but not tagged for the same

  dialect, then it should just show up without any warnings.

- If an article is not available in the active language, only the title should

  show up, but where the short intro text would normally be, there should be an

  explanation that it's only available in other languages, and provide links to

  those versions.

"""

# Look, you think this function is worthless, it's not. It's required to make

# migrations with manage.py, so here it stays, being empty and hollow like the

# piece of shit it is.

def post_title_directory():

    pass

class Post(models.Model):

    """ Represents a blog post."""

    published = models.DateTimeField(auto_now_add=True)

    visible = models.BooleanField(default=True, 

            help_text="Whether this post is shown in the index. If False, it's \

            only accessible by direct link.")

    # TODO: The titles should all be changed to 'unique=True' to avoid slug

    # collisions. But at this moment, there are still some posts that don't have

    # a title in all these languages (and "" collides with ""), so until that's

    # fixed, they're set to False.

    title_en = models.CharField(max_length=64, unique=False, blank=False)

    title_nl = models.CharField(max_length=64, unique=False, blank=False)

    title_fr = models.CharField(max_length=64, unique=False, blank=True)

    title_de = models.CharField(max_length=64, unique=False, blank=True)

    title_es = models.CharField(max_length=64, unique=False, blank=True)

    title_eo = models.CharField(max_length=64, unique=False, blank=True)

    title_af = models.CharField(max_length=64, unique=False, blank=True)

    title_nl_be=models.CharField(max_length=64, unique=False, blank=True)

    title_fr_be=models.CharField(max_length=64, unique=False, blank=True)

    def __str__(self):

        return self.title()

    def articles(self):

        #print(len(Article.objects.filter(post=self)))

        return Article.objects.filter(post=self)

    def article(self):

        language_code = translation.get_language()

        #print(language_code)

        # Retrieves all articles that have this post as their foreign key

        articles = Article.objects.filter(post=self)

        for a in articles:

            if a.language_code == language_code:

                return a

        # If no exact match was found, try again, but now accept other dialects

        # as well:

        for a in articles:

            if a.language_code.startswith(language_code):

                return a

        # If still no article was found, return None

        return None

    def title(self):

        language_code = translation.get_language()

        options = {'af': self.title_af,

                   'de': self.title_de,

                   'es': self.title_es,

                   'en': self.title_en,

                   'eo': self.title_eo,

                   'fr': self.title_fr,

                   'nl-be': self.title_nl_be,

                   'fr-be': self.title_fr_be,

                   'nl': self.title_nl}

        for code, translated_title in options.items():

            if language_code.startswith(code):

                return translated_title

        # If no return has happened, default to English

        return self.title_en

def org_to_html(file_path, slug, return_djhtml_path=False):

    """ Converts the given org formatted file to HTML.

    This function directly returns the resulting HTML code. This function uses

    the amazing Haskell library Pandoc to convert the file (and takes care

    of header id's and all that stuff).

    """

    # FIXME: Remove hardcoded link to media. Replace with media tag!

    # XXX: The reason I'm first converting all occurences of .jpg][ and .png][

    # to .jpgPANDOCBUG][ and .pngPANDOCBUG][, is because of a Pandoc bug that

    # removes the text links for images. It is afterwards converted back, no

    # worries.

    file = open(file_path, "r", encoding="utf-8")

    text = file.read()

    file.close()

    text = text.replace(".jpg][", ".jpgPANDOCBUG][")

    text = text.replace(".png][", ".pngPANDOCBUG][")

    file = open("/tmp/blog-file-"+slug+".org", "w", encoding="utf-8")

    file.write(text)

    file.close()

    # --wrap=none is necessary for the Article.headings method to function

    # properly, otherwise the heuristic fails on a regular basis

    html_text = subprocess.check_output(["pandoc", "--from=org", "--to=html", "--wrap=none", "/tmp/blog-file-"+slug+".org"])

    html_text = html_text.decode("utf-8").replace(".jpgPANDOCBUG", ".jpg")

    html_text = html_text.replace(".pngPANDOCBUG", ".png")

    # Detecting where the footnote section starts, and removing that tag

    html_text = html_text.replace('<aside id="footnotes" class="footnotes footnotes-end-of-document" role="doc-endnotes">\n<hr />', _("</section><section><h2>Footnotes</h2>"))

    html_text = html_text.replace('</aside>',"")

    #rendered_file_path = "file_path.rpartition('.')[0] + ".djhtml"

    rendered_file_path = "/tmp/blog-file-"+slug+".djhtml"

    rendered_file = open(rendered_file_path, "w", encoding="utf-8")

    rendered_file.write(html_text)

    rendered_file.close()

    if return_djhtml_path:

        return rendered_file_path

    else:

        return html_text

class Article(models.Model):

    AFRIKAANS = 'af'

    BELGIAN_FRENCH = 'fr-be'

    DUTCH = 'nl'

    ESPERANTO = 'eo'

    ENGLISH = 'en'

    FLEMISH = 'nl-be'

    FRENCH = 'fr'

    GERMAN = 'de'

    SPANISH = 'es'

    LANGUAGE_CODES = [

        (AFRIKAANS, 'Afrikaans'),

        (BELGIAN_FRENCH, 'Français (Belgique)'),

        (DUTCH, 'Nederlands'),

        (ESPERANTO, 'Esperanto'),

        (ENGLISH, 'English'),

        (FLEMISH, 'Vlaams'),

        (FRENCH, 'Français'),

        (GERMAN, 'Deutsch'),

        (SPANISH, 'Español')]

    visible = models.BooleanField(default=True)

    post = models.ForeignKey(Post, on_delete=models.CASCADE)

    language_code = models.CharField(max_length=16,

                                      choices = LANGUAGE_CODES,

                                      blank=False)

    # file_path shouldn't be unique, because the same article file could be used

    # for multiple dialects of the same language.

    file_path = models.FilePathField(path=settings.MEDIA_ROOT + "blog/articles/",

                                     blank=False)

    # Same reason, slug shouldn't be unique

    slug = models.SlugField(unique=False, blank=False, allow_unicode=True)

    title = models.CharField(max_length=64, unique=False, blank=True)

    def text(self):

        return org_to_html(self.file_path, self.slug)

    def djhtml_file(self):

        return org_to_html(self.file_path, self.slug, return_djhtml_path=True)

    def headings(self):

        """ Returns the headings and their slugs present in this article. Useful

        for building the navigation drawer. """

        text = self.text()

        headers = list()

        lines = text.splitlines()

        for line in lines:

            # Heuristic approach to collecting headers

            if "<h" in line and "id=" in line and "</h" in line:

                first_part, second_part = line.split(">", maxsplit=1)

                slug = first_part.split('"')[-2]

                header = second_part.split("<", maxsplit=1)[0]

                headers.append((header, slug))

        return headers

class Comment(models.Model):

    """ Represents a comment on a blog post.

    Comments are not filtered by language; a

    comment made by someone reading the article in Dutch, that's written in

    Dutch, will show up (unedited) for somebody whom's reading the Spanish

    version.

    """

    # Allows me to manually hide certain messages if need be

    visible = models.BooleanField(default=True)

    date = models.DateTimeField(auto_now_add=True)

    name = models.CharField(max_length=64, blank=True)

    text = models.TextField(max_length=10000, blank=False)  # Should be more than enough

    # reaction_to is null if it's not a reaction to an existing comment

    reaction_to = models.ForeignKey('Comment', on_delete=models.CASCADE,

            null=True, blank=True)

    # blank=True is also needed per the Django documentation:

    # For both string-based and non-string-based fields, you will also need to

    # set blank=True if you wish to permit empty values in forms, as the null

    # parameter only affects database storage.

    from_myself = models.BooleanField(

        help_text="""I trust myself, so if I write a comment, I should be able

        to use the entire HTML5 suite. Ticking this box activates the DTL "safe"

        tag, instead of the "urlize" tag used for normal comments.""",

        default=False)

    post = models.ForeignKey(

        Post,

        on_delete=models.CASCADE,

        null=False,

        )

    class meta:

        ordering = ['date']  # When printed, prints the oldest comment first.

    def reactions(self):

        # Should return the comments that are a reaction to this comment

        return Comment.objects.filter(reaction_to=self).order_by('-date')

    def __str__(self):

        return str(self.id) +" | "+ self.name

    def is_new(self):

        # True if this comment was created less than one minute ago.

        now = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)

        delta = now-self.date

        return delta.seconds < 60

class FeedItem(models.Model):

    """ An item that shows up in the RSS feed."""

    title = models.CharField(max_length=64)

    added = models.DateTimeField(auto_now_add=True)

    description = models.CharField(max_length=400)

    link = models.URLField()