matekasse/main.py

import queue
from flask import Flask, render_template, request, make_response, session
from flask_socketio import SocketIO, join_room, leave_room 
from flask_session import Session
import sqlite3
import time
import atexit
import sys
import uuid
import json

db_path = 'mate.db'
conn = sqlite3.connect(db_path, check_same_thread=False)
c = conn.cursor()

app = Flask(__name__)
key = str(uuid.uuid4().hex)
app.config['SESSION_TYPE'] = 'filesystem'
app.config['SECRET_KEY'] = key
Session(app)
socketio = SocketIO(app)


status = True
users = queue.Queue()
finished = None
message = None

def exit_handler():
    conn.close()
    sys.exit("Program sucsesfully exited")

#website
@app.route("/")
def index():
    return '<a href="/list">user and tag list</a> <p>The creator of this website accepts no liability for any linguistic or technical errors!</p><br style="line-height: 500%;"></br><a href="/documentation">Doumentation</a>'

@app.route("/list")
def list():
    c.execute("SELECT * FROM users")   
    users = c.fetchall()
    text = ""
    for i in users:
        text = text + f'<p><a href="list/user?user={i[1]}">{i[1]}</a>: {i[2]} <form action="/change" method="get"><input name="id" type="hidden" value="{i[0]}"> Change balance: <input name="change"><input type="submit"></form></p> <br style="line-height: 50%;"></br>'
    return '''<!DOCTYPE html>
        <html lang="en">
        <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>
        <script type="text/javascript" charset="utf-8">
            var socket = io();
            socket.on("update", function(){
                window.location="http://matekasse.server.c3h/list"
            });
        </script>
        <form action="/list/user" method="get"> Search for User: <input name="user"><input type="submit"></form>
        <form action="/adduser" method="get"><button type="submit">Add User</button></form> 
        <br></br>
        ''' + text + '</html>'  

@app.route("/list/user", methods=['GET'])
def user_info():
    username = request.args.get("user")
    c.execute("SELECT * FROM users WHERE username = ?", [username])
    user_list = c.fetchall()
    if user_list != []:
        user = user_list[0]
        c.execute(f"SELECT * FROM tags WHERE userid={user[0]}")
        tags = c.fetchall()
        text = ""
        for tag in tags:
            text = text + f"<p>{tag[0]}</p>"
        return f"""<!DOCTYPE html>
        <html lang="en">
            <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>
            <script type="text/javascript" charset="utf-8">
            var socket = io();
        """ + 'socket.on("update", function(){ window.location="http://matekasse.server.c3h/list/user?user=' + username + '"});' + f"""
            </script>
            <p> {user[1]} : {user[2]} <p>
            <form action="/addtag" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Add Tag</button></form>
            <form action="/removetag" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Remove Tag</button></form>
            </p><form action="/change" method="get"><input name="id" type="hidden" value="{user[0]}"> Change balance: <input name="change"><input type="submit"></form>
            </p>
            <br></br>
            <p>Tags:</p>
            {text}
            <br></br>
            <form action="/removeuser/confirmation" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Remove User</button></form>
        </html>
        """
    else:
        return "User does not exists"

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

@app.route("/removeuser/confirmation", methods=['GET'])
def confirm_remove_user():
    user_id = request.args.get("id")
    return f'Do your realy want to <a href="/removeuser?id={user_id}">remove the user</a>'

@app.route("/removeuser", methods=['GET'])
def remove_user():
    user_id = request.args.get("id")
    c.execute(f"SELECT * FROM users WHERE id={user_id}")
    user_name = c.fetchall()[0][1]
    c.execute(f"DELETE FROM tags WHERE userid={user_id}")  
    c.execute(f"DELETE FROM users WHERE id={user_id}")
    conn.commit()
    socketio.emit("update", "update")
    return f'<p>Deleted user {user_name}</p><a href="/list">return to the tags and user list</a>'

@app.route("/adduser/user", methods=['GET'])
def adduser():
    user = request.args.get("username")
    c.execute("SELECT * FROM users WHERE username=?", [user]) 
    if c.fetchall() == []:
        c.execute("INSERT or IGNORE INTO users (username, balance) VALUES (?, 0)", [user])
        conn.commit()
        socketio.emit("update", "update")
        return 'Added user <a href="/list">user and tag list</a> <p>The creator of this website accepts no liability for any linguistic or technical errors!</p>'
    else:
        return '<p>User already exists</p> <a href="/list">user and tag list</a>'


