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