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