@app.route("/change", methods=['GET'])
def change():
    user_id = int(request.args.get("id"))
    try: 
        change = int(request.args.get("change"))
    except ValueError:
        return '<p>Please enter a number!</p><a href="/list">tags and user list</a>'
    c.execute(f"UPDATE users SET balance = balance + {change} WHERE id={user_id}")
    socketio.emit("update", "update")
    return """<html>
            <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>
            <script type="text/javascript" charset="utf-8">
                window.location="http://matekasse.server.c3h/list";
            </script>
            </html>
            """
    #socketio.emit("update", "update")
    #conn.commit()
    #if change < 0:
    #    text = "removed from"
    #    change_text = change * -1
    #elif change > 0:
    #    text = "added to"
    #    change_text = change
    #elif change == 0:
    #    return "<p>Nothing was done!</p>"
    #c.execute(f"SELECT * FROM users WHERE id={user_id}")
    #user = c.fetchall()[0][1]
    #return f'<p>{change_text} was {text} {user}</p> <a href="/list">back to the list</a>'

@app.route("/addtag", methods=['GET'])
def get_addtag_request():
    global users 
    try:
        user_id = int(request.args.get("id"))
    except:  #except im Normalen Code!
        return "Wrong user id!"
    session_id = uuid.uuid4()
    session[id] = session_id
    users.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(users.queue) > 0:
        user = users.queue[len(users.queue) - 1]
        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", "timeout", to=session[id])
                    notimportant = users.get()
                    break
            else:
                finished = None
                c.execute(f"SELECT * FROM users WHERE id ={user[0]}")
                username = c.fetchall()[0][1]
                if message == "Tag already exists":
                    socketio.emit("finished", f"{message}")
                else:
                    socketio.emit("finished", f"Added {message} to {username}", to=session[id])
        else:
            socketio.emit("busy", "busy", to=session[id])
    else:
        socketio.emit("error", "error", to=session[id])
    leave_room(session[id])

@app.route("/removetag", methods=['GET'])
def get_removetag_request():
    global users 
    try:
        user_id = int(request.args.get("id"))
    except:  #except im Normalen Code!
        return "Wrong user id!"
    session_id = uuid.uuid4()
    session[id] = session_id
    users.put([user_id, "remove", session_id])
    return render_template("removetag.html", user=user_id)

@socketio.on('removetag')
def request_removetag(data):
    global finished
    global message
    join_room(session[id])
    if len(users.queue) > 0:
        queue_item = users.queue[len(users.queue) - 1]
        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", "timeout", to=session[id])
                    notimportant = users.get()
                    break
            else:
                finished = None
                c.execute(f"SELECT * FROM users WHERE id ={user}")
                username = c.fetchall()[0][1]
                if message == "Tag does not exist":
                    socketio.emit("finished", f"{message}")
                else:
                    socketio.emit("finished", f"removed {message} from {username}")
        else:
            socketio.emit("busy", "busy", to=session[id])
    else:
        socketio.emit("error", "error", to=session[id])
    leave_room(session[id])

