paniktags.py

import email.utils
import datetime
import re
import time
import urllib2
import uuid

from django import template
from django.conf import settings
from django.db.models.query import QuerySet
from django.utils import simplejson
from datetime import datetime, timedelta
from django.views.generic.dates import _date_from_string

from emissions.utils import period_program

register = template.Library()

@register.filter(name='zip')
def zip_lists(a, b):
    return zip(a, b)

@register.inclusion_tag('includes/audio.html', takes_context=True)
def audio(context, sound=None):
    return {
        'episode': context.get('episode'),
        'sound': sound
    }

@register.inclusion_tag('news/nav.html', takes_context=True)
def news_nav(context, date=None):
    return {
        'newsitem': context.get('newsitem'),
        'news': context.get('news'),
    }

@register.inclusion_tag('emissions/nav.html', takes_context=True)
def emission_nav(context, date=None, klass=None):
    return {
        'class': klass,
        'categories': context.get('categories'),
        'episodes': context.get('episodes'),
        'emission': context.get('emission'),
        'episode': context.get('episode'),
    }

@register.inclusion_tag('episodes/resume.html', takes_context=True)
def episode_resume(context, date=None, model=None, klass=None):
    return {
        'model': model,
        'class': klass,
        'episode': context.get('episode'),
        'date': date,
    }

@register.inclusion_tag('episodes/detail.html', takes_context=True)
def episode_detail(context, date=None):
    return {
        'episode': context.get('episode'),
        'emission': context.get('emission'),
        'diffusions': context.get('diffusions'),
    }

@register.inclusion_tag('emissions/detail.html', takes_context=True)
def emission_detail(context, date=None):
    return {
        'emission': context.get('emission'),
        'schedules': context.get('schedules'),
    }

@register.inclusion_tag('emissions/resume.html', takes_context=True)
def emission_resume(context, date=None):
    return {
        'emission': context.get('emission'),
        'schedules': context.get('schedules'),
    }

@register.inclusion_tag('emissions/inline.html', takes_context=True)
def emission_inline(context, date=None):
    return {
        'emission': context.get('emission'),
        'schedules': context.get('schedules'),
    }

@register.inclusion_tag('includes/player.html', takes_context=False)
def player():
    return {'unique': uuid.uuid4()}

@register.inclusion_tag('includes/metaNav.html', takes_context=False)
def metanav():
    return {}

@register.inclusion_tag('includes/week.html', takes_context=True)
def weekview(context, year=None, week=None, weekday=None, fragment= None):
    year = year if year else datetime.today().year
    week = week if week else datetime.today().isocalendar()[1]-1
    weekday = weekday if weekday else datetime.today().weekday()
    date = _date_from_string(str(year), '%Y', '1', '%w', str(week), '%W')
    date = datetime(*date.timetuple()[:3])

    program = period_program(date, date+timedelta(days=7))
    days = []
    for day in range(7):
        days.append({'cells': [x for x in program if x.is_on_weekday(day+1)],
                     'datetime': date+timedelta(days=day)})
    return {
        'fragment': fragment,
        'days': days,
        'weekday': weekday,
        'week': week,
        'year': year,
    }

@register.inclusion_tag('news/inline.html', takes_context=False)
def news_inline(content=None, klass=None, logo=None):
    return {
            'content': content,
            'class': klass,
            'logo': logo
    }


@register.filter
def jsonify(object):
    if isinstance(object, QuerySet):
        return serialize('json', object)
    return simplejson.dumps(object)

@register.filter
def strreplace ( string, args ): 
    find  = args.split(',')[0]
    replace = args.split(',')[1]
    return string.replace(find,replace)

@register.filter
def replace ( string, args ): 
    search  = args.split(args[0])[1]
    replace = args.split(args[0])[2]

    return re.sub( search, replace, string )

@register.filter
def remove_tag_facet(url, facet):
    facet = urllib2.quote(facet.encode('utf-8'), safe='')
    return re.sub(r'&page=\d+', '', url.replace('&selected_facets=tags_exact:%s' % facet, ''))

@register.filter
def remove_category_facet(url, facet):
    facet = urllib2.quote(facet.encode('utf-8'), safe='')
    return re.sub(r'&page=\d+', '', url.replace('&selected_facets=categories_exact:%s' % facet, ''))


@register.filter
def append_tag_facet(url, facet):
    facet = urllib2.quote(facet.encode('utf-8'), safe='')
    return re.sub(r'&page=\d+', '', url + '&selected_facets=tags_exact:%s' % facet)

@register.filter
def append_category_facet(url, facet):
    facet = urllib2.quote(facet.encode('utf-8'), safe='')
    return re.sub(r'&page=\d+', '', url + '&selected_facets=categories_exact:%s' % facet)


@register.tag
def search_result_template(parser, token):
    try:
        tag_name, result_str = token.split_contents()
    except ValueError:
        raise template.TemplateSyntaxError("%r tag requires exactly one argument" % token.contents.split()[0])
    return FormatSearchResultNode(result_str)


class FormatSearchResultNode(template.Node):
    def __init__(self, result_str):
        self.result_var = template.Variable(result_str)

    def render(self, context):
        result = self.result_var.resolve(context)
        dir_mapping = {
            'newsitem': 'news',
            'emission': 'emissions',
            'episode': 'episodes'
        }
        t = template.loader.get_template('%s/search_result.html' % dir_mapping.get(result.model_name))
        return t.render(template.context.Context({'result': result}, autoescape=context.autoescape))


@register.inclusion_tag('includes/piwik.html')
def piwik():
    return {'enabled': settings.ENABLE_PIWIK}


@register.filter
def rfc822(datetime):
    if datetime is None:
        return ''
    return email.utils.formatdate(time.mktime(datetime.timetuple()))