forked from bton/matekasse
421 lines
16 KiB
Python
421 lines
16 KiB
Python
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("/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}
|