#api
@app.route("/api/tag_id", methods=['GET'])
def get_id():
    global finished
    global message
    tag_id = int(request.args.get("id"))
    c.execute(f"SELECT * FROM tags WHERE tagid ={tag_id}")

    tag_list = c.fetchall()
    if users.qsize() > 0:
        queue_item = users.get()
        user = queue_item[0]
        state = queue_item[1]
        if state == "add":
            c.execute(f"SELECT * FROM tags WHERE tagid={tag_id}")
            if c.fetchall() != []:
                message = "Tag already exists"
                finished = queue_item
                return make_response(json.dumps({"mode":"0","error":"170"}))
            else:
                c.execute(f"INSERT OR IGNORE INTO tags (tagid, userid) VALUES ({tag_id}, {user})")
                message = tag_id
                finished = queue_item
                c.execute(f"SELECT * FROM users WHERE id={user}")
                username = c.fetchall()
                conn.commit()
                return make_response(json.dumps({"mode":"2","username":username,"code":"1"}))
        elif state == "remove":
            c.execute(f"SELECT * FROM tags WHERE (tagid = {tag_id} AND userid = {user})")
            tags = c.fetchall()
            if tags != []:
                c.execute(f"DELETE FROM tags WHERE (tagid = {tag_id} AND userid = {user}) ")
                message = tag_id
                finished = queue_item
                c.execute(f"SELECT * FROM users WHERE id={user}")
                username = c.fetchall()
                conn.commit()
                return make_response(json({"mode":"2","username":username,"code":"2"}))
            else:
                message = "Tag does not exist"
                finished = queue_item
                return make_response(json.dumps({"mode":"0","error":"054"}))
        finished = queue_item
        socketio.emit("update", "update")
        return make_response(json.dumps({"mode":"0","error":"418"}))
    
    elif tag_list != []:
        tag = tag_list[0]
        if users.qsize() == 0:
            c.execute(f"UPDATE users SET balance = balance - 1 WHERE id={tag[1]}")
            conn.commit() 
            c.execute(f"SELECT * FROM users WHERE id={tag[1]}")
            user = c.fetchall()[0]
            socketio.emit("update", "upfinished = queue_itemdate")
            return make_response(json.dumps({"mode":"1", "username":user[1], "balance":user[2]}))
    socketio.emit("update", "update")
    return make_response(json.dumps({"mode":"0","error":"418"}))

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

def main():
    atexit.register(exit_handler)
    socketio.run(app, host='0.0.0.0', port=5000)
initial 2023-05-31 20:33:45 +02:00			`import queue`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`from flask import Flask, render_template, request, make_response, session`
Don't show a message after change 2023-06-16 19:29:49 +02:00			`from flask_socketio import SocketIO, join_room, leave_room`
Session fix 2023-06-09 22:44:36 +02:00			`from flask_session import Session`
initial 2023-05-31 20:33:45 +02:00			`import sqlite3`
			`import time`
			`import atexit`
			`import sys`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`import uuid`
API return json 2023-06-21 19:03:59 +02:00			`import json`
initial 2023-05-31 20:33:45 +02:00
			`db_path = 'mate.db'`
penis 2023-05-31 19:23:40 +00:00			`conn = sqlite3.connect(db_path, check_same_thread=False)`
initial 2023-05-31 20:33:45 +02:00			`c = conn.cursor()`

			`app = Flask(__name__)`
typo fix 2023-06-09 22:27:45 +02:00			`key = str(uuid.uuid4().hex)`
change session type to file system 2023-06-09 22:57:59 +02:00			`app.config['SESSION_TYPE'] = 'filesystem'`
session fix? 2023-06-09 22:54:01 +02:00			`app.config['SECRET_KEY'] = key`
seltsames Session kram 2023-06-09 22:39:09 +02:00			`Session(app)`
stuf 2023-06-09 21:47:15 +02:00			`socketio = SocketIO(app)`


initial 2023-05-31 20:33:45 +02:00
			`status = True`
			`users = queue.Queue()`
			`finished = None`
fix 2023-06-14 21:37:51 +02:00			`message = None`
initial 2023-05-31 20:33:45 +02:00
			`def exit_handler():`
			`conn.close()`
			`sys.exit("Program sucsesfully exited")`

			`#website`
			`@app.route("/")`
			`def index():`
typo 2023-06-21 20:01:16 +02:00			`return '<a href="/list">user and tag list</a> <p>The creator of this website accepts no liability for any linguistic or technical errors!</p><br style="line-height: 500%;"></br><a href="/documentation">Doumentation</a>'`
initial 2023-05-31 20:33:45 +02:00
			`@app.route("/list")`
			`def list():`
			`c.execute("SELECT * FROM users")`
			`users = c.fetchall()`
			`text = ""`
			`for i in users:`
