matekasse/Website/__init__.py

import queue, time, uuid, json, logging, datetime, os
from flask import Flask, render_template, render_template_string, request, make_response, session, send_file, g 
from flask_socketio import SocketIO, join_room, leave_room 
from flask_session import Session
from Website.db import get_db
import Website.db as db_handler
from datetime import datetime
finished = None
preis = -150 #Ein Getraenk
#flask_config
DATABASE = './Website/mate.db'

def limit_length(text, length=50):
    if type(text) != str:
        text = str(text)
    if len(text) > length:
        return f"{text[:(length -3)]}..."
    return text

def create_app(test_config=None):
    app = Flask(__name__)
    key = str(uuid.uuid4().hex)
    if test_config is None:
        app.config['SESSION_TYPE'] = 'filesystem'
        app.config['SECRET_KEY'] = key
        app.config['DATABASE'] = DATABASE
        app.jinja_env.filters['limit_length'] = limit_length
    else:
        app.config.from_mapping(test_config)

    try:
        os.makedirs(app.instance_path)

    except OSError:
        pass

    Session(app)
    socketio = SocketIO(app) 
    
    #@app.teardown_appcontext
    #def close_connection(exception): 
    #    db = getattr(g, '_database', None)
    #    if db is not None:
    #        db.close()
    #    appt.logger.info("Website exited")
    
    #var
    user_queue = queue.Queue()

    #website
    @app.route('/favicon.ico')
    @app.route('/ccc_logo.png')
    def favicon():
        return send_file("../static/Logo_CCC.svg.png") 

    @app.route('/socket.io.js')
    def socketiojs():
        return send_file('../static/socket.io.js')

    @app.route('/ka-ching.wav')
    def kaching():
        return send_file('../static/ka-ching.wav')

    @app.route('/new.css')
    def newcss():
        return send_file('../static/new.min.css')

    @app.route("/")
    def index():
        return render_template("index.html")

    @app.route("/list")
    def list():
        db = get_db()
        c = db.cursor()
        c.execute("SELECT * FROM users")   
        users = c.fetchall()
        return render_template("list.html", users=users, preis=(preis/100), min_value=-50000)

    @app.route("/transactionlist")
    def transactionlist():
        db = get_db()
        c = db.cursor()
        action_list = []
        c.execute("SELECT * FROM transaction_log ORDER BY ROWID DESC LIMIT 1000")
        transactionlist = c.fetchall()
        for i in transactionlist:
            action = {
                    "statement":i[0],
                    "user_id":i[1],
                    "before":i[2],
                    "after":i[3],
                    "change":i[4]
                }
            if action["statement"] == "balance":
                action["reverse_statement"] = "balance"
                action["reverse_user_id"] = action["user_id"]
                action["reverse_before"] = None
                action["reverse_after"] = None
                action["reverse_change"] = action["change"] *(-1)
            elif action["statement"] == "add_user":
                action["reverse_statement"] = "remove_user"
                action["reverse_user_id"] = action["user_id"]
                action["reverse_before"] = action["after"]
                action["reverse_after"] = None
                action["reverse_change"] = None
            elif action["statement"] == "remove_user":
                action["reverse_statement"] = "add_user"
                action["reverse_user_id"] = action["user_id"]
                action["reverse_before"] = None
                action["reverse_after"] = action["before"]
                action["reverse_change"] = None
            elif action["statement"] == "add_tag":
                action["reverse_statement"] = "remove_tag"
                action["reverse_user_id"] = action["user_id"]
                action["reverse_before"] = action["after"]
                action["reverse_after"] = None
                action["reverse_change"] = None
            elif action["statement"] == "remove_tag":
                action["reverse_statement"] = "add_tag"
                action["reverse_user_id"] = action["user_id"]
                action["reverse_before"] = None
                action["reverse_after"] = action["before"]
                action["reverse_change"] = None
            else:
                raise Exception(statement)
            action_list.append(action)
        return render_template("transactionlist.html", action_list=action_list)
    
    @app.route("/list/user", methods=['GET'])
    def user_info():
        db = get_db()
        c = db.cursor()
        id = request.args.get("id")
        c.execute(f"SELECT * FROM users WHERE id=?", [id])
        user = c.fetchone()
        if user != None :
            c.execute(f"SELECT * FROM tags WHERE userid={user[0]}")
            tags = c.fetchall()
            return render_template("user.html",  user=user, tags=tags, min_value=-50000)
            
        else:
            return render_template("error.html", error_code="043")
    
    @app.route("/adduser", methods=['POST'])
    def new_user():
       	return render_template("adduser.html")

    @app.route("/removeuser", methods=['POST'])
    def remove_user():
        db = get_db()
        c = db.cursor()
        user_id = request.form["id"]
        c.execute(f"SELECT * FROM users WHERE id=?", [user_id])
        user = c.fetchone()
        if user != None:
            user_name = user[1]
            db_handler.remove_user(user_id)
            socketio.emit("update", "update")
            return render_template("removeuser.html", user_name=user_name)
        else:
            return render_template("error.html", error_code="043")

    @app.route("/adduser/user", methods=['POST'])
    def adduser():
        db = get_db()
        c = db.cursor()
        username = request.form["username"]
        if username == None:
            return render_template("error.html", error_code="418")
        c.execute("SELECT * FROM users WHERE username=?", [username]) 
        if c.fetchall() == []:
            db_handler.add_user(username)
            socketio.emit("update", "update")
            c.execute(f"SELECT * FROM users WHERE username=?", [username])
            user = c.fetchone()
            return render_template("redirect.html")
        else:
            return render_template("error.html", error_code="757")


    @app.route("/change", methods=['POST'])
    def change():
        db = get_db()
        c = db.cursor()
        try: 
            user_id = request.form["id"]
            change = int(float(request.form["change"]) * float(100))
        except:
            return render_template("error.html", error_code="095")
        c.execute(f"SELECT * FROM users WHERE id=?", [user_id])
        users = c.fetchall()
        if users != []:
            balance_old = users[0][2]
            db_handler.change_balance(user_id, change)
            socketio.emit("update", "update")
            return render_template("redirect.html")
        else:
            return render_template("error.html", error_code="043")

    @app.route("/addtag", methods=['POST'])
    def get_addtag_request(): 
        try:
            user_id = int(request.form["id"])
        except:  #except im Normalen Code!
            return render_template("error.html", error_code="095")
        session_id = uuid.uuid4()
        session[id] = session_id
        user_queue.put([user_id, "add", session_id])
        return render_template("addtag.html", user=user_id)
    
    @socketio.on('addtag')
    def request_addtag(data):
        global finished
        global message
        join_room(session[id])
        if len(user_queue.queue) > 0:
            user = user_queue.queue[0]
            if user == [data["data"], "add", session[id]]:
                socketio.emit("wait", "wait", to=session[id])
                i = 0
                while finished != [data["data"], "add", session[id]]:
                    time.sleep(1)
                    i += 1
                    if i > 20:
                        socketio.emit("error", "352", to=session[id])
                        notimportant = user_queue.get()
                        break
                else:
                    finished = None
                    socketio.emit("finished", f"{message}", to=session[id])
                    
            else:
                socketio.emit("busy", "busy", to=session[id])
        else:
            socketio.emit("error", "418", to=session[id])
        leave_room(session[id])
    
    @app.route("/removetag", methods=['POST'])
    def get_removetag_request(): 
        try:
            user_id = int(request.form["id"])
        except:  #except im Normalen Code!
            return render_template("error.html", error_code="043")
        try:
            tag_id = int(request.form["tagid"])
        except:
            session_id = uuid.uuid4()
            session[id] = session_id
            user_queue.put([user_id, "remove", session_id])
            return render_template("removetag.html", user=user_id)
        else:
            db = get_db()
            c = db.cursor()
            c.execute(f"SELECT * FROM tags WHERE (tagid = ? AND userid = ?)", [tag_id, user_id])
            if c.fetchall != []:
                db_handler.remove_tag(tag_id)
                message = f"Removed {tag_id} from user {user_id}"
                return render_template("redirect.html")
            else:
                return render_template("error.html", error_code="054")

    @socketio.on('removetag')
    def request_removetag(data):
        global finished
        global message
        join_room(session[id])
        if len(user_queue.queue) > 0:
            queue_item = user_queue.queue[0]
            user = queue_item[0]
            if queue_item == [data["data"], "remove", session[id]]:
                socketio.emit("wait", "wait", to=session[id])
                i = 0
                while finished != [data["data"], "remove", session[id]]:
                    time.sleep(1)
                    i += 1
                    if i > 20:
                        socketio.emit("error", "352", to=session[id])
                        notimportant = user_queue.get()
                        break
                else:
                    finished = None
                    socketio.emit("finished", f"{message}", to=session[id])
            else:
                socketio.emit("busy", "busy", to=session[id])
        else:
            socketio.emit("error", "418", to=session[id])
        leave_room(session[id])

    @app.route("/transfare")
    def transfare():
        db = get_db()
        c = db.cursor()
        c.execute("SELECT * FROM users")
        user_list = c.fetchall()
        return render_template("transfare.html", user_list=user_list)

    @app.route("/api/transfare", methods=['POST'])
    def api_transfare():
        db = get_db()
        c = db.cursor()
        transfare_from = request.form["transfarefrom"]
        transfare_to = request.form["transfareto"]
        change = int(float(request.form["change"]) * float(100))
        c.execute("SELECT * FROM users WHERE id=?", [transfare_from])
        if c.fetchall()  == []:
            return render_template("error.html", error_code="043")
        c.execute("SELECT * FROM users WHERE id=?", [transfare_to])
        if c.fetchall()  == []:
            return render_template("error.html", error_code="043")
        db_handler.change_balance(transfare_from, -change)
        db_handler.change_balance(transfare_to, change)
        return render_template("redirect.html")

    @app.route("/api/balance", methods=['POST', 'GET']) 
    def api_change():
        if request.method == 'POST':
            db = get_db() 
            c = db.cursor()
            userid = request.form["id"]
            c.execute("SELECT * FROM users WHERE id=?", [userid])
            user_list = c.fetchall()
            if user_list != []:
                user = user_list[0]
                try:
                    change = int(request.args.get("change"))
                except:
                    change = preis
                db_handler.change_balance(userid, change)
                socketio.emit("update", "update")
                c.execute("SELECT * FROM users WHERE id=?",[userid])
                return make_response(json.dumps({"mode":"balance", "username":user[1], "balance":c.fetchone()[2]}))
            else:
                return make_response(json.dumps({"mode":"error","error":"043"}))
        
        elif request.method == 'GET':
            db = get_db()
            c = db.cursor()
            userid = request.args.get("id")
            c.execute("SELECT * FROM users WHERE id=?", [userid])
            user = c.fetchone()
            if user != None:
                return make_response(json.dumps({"mode":"balance", "username":user[1], "balance":user[2]}))
            else:
                return make_response(json.dumps({"mode":"error", "error":"043"}))
            


    @app.route("/api/tag_id", methods=['POST'])
    def get_id():
        db = get_db()
        c = db.cursor()
        global finished
        global message
        try:
            tag_id = request.form["id"]
        except:
            return make_response(json.dumps({"mode":"error", "error":"638"}))
        c.execute(f"SELECT * FROM tags WHERE tagid=?", [tag_id])

        tag_list = c.fetchall()
        if user_queue.qsize() > 0:
            queue_item = user_queue.get()
            user = queue_item[0]

            state = queue_item[1]
            c.execute(f"SELECT * FROM users WHERE id=?", [user])
            user = c.fetchone()
            user_id = user[0]
            username = user[1]
            if state == "add":
                c.execute(f"SELECT * FROM tags WHERE tagid={tag_id}")
                if c.fetchall() != []:
                    message = "Error: 170"
                    finished = queue_item
                    return make_response(json.dumps({"mode":"error","error":"170"}))
                else:
                    db_handler.add_tag(user_id, tag_id)
                    message = f"Added {tag_id} to {username}"
                    finished = queue_item
                    return make_response(json.dumps({"mode":"message","username":"{}".format(username),"message":"A tag was added"}))
            elif state == "remove":
                c.execute(f"SELECT * FROM tags WHERE (tagid = {tag_id} AND userid = ?)", [user_id])
                tags = c.fetchall()
                if tags != []:
                    db.commit()
                    message = f"Removed {tag_id} from {username}"
                    finished = queue_item
                    return make_response(json.dumps({"mode":"message","username":"{}".format(username),"message":"A tag was removed"}))
                else:
                    message = "054"
                    finished = queue_item
                    return make_response(json.dumps({"mode":"error","error":"054"}))
            finished = queue_item
            socketio.emit("update", "update")
            return make_response(json.dumps({"mode":"error","error":"418"}))

        elif tag_list != []:
            tag = tag_list[0]
            c.execute(f"SELECT * FROM users WHERE id={tag[1]}")
            user_list = c.fetchall()
            if user_list != []:
                balance_old = user_list[0][2]
                if user_queue.qsize() == 0:
                    db_handler.change_balance(tag[1], preis)
                    c.execute(f"SELECT * FROM users WHERE id={tag[1]}")
                    user = c.fetchone()
                    socketio.emit("update", "update")
                    return make_response(json.dumps({"mode":"balance", "username":user[1], "balance":user[2]/100}))
            else:
                return make_response(json.dumps({"mode":"error", "error":"043"}))
        socketio.emit("update", "update")
        return make_response(json.dumps({"mode":"error","error":"054"}))


    @app.route("/api/change", methods=['POST'])
    def reroll():
        statement = request.form["statement"]
        user_id = request.form["user_id"]
        before = request.form["before"]
        after = request.form["after"]
        change = request.form["change"]
        
        if statement == "add_user":
            db_handler.add_user(after)
        elif statement == "remove_user":
            db_handler.remove_user(user_id)
        elif statement == "add_tag":
            db_handler.add_tag(user_id, after)
        elif statement == "remove_tag":
            db_handler.remove_tag(befor)
        elif statement == "balance":
            db_handler.change_balance(user_id, change)
        else:
            return make_response(json.dumps({"mode":"error", "error":"418"})) #Error code

        socketio.emit("update", "update")
        return render_template("index.html")

    #Documentation
    @app.route("/documentation")
    def documentation():
        return render_template("documentation.html")


    return {"app":app,"socketio":socketio}