rpiwebapp-public/rpiWebApp.py

import base64
import datetime
import inspect
import json
import logging
import os
import pathlib
import threading
from urllib.parse import urljoin, urlsplit, urlunsplit

import inotify.adapters
import inotify.constants
import requests
from flask import Flask, Response, current_app, flash, g, redirect, render_template, request, url_for, make_response
from flask_login import LoginManager, current_user, login_required, login_user, logout_user
from oauthlib.oauth2 import WebApplicationClient
from werkzeug.middleware.proxy_fix import ProxyFix

import func
from admin import admin
from comics import comics
from games import games
import database
from tv_movies import tv_movies


class NullHandler(logging.Handler):
    def emit(self, record=None):
        pass

    def debug(self, *arg):
        pass


nullLog = NullHandler()
inotify.adapters._LOGGER = nullLog


GOOGLE_CLIENT_ID = "***REMOVED***"
GOOGLE_CLIENT_SECRET = "***REMOVED***"
GOOGLE_DISCOVERY_URL = "https://accounts.google.com/.well-known/openid-configuration"
client = WebApplicationClient(GOOGLE_CLIENT_ID)


def get_google_provider_cfg():
    return requests.get(GOOGLE_DISCOVERY_URL).json()


app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_for=1)
app.register_blueprint(comics.Comics)
app.register_blueprint(admin.Admin)
app.register_blueprint(tv_movies.TV_Movies)
app.register_blueprint(games.Games)
app.config["SECRET_KEY"] = "***REMOVED***"
app.logger.setLevel("DEBUG")
# app.use_x_sendfile = True

login_manager = LoginManager(app)
# login_manager.login_view = "login"
app.config["REMEMBER_COOKIE_DOMAIN"] = "narnian.us"


MOBILE_DEVICES = ["android", "blackberry", "ipad", "iphone"]


def get_comics():
    with app.app_context():
        i = inotify.adapters.InotifyTree(str(func.COMICS_DIRECTORY))
        new_dirs = []
        func.get_comics()
        while True:
            for event in i.event_gen(timeout_s=5*60, yield_nones=False):
                (header, type_names, path, filename) = event
                file_path = pathlib.Path(path, filename)
                if "IN_CLOSE_WRITE" in type_names or "IN_MOVED_TO" in type_names:
                    func.get_comic(file_path)
                elif "IN_CREATE" in type_names:
                    if file_path.is_dir():
                        new_dirs.append(file_path)
            for new_dir in new_dirs:
                for file in new_dir.glob("*"):
                    func.get_comic(file)
            new_dirs.clear()



def get_movies():
    with app.app_context():
        i = inotify.adapters.InotifyTree(str(func.MOVIES_DIRECTORY))

        func.get_movies()

        for event in i.event_gen(yield_nones=False):
            (header, type_names, path, filename) = event
            file_path = pathlib.Path(path, filename)
            if "IN_CLOSE_WRITE" in type_names or "IN_MOVED_TO" in type_names:
                func.get_movie(file_path)


def get_tv_shows():
    with app.app_context():
        i = inotify.adapters.InotifyTree(str(func.TV_SHOWS_DIRECTORY))
        func.get_tv_shows()
        func.get_tv_episodes()
        for event in i.event_gen(yield_nones=False):
            (header, type_names, path, filename) = event
            file_path = pathlib.Path(path, filename)
            if "IN_CLOSE_WRITE" in type_names or "IN_MOVED_TO" in type_names:
                if file_path.is_dir():
                    func.get_tv_shows()
                else:
                    func.get_tv_episode(file_path)


def get_games():
    with app.app_context():
        i = inotify.adapters.Inotify()
        i.add_watch(str(func.GAMES_DIRECTORY))
        for directory in func.GAMES_DIRECTORY.iterdir():
            path = func.GAMES_DIRECTORY / directory
            if path.is_dir():
                i.add_watch(str(path))

        func.get_games()
        func.update_games()

        for event in i.event_gen(yield_nones=False):
            (header, type_names, path, filename) = event
            file_path = pathlib.Path(path, filename)
            if "IN_CLOSE_WRITE" in type_names or "IN_MOVED_TO" in type_names:
                func.get_game(file_path)
            elif "IN_CREATE" in type_names:
                if file_path.is_dir() and len(file_path.name) > 2:
                    i.add_watch(str(file_path))
            elif "IN_DELETE_SELF" in type_names:
                if file_path.is_dir():
                    i.remove_watch(file_path)


with app.app_context():
    current_app.logger.info("server start")
    thread = threading.Thread(target=get_comics, args=())
    thread.daemon = True
    thread.start()
    thread2 = threading.Thread(target=get_movies, args=())
    thread2.daemon = True
    thread2.start()
    thread3 = threading.Thread(target=get_tv_shows, args=())
    thread3.daemon = True
    thread3.start()
    thread4 = threading.Thread(target=get_games, args=())
    thread4.daemon = True
    thread4.start()


@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, "_database", None)
    if db is not None:
        db.close()


def update_comic_db(sender, **kw):
    try:
        database.add_comics(kw["meta"], kw["thumbnails"])
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


def update_movie_db(sender, **kw):
    try:
        database.add_movies(kw["movies"])
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


def update_tv_show_db(sender, **kw):
    try:
        database.add_tv_shows(kw["tv_show"])
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


def update_tv_episodes_db(sender, **kw):
    try:
        database.add_tv_episodes(kw["tv_episodes"])
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


