fet2020/fet2020/posts/views.py

from collections import deque
import logging
from taggit.models import Tag

from django.shortcuts import render
from django.http import HttpResponse, JsonResponse, HttpResponseServerError
from django.utils.text import slugify
from django.utils import timezone

from documents.api import get_pad_link
from documents.etherpadlib import add_ep_cookie
from members.models import Member, JobMember


from .models import Post, FetMeeting


logger = logging.getLogger(__name__)


##################
# RENDERED VIEWS #
##################


def index(request):
    "Index von aktuellen Posts"
    posts = deque(Post.objects.get_visible_articles().order_by("-public_date"))

    taglist = map(lambda post: post.tags, posts)

    return render(request, "posts/index.html", {"posts": posts, "tags_list": taglist})


def calendar(request):
    "Kalender Ansicht ICS zur Verknüpfung mit Outlook"
    events = deque(Post.objects.all_post_with_date().all())

    return render(
        request,
        "posts/fet_calendar.ics",
        {"events": events},
        content_type="text/calendar",
    )


def tags(request, tag=""):
    posts = deque(Post.objects.get_visible_articles().filter(tags__name=tag))
    featured_post = Post.objects.get_visible_articles().filter(slug=tag).first()

    job_members = JobMember.active_member.get_all_by_slug(slug=tag)

    author_image = None
    if featured_post:
        post_author = Member.all_members.filter(nickname=featured_post.author).first()

        if post_author:
            author_image = post_author.image["avatar"].url

    context = {
        "posts": posts,
        "author_image": author_image,
        "featured_post": featured_post,
        "job_members": job_members,
        "tags_list": None,
    }

    return render(request, "posts/tag.html", context)


def show(request, id=None):
    if id.isdigit() or id is int:
        p = Post.objects.get(id=int(id))
    elif id != "" and id is not None:
        p = Post.objects.get(slug=(id))

    post_author = Member.all_members.filter(username=p.author).first()
    author_image = None
    author = None

    if post_author:
        author_image = post_author.image["avatar"].url
        author = post_author

    ep_agenda_link = "#"
    ep_protocol_link = "#"

    if p.has_agenda:  # and p.agenda_key:
        try:
            ep_agenda_link = get_pad_link(p.agenda_key)
        except Exception as e:
            logger.error(
                "Can't get the agenda link from '%s'. Error: %s", p.agenda_key, e
            )
            ep_agenda_link = "#"

    if p.has_protocol:  # and p.protocol_key:
        try:
            ep_protocol_link = get_pad_link(p.protocol_key)
        except Exception as e:
            logger.error(
                "Can't get the protocol link from '%s. Error: %s", p.protocol_key, e
            )
            ep_protocol_link = "#"

    context = {
        "post": p,
        "author": author,
        "author_image": author_image,
        "next": get_next_dict(p),
        "related_posts": p.tags.similar_objects()[:6],
        "ep_agenda_link": ep_agenda_link,
        "ep_protocol_link": ep_protocol_link,
    }

    response = render(request, "posts/show.html", context)

    # check if etherpad server works
    if ep_agenda_link or ep_protocol_link:
        try:
            response = add_ep_cookie(request, response)
        except Exception as e:
            logger.info("Etherpad Server doesn't work. Error: %s", e)

    return response


###########
# HELPERS #
###########


def slug_calc(request):
    """
    Ajax function that is called to calculate a slug from the title
    """
    if request.method == "GET":
        get = request.GET.copy()
        title = get["title"]

        datetime_now = timezone.now()
        date_str = datetime_now.strftime("%Y-%m-%d")

        slug_str = slugify(date_str) + "-" + slugify(title)

        return HttpResponse(slug_str)

    return HttpResponseServerError("Requires a title field.")


def tag_complete(request):
    """
    Ajax function that returns autocomplete suggestions for a given tag input
    """
    if request.method == "GET":
        get = request.GET.copy()
        term = get["term"]

        tag_objects = Tag.objects.filter(name__istartswith=term)

        tag_array = []
        for elem in tag_objects:
            tag_array.append(elem.name)

        return JsonResponse(tag_array, safe=False)

    return HttpResponseServerError("Requires a term field.")


def get_next_dict(post=None):
    # TODO: Docstring
    posts = None
    d = post.slug

    if post:
        # TODO: bad implementation but it works!!
        if post.post_type == "N" or post.post_type == "E":
            posts = Post.articles.get_visible_articles()
        elif post.post_type == "F":
            posts = FetMeeting.objects.get_queryset().order_by("-event_start")

    if posts:
        for k, v in enumerate(posts):
            if post.slug == v.slug:
                if (k + 1) < len(posts):
                    d = posts[k + 1].slug
                else:
                    d = posts[0].slug
                break

    return d