blog

  annoying bug where the layout of the input fields cannot be reverted to the

  browser default, despite using a class for *exactly that fucking reason*. I'm

  currently too fed up to care about fixing that shit right now.

from .models import Post, Comment

admin.site.register(Post)

admin.site.register(Comment)

from django.utils import translation

from django.template.defaultfilters import slugify

from django.db import models

import datetime

import os

def post_title_directory(instance, filename):

    """ Files will be uploaded to MEDIA_ROOT/blog/<year of publishing>/<blog

    title>

    The blog title is determined by the text before the first period (".") in

    the filename. So if the file has the name "Trains are bæ.en.md", the file

    will be stored in "blog/<this year>/Trains are bæ". Name your files

    properly!

    It should also be noted that all files are stored in the same folder if they

    belong to the same blogpost, regardless of language. The titles that are

    displayed to the user however, should be the titles of the files themselves,

    which should be in the native language. So if a blog post is titled

    "Universities of Belgium", its Dutch counterpart should be titled

    "Universiteiten van België", so the correct title can be derived from the

    filename.

    Recommended way to name the uploaded file: "<name of blog post in language

    it's written>.org". This removes the maximum amount of redundancy (e.g. the

    language of the file can be derived from the title, no ".fr.org" or something

    like that necessary), and can directly be used for the end user (the title

    is what should be displayed).

    """

    english_file_name = os.path.basename(instance.english_file.name) # TODO: Test if this returns the file name!

    english_title = english_file_name.rpartition(".")[0]

    year = datetime.date.today().year

    return "blog/{0}/{1}/{2}".format(year, english_title, filename)

class Post(models.Model):

    """ Represents a blog post. The title of the blog post is determnined by the name

    of the files.

    A blog post can be in 5 different languages: German, Spanish, English, French,

    and Dutch. For all these languages, a seperate field exists. Thus, a

    translated blog post has a seperate file for each translation, and is

    seperated from Django's internationalization/localization system.

    Only the English field is mandatory. The others may contain a value if a

    translated version exists, which will be displayed accordingly.

    """

    published = models.DateTimeField(auto_now_add=True)

    english_file = models.FileField(upload_to=post_title_directory, unique=True, blank=False)

    dutch_file = models.FileField(upload_to=post_title_directory, blank=True)

    french_file = models.FileField(upload_to=post_title_directory, blank=True)

    german_file = models.FileField(upload_to=post_title_directory, blank=True)

    spanish_file = models.FileField(upload_to=post_title_directory, blank=True)

    # Only the English file can be unique, because apparantly, there can't be

    # two blank fields in a unique column. Okay then.

    def __str__(self):

        return self.slug("en")

    def slug(self, language_code=translation.get_language()):

        """ Returns a slug of the requested language, or None if no version exists in that language. """

        possibilities = {

            "en" : self.english_file,

            "de" : self.german_file,

            "nl" : self.dutch_file,

            "fr" : self.french_file,

            "es" : self.spanish_file,

            }

        if possibilities[language_code]:

            return slugify(os.path.basename(possibilities[language_code].name).rpartition(".")[0])

        else:

            return None

class Comment(models.Model):

    """ Represents a comment on a blog post.

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

    version.

    XXX: Remember to notify (tiny footnote or something) that comments showing

    date = models.DateTimeField(auto_now_add=True)

    name = models.CharField(max_length=64)

    text = models.TextField(max_length=1000)  # Should be more than enough.

    post = models.ForeignKey(

        Post,

        on_delete=models.CASCADE,

        null=False,

        )

    class meta:

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

{% load i18n %}

{% load static %}

{% block stylesheets %}

{{ block.super }}

{#<link href="{% static "blog/stylesheet.css" %}" rel="stylesheet" media="screen, projection" />#}

{% endblock %}

{% block title %}{% trans "Maarten's blog" %}{% endblock title %}

{% block description %}{% blocktrans %}The always coherently put together, yet

fuzzy blog of whatever sprouts in my mind.{% endblocktrans %}

{% endblock description %}

{% block main %}

{% with color="brown" accent_color="yellow" %}

<div class="section {{ color }} z-depth-3">

    <div class="container">

        <div class="white-text">

            <h3>{% trans "Blog" %}</h3>

            <p>

                {% blocktrans %}Welcome to my blog. Here, I write

                about things that interest me. Politics, coding,

                studying, life, or anything else I fancy rambling

                about. If you're in luck, I may've written it in a

                language that you understand better than English.

                {% endblocktrans %}

            </p>

        </div>

    </div>

</div>

<div class="container row">

    <div class="col s12 m6">

        <h1 id="weekly" class="{{ color }}-text">Weekly</h1>

        {% include "blog/weekly.html" %}

    </div>

    <div class="container col s12 m6">

        {% for title, date, blog_text, link in posts %}

            <h1 class="{{ color}}-text">{{ title }}</h2>

            <span class="grey-text">{{ date|date:"DATE_FORMAT" }}</span>

            <p class="hide-on-small-only">{{ blog_text|safe|truncatewords_html:100 }}</p>

            <a class="btn black-text waves-effect {{accent_color}} accent-4" href="{{link}}">

                📚 {% trans "Read on"%}

            </a>

            <hr />

        {% endfor %}

    </div>

</div>

{% endwith %}

{% endblock main %}

from . import views # Imports the views from the same directory (which is views.py).

urlpatterns = [

    url(r'^$', views.index, name='blog-index'),

    url(r'^(?P<language>(.){2})/(?P<post_slug>(.)+)$', views.post, name='blog-post-language'),

    url(r'^(?P<post_slug>(.)+)$', views.post, name='blog-post'),

        ]

import subprocess

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.core.urlresolvers import reverse

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

from .models import Post, Comment

from django.core.exceptions import ObjectDoesNotExist

from django.utils import translation

GERMAN = "de"

SPANISH = "es"

FRENCH = "fr"

DUTCH = "nl"

ENGLISH = "en"

footer_links = [

        [_("Blog main page"), "/blog"],

        [_("Contact"), "mailto:maarten.vangeneugden@student.uhasselt.be"],

        ]

footer_description = _("Maarten's personal blog, with sprinkles and a dollop of healthy bugs.")

# FIXME: Remove this template trash. THIS IS A VIEW, NOT A FUCKING TEMPLATE FFS

context = {

    'materialDesign_color': "green",

    'materialDesign_accentColor': "purple",

    'navbar_title': "Blog",

    'navbar_fixed': True,

    'navbar_backArrow': True,

    #'footer_title': "Maarten's blog",

    #'footer_description': "My personal scribbly notepad.",

    #'footer_links': footer_links,

    }

def org_to_html(file_path):

    """ 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!

    return subprocess.check_output(["pandoc", "--from=org", "--to=html", "/srv/django/website/media/"+file_path])

