blog

from django.forms import ModelForm

from . import models

class CommentForm(ModelForm):

    class Meta:

        model = models.Comment

        fields = ['name',

                  'reaction_to',

                  ]

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

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.")

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

    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, 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.org", "w", encoding="utf-8")

    file.write(text)

    file.close()

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

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

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

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

    rendered_file_path = "/tmp/blog-file.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)

    def djhtml_file(self):

        return org_to_html(self.file_path, return_djhtml_path=True)

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)

    from_myself = models.BooleanField(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')

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()

{% load humanize %}

<div class="comment" id="reago-{{ comment.id }}">

    <p><a href="#reago-{{ comment.id }}">#{{ comment.id }}</a>

        {{ comment.name }} |

        {{ comment.date|naturaltime }} 

       ({{ comment.date|date:"SHORT_DATE_FORMAT" }})

    </p>

    <p>{{ comment.text|urlize }}</p>

    <details>

        <summary>{% translate "Respond" %}</summary>

        <form method="POST">

            {% csrf_token %}

            <input type="hidden" name="reaction_to" value="{{ comment.id }}">

            <input type="text" id="name-{{ comment.id }}" name="name" maxlength="64" required>

            <label for="name-{{ comment.id }}">{% translate "Your name" %}</label><br>

            <textarea name="text" id="text-{{ comment.id }}" maxlength="10000" required></textarea>

            <label for="text-{{ comment.id }}">{% translate "Your comment" %}</label><br>

            <input type="submit" value="{% translate "Submit" %}">

        </form>

    </details>

    {% for subcomment in comment.reactions %}

        {% include "blog/comment.djhtml" with comment=subcomment %}

    {% endfor %}

</div>

{% load humanize %}

{% load i18n %}

{% load static %}

{% block stylesheets %}

{{ block.super }}

<style>

@font-face {

  font-family: 'Merriweather';

  font-style: italic;

  font-weight: 400;

  src: url({% get_static_prefix %}fonts/merriweather-400-italic.woff2) format('woff2');

  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;

}

@font-face {

  font-family: 'Merriweather';

  font-style: normal;

  font-weight: 400;

  src: url({% get_static_prefix %}fonts/merriweather-400-regular.woff2) format('woff2');

  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;

}

@font-face {

  font-family: 'Merriweather';

  font-style: normal;

  font-weight: 700;

  src: url({% get_static_prefix %}fonts/merriweather-700-regular.woff2) format('woff2');

  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;

}

body {

    background-color: #0d1521; /*#0d47a1; /* Material blue P900 */

}

body video {

    width: 80%;

}

header {

    background-color: #3e2723;

}

section.article {

    background-color: #efebe9;/*rgb(210, 188, 157);*/

    font-family: Merriweather, serif;

}

</style>

{% endblock stylesheets %}

{% block description %}

{{ article.text|safe|truncatewords_html:10 }}

{% endblock description %}

{% block title %}📚 {{ navbar_title }}{% endblock title %}

{% block header %}

<header>

<h1>{{ navbar_title }}</h1>

</header>

{% endblock header %}

{% block main %}

<section class="article">

    <!--<article style="font-family:serif;">-->

    {#{{ article.text|safe }}#}

    {% include "/tmp/django-templates/blog-file.djhtml" %}

    <!--</article>-->

</section>

<section class="reagoj">

    <h2>{% translate "Comments" %}</h2>

    <form method="POST">

        {% csrf_token %}

        <input type="hidden" name="reaction_to" value="">

        <input type="text" id="name-root" name="name" maxlength="64" required>

        <label for="name-root">{% translate "Your name" %}</label><br>

        <textarea name="text" id="text-root" maxlength="10000" required></textarea>

        <label for="text-root">{% translate "Your comment" %}</label><br>

        <input type="submit" value="{% translate "Submit" %}">

    </form>

    <hr>

    {% for root_comment in root_comments %}

        {% include "blog/comment.djhtml" with comment=root_comment %}

    {% endfor %}

</section>

{% comment %}

<h5 class="white-text">{% trans "This article in other languages" %}</h5>

{% get_language_info for 'nl' as LANG %}

<a {% if dutch_link %} href="{{dutch_link}}" {% endif %}

   class="btn fill

   {% if not dutch_link %}disabled{% endif %}">

    🇧🇪 {{ LANG.name_translated}} 🇳🇱

</a>

{% get_current_language as lang %}

{% get_language_info for 'fr' as LANG %}

<a {% if french_link %} href="{{french_link}}" {% endif %}

   class="btn fill

   {% if not french_link %}disabled{% endif %}">

    🇧🇪 {{ LANG.name_translated}} 🇫🇷

</a>

{% get_language_info for 'en' as LANG %}

<a {% if english_link %} href="{{english_link}}" {% endif %}

   class="btn fill

   {% if not english_link %}disabled{% endif %}">

    🇬🇧 {{ LANG.name_translated}} 🇺🇸

</a>

{% get_language_info for 'de' as LANG %}

<a {% if german_link %} href="{{german_link}}" {% endif %}

   class="btn fill

   {% if not german_link %}disabled{% endif %}">

    🇧🇪 {{ LANG.name_translated}} 🇩🇪

</a>

{% get_language_info for 'es' as LANG %}

<a {% if spanish_link %} href="{{spanish_link}}" {% endif %}

   class="btn

   {% if not spanish_link %}disabled{% endif %}">

    🇪🇸 {{ LANG.name_translated}} 🇲🇽

</a>

{% endcomment %}

<h5 class="white-text">{% trans "Comments" %}</h5>

<a href="{% url 'blog-post' post_slug %}" class="btn {{accent_color}} accent-4 black-text tooltipped" data-position="bottom" data-delay="50" data-tooltip="{% trans "Multilingual link. Links to the version in the viewer's preferred language." %}">🏳️‍🌈 {% trans "All available languages" %}</a>

    {# TODO: Change to rainbow flag when possible #}

{% endcomment %}

    </div>

</div>

{% endblock main %}

import requests

from django.utils.translation import ugettext as _

from django.shortcuts import get_object_or_404, render # This allows to render the template with the view here. It's pretty cool and important.

from django.http import HttpResponseRedirect, HttpResponse

from django.urls import reverse

from django.template import loader # This allows to actually load the template.

from .models import *

from .forms import CommentForm

from django.core.exceptions import ObjectDoesNotExist

from django.utils import translation

GERMAN = "de"

SPANISH = "es"

FRENCH = "fr"

DUTCH = "nl"

ENGLISH = "en"

def generate_comments_section(post, comment=None):

    template = "blog/index.djhtml"

    posts = Post.objects.exclude(visible=False)

    context = {

            'posts': posts,

            'navbar_title': _("Notepad from a student"),

            'navbar_backArrow': True,

            'stylesheet_name': "blog",

            }

    return render(request, template, context)

def post(request, language_code, post_slug):

    if request.method == "POST":  # Handling a reply if one is sent

        form = CommentForm(request.POST)

        for post in Post.objects.all():

            new_comment = form.save(commit=False)

            for post in Post.objects.all():

    template = "blog/post.djhtml"

    article = Article.objects.get(slug=post_slug, language_code=language_code)

    root_comments = Comment.objects.filter(post=article.post, reaction_to=None)

    context = {

            'article': article,

            'navbar_title': article.post.title(),

            'title': article.post.title(),

            'navbar_title': article.post.title(),

            'navbar_backArrow': True,

            'stylesheet_name': "blog"}

    return render(request, template, context)

def rss(request):

    template = "blog/feed.rss"

    context = {

        'items': FeedItem.objects.all(),

        }

    return render(request, template, context, content_type="application/rss+xml")

def archive(request):

    template = "blog/monthly_archive.djhtml"

    language = translation.get_language()

    file_2017 = org_to_html("blog/weekly/2017.org")