apps/catalogue/utils.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   4 #
   5 from __future__ import with_statement
   6
   7 import hashlib
   8 import random
   9 import re
  10 import time
  11 from base64 import urlsafe_b64encode
  12
  13 from django.http import HttpResponse
  14 from django.core.files.uploadedfile import UploadedFile
  15 from django.core.files.storage import DefaultStorage
  16 from django.utils.encoding import force_unicode
  17 from django.utils.translation import get_language
  18 from django.conf import settings
  19 from os import mkdir, path, unlink
  20 from errno import EEXIST, ENOENT
  21 from fcntl import flock, LOCK_EX
  22 from zipfile import ZipFile
  23
  24 from reporting.utils import read_chunks
  25
  26 # Use the system (hardware-based) random number generator if it exists.
  27 if hasattr(random, 'SystemRandom'):
  28     randrange = random.SystemRandom().randrange
  29 else:
  30     randrange = random.randrange
  31 MAX_SESSION_KEY = 18446744073709551616L     # 2 << 63
  32
  33
  34 def get_random_hash(seed):
  35     sha_digest = hashlib.sha1('%s%s%s%s' %
  36         (randrange(0, MAX_SESSION_KEY), time.time(), unicode(seed).encode('utf-8', 'replace'),
  37         settings.SECRET_KEY)).digest()
  38     return urlsafe_b64encode(sha_digest).replace('=', '').replace('_', '-').lower()
  39
  40
  41 def split_tags(tags, initial=None):
  42     if initial is None:
  43         result = {}
  44     else:
  45         result = initial
  46
  47     for tag in tags:
  48         result.setdefault(tag.category, []).append(tag)
  49     return result
  50
  51
  52 def get_dynamic_path(media, filename, ext=None, maxlen=100):
  53     from fnpdjango.utils.text.slughifi import slughifi
  54
  55     # how to put related book's slug here?
  56     if not ext:
  57         # BookMedia case
  58         ext = media.formats[media.type].ext
  59     if media is None or not media.name:
  60         name = slughifi(filename.split(".")[0])
  61     else:
  62         name = slughifi(media.name)
  63     return 'book/%s/%s.%s' % (ext, name[:maxlen-len('book/%s/.%s' % (ext, ext))-4], ext)
  64
  65
  66 # TODO: why is this hard-coded ?
  67 def book_upload_path(ext=None, maxlen=100):
  68     return lambda *args: get_dynamic_path(*args, ext=ext, maxlen=maxlen)
  69
  70
  71 class ExistingFile(UploadedFile):
  72
  73     def __init__(self, path, *args, **kwargs):
  74         self.path = path
  75         super(ExistingFile, self).__init__(*args, **kwargs)
  76
  77     def temporary_file_path(self):
  78         return self.path
  79
  80     def close(self):
  81         pass
  82
  83
  84 class LockFile(object):
  85     """
  86     A file lock monitor class; createas an ${objname}.lock
  87     file in directory dir, and locks it exclusively.
  88     To be used in 'with' construct.
  89     """
  90     def __init__(self, dir, objname):
  91         self.lockname = path.join(dir, objname + ".lock")
  92
  93     def __enter__(self):
  94         self.lock = open(self.lockname, 'w')
  95         flock(self.lock, LOCK_EX)
  96
  97     def __exit__(self, *err):
  98         try:
  99             unlink(self.lockname)
 100         except OSError as oe:
 101             if oe.errno != EEXIST:
 102                 raise oe
 103         self.lock.close()
 104
 105
 106 #@task
 107 def create_zip(paths, zip_slug):
 108     """
 109     Creates a zip in MEDIA_ROOT/zip directory containing files from path.
 110     Resulting archive filename is ${zip_slug}.zip
 111     Returns it's path relative to MEDIA_ROOT (no initial slash)
 112     """
 113     # directory to store zip files
 114     zip_path = path.join(settings.MEDIA_ROOT, 'zip')
 115
 116     try:
 117         mkdir(zip_path)
 118     except OSError as oe:
 119         if oe.errno != EEXIST:
 120             raise oe
 121     zip_filename = zip_slug + ".zip"
 122
 123     with LockFile(zip_path, zip_slug):
 124         if not path.exists(path.join(zip_path, zip_filename)):
 125             zipf = ZipFile(path.join(zip_path, zip_filename), 'w')
 126             try:
 127                 for arcname, p in paths:
 128                     if arcname is None:
 129                         arcname = path.basename(p)
 130                     zipf.write(p, arcname)
 131             finally:
 132                 zipf.close()
 133
 134         return 'zip/' + zip_filename
 135
 136
 137 def remove_zip(zip_slug):
 138     """
 139     removes the ${zip_slug}.zip file from zip store.
 140     """
 141     zip_file = path.join(settings.MEDIA_ROOT, 'zip', zip_slug + '.zip')
 142     try:
 143         unlink(zip_file)
 144     except OSError as oe:
 145         if oe.errno != ENOENT:
 146             raise oe
 147
 148
 149 class AttachmentHttpResponse(HttpResponse):
 150     """Response serving a file to be downloaded.
 151     """
 152     def __init__ (self, file_path, file_name, mimetype):
 153         super(AttachmentHttpResponse, self).__init__(mimetype=mimetype)
 154         self['Content-Disposition'] = 'attachment; filename=%s' % file_name
 155         self.file_path = file_path
 156         self.file_name = file_name
 157
 158         with open(DefaultStorage().path(self.file_path)) as f:
 159             for chunk in read_chunks(f):
 160                 self.write(chunk)
 161
 162 class MultiQuerySet(object):
 163     def __init__(self, *args, **kwargs):
 164         self.querysets = args
 165         self._count = None
 166
 167     def count(self):
 168         if not self._count:
 169             self._count = sum(len(qs) for qs in self.querysets)
 170         return self._count
 171
 172     def __len__(self):
 173         return self.count()
 174
 175     def __getitem__(self, item):
 176         try:
 177             indices = (offset, stop, step) = item.indices(self.count())
 178         except AttributeError:
 179             # it's not a slice - make it one
 180             return self[item : item + 1][0]
 181         items = []
 182         total_len = stop - offset
 183         for qs in self.querysets:
 184             if len(qs) < offset:
 185                 offset -= len(qs)
 186             else:
 187                 items += list(qs[offset:stop])
 188                 if len(items) >= total_len:
 189                     return items
 190                 else:
 191                     offset = 0
 192                     stop = total_len - len(items)
 193                     continue
 194
 195 class SortedMultiQuerySet(MultiQuerySet):
 196     def __init__(self, *args, **kwargs):
 197         self.order_by = kwargs.pop('order_by', None)
 198         self.sortfn = kwargs.pop('sortfn', None)
 199         if self.order_by is not None:
 200             self.sortfn = lambda a, b: cmp(getattr(a, self.order_by),
 201                                            getattr(b, self.order_by))
 202         super(SortedMultiQuerySet, self).__init__(*args, **kwargs)
 203
 204     def __getitem__(self, item):
 205         sort_heads = [0] * len(self.querysets)
 206         try:
 207             indices = (offset, stop, step) = item.indices(self.count())
 208         except AttributeError:
 209             # it's not a slice - make it one
 210             return self[item : item + 1][0]
 211         items = []
 212         total_len = stop - offset
 213         skipped = 0
 214         i_s = range(len(sort_heads))
 215
 216         while len(items) < total_len:
 217             candidate = None
 218             for i in i_s:
 219                 def get_next():
 220                     return self.querysets[i][sort_heads[i]]
 221                 try:
 222                     if candidate is None:
 223                         candidate = get_next()
 224                     else:
 225                         competitor = get_next()
 226                         if self.sortfn(candidate, competitor) > 0:
 227                             candidate = competitor
 228                 except IndexError:
 229                     continue # continue next sort_head
 230                 sort_heads[i] += 1
 231             # we have no more elements:
 232             if candidate is None:
 233                 break
 234             if skipped < offset:
 235                 skipped += 1
 236                 continue # continue next item
 237             items.append(candidate)
 238
 239         return items
 240
 241
 242 def truncate_html_words(s, num, end_text='...'):
 243     """Truncates HTML to a certain number of words (not counting tags and
 244     comments). Closes opened tags if they were correctly closed in the given
 245     html. Takes an optional argument of what should be used to notify that the
 246     string has been truncated, defaulting to ellipsis (...).
 247
 248     Newlines in the HTML are preserved.
 249
 250     This is just a version of django.utils.text.truncate_html_words with no space before the end_text.
 251     """
 252     s = force_unicode(s)
 253     length = int(num)
 254     if length <= 0:
 255         return u''
 256     html4_singlets = ('br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input')
 257     # Set up regular expressions
 258     re_words = re.compile(r'&.*?;|<.*?>|(\w[\w-]*)', re.U)
 259     re_tag = re.compile(r'<(/)?([^ ]+?)(?: (/)| .*?)?>')
 260     # Count non-HTML words and keep note of open tags
 261     pos = 0
 262     end_text_pos = 0
 263     words = 0
 264     open_tags = []
 265     while words <= length:
 266         m = re_words.search(s, pos)
 267         if not m:
 268             # Checked through whole string
 269             break
 270         pos = m.end(0)
 271         if m.group(1):
 272             # It's an actual non-HTML word
 273             words += 1
 274             if words == length:
 275                 end_text_pos = pos
 276             continue
 277         # Check for tag
 278         tag = re_tag.match(m.group(0))
 279         if not tag or end_text_pos:
 280             # Don't worry about non tags or tags after our truncate point
 281             continue
 282         closing_tag, tagname, self_closing = tag.groups()
 283         tagname = tagname.lower()  # Element names are always case-insensitive
 284         if self_closing or tagname in html4_singlets:
 285             pass
 286         elif closing_tag:
 287             # Check for match in open tags list
 288             try:
 289                 i = open_tags.index(tagname)
 290             except ValueError:
 291                 pass
 292             else:
 293                 # SGML: An end tag closes, back to the matching start tag, all unclosed intervening start tags with omitted end tags
 294                 open_tags = open_tags[i+1:]
 295         else:
 296             # Add it to the start of the open tags list
 297             open_tags.insert(0, tagname)
 298     if words <= length:
 299         # Don't try to close tags if we don't need to truncate
 300         return s
 301     out = s[:end_text_pos]
 302     if end_text:
 303         out += end_text
 304     # Close any tags still open
 305     for tag in open_tags:
 306         out += '</%s>' % tag
 307     # Return string
 308     return out
 309
 310
 311 def customizations_hash(customizations):
 312     customizations.sort()
 313     return hash(tuple(customizations))
 314
 315
 316 def get_customized_pdf_path(book, customizations):
 317     """
 318     Returns a MEDIA_ROOT relative path for a customized pdf. The name will contain a hash of customization options.
 319     """
 320     h = customizations_hash(customizations)
 321     return 'book/%s/%s-custom-%s.pdf' % (book.slug, book.slug, h)
 322
 323
 324 def clear_custom_pdf(book):
 325     """
 326     Returns a list of paths to generated customized pdf of a book
 327     """
 328     from waiter.utils import clear_cache
 329     clear_cache('book/%s' % book.slug)
 330
 331
 332 class AppSettings(object):
 333     """Allows specyfying custom settings for an app, with default values.
 334
 335     Just subclass, set some properties and instantiate with a prefix.
 336     Getting a SETTING from an instance will check for prefix_SETTING
 337     in project settings if set, else take the default. The value will be
 338     then filtered through _more_SETTING method, if there is one.
 339
 340     """
 341     def __init__(self, prefix):
 342         self._prefix = prefix
 343
 344     def __getattribute__(self, name):
 345         if name.startswith('_'):
 346             return object.__getattribute__(self, name)
 347         value = getattr(settings,
 348                          "%s_%s" % (self._prefix, name),
 349                          object.__getattribute__(self, name))
 350         more = "_more_%s" % name
 351         if hasattr(self, more):
 352             value = getattr(self, more)(value)
 353         return value
 354
 355
 356 def trim_query_log(trim_to=25):
 357     """
 358 connection.queries includes all SQL statements -- INSERTs, UPDATES, SELECTs, etc. Each time your app hits the database, the query will be recorded.
 359 This can sometimes occupy lots of memory, so trim it here a bit.
 360     """
 361     if settings.DEBUG:
 362         from django.db import connection
 363         connection.queries = trim_to > 0 \
 364             and connection.queries[-trim_to:] \
 365             or []
 366
 367
 368 def related_tag_name(tag_info, language=None):
 369     return tag_info.get("name_%s" % (language or get_language()),
 370         tag_info.get("name_%s" % settings.LANGUAGE_CODE, ""))
 371
 372
 373 def delete_from_cache_by_language(cache, key_template):
 374     cache.delete_many([key_template % lc for lc, ln in settings.LANGUAGES])