fet2020/fet2020/posts/views.py

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

from collections import deque
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework import viewsets
from taggit.models import Tag

from .models import Post, FetMeeting
from .serializers import PostSerializer
from documents.api import get_pad_link
from documents.etherpadlib import add_ep_cookie
from members.models import Member, JobMember

import logging

logger = logging.getLogger(__name__)


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

def index(request):
    posts = deque(Post.objects.get_visible_articles().order_by('-public_date'))

    def f(p):
        return p.tags
    t = map(f, posts)

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

def calendar(request):
    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()
    members = []

    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 '{}'. Error: {}".format(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 '{}'. Error: {}".format(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: {}".format(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


class PostViewSet(viewsets.ModelViewSet):
    """
    API endpoint that allows users to be viewed or edited.
    """
    queryset = Post.objects.all().order_by('-public_date')
    serializer_class = PostSerializer
    # permission_classes = [permissions.IsAuthenticated]
    filter_backends = [DjangoFilterBackend]
    filterset_fields = ['legacy_id', 'slug', 'legacy_rubrik_id']
    lookup_field = 'slug'

    def pre_save(self, obj):
        obj.image = self.request.FILES.get('image')