def update_games_db(sender, **kw):
    try:
        database.add_games(kw["games"])
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


func.comic_loaded.connect(update_comic_db)
func.movie_loaded.connect(update_movie_db)
func.tv_show_loaded.connect(update_tv_show_db)
func.tv_episodes_loaded.connect(update_tv_episodes_db)
func.games_loaded.connect(update_games_db)


@login_manager.user_loader
def load_user(email):
    try:
        return database.get_user(email)
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


@login_manager.request_loader
def load_user_from_request(request):
    try:
        basic_auth = request.headers.get("Authorization")
        api_key = request.args.get("api_key")
        auth_key = basic_auth if basic_auth else api_key
        if auth_key:
            auth_key = auth_key.replace("Basic ", "", 1)
            try:
                auth_key = base64.b64decode(auth_key).decode("utf-8")
            except TypeError:
                pass
            email = auth_key.split(":")[0]
            password = auth_key.split(":")[1]
            user = load_user(email)
            if user and user.check_password(password):
                return user
        return None
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))


@app.route("/login", methods=["GET", "POST"])
def login():
    try:
        url = urlsplit(request.url)
        google_redirect = urlunsplit(("", "", url.path, url.query, ""))
        next_page = google_redirect
        if "login" in url.path:
            next_page = url_for("home")
        if request.args.get("url", default=None):
            next_page = request.args.get("url", default=None)

        google_provider_cfg = get_google_provider_cfg()
        authorization_endpoint = google_provider_cfg["authorization_endpoint"]

        request_uri = client.prepare_request_uri(
            authorization_endpoint,
            redirect_uri=urljoin(request.host_url, url_for("callback")),
            scope=["openid", "email", "profile"],
            state=next_page,
            hd="narnian.us",
        )

        if request.method == "POST":
            email = request.form.get("email")
            password = request.form.get("password")
            user = database.get_user(email)
            if user is None or not user.check_password(password):
                flash("invalid email or password")
                return redirect(url_for("login"))
            login_user(user, remember=True, duration=datetime.timedelta(days=7))
            return redirect(next_page)
        return render_template("login.html", title="login", auth_url=request_uri)
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@app.route("/login/callback")
def callback():
    try:
        # Get authorization code Google sent back to you
        code = request.args.get("code")

        google_provider_cfg = get_google_provider_cfg()
        token_endpoint = google_provider_cfg["token_endpoint"]

        token_url, headers, body = client.prepare_token_request(
            token_endpoint, authorization_response=request.url, redirect_url=request.base_url, code=code
        )
        token_response = requests.post(token_url, headers=headers, data=body, auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET))

        client.parse_request_body_response(json.dumps(token_response.json()))

        userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
        uri, headers, body = client.add_token(userinfo_endpoint)
        userinfo_response = requests.get(uri, headers=headers, data=body)

        if userinfo_response.json().get("email_verified"):
            unique_id = userinfo_response.json()["sub"]
            users_email = userinfo_response.json()["email"]
            users_name = userinfo_response.json()["given_name"]
        else:
            return "User email not available or not verified by Google.", 400

        data = (unique_id, users_name, users_email, None, False)

        current_app.logger.info("user data from google: " + str(data))
        user = database.get_user(users_email)

        if not user:
            user = database.add_user(data)
            current_app.logger.info("new user: {} created".format(users_email))

        current_app.logger.info("email: " + str(user.email))
        current_app.logger.info("username: " + str(user.username))
        current_app.logger.info("authenticated: " + str(user.is_authenticated))
        current_app.logger.info("active: " + str(user.is_active))
        current_app.logger.info("id: " + str(user.get_id()))
        login_user(user, remember=True, duration=datetime.timedelta(days=7), force=True)

        return redirect(request.args.get("state"))
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@app.route("/logout")
def logout():
    try:
        logout_user()
        return redirect(url_for("login"))
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@app.route("/")
def root():
    return redirect(url_for("home"))


@app.route("/home")
@login_required
def home():
    try:
        return render_template("home.html", title="Home", current_user=current_user)
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@app.after_request
def apply_headers(response: Response):
    try:
        user_name = "anonymous"
        if current_user:
            user_name = getattr(current_user, "email", "anonymous")
        response.set_cookie("rpi_name", user_name)
        response.headers.set("email", user_name)
        return response
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@app.route("/music")
@login_required
def music():
    return "No music"


@app.errorhandler(404)
def resource_not_found(e):
    try:
        return render_template("404.html"), 404
    except Exception as e:
        current_app.logger.error(inspect.stack()[0][3] + " " + str(type(e)) + " " + str(e))
        return str(e)


@login_manager.unauthorized_handler
def handle_unauthorized():
    temp = login()
    t = make_response(temp)
    t.headers['WWW-Authenticate'] = 'Basic realm="Access to the staging site"'
    return t, 401


@app.errorhandler(Exception)
def handle_exception(e):
    return render_template("error.html", e=e), 500


games.Games.register_error_handler(404, resource_not_found)
tv_movies.TV_Movies.register_error_handler(404, resource_not_found)
comics.Comics.register_error_handler(404, resource_not_found)
admin.Admin.register_error_handler(404, resource_not_found)
games.Games.register_error_handler(Exception, handle_exception)
tv_movies.TV_Movies.register_error_handler(Exception, handle_exception)
comics.Comics.register_error_handler(Exception, handle_exception)
admin.Admin.register_error_handler(Exception, handle_exception)


if __name__ == "__main__":
    app.run()