changet br space to 50% 2023-06-09 20:11:51 +02:00			`text = text + f'<p><a href="list/user?user={i[1]}">{i[1]}</a>: {i[2]} <form action="/change" method="get"><input name="id" type="hidden" value="{i[0]}"> Change balance: <input name="change"><input type="submit"></form></p> <br style="line-height: 50%;"></br>'`
Updatelist if balance is changed 2023-06-14 20:55:54 +02:00			`return '''<!DOCTYPE html>`
Added update to /list/user 2023-06-14 21:06:50 +02:00			`<html lang="en">`
Updatelist if balance is changed 2023-06-14 20:55:54 +02:00			`<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>`
			`<script type="text/javascript" charset="utf-8">`
			`var socket = io();`
			`socket.on("update", function(){`
			`window.location="http://matekasse.server.c3h/list"`
			`});`
			`</script>`
			`<form action="/list/user" method="get"> Search for User: <input name="user"><input type="submit"></form>`
			`<form action="/adduser" method="get"><button type="submit">Add User</button></form>`
			`<br></br>`
			`''' + text + '</html>'`
initial 2023-05-31 20:33:45 +02:00
			`@app.route("/list/user", methods=['GET'])`
socket 2023-05-31 22:29:47 +02:00			`def user_info():`
fixed error in /remove user 2023-06-14 18:54:58 +02:00			`username = request.args.get("user")`
Fixed SQlite injektions 2023-06-16 19:20:25 +02:00			`c.execute("SELECT * FROM users WHERE username = ?", [username])`
fixed error in /remove user 2023-06-14 18:54:58 +02:00			`user_list = c.fetchall()`
			`if user_list != []:`
			`user = user_list[0]`
Remove User tag list 2023-06-10 00:09:52 +02:00			`c.execute(f"SELECT * FROM tags WHERE userid={user[0]}")`
			`tags = c.fetchall()`
			`text = ""`
			`for tag in tags:`
			`text = text + f"<p>{tag[0]}</p>"`
fixed vars in the script of /user r 2023-06-14 21:13:03 +02:00			`return f"""<!DOCTYPE html>`
Added update to /list/user 2023-06-14 21:06:50 +02:00			`<html lang="en">`
			`<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>`
			`<script type="text/javascript" charset="utf-8">`
fiX 2023-06-14 21:20:44 +02:00			`var socket = io();`
			`""" + 'socket.on("update", function(){ window.location="http://matekasse.server.c3h/list/user?user=' + username + '"});' + f"""`
			`</script>`
fix 2023-06-14 21:14:25 +02:00			`<p> {user[1]} : {user[2]} <p>`
fixed vars in the script of /user r 2023-06-14 21:13:03 +02:00			`<form action="/addtag" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Add Tag</button></form>`
			`<form action="/removetag" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Remove Tag</button></form>`
			`</p><form action="/change" method="get"><input name="id" type="hidden" value="{user[0]}"> Change balance: <input name="change"><input type="submit"></form>`
Added update to /list/user 2023-06-14 21:06:50 +02:00			`</p>`
			`<br></br>`
			`<p>Tags:</p>`
fixed vars in the script of /user r 2023-06-14 21:13:03 +02:00			`{text}`
Added update to /list/user 2023-06-14 21:06:50 +02:00			`<br></br>`
fix 2023-06-14 21:26:03 +02:00			`<form action="/removeuser/confirmation" method="get"><input name="id" type="hidden" value="{user[0]}"><button type="submit">Remove User</button></form>`
Added update to /list/user 2023-06-14 21:06:50 +02:00			`</html>`
			`"""`
initial 2023-05-31 20:33:45 +02:00			`else:`
			`return "User does not exists"`

			`@app.route("/adduser")`
			`def new_user():`
			`return render_template("adduser.html")`

typo 2023-06-14 19:49:28 +02:00			`@app.route("/removeuser/confirmation", methods=['GET'])`
Added confirmation to /removeuser 2023-06-14 19:48:21 +02:00			`def confirm_remove_user():`
			`user_id = request.args.get("id")`
typo 2023-06-14 19:59:22 +02:00			`return f'Do your realy want to <a href="/removeuser?id={user_id}">remove the user</a>'`
Added confirmation to /removeuser 2023-06-14 19:48:21 +02:00
typo 2023-06-14 18:28:45 +02:00			`@app.route("/removeuser", methods=['GET'])`
Remove User tag list 2023-06-10 00:09:52 +02:00			`def remove_user():`
fixed error in /removeuser 2023-06-14 18:56:26 +02:00			`user_id = request.args.get("id")`
Added confirmation to /removeuser 2023-06-14 19:48:21 +02:00			`c.execute(f"SELECT * FROM users WHERE id={user_id}")`
			`user_name = c.fetchall()[0][1]`
