def get_user_repos(username):
try:
current_user = None
if 'token' in request.headers:
token = request.headers["token"]
if token != "undefined" and token != "null":
current_user = db.get_user_by_token(token)
if current_user == None:
return jsonify({"error": "The token is not correct"}), 200
user = db.get_user_by_username(username)
if user == None:
return jsonify({"error": "No user with that name"})
rlist = []
repos = db.get_repositories_by_user(user.id)
if repos != None:
for r in repos:
if not r.private:
rlist.append(r.name)
elif current_user != None:
if db.can_user_read_repo(r.id, current_user.id):
rlist.append(r.name)
return jsonify({
"success": "true",
"repositories": rlist,
"email": user.email
}), 200
except:
abort(500)
def wrapper(*args, **kw):
try:
if "token" not in request.headers:
logger.warning("400 Error, no token provided." +
str(request.remote_addr))
return jsonify({"error": "No token provided"}), 400
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
logger.warning("400 Error, incorrect token. " +
str(request.remote_addr))
return jsonify({"error": "Incorrect token"}), 400
session = db.get_session_by_token(token)
if session.check_token_expired():
logger.warning("400 Error," + user.username +
" users token is expired " +
str(request.remote_addr))
return jsonify({"error": "Incorrect token"}), 400
except Exception as e:
logger.error("Exception 'validate_token': " + str(e) + " " +
str(request.remote_addr))
return jsonify({"error": "Incorrect request"}), 400
return f(*args, **kw)
def get_file_content():
try:
data = request.get_json(silent=True)
current_user = None
if 'token' in request.headers:
token = request.headers["token"]
if token != "undefined" and token != "null":
current_user = db.get_user_by_token(token)
if current_user == None:
return jsonify({"error": "The token is not correct"}), 200
user = db.get_user_by_username(data["owner"])
if user == None:
return jsonify({"error": "The owner is not correct"}), 200
repo = db.get_repositories_by_user_and_name(user.id, data["repoName"])
if repo == None:
return jsonify({"error": "The repo doesn't exist"}), 200
fcontent = git.get_file_content(user.username, repo.name, data["path"])
if fcontent == None:
return jsonify({"error": "The file doesn't exist"}), 200
if repo.private:
if current_user == None:
return jsonify({"error": "This repository is private"}), 200
elif not db.can_user_read_repo(repo.id, current_user.id):
return jsonify(
{"error": "You don't have access to this repository"}), 200
else:
return jsonify({"success": "true", "fcontent": fcontent}), 200
else:
return jsonify({"success": "true", "fcontent": fcontent}), 200
except:
abort(500)
def create_campaign():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
data = request.get_json(silent=True) # name & chclass
name = data["name"]
characters = data["characters"]
for c in characters:
if db.get_character_by_id(c) == None:
return jsonify({"error": "Character is not correct"}), 400
campaign = db.add(Campaign(user.id, name))
if not campaign:
abort(500)
for c in characters:
db.add(CampaignCharacter(c, campaign.id))
return jsonify({"campaign_id": campaign.id})
except Exception as e:
print("[DEBUG] Error in 'create_campaign' : " + str(e))
logger.error("Error in 'create_campaign' : " + str(e) + " " +
str(request.remote_addr))
abort(500)
def wrapper(*args, **kw):
try:
if "token" not in request.headers:
logger.warning("400 Errorea, tokenik ez." +
str(request.remote_addr))
return jsonify({"error": "Gakorik ez"}), 400
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
logger.warning("400 Errorea, tokena ez da egokia. " +
str(request.remote_addr))
return jsonify({"error": "Gakoa ez da zuzena"}), 400
session = db.get_session_by_token(token)
if session.check_token_expired():
logger.warning("400 Errorea," + user.username +
" erabiltzailearen tokena iraungita dago. " +
str(request.remote_addr))
return jsonify({"error": "Gakoa ez da zuzena"}), 400
except Exception as e:
logger.error("Extepzioa 'validate_token': " + str(e) + " " +
str(request.remote_addr))
return jsonify({"error": "Eskaera ez da egokia"}), 400
return f(*args, **kw)
def add_device():
try:
token = request.headers["token"] # TODO: Wrapper bat?
user = db.get_user_by_token(token)
if user == None:
return jsonify({"error": "Gakoa ez da zuzena"}), 200
data = request.get_json(silent=True) # device auth
device = db.get_device_by_code(data["code"])
if device == None:
return jsonify({"error": "Kodea ez da baliozkoa"}), 400
if db.device_has_owner(device.id):
return jsonify({"error": "Kodea ez da baliozkoa"}), 400
if db.add(Permission(user.id, device.id, Permission.OWNER)) == False:
return jsonify({"error": "Errorea datubasean"}), 500
logger.info("Device bati jabea jarri zaio. Auth:" + device.auth +
" UserId:" + str(user.id) + " addr:" +
str(request.remote_addr))
return jsonify({"success": "true"}), 200
except Exception as e:
logger.error("Errorea 'add_device' : " + str(e) + " " +
str(request.remote_addr))
abort(500)
def get_curr_user():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
return jsonify({"username": user.username, "token": token}), 200
except Exception as e:
logger.error("Errorea 'get_curr_user' : " + str(e) + " " +
str(request.remote_addr))
abort(500)
def logout():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
db.delete_session_by_user(user.id)
return jsonify({}), 200
except Exception as e:
logger.error("Errorea 'logout' : " + str(e) + " " +
str(request.remote_addr))
abort(500)
def get_user_keys():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
return jsonify({"error": "The token is not correct"}), 200
keys = git.get_user_ssh_keys(
user.username) # we don't get the entire key, not safe
return jsonify(success="true", keys=[e.serialize() for e in keys]), 200
except:
abort(500)
def sign_out():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
return jsonify({"error": "The token is not correct"}), 200
if db.delete_session_by_user(user.id) == None:
return jsonify({"error": "The user is not logged in"}), 200
return jsonify({"success": "true"}), 200
except:
abort(500)
def get_current_user():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
return jsonify({"error": "The token is not correct"}), 200
return jsonify({
"success": "true",
"username": user.username,
"email": user.email
}), 200
except:
abort(500)
def get_shared_repos():
try:
user = db.get_user_by_token(request.headers["token"])
if user == None:
return jsonify({"error": "The token is not correct"}), 200
repos = db.get_shared_repositories_by_user(user.id)
return jsonify(success="true",
repositories=[
e.serialize(db.get_user_by_id(e.owner).username)
for e in repos
]), 200
except:
abort(500)
def change_password():
try:
data = request.get_json(silent=True)
user = db.get_user_by_token(request.headers["token"])
if user == None:
return jsonify({"error": "The token is not correct"}), 200
if user.password != data["oldPass"]:
return jsonify({"error": "The password is not correct"}), 200
db.change_user_password(user.id, data["newPass"])
git.change_user_password(user.username, data["newPass"])
return jsonify({"success": "true"}), 200
except:
abort(500)
def remove_user_key():
try:
data = request.get_json(silent=True)
token = request.headers["token"]
user = db.get_user_by_token(token)
if user == None:
return jsonify({"error": "The token is not correct"}), 200
if not git.remove_user_ssh_key(user.username, data["key"]):
return jsonify({"error": "The key is not correct"}), 200
return jsonify({
"success": "true",
"message": "The key has been removed"
}), 200
except:
abort(500)
def create_repository():
try:
data = request.get_json(silent=True)
user = db.get_user_by_token(request.headers["token"])
if user == None:
return jsonify({"error": "The token is not correct"}), 200
if db.get_repositories_by_user_and_name(user.id,
data["repoName"]) != None:
return jsonify({"error":
"You have a repo with the same name"}), 200
db.add(
Repository(user.id, data["repoName"], data["repoDesc"],
data["private"]))
if GIT:
git.create_repository(user.username, data["repoName"],
data["private"])
return jsonify({"success": "true"}), 200
except:
abort(500)
def remove_collaborator():
try:
data = request.get_json(silent=True)
token = request.headers["token"]
owner = db.get_user_by_username(data["owner"])
user = db.get_user_by_username(data["user"])
if owner == None:
return jsonify({"error": "The owner is not correct"}), 200
if user == None:
return jsonify({"error": "The user does not exist"}), 200
if user.id == owner.id:
return jsonify({
"error":
"You can't take permissions from the owner of the repository"
}), 200
current_user = db.get_user_by_token(token)
if current_user.id != owner.id:
return jsonify(
{"error": "You are not the owner of this repository"}), 200
repo = db.get_repositories_by_user_and_name(owner.id, data["repo"])
if repo == None:
return jsonify({"error": "The repository doesn't exist"}), 200
if not db.remove_collaborator_by_repo(user.id, repo.id):
return jsonify({"error": "Database error"})
if GIT:
git.add_user_to_repository(owner.username, repo.name,
user.username, "none")
return jsonify({"success": "true"})
except:
abort(500)
def create_character():
try:
token = request.headers["token"]
user = db.get_user_by_token(token)
data = request.get_json(silent=True) # name & chclass
ch_class = db.get_character_class_by_name(data["character_class"])
name = data["name"]
if ch_class == None:
return jsonify({"error": "Character class is not correct"}), 400
character = db.add(Character(name, ch_class.id, user.id))
if not character:
abort(500)
return jsonify({"character_id": character.id})
except Exception as e:
print("[DEBUG] Error in 'create_character' : " + str(e))
logger.error("Error in 'create_character' : " + str(e) + " " +
str(request.remote_addr))
abort(500)
def add_collaborator():
try:
data = request.get_json(silent=True)
token = request.headers["token"]
owner = db.get_user_by_username(data["owner"])
user = db.get_user_by_username(data["user"])
if owner == None:
return jsonify({"error": "The owner is not correct"}), 200
if user == None:
return jsonify({"error": "The user does not exist"}), 200
if user.id == owner.id:
return jsonify({
"error":
"You can't give permissions to the owner of the repository"
}), 200
current_user = db.get_user_by_token(token)
if current_user.id != owner.id:
return jsonify(
{"error": "You are not the owner of this repository"}), 200
repo = db.get_repositories_by_user_and_name(owner.id, data["repo"])
if repo == None:
return jsonify({"error": "The repository doesn't exist"}), 200
write = bool(data["level"] == "write")
db.add(Collaboration(user.id, repo.id, write))
if GIT:
git.add_user_to_repository(owner.username, repo.name,
user.username, data["level"])
return jsonify({"success": "true", "message": "User added"})
except:
abort(500)
