def update_user_password():
json_data = get_json_data()
dbw = DatabaseWrapper()
username = "******"
new_password = json_data.get("password")
dbw.update_password(username, new_password)
return jsonify(password_added=new_password)
def update_project_info(class_url, project_url):
new_description = request.form.get("description")
new_long_name = request.form.get("long_name")
new_owner = request.form.get("owner")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
dbw.update_project_info(class_url, project_url, new_description, new_long_name, new_owner)
return jsonify(description_added=new_description)
def remove_contributor(username, submission_name, removed_username):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.remove_contributor(username, submission_name, removed_username)
return jsonify(contributor_removed=removed_username)
except StandardError as e:
return jsonify({"error": "Placeholder error until exceptions are raised by the backend.", "exception": str(e)}), 404
def class_students(class_url):
""" civered by test 0_classes / `Can list students in a class` """
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
class_obj = dbw.get_class_or_error(class_url)
return jsonify(students=class_obj["students"])
except ClassDoesNotExistError as e:
return jsonify({"error": "class not found!", "exception": str(e)}), 404
def class_teachers(class_url):
""" covered by test 0_classes / `Can get the teachers of a class`"""
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
class_obj = dbw.get_class_or_error(class_url)
return jsonify(teachers=class_obj["teachers"])
except ClassDoesNotExistError as e:
return jsonify({"error": "class not found!", "exception": str(e)}), 404
def get_submission(username, submission_name):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
gitolite_url = username + "/submissions/" + submission_name
try:
submission=dbw.get_submission_or_error(gitolite_url=gitolite_url)
return jsonify(submission=submission)
except SubmissionDoesNotExistError as e:
return jsonify(error="submission does not exist!", exception=str(e)), 404
def delete_user_submission(username, submission_name):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
gitolite_url = username + "/submissions/" + submission_name
try:
dbw.delete_submission(gitolite_url)
return jsonify(deleted=True)
except SubmissionDoesNotExistError:
return jsonify(error="submission does not exist!"), 404
def get_project_owner(class_url, project_url):
""" covered by test 2_projects / `Can get owner of a project` """
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
project_obj = dbw.get_project_or_error(class_url, project_url)
return jsonify(owner=project_obj["owner"])
except ClassDoesNotExistError as e:
return jsonify({"error": "project not found!", "exception": str(e)}), 404
def add_contributor(username, submission_name):
json_data = get_json_data()
new_contributor = json_data.get("username")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.add_contributor(username, submission_name, new_contributor)
return jsonify(contributor_added=new_contributor)
except StandardError as e:
return jsonify({"error": "Placeholder error until exceptions are raised by the backend.", "exception": str(e)}), 404
def update_user_info():
json_data = get_json_data()
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
username = get_current_logged_in_user()
if username is None:
username = "******" # TODO: instead raise here
new_email = json_data.get("email")
dbw.update_email(username, new_email)
return jsonify(email_added=new_email)
def login():
json_data = get_json_data()
username = json_data.get("username")
password = json_data.get("password")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
result = dbw.login(username, password)
if not result:
return jsonify({"error": "bad login credentials!", "exception": None}), 400
return jsonify({"token": result}), 200
def add_student(class_url):
""" covered by test 0_classes / `Student can enroll in a class` """
json_data = get_json_data()
student = json_data.get("username")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.add_student_to_class(class_url, student)
except ClassDoesNotExistError as e:
return jsonify({"error": "class not found!", "exception": str(e)}), 404
except UserDoesNotExistError as e:
return jsonify({"error": "username not found!", "exception": str(e)}), 404
return jsonify(class_updated=dbw.get_class_or_error(class_url))
def add_teacher(class_url):
""" covered by test 0_classes / `Teacher can add other teachers to class they own` """
json_data = get_json_data()
teacher = json_data.get("username")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.add_teacher_to_class(class_url, teacher)
except ClassDoesNotExistError as e:
return jsonify({"error": "class not found!", "exception": str(e)}), 404
except UserDoesNotExistError as e:
return jsonify({"error": "username not found!", "exception": str(e)}), 404
return jsonify(class_updated=dbw.get_class_or_error(class_url))
def make_submission(class_name, project_name):
json_data = get_json_data()
owner = json_data.get("owner")
url_name = class_name + "_" + project_name
parent_url = class_name + '/' + project_name
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.create_submission(url_name, project_name, parent_url, owner)
return jsonify(submission_made=url_name)
except UrlNameAlreadyTakenError as e:
return jsonify({"error": "Url name was already taken!", "exception": str(e)}), 403
except ProjectDoesNotExistError as e:
return jsonify({"error": "That project does not exist!", "exception": str(e)}), 404
except ClassDoesNotExistError as e:
return jsonify({"error": "Class does not exist!", "exception": str(e)}), 404
except UserDoesNotExistError as e:
return jsonify({"error": "Sorry! You need to upload a public key in order to do this!", "exception": str(e)}), 400
def new_class():
""" covered by test 0_classes / `Can create classes` """
json_data = get_json_data()
class_name = json_data.get("class_name")
url_name = json_data.get("url_name")
description = json_data.get("description")
owner = get_current_logged_in_user()
if owner is None:
owner = "spencer" # TODO: instead raise here
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
c = dbw.create_class(url_name, class_name, description, owner)
return jsonify(class_created=url_name)
except UrlNameAlreadyTakenError as e:
return jsonify({"error": "Url name was already taken!", "exception": str(e)}), 403
except UserDoesNotExistError as e:
return jsonify({"error": "Sorry! You need to upload a public key in order to do this!", "exception": str(e)}), 400
def new_project(class_url):
""" covered by test 2_projects / `Teacher can create new project` """
json_data = get_json_data()
project_name = json_data.get("project_name")
url_name = json_data.get("url_name")
description = json_data.get("description")
team_based = json_data.get("team_based") in ["True", "true", "Yes", "yes"]
max_size = int(json_data.get("max_members"))
due_date = json_data.get("due_date") # TODO: check formatting from js
owner = get_current_logged_in_user()
if owner is None:
owner = "spencer" # TODO: instead raise here
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.create_project(url_name, project_name, description, class_url, team_based, due_date, owner, max_size)
return jsonify(project_created=url_name)
except UrlNameAlreadyTakenError as e:
return jsonify({"error": "Url name was already taken!", "exception": str(e)}), 403
except ClassDoesNotExistError as e:
return jsonify({"error": "Class does not exist!", "exception": str(e)}), 404
def signup():
json_data = get_json_data()
username = json_data.get("username")
password = json_data.get("password")
email = json_data.get("email")
if '@' not in parseaddr(email)[1]:
return jsonify({"error": "Invalid email address: "+str(email)}), 400
if len(password) < 8:
return jsonify({"error": "Invalid password: must be 8 characters or more"}), 400
if len(username) < 1:
return jsonify({"error": "Invalid username: cannot use an empty username"}), 400
first_name = json_data.get("firstname")
last_name = json_data.get("lastname")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
try:
dbw.create_user(username, email, password, first_name, last_name)
except UsernameAlreadyTakenError as e:
return jsonify({"error": "Username is already taken!", "exception": str(e)}), 400
except EmailAlreadyTakenError as e:
return jsonify({"error": "Email is already taken!", "exception": str(e)}), 400
result = dbw.login(username, password)
return jsonify({"token": result}), 200
def get_submissions_for_user(username):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify({"submissions": dbw.get_submissions_for_user(username)})
def get_contributors(username, submission_name):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return dbw.get_contributors(username, submission_name)
def list_classes():
""" covered by test 0_classes / `Can list classses` """
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify(classes=dbw.get_all_classes())
def get_class(class_url):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify({"class": dbw.get_class_or_error(class_url)})
def list_projects(class_url):
""" covered by test 2_projects / `Can list projects in a class` """
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
projects = dbw.get_ontime_projects_for_class(class_url)
overdue_projects = dbw.get_overdue_projects_for_class(class_url)
return jsonify(projects=projects, overdue_projects=overdue_projects)
def new_project_due_date(class_url, project_url):
""" covered by test 2_projects / `Can update due date in a project` """
json_data = get_json_data()
due_date = json_data.get("date")
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify(project_updated=dbw.update_project_due_date(class_url, project_url, due_date))
""" Importiert die Backups aus dem Speicher und
uploaded tageweise in amazon s3 """
import os
import re
import pandas as pd
from datetime import datetime
# compatibility with ipython
# os.chdir(os.path.dirname(__file__))
from db import DatabaseWrapper
import json
import boto3
from pathlib import Path
db = DatabaseWrapper("localhost", "hafasdb2", "hafas", "123")
path = "/home/bemootzer/Documents/SoftwareProjekte/stewardless/stewardless-crawler/dbbackup"
# path = "/home/bemootzer/Documents/SoftwareProjekte/stewardless/stewardless-crawler/dbbackup"
re_sql = re.compile(r"arrival.*.sql")
_, blacklist, _ = next(os.walk(os.path.join("summaries", "data")))
blacklist.append("2020-02-01") # data not complete
for file in os.listdir(path):
if re_sql.match(file):
# LOAD BACKUP
#file = "arrivals-2020-03-01.sql"
date_string = file.replace("arrivals-", "").replace(".sql", "")
date = datetime.fromisoformat(date_string)
print(date)
if date_string in blacklist or (date <= datetime(2020, 3, 22)):
def get_classes_for_user(username):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify({"classes": dbw.get_classes_for_user(username)})
def get_landing_for_user(username):
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
classes = dbw.get_classes_for_user(username)
projects = dbw.get_projects_for_user(username)
submissions = dbw.get_submissions_for_user(username)
return jsonify(dict(classes=classes, projects=projects, submissions=submissions))
def get_project(class_url, project_url):
""" covered by test 2_projects / `Can list projects in a class` """
dbw = DatabaseWrapper(GITOLITE_ADMIN_PATH, DATABASE_PORT)
return jsonify(project=dbw.get_project_or_error(class_url, project_url))
def convert_ssh_key_to_colon_string(key):
hexstring = hashlib.md5(key.strip().split()[1]).hexdigest()
colonstring = ':'.join(hexstring[i:i+2] for i in range(0, len(hexstring), 2))
return colonstring
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-p", "--mongo_port", help="the mongodb port to connect to", type=int)
parser.add_argument("-s", "--ssh_host", help="the ssh host string to connect to")
parser.add_argument("-pyo", "--pyolite_location", help="the folder pyolite should bind to")
args = parser.parse_args()
password = "******"
dbw = DatabaseWrapper(args.pyolite_location, port=args.mongo_port, repositories_root="/var/lib/jenkins/jobs/acceptance-tests/workspace/temp")
gw = GitoliteWrapper(args.pyolite_location)
# give one user a REAL pubkey, so git can interact with server
# note: this is the contents of /home/git/.ssh/test_key.pub and test_key2.pub
test_key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDAObvHN/F6EX4L9/ExE4LdezTD1Dx/+fX0wZdropEyx63VxBn8HpgwVcjYq5fINAUAqtNoNpIgyXpp8RhoFv488qaCL9V7qwSf1Bnv5uaZ5lxIpdfEFXhu4JsgtdphMangwvSf2ADLASFdB99Sjxo/nxmjHsvyPZXuvYMNdmKn9ZBQyimUNpERlL4/ECVRoebnL4lD/+rzreacTiZA6KvPn8f7Xh8JNHwm9ndRCxflc8fTH+0VgkC2kpQVkWOoXqhQUQpX8fYxrmCamDG4oRAKJpF2SLkRv1OAv+jY58e2fxAUqFK/u2k6XFPn9Sxmz8pZsvp8OHAuVeSdECyoKw/J git@gitsubmit"
test_key2 = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8DylxzTAc4y/AG/RCONTiZx2+2hfAgfuncXwZylUse6JkHKIIFbjkXqoAkmT0hsugMHb6IpnINcc41vXXOPTwjLrgMaO7r/eK6gs6rqUiVaJ3oVuJK9qw1PwPo/4O/eCQ3mtoDSm+U27/Q5D391jAuqngmMtYxQAUqS+Hv4/ORNbCNXl/b4UQYldUz3N2giNPCIXA78CCDwz4V/jOq6zejnt+DLoiBCTnCQWCIANX+Ij5pvqBP2pDtO9RnFVHEK1O2jXUHGiLq9AcLvDDYGnATwnXbXtPn5Ub0tLFcanO4DW93WTljhCS7TyzUq/MyAGwNmwi7OSVqpNYcHvhUg37 git@gitsubmit"
# give the users some pkeys
bogus_key = create_bogus_key()
gw.add_pkey_to_user("student1", bogus_key["pubkey_contents"])
bogus_key2 = create_bogus_key()
gw.add_pkey_to_user("student2", bogus_key2["pubkey_contents"])
bogus_key3 = create_bogus_key()
gw.add_pkey_to_user("teacher1", bogus_key3["pubkey_contents"])
bogus_key4 = create_bogus_key()
import boto3
from pathlib import Path
import geopandas.tools
from shapely.geometry import Point
import pymysql
# download shapefiles
countries = geopandas.GeoDataFrame.from_file(
"https://raw.githubusercontent.com/AliceWi/TopoJSON-Germany/master/germany.json",
layer=1,
driver="TopoJSON")
# clean unnecessary columns
countries = countries[["id", "name", "geometry"]]
countries.columns = ["landkreise_id", "landkreis", "geometry"]
db = DatabaseWrapper("localhost", "hafasdb2", "hafas", "123")
connection_aws = pymysql.connect(host=config["host"],
user=config["user"],
password=config["password"],
db=config["database"],
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
connection_local = pymysql.connect(host="localhost",
user="******",
password="******",
db="hafasdb2",
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