Deleted * from sql 2023-06-14 19:36:30 +02:00			`c.execute(f"DELETE FROM tags WHERE userid={user_id}")`
			`c.execute(f"DELETE FROM users WHERE id={user_id}")`
Remove User tag list 2023-06-10 00:09:52 +02:00			`conn.commit()`
Don't show a message after change 2023-06-16 19:29:49 +02:00			`socketio.emit("update", "update")`
Added confirmation to /removeuser 2023-06-14 19:48:21 +02:00			`return f'<p>Deleted user {user_name}</p><a href="/list">return to the tags and user list</a>'`
Remove User tag list 2023-06-10 00:09:52 +02:00
initial 2023-05-31 20:33:45 +02:00			`@app.route("/adduser/user", methods=['GET'])`
			`def adduser():`
			`user = request.args.get("username")`
Fixed SQlite injektions 2023-06-16 19:20:25 +02:00			`c.execute("SELECT * FROM users WHERE username=?", [user])`
initial 2023-05-31 20:33:45 +02:00			`if c.fetchall() == []:`
Fixed SQlite injektions 2023-06-16 19:20:25 +02:00			`c.execute("INSERT or IGNORE INTO users (username, balance) VALUES (?, 0)", [user])`
initial 2023-05-31 20:33:45 +02:00			`conn.commit()`
Don't show a message after change 2023-06-16 19:29:49 +02:00			`socketio.emit("update", "update")`
penis 2023-05-31 19:23:40 +00:00			`return 'Added user <a href="/list">user and tag list</a> <p>The creator of this website accepts no liability for any linguistic or technical errors!</p>'`
initial 2023-05-31 20:33:45 +02:00			`else:`
Shunlnd do anything (that is right inglish) 2023-06-16 18:54:34 +02:00			`return '<p>User already exists</p> <a href="/list">user and tag list</a>'`
initial 2023-05-31 20:33:45 +02:00

			`@app.route("/change", methods=['GET'])`
			`def change():`
			`user_id = int(request.args.get("id"))`
			`try:`
			`change = int(request.args.get("change"))`
			`except ValueError:`
list and change 2023-06-09 19:53:27 +02:00			`return '<p>Please enter a number!</p><a href="/list">tags and user list</a>'`
more bug fixing inside the change funktion 2023-06-09 20:17:30 +02:00			`c.execute(f"UPDATE users SET balance = balance + {change} WHERE id={user_id}")`
Don't show a message after change 2023-06-16 19:29:49 +02:00			`socketio.emit("update", "update")`
			`return """<html>`
			`<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js" integrity="sha512-q/dWJ3kcmjBLU4Qc47E4A9kTB4m3wuTY7vkFJDTZKjTs8jhyGQnaUrxa0Ytd0ssMZhbNua9hE+E7Qv1j+DyZwA==" crossorigin="anonymous"></script>`
			`<script type="text/javascript" charset="utf-8">`
			`window.location="http://matekasse.server.c3h/list";`
			`</script>`
			`</html>`
			`"""`
			`#socketio.emit("update", "update")`
			`#conn.commit()`
			`#if change < 0:`
			`# text = "removed from"`
			`# change_text = change * -1`
			`#elif change > 0:`
			`# text = "added to"`
			`# change_text = change`
			`#elif change == 0:`
			`# return "<p>Nothing was done!</p>"`
			`#c.execute(f"SELECT * FROM users WHERE id={user_id}")`
			`#user = c.fetchall()[0][1]`
			`#return f'<p>{change_text} was {text} {user}</p> <a href="/list">back to the list</a>'`
initial 2023-05-31 20:33:45 +02:00
			`@app.route("/addtag", methods=['GET'])`
			`def get_addtag_request():`
			`global users`
			`try:`
			`user_id = int(request.args.get("id"))`
			`except: #except im Normalen Code!`
			`return "Wrong user id!"`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`session_id = uuid.uuid4()`
random fix sachen 2023-06-09 22:23:01 +02:00			`session[id] = session_id`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`users.put([user_id, "add", session_id])`
initial 2023-05-31 20:33:45 +02:00			`return render_template("addtag.html", user=user_id)`

			`@socketio.on('addtag')`
			`def request_addtag(data):`
			`global finished`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`global message`
