def get_user_reviews(username):
"""
Returns a list of books that the username has submitted a review for.
Returns None if username hasn't submitted any reviews.
"""
user_id = get_user_id(username)
books_search = db.execute(
"SELECT DISTINCT isbn, title, author_id, year FROM books INNER JOIN reviews ON reviews.book_id = books.id WHERE user_id = :user_id",
{
"user_id": user_id
}).fetchall()
books = []
reviews_ids = []
for book in books_search:
books.append(
get_book_data(book.isbn,
cover_size="medium",
get_description=False))
reviews_ids.append(get_user_review(book.isbn, username).id)
return {"books": books, "reviews_ids": reviews_ids}
def course_page(course_id):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
fail = False
if request.method == "POST":
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
update_type = request.form["update_type"]
if update_type == "intro_update":
if not courses.update_intro(course_id, request.form["content"]):
fail = True
if update_type == "material_update":
if not coursematerials.update_material(request.form["material_id"], request.form["title"], request.form["content"]):
fail = True
if fail:
return render_template("error.html", message="Kurssimateriaalin päivittäminen ei onnistunut!")
else:
course = courses.get_course(course_id)
course_published = course[5]
course_visible = course[6]
course_owner = courses.check_for_ownership(user_id, course_id)
coursematerial = coursematerials.get_all_coursematerials(course_id)
course_statistics = statistics.get_course_status(user_id, course_id)
no_material = (len(coursematerial) == 0)
no_more_material = (coursematerials.get_amount_of_material_slots(course_id) == 10)
return render_template("course.html", course=course, course_published=course_published, course_visible=course_visible, course_owner=course_owner,
coursematerial=coursematerial, course_statistics=course_statistics, no_material=no_material, no_more_material=no_more_material)
def answer_to_exercises():
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
course_id = request.form["course_id"]
user_signedup = courses.check_for_signup(user_id, course_id)
if not user_signedup:
return render_template("error.html", message="Ilmoittaudu ensin kurssille!")
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
exercise_type = int(request.form["exercise_type"])
all_answers = []
if exercise_type == 1:
all_quizzes = request.form.getlist("quizzes")
for exercise_id in all_quizzes:
all_answers.append(request.form[f"choice_{exercise_id}"])
if exercise_type == 2:
all_text_exercises = request.form.getlist("texts")
for exercise_id in all_text_exercises:
all_answers.append((exercise_id, request.form[f"answer_{exercise_id}"]))
if answers.save_answers(user_id, course_id, exercise_type, all_answers):
return redirect(f"/course/{course_id}/exercises")
else:
return render_template("error.html", message="Vastausten tallentaminen ei onnistunut!")
def exercise_page(id):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
fail = False
if request.method == "POST":
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
exercise_type = int(request.form["exercise_type"])
if exercise_type == 1:
right_choice = request.form["right_choice"]
wrong_choices = request.form.getlist("wrong_choice")
if not exercises.add_quiz_exercise(id, exercise_type, int(request.form["points"]), request.form["question"],
request.form["right_feedback"], request.form["false_feedback"], right_choice, wrong_choices):
fail = True
if exercise_type == 2:
if not exercises.add_text_exercise(id, exercise_type, int(request.form["points"]), request.form["question"],
request.form["right_text"], request.form["right_feedback"], request.form["false_feedback"]):
fail = True
if fail:
return render_template("error.html", message="Tehtävän lisääminen ei onnistunut!")
else:
course = courses.get_course(id)
quiz_exercises = exercises.get_all_quiz_exercises(id)
quizzes_and_choises = []
for quiz in quiz_exercises:
choices = exercises.get_all_choises(quiz[0])
quizzes_and_choises.append((quiz, choices))
text_exercises = exercises.get_all_text_exercises(id)
no_quizzes = (len(quizzes_and_choises) == 0)
no_text_exercises = (len(text_exercises) == 0)
course_visible = course[6]
course_published = course[5]
course_owner = courses.check_for_ownership(user_id, id)
student_signedup = courses.check_for_signup(user_id, id)
all_quizzes_answered = statistics.all_exercises_answered(user_id, id, 1)
all_text_exercises_answered = statistics.all_exercises_answered(user_id, id, 2)
course_statistics = statistics.get_course_status(user_id, id)
correct_quiz_answers = []
correct_text_exercise_answers = []
all_quiz_answers = []
all_text_exercise_answers = []
if all_quizzes_answered:
correct_quiz_answers = answers.get_correct_answers(user_id, id, 1)
all_quiz_answers = answers.get_all_answers(user_id, id, 1)
if all_text_exercises_answered:
all_text_exercise_answers = answers.get_all_answers(user_id, id, 2)
return render_template("exercises.html",
course=course, quizzes_and_choises=quizzes_and_choises, text_exercises=text_exercises,
no_quizzes=no_quizzes, no_text_exercises=no_text_exercises, course_visible=course_visible,
course_published=course_published, course_owner=course_owner, student_signedup=student_signedup,
all_quizzes_answered=all_quizzes_answered, all_text_exercises_answered=all_text_exercises_answered,
course_statistics=course_statistics, correct_quiz_answers=correct_quiz_answers,
all_quiz_answers=all_quiz_answers, all_text_exercise_answers=all_text_exercise_answers)
def add_review(isbn, username, rating, review):
book_id = get_book_id(isbn)
user_id = get_user_id(username)
db.execute("INSERT INTO reviews (book_id, user_id, rating, reviews) VALUES (:book_id, :user_id, :rating, :review)",
{"book_id": book_id, "user_id": user_id, "rating": rating, "review": review})
db.commit()
def register_user():
username_info = username.get()
password_info = password.get()
global reg_user_id
u.add_user(username_info, password_info)
reg_user_id = u.get_user_id(username_info)
username_entry.delete(0, END)
password_entry.delete(0, END)
Label(register_screen, text="Registration Success", fg="green", font=11).pack()
def __init__(self, username, business=False):
self.username = username
if (business):
temp_id = businessdata.get_business_id(username)
session["business"] = True
else:
temp_id = users.get_user_id(username)
session["business"] = False
if (temp_id):
self.id = temp_id[0]
def hide_course(course_id):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
course_owner = courses.check_for_ownership(user_id, course_id)
if not course_owner:
return render_template("error.html", message="Et ole kurssin opettaja!")
courses.hide_course(course_id)
return redirect("/")
def get_user_review(isbn, username):
"""
Returns review(the first one) made by username to book(based on isbn).
Returns None if username hasn't submitted any reviews to this particular book.
"""
book_id = get_book_id(isbn)
user_id = get_user_id(username)
return db.execute("SELECT * FROM reviews WHERE (book_id = :book_id) AND (user_id = :user_id) LIMIT 1",
{"book_id": book_id, "user_id": user_id}).fetchone()
def signup(course_id):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
if users.get_usertype() != 2:
return render_template("error.html", message="Vain opiskelijat voivat ilmoittautua kursseille!")
if courses.signup_to_course(user_id, course_id):
return redirect("/")
else:
return render_template("error.html", message="Kurssille ilmoittautuminen ei onnistunut")
def add_teacher():
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
if users.user_is_admin() != True:
return redirect("/")
username = request.form.get("username").strip()
user_id = users.get_user_id(username)
if user_id == 0:
return render_template("teachers.html", error=True)
users.add_teacher(user_id)
return render_template("teachers.html", error=False)
def update_material(course_id, material_id):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
course_owner = courses.check_for_ownership(user_id, course_id)
if not course_owner:
return render_template("error.html", message="Et ole kurssin opettaja!")
course = courses.get_course(course_id)
material = coursematerials.get_material(material_id)
return render_template("updatematerial.html", course=course, material=material)
def login_sucess():
global login_success_screen
logoinscreendestroy()
login_success_screen = Toplevel(main_screen)
login_success_screen.title("Success")
login_success_screen.geometry("250x100")
Label(login_success_screen, text="Welcome back!", pady=5).pack()
Button(login_success_screen, text="Surprise me...", command=home).pack()
global user_id
user_id = u.get_user_id(username1)
def newcourse():
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
coursename = request.form["coursename"]
if courses.create_new(user_id, coursename):
return redirect("/")
else:
return render_template("error.html", message="Kurssin lisääminen ei onnistunut, kurssin nimi saattaa jo olla käytössä...")
def registration():
new_user = True
if request.method == 'POST':
user_name = request.form.get("user_name")
password = request.form.get("password")
hashed_password = common.get_hashed_password(password)
new_user = users.register_user(user_name, hashed_password)
if new_user:
session['username'] = user_name
session['user_id'] = users.get_user_id(user_name)
return redirect("/")
return render_template("registration.html", new_user=new_user)
def create_chat(id):
campaign_list = campaigns.get_campaigns()
user_id = session.get("user_id", 0)
if not campaigns.is_creator(id, user_id):
return render_template(
"error.html", error="No authority", campaigns=campaign_list)
if not campaigns.is_active(id):
return render_template(
"error.html",
error="Campaign has been deleted",
campaigns=campaign_list
)
campaign = campaigns.get_campaign_info(id)
players = campaigns.get_campaign_players(id)
if request.method == "GET":
return render_template(
"newchat.html",
campaign=campaign,
players=players,
id=id,
campaigns=campaign_list
)
if request.method == "POST":
users.check_csrf(request.form["csrf_token"])
title = request.form["title"]
if len(title) < 1:
return render_template(
"newchat.html",
error="Title cannot be empty",
campaign=campaign,
players=players,
id=id,
campaigns=campaign_list
)
if len(title) > 300:
return render_template(
"newchat.html",
error="Title is too long",
campaigns=campaign_list
)
private = request.form.get("private", 0)
chat_id = chats.create_chat(id, title, private)
chats.add_chatter(chat_id, user_id)
chatters = request.form.getlist("chatter")
for chatter in chatters:
chatter_id = users.get_user_id(chatter)
if chatter_id:
chats.add_chatter(chat_id, chatter_id)
return redirect("/campaign/" + str(id))
def modify_coursematerial_order(course_id, material_id, modify_type):
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
course_owner = courses.check_for_ownership(user_id, course_id)
if not course_owner:
return render_template("error.html", message="Et ole kurssin opettaja!")
slotcount = coursematerials.get_amount_of_material_slots(course_id)
if modify_type != "delete" and slotcount >= 10:
return render_template("error.html", message="Et voi lisätä uusia osioita, maksimimäärä on 10!")
if coursematerials.modify_material_order(course_id, material_id, modify_type):
return redirect(f"/course/{course_id}")
else:
return render_template("error.html", message="Materiaalin lisääminen ei onnistunut!")
def update_passgrade():
user_id = users.get_user_id()
if user_id == 0:
return render_template("error.html", message="Kirjaudu sisään nähdäksesi sisältöä!")
course_id = request.form["course_id"]
course_owner = courses.check_for_ownership(user_id, course_id)
if not course_owner:
return render_template("error.html", message="Et ole kurssin opettaja!")
if session["csrf_token"] != request.form["csrf_token"]:
abort(403)
new_passgrade = request.form["passgrade"]
if courses.update_passgrade(course_id, new_passgrade):
return redirect(f"course/{course_id}")
else:
return render_template("error.html", message="Läpipääsyrajan päivittäminen ei onnistunut!")
def get(self):
self.response.headers['Content-Type'] = 'text/javascript'
access_token = self.request.get('access_token', default_value = "NONE")
user_id = users.get_user_id(access_token)
if user_id == "NONE":
self.response.out.write("Error: Invalid access token")
users.check_in(user_id, access_token)
json = "filler text"
available_peeps_id_list = users.get_free_friends(user_id)
#try:
json = simplejson.dumps(users.get_json_ready_dic(available_peeps_id_list))
#json = users.get_json_ready_dic(available_peeps_id_list)
#json = str(available_peeps_id_list)
#except:
#json = "{'Oops. Something went wrong...'}"
self.response.out.write(json)
def login():
if request.method == 'GET':
return render_template('landing.html',
messageStatus="",
loginStatus="")
elif request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
if users.password_and_username_ok(username, password):
user_id = users.get_user_id(username)
user = User(user_id)
login_user(user)
user_data = users.get_user_info(user_id)
reservations = reservation.get_reservations_for_user(user_id)
return render_template('main.html',
userData=user_data,
listOfReservations=reservations)
else:
return render_template('landing.html',
messageStatus="",
loginStatus="login failed")
def index():
user_id = users.get_user_id()
if users.get_usertype() == 1:
open_courses_teacher = courses.get_open_courses_teacher(user_id)
unpublished_courses = courses.get_unpublished_courses(user_id)
course_statistics = []
for course in open_courses_teacher:
student_amount = statistics.get_students(course[0])
passed_students = statistics.get_passed_students(course[0])
if student_amount == 0:
pass_percent = 0
else:
pass_percent = int((passed_students / student_amount) * 100)
course_stats = (course[0], [student_amount, passed_students, pass_percent])
course_statistics.append(course_stats)
return render_template("index.html", open_courses_teacher=open_courses_teacher, unpublished_courses=unpublished_courses, course_statistics=course_statistics)
elif users.get_usertype() == 2:
completed_courses = courses.get_completed_courses(user_id)
uncompleted_courses = courses.get_uncompleted_courses(user_id)
open_courses = courses.get_open_courses(user_id)
return render_template("index.html", completed_courses=completed_courses, uncompleted_courses=uncompleted_courses, open_courses=open_courses)
else:
return render_template("index.html")
def friends_settings():
users.check_csrf()
users.require_role(2)
if request.form["friend"]:
friend_name = request.form["friend"].strip()
if len(friend_name) == 0:
return render_template(
"error.html",
message=
"Nimikenttä oli tyhjä, tarkista nimi ja tallenna pyyntö uudelleen"
)
friend_id = users.get_user_id(friend_name)
if friend_id == -1:
return render_template(
"error.html",
message=
"Kaveria ei löytynyt antamallasi nimellä, tarkista nimi ja tallenna pyyntö uudelleen"
)
if not friends.add_friend_request(session["user_id"], friend_id):
return render_template("error.html",
message="Kaveripyyntö on jo lähetetty")
if request.form.getlist("friend_asks"):
if not friends.accept_friends(session["user_id"],
request.form.getlist("friend_asks")):
return render_template("error.html",
message="Kaveripäivitys ei onnistunut")
if request.form.getlist("friends"):
if not friends.remove_friends(session["user_id"],
request.form.getlist("friends")):
return render_template("error.html",
message="Kaveripäivitys ei onnistunut")
if request.form.getlist("ask_cancel"):
if not friends.cancel_friend_request(
session["user_id"], request.form.getlist("ask_cancel")):
return render_template("error.html",
message="Kaveripäivitys ei onnistunut")
return redirect("/settings")