255 lines
9.2 KiB
Python
255 lines
9.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
|
|
from datetime import datetime
|
|
import mimetypes
|
|
import os
|
|
from urllib.request import quote
|
|
import zipfile
|
|
import base64
|
|
|
|
import ox
|
|
|
|
from .models import Item, File
|
|
from user.models import List
|
|
from .scan import add_file
|
|
import db
|
|
import settings
|
|
import tornado.web
|
|
import tornado.gen
|
|
import tornado.concurrent
|
|
|
|
from oxtornado import json_dumps, json_response
|
|
|
|
from media import get_id
|
|
import state
|
|
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class OptionalBasicAuthMixin(object):
|
|
class SendChallenge(Exception):
|
|
pass
|
|
|
|
def prepare(self):
|
|
if settings.preferences.get('authentication'):
|
|
try:
|
|
self.authenticate_user()
|
|
except self.SendChallenge:
|
|
self.send_auth_challenge()
|
|
|
|
def send_auth_challenge(self):
|
|
realm = "Open Media Library"
|
|
hdr = 'Basic realm="%s"' % realm
|
|
self.set_status(401)
|
|
self.set_header('www-authenticate', hdr)
|
|
self.finish()
|
|
return False
|
|
|
|
def authenticate_user(self):
|
|
auth_header = self.request.headers.get('Authorization')
|
|
if not auth_header or not auth_header.startswith('Basic '):
|
|
raise self.SendChallenge()
|
|
|
|
auth_data = auth_header.split(None, 1)[-1]
|
|
auth_data = base64.b64decode(auth_data).decode('ascii')
|
|
username, password = auth_data.split(':', 1)
|
|
|
|
auth = settings.preferences.get('authentication')
|
|
if auth.get('username') == username and auth.get('password') == password:
|
|
self._current_user = username
|
|
else:
|
|
raise self.SendChallenge()
|
|
|
|
class OMLHandler(OptionalBasicAuthMixin, tornado.web.RequestHandler):
|
|
|
|
def initialize(self):
|
|
pass
|
|
|
|
class EpubHandler(OMLHandler):
|
|
|
|
def get(self, id, filename):
|
|
with db.session():
|
|
item = Item.get(id)
|
|
path = item.get_path()
|
|
if not item or item.info['extension'] != 'epub' or not path:
|
|
self.set_status(404)
|
|
self.write('')
|
|
else:
|
|
z = zipfile.ZipFile(path)
|
|
if filename == '':
|
|
self.write('<br>\n'.join([f.filename for f in z.filelist]))
|
|
elif filename not in [f.filename for f in z.filelist]:
|
|
self.set_status(404)
|
|
self.write('')
|
|
else:
|
|
content_type = {
|
|
'xpgt': 'application/vnd.adobe-page-template+xml'
|
|
}.get(filename.split('.')[0], mimetypes.guess_type(filename)[0]) or 'text/plain'
|
|
self.set_header('Content-Type', content_type)
|
|
self.write(z.read(filename))
|
|
|
|
def serve_static(handler, path, mimetype, include_body=True, disposition=None):
|
|
handler.set_header('Content-Type', mimetype)
|
|
size = os.stat(path).st_size
|
|
handler.set_header('Accept-Ranges', 'bytes')
|
|
if disposition:
|
|
handler.set_header('Content-Disposition', "attachment; filename*=UTF-8''%s" % quote(disposition.encode('utf-8')))
|
|
if include_body:
|
|
if 'Range' in handler.request.headers:
|
|
handler.set_status(206)
|
|
r = handler.request.headers.get('Range').split('=')[-1].split('-')
|
|
start = int(r[0])
|
|
end = int(r[1]) if r[1] else (size - 1)
|
|
length = end - start + 1
|
|
handler.set_header('Content-Length', str(length))
|
|
handler.set_header('Content-Range', 'bytes %s-%s/%s' % (start, end, size))
|
|
with open(path, 'rb') as fd:
|
|
fd.seek(start)
|
|
handler.write(fd.read(length))
|
|
else:
|
|
handler.set_header('Content-Length', str(size))
|
|
with open(path, 'rb') as fd:
|
|
handler.write(fd.read())
|
|
else:
|
|
handler.set_header('Content-Length', str(size))
|
|
return
|
|
|
|
class FileHandler(OMLHandler):
|
|
|
|
def initialize(self, attachment=False):
|
|
self._attachment = attachment
|
|
|
|
def head(self, id):
|
|
self.get(id, include_body=False)
|
|
|
|
def get(self, id, include_body=True):
|
|
with db.session():
|
|
item = Item.get(id)
|
|
path = item.get_path() if item else None
|
|
if not item or not path:
|
|
self.set_status(404)
|
|
return
|
|
mimetype = {
|
|
'cbr': 'application/x-cbr',
|
|
'cbz': 'application/x-cbz',
|
|
'epub': 'application/epub+zip',
|
|
'pdf': 'application/pdf',
|
|
'txt': 'text/plain',
|
|
}.get(path.split('.')[-1], None)
|
|
if mimetype == 'text/plain':
|
|
try:
|
|
open(path, 'rb').read().decode('utf-8')
|
|
mimetype = 'text/plain; charset=utf-8'
|
|
except:
|
|
mimetype = 'text/plain; charset=latin-1'
|
|
if self._attachment:
|
|
disposition = os.path.basename(path)
|
|
else:
|
|
disposition = None
|
|
return serve_static(self, path, mimetype, include_body, disposition=disposition)
|
|
|
|
class ReaderHandler(OMLHandler):
|
|
|
|
def get(self, id):
|
|
with db.session():
|
|
item = Item.get(id)
|
|
if not item:
|
|
self.set_status(404)
|
|
return
|
|
if item.info['extension'] in ('cbr', 'cbz'):
|
|
html = 'html/cbr.html'
|
|
elif item.info['extension'] == 'epub':
|
|
html = 'html/epub.html'
|
|
elif item.info['extension'] == 'pdf':
|
|
html = 'html/pdf.html'
|
|
elif item.info['extension'] == 'txt':
|
|
html = 'html/txt.html'
|
|
else:
|
|
self.set_status(404)
|
|
return
|
|
item.accessed = datetime.utcnow()
|
|
item.timesaccessed = (item.timesaccessed or 0) + 1
|
|
item.update_sort()
|
|
item.save()
|
|
path = os.path.join(settings.static_path, html)
|
|
return serve_static(self, path, 'text/html')
|
|
|
|
class UploadHandler(OMLHandler):
|
|
|
|
def initialize(self, context=None):
|
|
self._context = context
|
|
|
|
def get(self):
|
|
self.write('use POST')
|
|
|
|
@tornado.web.asynchronous
|
|
@tornado.gen.coroutine
|
|
def post(self):
|
|
if 'origin' in self.request.headers and self.request.host not in self.request.headers['origin']:
|
|
logger.debug('reject cross site attempt to access api %s', self.request)
|
|
self.set_status(403)
|
|
self.write('')
|
|
return
|
|
|
|
def save_files(context, request, callback):
|
|
listname = request.arguments.get('list', None)
|
|
if listname:
|
|
listname = listname[0]
|
|
if isinstance(listname, bytes):
|
|
listname = listname.decode('utf-8')
|
|
with context():
|
|
prefs = settings.preferences
|
|
ids = []
|
|
for upload in request.files.get('files', []):
|
|
filename = upload.filename
|
|
id = get_id(data=upload.body)
|
|
ids.append(id)
|
|
file = File.get(id)
|
|
if not file or not os.path.exists(file.fullpath()):
|
|
logger.debug('add %s to library', id)
|
|
prefix_books = os.path.join(os.path.expanduser(prefs['libraryPath']), 'Books' + os.sep)
|
|
prefix_imported = os.path.join(prefix_books, '.import' + os.sep)
|
|
ox.makedirs(prefix_imported)
|
|
import_name = os.path.join(prefix_imported, filename)
|
|
n = 1
|
|
while os.path.exists(import_name):
|
|
n += 1
|
|
name, extension = filename.rsplit('.', 1)
|
|
if extension == 'kepub':
|
|
extension = 'epub'
|
|
import_name = os.path.join(prefix_imported, '%s [%d].%s' % (name, n, extension))
|
|
with open(import_name, 'wb') as fd:
|
|
fd.write(upload.body)
|
|
file = add_file(id, import_name, prefix_books)
|
|
file.move()
|
|
else:
|
|
user = state.user()
|
|
if not file.item:
|
|
item = Item.get_or_create(id=file.sha1, info=file.info)
|
|
file.item_id = item.id
|
|
state.db.session.add(file)
|
|
state.db.session.commit()
|
|
else:
|
|
item = file.item
|
|
if user not in item.users:
|
|
logger.debug('add %s to local user', id)
|
|
item.add_user(user)
|
|
add_record('additem', item.id, file.info)
|
|
add_record('edititem', item.id, item.meta)
|
|
item.update()
|
|
if listname and ids:
|
|
l = List.get(settings.USER_ID, listname)
|
|
if l:
|
|
l.add_items(ids)
|
|
response = json_response({'ids': ids})
|
|
callback(response)
|
|
|
|
response = yield tornado.gen.Task(save_files, self._context, self.request)
|
|
if 'status' not in response:
|
|
response = json_response(response)
|
|
response = json_dumps(response)
|
|
self.set_header('Content-Type', 'application/json')
|
|
self.write(response)
|