SoftwareEngineering/DualHub
4
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Refactoring

Browse Source
This commit is contained in:
Paul Martin
2024-06-02 19:03:00 +02:00
parent 57b5b4ffab
commit 8c11166397
14 changed files with 401 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
routing.py
View File

@ -1,16 +1,14 @@
#!/usr/bin/env python3.6
from flask import make_response
from flask import render_template, url_for, redirect, request
from flask_login import login_user, login_required, current_user, logout_user
from flask_login import (login_user as loginUser, login_required as loginRequired,
logout_user as logoutUser, current_user as currentUser)
from werkzeug.exceptions import HTTPException
from werkzeug.security import generate_password_hash, check_password_hash
import hashlib
import datetime
import time
import random
import fetchDUALIS
import fetchMENSA
import fetchRAPLA
from requesthelpers import *
from fetchRAPLA import *
@ -18,9 +16,10 @@ from calendar_generation import getWeek
from init import *
def init_routes(app: Flask):
def initRoutes(app: Flask):
"""
Initialisiert die App-Routen. Nötig für Tests.
:param app:
"""
@app.route("/")
@ -32,59 +31,60 @@ def init_routes(app: Flask):
return redirect(url_for("login"))
@app.route("/dashboard")
@login_required
@loginRequired
def welcome():
"""
Dashboard
:return HTML:
"""
if not current_user.kurs:
if not currentUser.kurs:
return redirect(url_for("getKurs", next=url_for(request.endpoint)))
sel = request.args.get("sel")
if not sel:
sel = "theorie"
kurs = current_user.kurs
name = current_user.name
if sel == "theorie":
t = ""
p = "hidden"
selectedPhase = request.args.get("sel")
if not selectedPhase:
selectedPhase = "theorie"
kurs = currentUser.kurs
name = currentUser.name
if selectedPhase == "theorie":
theorie = ""
praxis = "hidden"
else:
t = "hidden"
p = ""
return render_template('dashboard.html', kurs=kurs, name=name, theorie=t, praxis=p)
theorie = "hidden"
praxis = ""
return render_template('dashboard.html', kurs=kurs, name=name, theorie=theorie, praxis=praxis)
@app.route("/theorie/noten", methods=["GET", "POST"])
@login_required
@loginRequired
async def displayNoten():
"""
Zeigt die Noten aus Dualis an. Hierfür ist ein aktives Token nötig.
:return HTML:
"""
d = Dualis.query.filter_by(uid=current_user.id).first()
dualisUser = Dualis.query.filter_by(uid=currentUser.id).first()
if request.method == "POST":
d.semester = request.form.get("sem")
dualisUser.semester = request.form.get("sem")
db.session.commit()
if not d.semester:
if not dualisUser.semester:
return redirect(url_for("getSemester", next=url_for(request.endpoint)))
t = d.token
chosensemester = d.semester
c = request.cookies.get("cnsc")
timeout = fetchDUALIS.timeOut(d, c, "displayNoten")
token = dualisUser.token
chosenSemester = dualisUser.semester
cookie = request.cookies.get("cnsc")
timeout = fetchDUALIS.timeOut(dualisUser, cookie, "displayNoten")
if timeout:
return timeout
semester = getSemesterList(current_user.id)
noten = await fetchDUALIS.getResults(t, c, chosensemester)
return render_template("noten.html", noten=noten, semester=semester, sel=chosensemester, s="n", praxis="hidden")
semester = getSemesterList(currentUser.id)
noten = await fetchDUALIS.getResults(token, cookie, chosenSemester)
return render_template("noten.html", noten=noten, semester=semester, sel=chosenSemester, s="n",
praxis="hidden")
@app.route("/plan", methods=["GET"])
@login_required
@loginRequired
async def displayRapla():
"""
Zeigt den Stundenplan für eingeloggte User an. \n
TODO: Persönliche Filter, Notizen, Essensvorlieben etc. berücksichtigen.
:return HTML:
"""
if not current_user.kurs:
if not currentUser.kurs:
return redirect(url_for("getKurs", next=url_for(request.endpoint)))
week = request.args.get("week")
if week:
@ -94,9 +94,9 @@ def init_routes(app: Flask):
samstag = request.args.get("samstag")
if not samstag:
samstag = False
events = await getWeek(week, fetchRAPLA.getIcal(current_user.kurs), samstag)
events = await getWeek(week, fetchRAPLA.getIcal(currentUser.kurs), samstag)
return render_template("plan-user.html", events=events[0], eventdays=events[1],
name=current_user.name, prev=str(events[2])[:10], next=str(events[3])[:10],
name=currentUser.name, prev=str(events[2])[:10], next=str(events[3])[:10],
mon=events[4],
s="p", praxis="hidden")
@ -114,7 +114,7 @@ def init_routes(app: Flask):
else:
week = "today"
try:
if current_user.kurs == kurs.upper():
if currentUser.kurs == kurs.upper():
return redirect(url_for("displayRapla"))
except AttributeError:
pass
@ -139,88 +139,89 @@ def init_routes(app: Flask):
return redirect(url_for("getKurs"))
@app.route("/set-up/kurs")
@login_required
@loginRequired
async def getKurs():
"""
Automatische Kurs-Auswahl. \n
Aktives Dualis-Token benötigt.
:return HTML:
"""
d = Dualis.query.filter_by(uid=current_user.id).first()
if d:
dualisUser = Dualis.query.filter_by(uid=currentUser.id).first()
if dualisUser:
cookie = request.cookies.get("cnsc")
timeout = fetchDUALIS.timeOut(d, cookie, "getKurs")
timeout = fetchDUALIS.timeOut(dualisUser, cookie, "getKurs")
if timeout:
return timeout
e = False
if not current_user.kurs:
kurs = await fetchDUALIS.getKurs(d.token, cookie)
dualisError = False
if not currentUser.kurs:
kurs = await fetchDUALIS.getKurs(dualisUser.token, cookie)
if kurs != 0:
if not fetchRAPLA.getIcal(kurs):
return render_template('kurs.html', detected=(kurs, e), s="s", theorie="hidden",
praxis="hidden",
file=False)
current_user.kurs = kurs
return render_template('kurs.html', detected=(kurs, dualisError), s="s",
theorie="hidden", praxis="hidden", file=False)
currentUser.kurs = kurs
db.session.commit()
else:
e = True
dualisError = True
else:
kurs = current_user.kurs
current_user.kurs = kurs
kurs = currentUser.kurs
currentUser.kurs = kurs
db.session.commit()
else:
e = True
dualisError = True
kurs = ""
return render_template('kurs.html', detected=(kurs, e), s="s", theorie="hidden", praxis="hidden", file=True)
return render_template('kurs.html', detected=(kurs, dualisError), s="s", theorie="hidden",
praxis="hidden", file=True)
@app.route("/set-up/semester")
@login_required
@loginRequired
async def getSemester():
"""
Manuelle Semester-Auswahl.
:return HTML:
"""
t = Dualis.query.filter_by(uid=current_user.id).first().token
c = request.cookies.get("cnsc")
semesterlist = Semesterlist.query.filter_by(uid=current_user.id).all()
if not semesterlist:
semester = await fetchDUALIS.getSem(t, c)
token = Dualis.query.filter_by(uid=currentUser.id).first().token
cookie = request.cookies.get("cnsc")
semesterList = Semesterlist.query.filter_by(uid=currentUser.id).all()
if not semesterList:
semester = await fetchDUALIS.getSem(token, cookie)
for i in semester:
semitem = Semesterlist(semestername=i[0], semesterid=i[1], uid=current_user.id,
itemid=current_user.id * int(i[1][-7:]) // 1000000)
db.session.add(semitem)
semsterItem = Semesterlist(semestername=i[0], semesterid=i[1], uid=currentUser.id,
itemid=currentUser.id * int(i[1][-7:]) // 1000000)
db.session.add(semsterItem)
db.session.commit()
else:
semester = getSemesterList(current_user.id)
return render_template("semester.html", semester=semester, s="s", theorie="hidden", praxis="hidden")
semester = getSemesterList(currentUser.id)
return render_template("semester.html", semester=semester, s="s",
theorie="hidden", praxis="hidden")
@app.route("/set-up/semester", methods=["POST"])
@login_required
@loginRequired
def setSemester():
"""
Speichern der Semester-Auswahl.
:return HTML:
"""
n = request.args.get("next")
if not n:
n = url_for("welcome")
d = Dualis.query.filter_by(uid=current_user.id).first()
d.semester = request.form.get("sem")
nextArg = request.args.get("next")
if not nextArg:
nextArg = url_for("welcome")
dualisUser = Dualis.query.filter_by(uid=currentUser.id).first()
dualisUser.semester = request.form.get("sem")
db.session.commit()
return redirect(n)
return redirect(nextArg)
@app.route("/set-up/rapla")
@login_required
@loginRequired
def chooseRaplas():
"""
Manuelle Rapla-Auswahl.
:return HTML:
"""
r = getRaplas()
return render_template("rapla.html", raplas=r, s="s", theorie="hidden", praxis="hidden")
raplas = getRaplas()
return render_template("rapla.html", raplas=raplas, s="s", theorie="hidden", praxis="hidden")
@app.route("/set-up/rapla", methods=["POST"])
@login_required
@loginRequired
async def getRapla():
"""
Verarbeitet die Eingabe von chooseRaplas().
@ -231,12 +232,12 @@ def init_routes(app: Flask):
if file == url == "None":
return redirect(url_for("chooseRaplas"))
if file != "None":
loadUser(current_user.id).kurs = file[5:-5]
loadUser(currentUser.id).kurs = file[5:-5]
db.session.commit()
elif url != "None":
file = await getNewRapla(url)
if type(file) is not int:
loadUser(current_user.id).kurs = file[5:-5]
loadUser(currentUser.id).kurs = file[5:-5]
db.session.commit()
else:
return redirect(url_for("error", ecode=900))
@ -260,89 +261,93 @@ def init_routes(app: Flask):
"""
email = request.form.get("email")
password = request.form.get("password")
n = request.args.get("next")
if n:
success = make_response(redirect(n))
nextArg = request.args.get("next")
if nextArg:
success = make_response(redirect(nextArg))
else:
success = make_response(redirect(url_for("getKurs")))
user = User.query.filter_by(email=email).first()
t = await fetchDUALIS.checkUser(email, password)
if t[0] == -2:
tokenAndCookie = await fetchDUALIS.checkUser(email, password)
if tokenAndCookie[0] == -2:
return redirect(url_for("login", code=-2))
if user:
dualis = Dualis.query.filter_by(uid=user.id).first()
dualis.token = t[0]
newcookie = t[1]
dualis.token_created = time.time()
dualisUser = Dualis.query.filter_by(uid=user.id).first()
dualisUser.token = tokenAndCookie[0]
newCookie = tokenAndCookie[1]
dualisUser.token_created = time.time()
db.session.commit()
login_user(user)
loginUser(user)
if user.kurs:
if not dualis.semester:
if not dualisUser.semester:
success = make_response(redirect(url_for("getSemester")))
elif not n:
elif not nextArg:
success = make_response(redirect(url_for("welcome")))
success.set_cookie("cnsc", value=newcookie, httponly=True, secure=True)
success.set_cookie("cnsc", value=newCookie, httponly=True, secure=True)
else:
hashid = int(hashlib.sha1(email.encode("utf-8")).hexdigest(), 16) % (10 ** 8)
pname = email.find(".") + 1
ename = min(email[pname:].find("."), email[pname:].find("@"))
name = email[pname:pname + ename].capitalize()
new_user = User(email=email, name=name, id=hashid)
hashedID = int(hashlib.sha1(email.encode("utf-8")).hexdigest(), 16) % (10 ** 8)
vorname = email.find(".") + 1
nachname = min(email[vorname:].find("."), email[vorname:].find("@"))
name = email[vorname:(vorname + nachname)].capitalize()
new_user = User(email=email, name=name, id=hashedID)
db.session.add(new_user)
cookie = t[1]
cookie = tokenAndCookie[1]
new_dualis = Dualis(uid=hashid, token=t[0], token_created=int(time.time()))
db.session.add(new_dualis)
newDualis = Dualis(uid=hashedID, token=tokenAndCookie[0], token_created=int(time.time()))
db.session.add(newDualis)
db.session.commit()
login_user(new_user)
loginUser(new_user)
success.set_cookie("cnsc", value=cookie, httponly=True, secure=True)
return success
@app.route("/log-out")
@login_required
@loginRequired
async def logout():
"""
Loggt den User aus.
:return Empty Token:
"""
cookie = request.cookies.get("cnsc")
dualis = Dualis.query.filter_by(uid=current_user.id).first()
await fetchDUALIS.logOut(dualis.token, cookie)
dualis.token = None
dualisUser = Dualis.query.filter_by(uid=currentUser.id).first()
await fetchDUALIS.logOut(dualisUser.token, cookie)
dualisUser.token = None
db.session.commit()
logout_user()
red = make_response(redirect(url_for("login", code=1, next=url_for("welcome"))))
red.set_cookie("cnsc", value="Logged out! Your temporary token "
logoutUser()
redirection = make_response(redirect(url_for("login", code=1, next=url_for("welcome"))))
redirection.set_cookie("cnsc", value="Logged out! Your temporary token "
"on our server and the cookie on your device have been deleted.", httponly=True,
secure=True)
return red
return redirection
@app.route("/error")
def error():
"""
Error Page für custom-Errors. \n
TODO: Funktion depreciaten. Ersetzen durch Errors auf den entsprechenden Seiten.
:return:
:return HTML:
"""
error = request.args.get("ecode")
if error == "900":
msg = "Ungültige RAPLA-URL! Sicher, dass der Link zum DHBW-Rapla führt?"
elif error == "899":
msg = "Der Kalender wurde nicht gefunden! Sicher, dass der Link korrekt ist?"
errorCode = request.args.get("ecode")
if errorCode == "900":
message = "Ungültige RAPLA-URL! Sicher, dass der Link zum DHBW-Rapla führt?"
elif errorCode == "899":
message = "Der Kalender wurde nicht gefunden! Sicher, dass der Link korrekt ist?"
else:
msg = str(error)
return render_template('display-message.html', message=msg)
message = str(errorCode)
return render_template('display-message.html', message=message)
@app.route("/error")
@app.errorhandler(HTTPException)
def handle(e):
""""
HTTP-Exception-Handler
:param e:
:return HTML:
"""
return render_template('display-message.html', message=e)
if __name__ == "__main__":
init_routes(flask_app)
flask_app.run(host='0.0.0.0', port=2024, debug=True)
initRoutes(flaskApp)
flaskApp.run(host='0.0.0.0', port=2024, debug=True)
else:
initRoutes(flaskApp)