ii 2023-06-09 23:16:16 +02:00			`join_room(session[id])`
initial 2023-05-31 20:33:45 +02:00			`if len(users.queue) > 0:`
			`user = users.queue[len(users.queue) - 1]`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`if user == [data["data"], "add", session[id]]:`
ii 2023-06-09 23:16:16 +02:00			`socketio.emit("wait", "wait", to=session[id])`
initial 2023-05-31 20:33:45 +02:00			`i = 0`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`while finished != [data["data"], "add", session[id]]:`
initial 2023-05-31 20:33:45 +02:00			`time.sleep(1)`
			`i += 1`
			`if i > 20:`
ii 2023-06-09 23:16:16 +02:00			`socketio.emit("error", "timeout", to=session[id])`
delete user out of queue after timeout 2023-06-09 19:11:45 +02:00			`notimportant = users.get()`
socket 2023-05-31 22:29:47 +02:00			`break`
			`else:`
			`finished = None`
Remove User tag list 2023-06-10 00:09:52 +02:00			`c.execute(f"SELECT * FROM users WHERE id ={user[0]}")`
socket 2023-05-31 22:29:47 +02:00			`username = c.fetchall()[0][1]`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`if message == "Tag already exists":`
			`socketio.emit("finished", f"{message}")`
			`else:`
Removed all print statments 2023-06-14 21:46:10 +02:00			`socketio.emit("finished", f"Added {message} to {username}", to=session[id])`
initial 2023-05-31 20:33:45 +02:00			`else:`
ii 2023-06-09 23:16:16 +02:00			`socketio.emit("busy", "busy", to=session[id])`
initial 2023-05-31 20:33:45 +02:00			`else:`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`socketio.emit("error", "error", to=session[id])`
			`leave_room(session[id])`
initial 2023-05-31 20:33:45 +02:00
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`@app.route("/removetag", methods=['GET'])`
added html for remove tag 2023-06-09 21:26:17 +02:00			`def get_removetag_request():`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`global users`
			`try:`
			`user_id = int(request.args.get("id"))`
			`except: #except im Normalen Code!`
			`return "Wrong user id!"`
			`session_id = uuid.uuid4()`
