mygpo/web/utils.py

   1 import re
   2 import string
   3 import collections
   4 from datetime import datetime
   5
   6 from django.utils.translation import ungettext
   7 from django.views.decorators.cache import never_cache
   8 from django.utils.html import strip_tags
   9 from django.core.urlresolvers import reverse
  10 from django.shortcuts import render
  11 from django.http import Http404
  12
  13 from babel import Locale, UnknownLocaleError
  14
  15 from mygpo.podcasts.models import Podcast
  16
  17
  18 def get_accepted_lang(request):
  19     """ returns a list of language codes accepted by the HTTP request """
  20
  21     lang_str = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
  22     lang_str = filter(lambda c: c in string.letters+',', lang_str)
  23     langs = lang_str.split(',')
  24     langs = [s[:2] for s in langs]
  25     langs = map(str.strip, langs)
  26     langs = filter(None, langs)
  27     return list(set(langs))
  28
  29
  30 RE_LANG = re.compile('^[a-zA-Z]{2}[-_]?.*$')
  31
  32
  33 def sanitize_language_code(lang):
  34     return lang[:2].lower()
  35
  36
  37 def sanitize_language_codes(ls):
  38     """
  39     expects a list of language codes and returns a unique lost of the first
  40     part of all items. obviously invalid entries are skipped
  41
  42     >>> sanitize_language_codes(['de-at', 'de-ch'])
  43     ['de']
  44
  45     >>> sanitize_language_codes(['de-at', 'en', 'en-gb', '(asdf', 'Deutsch'])
  46     ['de', 'en']
  47     """
  48
  49     ls = [sanitize_language_code(l) for l in ls if l and RE_LANG.match(l)]
  50     return list(set(ls))
  51
  52
  53 def get_language_names(lang):
  54     """
  55     Takes a list of language codes and returns a list of tuples
  56     with (code, name)
  57     """
  58     res = {}
  59     for l in lang:
  60         try:
  61             locale = Locale(l)
  62         except UnknownLocaleError:
  63             continue
  64
  65         if locale.display_name:
  66             res[l] = locale.display_name
  67
  68     return res
  69
  70
  71 def get_page_list(start, total, cur, show_max):
  72     """
  73     returns a list of pages to be linked for navigation in a paginated view
  74
  75     >>> get_page_list(1, 100, 1, 10)
  76     [1, 2, 3, 4, 5, 6, '...', 98, 99, 100]
  77
  78     >>> get_page_list(1, 100, 50, 10)
  79     [1, '...', 48, 49, 50, 51, '...', 98, 99, 100]
  80
  81     >>> get_page_list(1, 100, 99, 10)
  82     [1, '...', 97, 98, 99, 100]
  83
  84     >>> get_page_list(1, 3, 2, 10)
  85     [1, 2, 3]
  86     """
  87
  88     if show_max >= (total - start):
  89         return range(start, total+1)
  90
  91     ps = []
  92     if (cur - start) > show_max / 2:
  93         ps.extend(range(start, show_max / 4))
  94         ps.append('...')
  95         ps.extend(range(cur - show_max / 4, cur))
  96
  97     else:
  98         ps.extend(range(start, cur))
  99
 100     ps.append(cur)
 101
 102     if (total - cur) > show_max / 2:
 103         # for the first pages, show more pages at the beginning
 104         add = show_max / 2 - len(ps)
 105         ps.extend(range(cur + 1, cur + show_max / 4 + add))
 106         ps.append('...')
 107         ps.extend(range(total - show_max / 4, total + 1))
 108
 109     else:
 110         ps.extend(range(cur + 1, total + 1))
 111
 112     return ps
 113
 114
 115 def process_lang_params(request):
 116
 117     lang = request.GET.get('lang', None)
 118
 119     if lang is None:
 120         langs = get_accepted_lang(request)
 121         lang = next(iter(langs), '')
 122
 123     return sanitize_language_code(lang)
 124
 125
 126 def symbian_opml_changes(podcast):
 127     podcast.podcast.description = podcast.podcast.display_title + '\n' + \
 128                                  (podcast.podcast.description or '')
 129     return podcast
 130
 131
 132 @never_cache
 133 def maintenance(request, *args, **kwargs):
 134     resp = render(request, 'maintenance.html', {})
 135     resp.status_code = 503
 136     return resp
 137
 138
 139 def get_podcast_link_target(podcast, view_name='podcast', add_args=[]):
 140     """ Returns the link-target for a Podcast, preferring slugs over Ids """
 141
 142     # we prefer slugs
 143     if podcast.slug:
 144         args = [podcast.slug]
 145         view_name = '%s-slug' % view_name
 146
 147     # as a fallback we use UUIDs
 148     else:
 149         args = [podcast.get_id()]
 150         view_name = '%s-id' % view_name
 151
 152     return reverse(view_name, args=args + add_args)
 153
 154
 155 def get_podcast_group_link_target(group, view_name, add_args=[]):
 156     """ the link-target for a Podcast group, preferring slugs over Ids """
 157     args = [group.slug]
 158     view_name = '%s-slug-id' % view_name
 159     return reverse(view_name, args=args + add_args)
 160
 161
 162 def get_episode_link_target(episode, podcast, view_name='episode',
 163                             add_args=[]):
 164     """ Returns the link-target for an Episode, preferring slugs over Ids """
 165
 166     # prefer slugs
 167     if episode.slug:
 168         args = [podcast.slug, episode.slug]
 169         view_name = '%s-slug' % view_name
 170
 171     # fallback: UUIDs
 172     else:
 173         podcast = podcast or episode.podcast
 174         args = [podcast.get_id(), episode.get_id()]
 175         view_name = '%s-id' % view_name
 176
 177     return strip_tags(reverse(view_name, args=args + add_args))
 178
 179
 180 # doesn't include the '@' because it's not stored as part of a twitter handle
 181 TWITTER_CHARS = string.ascii_letters + string.digits + '_'
 182
 183
 184 def normalize_twitter(s):
 185     """ normalize user input that is supposed to be a Twitter handle """
 186     return "".join(i for i in s if i in TWITTER_CHARS)
 187
 188
 189 CCLICENSE = re.compile(r'http://(www\.)?creativecommons.org/licenses/([a-z-]+)/([0-9.]+)?/?')
 190 CCPUBLICDOMAIN = re.compile(r'http://(www\.)?creativecommons.org/licenses/publicdomain/?')
 191 LicenseInfo = collections.namedtuple('LicenseInfo', 'name version url')
 192
 193 def license_info(license_url):
 194     """ Extracts license information from the license URL
 195
 196     >>> i = license_info('http://creativecommons.org/licenses/by/3.0/')
 197     >>> i.name
 198     'CC BY'
 199     >>> i.version
 200     '3.0'
 201     >>> i.url
 202     'http://creativecommons.org/licenses/by/3.0/'
 203
 204     >>> iwww = license_info('http://www.creativecommons.org/licenses/by/3.0/')
 205     >>> i.name == iwww.name and i.version == iwww.version
 206     True
 207
 208     >>> i = license_info('http://www.creativecommons.org/licenses/publicdomain')
 209     >>> i.name
 210     'Public Domain'
 211     >>> i.version is None
 212     True
 213
 214     >>> i = license_info('http://example.com/my-own-license')
 215     >>> i.name is None
 216     True
 217     >>> i.version is None
 218     True
 219     >>> i.url
 220     'http://example.com/my-own-license'
 221     """
 222     m = CCLICENSE.match(license_url)
 223     if m:
 224         _, name, version = m.groups()
 225         return LicenseInfo('CC %s' % name.upper(), version, license_url)
 226
 227     m = CCPUBLICDOMAIN.match(license_url)
 228     if m:
 229         return LicenseInfo('Public Domain', None, license_url)
 230
 231     return LicenseInfo(None, None, license_url)
 232
 233
 234 def check_restrictions(obj):
 235     """ checks for known restrictions of the object """
 236
 237     restrictions = obj.restrictions.split(',')
 238     if "hide" in restrictions:
 239         raise Http404
 240
 241     if "hide-author" in restrictions:
 242         obj.author = None
 243
 244     return obj
 245
 246
 247 def hours_to_str(hours_total):
 248     """ returns a human-readable string representation of some hours
 249
 250     >>> hours_to_str(1)
 251     u'1 hour'
 252
 253     >>> hours_to_str(5)
 254     u'5 hours'
 255
 256     >>> hours_to_str(100)
 257     u'4 days, 4 hours'
 258
 259     >>> hours_to_str(960)
 260     u'5 weeks, 5 days'
 261
 262     >>> hours_to_str(961)
 263     u'5 weeks, 5 days, 1 hour'
 264     """
 265
 266     weeks = hours_total / 24 / 7
 267     days = hours_total / 24 % 7
 268     hours = hours_total % 24
 269
 270     strs = []
 271
 272     if weeks:
 273         strs.append(ungettext('%(weeks)d week', '%(weeks)d weeks', weeks) %
 274             { 'weeks': weeks})
 275
 276     if days:
 277         strs.append(ungettext('%(days)d day', '%(days)d days', days) %
 278             { 'days': days})
 279
 280     if hours:
 281         strs.append(ungettext('%(hours)d hour', '%(hours)d hours', hours) %
 282             { 'hours': hours})
 283
 284     return ', '.join(strs)