Matthew Welch
1fb4a869b0
Added initial implementation of user data for tv shows and movies as well as OAuth for Google sign in.
171 lines
7.3 KiB
Python
171 lines
7.3 KiB
Python
from flask import Blueprint, render_template, request, make_response, current_app
|
|
from flask_login import login_required
|
|
|
|
from urllib import parse
|
|
from io import BytesIO
|
|
from wand.image import Image
|
|
import os, pytz, datetime
|
|
import inspect
|
|
|
|
from scripts import database, func
|
|
|
|
Comics = Blueprint("comics", __name__, template_folder="templates")
|
|
|
|
MOBILE_DEVICES = ["android", "blackberry", "ipad", "iphone"]
|
|
|
|
|
|
@Comics.route("/comics")
|
|
@login_required
|
|
def index():
|
|
try:
|
|
page = request.args.get("page", 1, type=int)
|
|
max_items = request.args.get("max_items", 30, type=int)
|
|
publishers = database.get_publishers()
|
|
start = (max_items*(page-1))
|
|
end = len(publishers) if len(publishers) < max_items*page else max_items*page
|
|
return render_template("comics/index.html", title="Comics", publishers=publishers, page=page, max_items=max_items, start=start, end=end, item_count=len(publishers))
|
|
except Exception as e:
|
|
current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
|
|
return str(type(e)) + " " + str(e)
|
|
|
|
|
|
@Comics.route("/comics/search")
|
|
@login_required
|
|
def search():
|
|
try:
|
|
page = request.args.get("page", 1, type=int)
|
|
max_items = request.args.get("max_items", 30, type=int)
|
|
publisher_end = 0
|
|
series_end = 0
|
|
comics_end = 0
|
|
publisher_start = 0
|
|
series_start = 0
|
|
comics_start = 0
|
|
item_count = 0
|
|
query = request.args.get("q")
|
|
results = {
|
|
"publisher": [],
|
|
"series": [],
|
|
"comics": []
|
|
}
|
|
if query:
|
|
results = database.db_search_comics(query)
|
|
item_count = len(results["publisher"]) + len(results["series"]) + len(results["comics"])
|
|
for temp_page in range(1, page+1):
|
|
publisher_start = publisher_end
|
|
series_start = series_end
|
|
comics_start = comics_end
|
|
items = 0
|
|
publisher_end = len(results["publisher"]) if len(results["publisher"]) < max_items*temp_page else max_items*temp_page
|
|
items += publisher_end - publisher_start
|
|
if items < max_items:
|
|
series_end = len(results["series"]) if len(results["series"]) < (max_items*temp_page)-items else (max_items*temp_page)-items
|
|
items += series_end-series_start
|
|
if items < max_items:
|
|
comics_end = len(results["comics"]) if len(results["comics"]) < (max_items*temp_page)-series_end-publisher_end else (max_items*temp_page)-series_end-publisher_end
|
|
return render_template("comics/search.html", title="Comics: Search", publishers=results["publisher"], publisher_series=results["series"],
|
|
comics=results["comics"], page=page, max_items=max_items, item_count=item_count,
|
|
publisher_start=publisher_start, series_start=series_start, comics_start=comics_start,
|
|
publisher_end=publisher_end, series_end=series_end, comics_end=comics_end)
|
|
except Exception as e:
|
|
current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
|
|
return str(type(e))+" "+str(e)
|
|
|
|
|
|
@Comics.route("/comics/<publisher>")
|
|
@login_required
|
|
def comics_publisher(publisher):
|
|
try:
|
|
publisher = parse.unquote(publisher)
|
|
series = request.args.get("series")
|
|
series_year = request.args.get("seriesYear")
|
|
issue = request.args.get("issue")
|
|
page_number = request.args.get("pageNumber")
|
|
page = request.args.get("page", 1, type=int)
|
|
max_items = request.args.get("max_items", 30, type=int)
|
|
publisher_series = database.db_get_series_by_publisher(publisher)
|
|
start = (max_items*(page-1))
|
|
end = len(publisher_series) if len(publisher_series) < max_items*page else max_items*page
|
|
if series:
|
|
comics = database.db_get_comics_in_series(series, publisher, series_year)
|
|
start = (max_items * (page - 1))
|
|
end = len(comics) if len(comics) < max_items * page else max_items * page
|
|
if issue:
|
|
if page_number:
|
|
return comic_viewer(publisher, series, series_year, issue)
|
|
return comic_gallery(publisher, series, series_year, issue)
|
|
return render_template("comics/seriesView.html", title="Comics", comics=comics,
|
|
start=start, end=end, page=page, max_items=max_items, item_count=len(comics))
|
|
return render_template("comics/publisherSeriesView.html", title="Comics", publisher_series=publisher_series,
|
|
start=start, end=end, page=page, max_items=max_items, item_count=len(publisher_series))
|
|
except Exception as e:
|
|
current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
|
|
return str(type(e)) + " " + str(e)
|
|
|
|
|
|
def comic_viewer(publisher, series, series_year, issue):
|
|
try:
|
|
on_mobile = False
|
|
if request.user_agent.platform in MOBILE_DEVICES:
|
|
on_mobile = True
|
|
publisher_parsed = parse.quote(publisher)
|
|
series_parsed = parse.quote(series)
|
|
page_number = int(request.args.get("pageNumber"))
|
|
meta = database.db_get_comic(publisher, series, series_year, issue)
|
|
page_count = int(meta.pageCount)
|
|
|
|
prev_page = page_number - 1
|
|
next_page = page_number + 1
|
|
if next_page >= page_count:
|
|
next_page = 0
|
|
if prev_page < 0:
|
|
prev_page = page_count - 1
|
|
prev_url = "/comics/{}?series={}&seriesYear={}&issue={}&pageNumber={}".format(publisher_parsed, series_parsed, series_year, issue, prev_page)
|
|
next_url = "/comics/{}?series={}&seriesYear={}&issue={}&pageNumber={}".format(publisher_parsed, series_parsed, series_year, issue, next_page)
|
|
title = "Comics: "+meta.series+": #"+meta.issueText+" "+(meta.title or "")
|
|
return render_template("comics/comicView.html", title=title, on_mobile=on_mobile, prev_url=prev_url, next_url=next_url, comic=meta, page_number=page_number)
|
|
except Exception as e:
|
|
current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
|
|
return str(type(e)) + " " + str(e)
|
|
|
|
|
|
def comic_gallery(publisher, series, series_year, issue):
|
|
try:
|
|
page = request.args.get("page", 1, type=int)
|
|
max_items = request.args.get("max_items", 30, type=int)
|
|
meta = database.db_get_comic(publisher, series, series_year, issue)
|
|
start = (max_items*(page-1))
|
|
end = meta.pageCount if meta.pageCount < max_items*page else max_items*page
|
|
return render_template("comics/comicGallery.html", title="Comics", comic=meta, start=start, end=end, page=page, max_items=max_items, item_count=meta.pageCount)
|
|
except Exception as e:
|
|
current_app.logger.info(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
|
|
return str(type(e)) + " " + str(e)
|
|
|
|
|
|
@Comics.route("/comics/get_comic/<int:comic_id>/<int:page_number>")
|
|
@login_required
|
|
def get_comic_page(comic_id, page_number):
|
|
meta = database.db_get_comic_by_id(comic_id)
|
|
comic = func.open_comic(meta.path)
|
|
byte_image = BytesIO(comic.getPage(page_number))
|
|
image = Image(file=byte_image)
|
|
response = make_response(image.make_blob())
|
|
response.headers["cache-control"] = "public"
|
|
date = pytz.utc.localize(datetime.datetime.utcfromtimestamp(os.path.getmtime(meta.path)))
|
|
response.headers["last-modified"] = date.strftime('%a, %d %b %Y %H:%M:%S %Z')
|
|
response.headers["content-type"] = "image/" + image.format
|
|
return response
|
|
|
|
|
|
@Comics.route("/comics/get_comic/<int:comic_id>/<int:page_number>/thumbnail")
|
|
@login_required
|
|
def get_comic_thumbnail(comic_id, page_number):
|
|
meta = database.db_get_comic_by_id(comic_id)
|
|
thumb = database.db_get_thumbnail_by_id_page(comic_id, page_number)
|
|
response = make_response(thumb.image)
|
|
response.headers["cache-control"] = "public"
|
|
date = pytz.utc.localize(datetime.datetime.utcfromtimestamp(os.path.getmtime(meta.path)))
|
|
response.headers["last-modified"] = date.strftime('%a, %d %b %Y %H:%M:%S %Z')
|
|
response.headers["content-type"] = thumb.type
|
|
return response
|