apps/api/management/commands/mobileinit.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 datetime import datetime
   6 import os
   7 import os.path
   8 import re
   9 import sqlite3
  10 from django.core.management.base import BaseCommand
  11
  12 from api.helpers import timestamp
  13 from api.settings import MOBILE_INIT_DB
  14 from catalogue.models import Book, Tag
  15
  16
  17 class Command(BaseCommand):
  18     help = 'Creates an initial SQLite file for the mobile app.'
  19
  20     def handle(self, **options):
  21         # those should be versioned
  22         last_checked = timestamp(datetime.now())
  23         db = init_db(last_checked)
  24         for b in Book.objects.all():
  25             add_book(db, b)
  26         for t in Tag.objects.exclude(
  27                 category__in=('book', 'set', 'theme')).exclude(book_count=0):
  28             # only add non-empty tags
  29             add_tag(db, t)
  30         db.commit()
  31         db.close()
  32         current(last_checked)
  33
  34
  35 def pretty_size(size):
  36     """ Turns size in bytes into a prettier string.
  37
  38         >>> pretty_size(100000)
  39         '97 KiB'
  40     """
  41     if not size:
  42         return None
  43     units = ['B', 'KiB', 'MiB', 'GiB']
  44     size = float(size)
  45     unit = units.pop(0)
  46     while size > 1000 and units:
  47         size /= 1024
  48         unit = units.pop(0)
  49     if size < 10:
  50         return "%.1f %s" % (size, unit)
  51     return "%d %s" % (size, unit)
  52
  53
  54     if not isinstance(value, unicode):
  55         value = unicode(value, 'utf-8')
  56
  57     # try to replace chars
  58     value = re.sub('[^a-zA-Z0-9\\s\\-]{1}', replace_char, value)
  59     value = value.lower()
  60     value = re.sub(r'[^a-z0-9{|}]+', '~', value)
  61
  62     return value.encode('ascii', 'ignore')
  63
  64
  65
  66 def init_db(last_checked):
  67     if not os.path.isdir(MOBILE_INIT_DB):
  68         os.makedirs(MOBILE_INIT_DB)
  69     db = sqlite3.connect(os.path.join(MOBILE_INIT_DB, 'initial.db-%d' % last_checked))
  70
  71     schema = """
  72 CREATE TABLE book (
  73     id INTEGER PRIMARY KEY,
  74     title VARCHAR,
  75     cover VARCHAR,
  76     html_file VARCHAR,
  77     html_file_size INTEGER,
  78     parent INTEGER,
  79     parent_number INTEGER,
  80
  81     sort_key VARCHAR,
  82     pretty_size VARCHAR,
  83     authors VARCHAR,
  84     _local BOOLEAN
  85 );
  86 CREATE INDEX IF NOT EXISTS book_title_index ON book (sort_key);
  87 CREATE INDEX IF NOT EXISTS book_title_index ON book (title);
  88 CREATE INDEX IF NOT EXISTS book_parent_index ON book (parent);
  89
  90 CREATE TABLE tag (
  91     id INTEGER PRIMARY KEY,
  92     name VARCHAR,
  93     category VARCHAR,
  94     sort_key VARCHAR,
  95     books VARCHAR);
  96 CREATE INDEX IF NOT EXISTS tag_name_index ON tag (name);
  97 CREATE INDEX IF NOT EXISTS tag_category_index ON tag (category);
  98 CREATE INDEX IF NOT EXISTS tag_sort_key_index ON tag (sort_key);
  99
 100 CREATE TABLE state (last_checked INTEGER);
 101 """
 102
 103     db.executescript(schema)
 104     db.execute("INSERT INTO state VALUES (:last_checked)", locals())
 105     return db
 106
 107
 108 def current(last_checked):
 109     target = os.path.join(MOBILE_INIT_DB, 'initial.db')
 110     if os.path.lexists(target):
 111         os.unlink(target)
 112     os.symlink(
 113         'initial.db-%d' % last_checked,
 114         target,
 115     )
 116
 117
 118
 119 book_sql = """
 120     INSERT INTO book
 121         (id, title, cover, html_file,  html_file_size, parent, parent_number, sort_key, pretty_size, authors)
 122     VALUES
 123         (:id, :title, :cover, :html_file, :html_file_size, :parent, :parent_number, :sort_key, :size_str, :authors);
 124 """
 125 book_tag_sql = "INSERT INTO book_tag (book, tag) VALUES (:book, :tag);"
 126 tag_sql = """
 127     INSERT INTO tag
 128         (id, category, name, sort_key, books)
 129     VALUES
 130         (:id, :category, :name, :sort_key, :book_ids);
 131 """
 132 categories = {'author': 'autor',
 133               'epoch': 'epoka',
 134               'genre': 'gatunek',
 135               'kind': 'rodzaj',
 136               'theme': 'motyw'
 137               }
 138
 139
 140 def add_book(db, book):
 141     id = book.id
 142     title = book.title
 143     if book.html_file:
 144         html_file = book.html_file.url
 145         html_file_size = book.html_file.size
 146     else:
 147         html_file = html_file_size = None
 148     if book.cover:
 149         cover = book.cover.url
 150     else:
 151         cover = None
 152     parent = book.parent_id
 153     parent_number = book.parent_number
 154     sort_key = book.sort_key
 155     size_str = pretty_size(html_file_size)
 156     authors = ", ".join(t.name for t in book.tags.filter(category='author'))
 157     db.execute(book_sql, locals())
 158
 159
 160 def add_tag(db, tag):
 161     id = tag.id
 162     #    category = categories[tag.category] # localized names here?
 163     category = tag.category
 164     name = tag.name
 165     sort_key = tag.sort_key
 166
 167     books = Book.tagged_top_level([tag])
 168     book_ids = ','.join(str(b.id) for b in books)
 169     db.execute(tag_sql, locals())