delet old fix try stuf 2023-06-09 22:59:30 +02:00			`session[id] = session_id`
fix 2023-06-09 23:01:55 +02:00			`users.put([user_id, "remove", session_id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`return render_template("removetag.html", user=user_id)`

			`@socketio.on('removetag')`
added html for remove tag 2023-06-09 21:26:17 +02:00			`def request_removetag(data):`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`global finished`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`global message`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`join_room(session[id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`if len(users.queue) > 0:`
Remove User tag list 2023-06-10 00:09:52 +02:00			`queue_item = users.queue[len(users.queue) - 1]`
typo and typu 2023-06-14 20:32:50 +02:00			`user = queue_item[0]`
Remove User tag list 2023-06-10 00:09:52 +02:00			`if queue_item == [data["data"], "remove", session[id]]:`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`socketio.emit("wait", "wait", to=session[id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`i = 0`
			`while finished != [data["data"], "remove", session[id]]:`
			`time.sleep(1)`
			`i += 1`
			`if i > 20:`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`socketio.emit("error", "timeout", to=session[id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`notimportant = users.get()`
			`break`
			`else:`
			`finished = None`
			`c.execute(f"SELECT * FROM users WHERE id ={user}")`
			`username = c.fetchall()[0][1]`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`if message == "Tag does not exist":`
			`socketio.emit("finished", f"{message}")`
			`else:`
			`socketio.emit("finished", f"removed {message} from {username}")`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`else:`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`socketio.emit("busy", "busy", to=session[id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`else:`
room specifik socketio emit 2023-06-09 23:19:11 +02:00			`socketio.emit("error", "error", to=session[id])`
			`leave_room(session[id])`
added removetag and sessionids 2023-06-09 21:22:25 +02:00
initial 2023-05-31 20:33:45 +02:00			`#api`
			`@app.route("/api/tag_id", methods=['GET'])`
			`def get_id():`
			`global finished`
typo 2023-06-14 21:39:13 +02:00			`global message`
initial 2023-05-31 20:33:45 +02:00			`tag_id = int(request.args.get("id"))`
			`c.execute(f"SELECT * FROM tags WHERE tagid ={tag_id}")`

removed print and fixed removeaddtag 2023-06-09 23:24:44 +02:00			`tag_list = c.fetchall()`
			`if users.qsize() > 0:`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`queue_item = users.get()`
			`user = queue_item[0]`
			`state = queue_item[1]`
			`if state == "add":`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`c.execute(f"SELECT * FROM tags WHERE tagid={tag_id}")`
			`if c.fetchall() != []:`
			`message = "Tag already exists"`
Error Codes 2023-06-21 19:39:13 +02:00			`finished = queue_item`
			`return make_response(json.dumps({"mode":"0","error":"170"}))`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`else:`
			`c.execute(f"INSERT OR IGNORE INTO tags (tagid, userid) VALUES ({tag_id}, {user})")`
			`message = tag_id`
Error Codes 2023-06-21 19:39:13 +02:00			`finished = queue_item`
			`c.execute(f"SELECT * FROM users WHERE id={user}")`
			`username = c.fetchall()`
Documentation 2023-06-21 20:08:31 +02:00			`conn.commit()`
typo 2023-06-21 20:01:16 +02:00			`return make_response(json.dumps({"mode":"2","username":username,"code":"1"}))`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`elif state == "remove":`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`c.execute(f"SELECT * FROM tags WHERE (tagid = {tag_id} AND userid = {user})")`
Test print 2023-06-14 21:43:41 +02:00			`tags = c.fetchall()`
			`if tags != []:`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`c.execute(f"DELETE FROM tags WHERE (tagid = {tag_id} AND userid = {user}) ")`
			`message = tag_id`
Error Codes 2023-06-21 19:39:13 +02:00			`finished = queue_item`
			`c.execute(f"SELECT * FROM users WHERE id={user}")`
			`username = c.fetchall()`
Documentation 2023-06-21 20:08:31 +02:00			`conn.commit()`
Error Codes 2023-06-21 19:39:13 +02:00			`return make_response(json({"mode":"2","username":username,"code":"2"}))`
Error message for remove and add tag 2023-06-14 21:35:11 +02:00			`else:`
			`message = "Tag does not exist"`
Error Codes 2023-06-21 19:39:13 +02:00			`finished = queue_item`
			`return make_response(json.dumps({"mode":"0","error":"054"}))`
added removetag and sessionids 2023-06-09 21:22:25 +02:00			`finished = queue_item`
Added update server side 2023-06-14 20:58:22 +02:00			`socketio.emit("update", "update")`
Documentation 2023-06-21 20:08:31 +02:00			`return make_response(json.dumps({"mode":"0","error":"418"}))`
removed print and fixed removeaddtag 2023-06-09 23:24:44 +02:00
			`elif tag_list != []:`
			`tag = tag_list[0]`
			`if users.qsize() == 0:`
			`c.execute(f"UPDATE users SET balance = balance - 1 WHERE id={tag[1]}")`
			`conn.commit()`
API return json 2023-06-21 19:03:59 +02:00			`c.execute(f"SELECT * FROM users WHERE id={tag[1]}")`
API return json 2023-06-21 19:07:02 +02:00			`user = c.fetchall()[0]`
Error Codes 2023-06-21 19:39:13 +02:00			`socketio.emit("update", "upfinished = queue_itemdate")`
			`return make_response(json.dumps({"mode":"1", "username":user[1], "balance":user[2]}))`
Added update server side 2023-06-14 20:58:22 +02:00			`socketio.emit("update", "update")`
typo 2023-06-21 20:01:16 +02:00			`return make_response(json.dumps({"mode":"0","error":"418"}))`
initial 2023-05-31 20:33:45 +02:00
typo 2023-06-21 20:01:16 +02:00			`#Documentation`
Documentation 2023-06-21 20:12:06 +02:00			`@app.route("/documentation")`
typo 2023-06-21 20:01:16 +02:00			`def documentation():`
			`return render_template("documentation.html")`
Documentation 2023-06-21 20:12:06 +02:00
initial 2023-05-31 20:33:45 +02:00			`def main():`
			`atexit.register(exit_handler)`
Don't show a message after change 2023-06-16 19:29:49 +02:00			`socketio.run(app, host='0.0.0.0', port=5000)`