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.description = (podcast.title or '') + '\n' + \
 128                           (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     automatically distringuishes between relational Podcast objects and
 143     CouchDB-based Podcasts """
 144
 145     # we prefer slugs
 146     if podcast.slug:
 147         args = [podcast.slug]
 148         view_name = '%s-slug' % view_name
 149
 150     # as a fallback we use UUIDs
 151     else:
 152         args = [podcast.get_id()]
 153         view_name = '%s-id' % view_name
 154
 155     return reverse(view_name, args=args + add_args)
 156
 157
 158 def get_podcast_group_link_target(group, view_name, add_args=[]):
 159     """ Returns the link-target for a Podcast group, preferring slugs over Ids
 160
 161     automatically distringuishes between relational Podcast objects and
 162     CouchDB-based Podcasts """
 163
 164     # we prefer slugs
 165     if group.slug:
 166         args = [group.slug]
 167         view_name = '%s-slug-id' % view_name
 168
 169     # as a fallback we use CouchDB-IDs
 170     else:
 171         args = [group._id]
 172         view_name = '%s-slug-id' % view_name
 173
 174     return reverse(view_name, args=args + add_args)
 175
 176
 177 def get_episode_link_target(episode, podcast, view_name='episode',
 178                             add_args=[]):
 179     """ Returns the link-target for an Episode, preferring slugs over Ids
 180
 181     automatically distringuishes between relational Episode objects and
 182     CouchDB-based Episodes """
 183
 184     # prefer slugs
 185     if episode.slug:
 186         args = [podcast.slug, episode.slug]
 187         view_name = '%s-slug' % view_name
 188
 189     # fallback: UUIDs
 190     else:
 191         podcast = podcast or episode.podcast
 192         args = [podcast.get_id(), episode.get_id()]
 193         view_name = '%s-id' % view_name
 194
 195     return strip_tags(reverse(view_name, args=args + add_args))
 196
 197
 198 # doesn't include the '@' because it's not stored as part of a twitter handle
 199 TWITTER_CHARS = string.ascii_letters + string.digits + '_'
 200
 201
 202 def normalize_twitter(s):
 203     """ normalize user input that is supposed to be a Twitter handle """
 204     return "".join(i for i in s if i in TWITTER_CHARS)
 205
 206
 207 CCLICENSE = re.compile(r'http://(www\.)?creativecommons.org/licenses/([a-z-]+)/([0-9.]+)?/?')
 208 CCPUBLICDOMAIN = re.compile(r'http://(www\.)?creativecommons.org/licenses/publicdomain/?')
 209 LicenseInfo = collections.namedtuple('LicenseInfo', 'name version url')
 210
 211 def license_info(license_url):
 212     """ Extracts license information from the license URL
 213
 214     >>> i = license_info('http://creativecommons.org/licenses/by/3.0/')
 215     >>> i.name
 216     'CC BY'
 217     >>> i.version
 218     '3.0'
 219     >>> i.url
 220     'http://creativecommons.org/licenses/by/3.0/'
 221
 222     >>> iwww = license_info('http://www.creativecommons.org/licenses/by/3.0/')
 223     >>> i.name == iwww.name and i.version == iwww.version
 224     True
 225
 226     >>> i = license_info('http://www.creativecommons.org/licenses/publicdomain')
 227     >>> i.name
 228     'Public Domain'
 229     >>> i.version is None
 230     True
 231
 232     >>> i = license_info('http://example.com/my-own-license')
 233     >>> i.name is None
 234     True
 235     >>> i.version is None
 236     True
 237     >>> i.url
 238     'http://example.com/my-own-license'
 239     """
 240     m = CCLICENSE.match(license_url)
 241     if m:
 242         _, name, version = m.groups()
 243         return LicenseInfo('CC %s' % name.upper(), version, license_url)
 244
 245     m = CCPUBLICDOMAIN.match(license_url)
 246     if m:
 247         return LicenseInfo('Public Domain', None, license_url)
 248
 249     return LicenseInfo(None, None, license_url)
 250
 251
 252 def check_restrictions(obj):
 253     """ checks for known restrictions of the object """
 254
 255     restrictions = obj.restrictions.split(',')
 256     if "hide" in restrictions:
 257         raise Http404
 258
 259     if "hide-author" in restrictions:
 260         obj.author = None
 261
 262     return obj
 263
 264
 265 def hours_to_str(hours_total):
 266     """ returns a human-readable string representation of some hours
 267
 268     >>> hours_to_str(1)
 269     u'1 hour'
 270
 271     >>> hours_to_str(5)
 272     u'5 hours'
 273
 274     >>> hours_to_str(100)
 275     u'4 days, 4 hours'
 276
 277     >>> hours_to_str(960)
 278     u'5 weeks, 5 days'
 279
 280     >>> hours_to_str(961)
 281     u'5 weeks, 5 days, 1 hour'
 282     """
 283
 284     weeks = hours_total / 24 / 7
 285     days = hours_total / 24 % 7
 286     hours = hours_total % 24
 287
 288     strs = []
 289
 290     if weeks:
 291         strs.append(ungettext('%(weeks)d week', '%(weeks)d weeks', weeks) %
 292             { 'weeks': weeks})
 293
 294     if days:
 295         strs.append(ungettext('%(days)d day', '%(days)d days', days) %
 296             { 'days': days})
 297
 298     if hours:
 299         strs.append(ungettext('%(hours)d hour', '%(hours)d hours', hours) %
 300             { 'hours': hours})
 301
 302     return ', '.join(strs)