def get_available_post_languages(post):

    """ Returns the language codes for which a blog post exists. This function

    always returns English (because that field mustn't be empty).

    So say a blog post has an English, Dutch and French version (which means

    english_file, french_file and dutch_file aren't empty), the function will return {"en",

    "fr", "nl"}. """

    available_languages = {ENGLISH}

    if post.german_file != "":

        available_languages.add(GERMAN)

    if post.spanish_file != "":

        available_languages.add(SPANISH)

    if post.french_file != "":

        available_languages.add(FRENCH)

    if post.dutch_file != "":

        available_languages.add(DUTCH)

    return available_languages

def get_preferred_post_language(post, language):

    """ Returns the post language file that best suits the given language. This

    is handy if you know what language the user prefers, but aren't sure whether

    you can provide that language. This function will try to provide the file

    for that language, or return English if that's not possible. """

    if language == GERMAN and post.german_file is not None:

        return post.german_file

    if language == SPANISH and post.spanish_file is not None:

        return post.spanish_file

    if language == FRENCH and post.french_file is not None:

        return post.french_file

    if language == DUTCH and post.dutch_file is not None:

        return post.dutch_file

    return post.english_file  # Returned if all other choices wouldn't be satisfactory, or the requested language is English.

def index(request):

    template = "blog/index.html"

    posts = Post.objects.all()

    language = translation.get_language()

    post_links = []

    for post in posts:

        blog_file = get_preferred_post_language(post, language)

        # TODO: Find a cleaner way to determine the title. First and foremost:

        # If the language differs from English, the other language file needs to

        # be loaded. Plus: look for a built in function to remove the full path

        # and only return the file name.

        title = (blog_file.name.rpartition("/")[2]).rpartition(".")[0]

        human_title = title.replace("_"," ")

        date = post.published

        blog_text = org_to_html(blog_file.name)

        # TODO: The link can possibly be reversed in the DTL using the title, which is actually

        # a cleaner way to do it. Investigate.

        link = reverse("blog-post-language", args=[language, post.slug(language)])

        post_links.append([human_title, date, blog_text, link])

    context = {

            'posts': post_links,

            'materialDesign_color': "brown",

            'materialDesign_accentColor': "yellow",

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

            'navbar_backArrow': True,

            'footer_links': footer_links,

            'footer_description': footer_description,

            }

    return render(request, template, context)

def post(request, post_slug, language=None):

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

        form = CommentForm(request.POST)

        if form.is_valid():

            form.save()

    if language is not None:

        if translation.check_for_language(language):

            translation.activate(language)

            request.session[translation.LANGUAGE_SESSION_KEY] = language

            #return post(request, post_slug)

    else:

        language = translation.get_language()

    template = "blog/post.html"

    posts = Post.objects.all()

    #comments = Comment.objects.filter(post

    for post in posts:

        if post.slug(language) == post_slug:

            comments = Comment.objects.filter(post=post)

            form = CommentForm(initial={'post': post})

            blog_file = get_preferred_post_language(post, language)

            blog_text = org_to_html(blog_file.name)

            context = {

                'comments': comments,

                'form' : form,

                'human_post_title': blog_file.name.replace("_"," "),

                'materialDesign_color': "brown",

                'materialDesign_accentColor': "yellow",

                'article': blog_text,

                'title': str(blog_file),

                'navbar_title': ((blog_file.name.rpartition("/")[2]).rpartition(".")[0]).replace("_"," "),

                'navbar_backArrow': False,

                'post_slug': post_slug,

                'footer_links': footer_links,

                'footer_description': footer_description,

                }

            # Getting all available article links

            available = get_available_post_languages(post)

            if ENGLISH in available:

                context['english_link'] = reverse("blog-post-language", args=[ENGLISH, post.slug(ENGLISH)])

            if DUTCH in available:

                context['dutch_link'] = reverse("blog-post-language", args=[DUTCH, post.slug(DUTCH)])

            if FRENCH in available:

                context['french_link'] = reverse("blog-post-language", args=[FRENCH, post.slug(FRENCH)])

            if SPANISH in available:

                context['spanish_link'] = reverse("blog-post-language", args=[SPANISH, post.slug(SPANISH)])

            if GERMAN in available:

                context['german_link'] = reverse("blog-post-language", args=[GERMAN, post.slug(GERMAN)])

            return render(request, template, context)