def login():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get("username", None)
if not username:
return jsonify({"msg": "Missing username parameter"}), 400
password = request.json.get("password", None)
if not password:
return jsonify({"msg": "Missing password parameter"}), 400
user = UserA.query.filter_by(username=username).first()
if (not user) or password != user.password:
return jsonify({"msg": "Bad username or password"}), 401
expires = datetime.timedelta(days=365)
# Identity can be any data that is json serializable
tokens = {
"access_token":
create_access_token(identity=username, expires_delta=expires),
"refresh_token":
create_refresh_token(identity=username),
"userId":
user.id,
}
############Agregando evento al logger####################
add_event_logger(user.id, LoggerEvents.user_login, MODULE)
##########################################################
return jsonify(tokens), 200
def edit():
current_user = (UserA.query.filter_by(
username=get_jwt_identity()).first().serialize())
if not current_user["role"] == "Product Owner":
return (
jsonify(
{"msg": current_user.usarname + " does not have privileges"}),
400,
)
username = request.json.get("username", None)
if not username:
return jsonify({"msg": "Missing username parameter"}), 400
roles = ["Product Owner", "Scrum Master", "Scrum Team"]
new_role = request.json.get("new_role", None)
if (not new_role) or (not new_role in roles):
return jsonify({"msg": "Invalid new_role parameter"}), 400
target = UserA.query.filter_by(username=username).first()
target.role = new_role
db.session.commit()
#############Agregando evento al logger###########################
add_event_logger(user.id, LoggerEvents.user_role_assign, MODULE)
##################################################################
return jsonify({"msg": username + " role changed to " + new_role}), 200
def add_tests():
if request.method == "POST":
description = request.json.get("description")
story_id = request.json.get("story_id")
user_id = request.json.get("user_id")
user = UserA.query.get_or_404(user_id)
if user.role != "Product Owner":
return jsonify({"server": "Debe ser Product Owner"}), 405
try:
test = AcceptanceTest(
story_id=story_id,
description=description,
user_id=user_id,
approved=False,
)
db.session.add(test)
db.session.commit()
###########Agregando evento al logger#######################
add_event_logger(user_id, LoggerEvents.add_test, MODULE)
############################################################
return jsonify(test.serialize())
except Exception as e:
print(e)
return jsonify({"server": "ERROR"})
def add_sprint():
if request.method == "POST":
description = request.json.get("description")
project_id = request.json.get("project_id")
end_date = request.json.get("end_date")
user_id = request.json.get("user_id")
sp_date = end_date.split("/")
date = int(sp_date[0])
mount = int(sp_date[1])
year = int(sp_date[2])
try:
sprint = Sprint(
user_id=user_id,
description=description,
project_id=project_id,
closed=False,
end_date=datetime(year, mount, date),
)
db.session.add(sprint)
db.session.commit()
###########Agregando evento al logger#######################
add_event_logger(user_id, LoggerEvents.add_sprint, MODULE)
############################################################
return jsonify(sprint.serialize()), 200
except Exception as e:
print(e)
return jsonify({"server": e})
def search_project(id_):
try:
project = Project.query.get_or_404(id_)
user_id = project.user_id
###########Agregando evento al logger###########################
add_event_logger(user_id, LoggerEvents.search_project, MODULE)
################################################################
return jsonify([project.serialize()])
except:
return jsonify({"server": "ERROR"})
def test_getall_logs(client, init_database):
# se inicializan dos logs temporales
logger_0 = add_event_logger(1, LoggerEvents.add_project, "PROJECTS")
logger_1 = add_event_logger(1, LoggerEvents.add_task, "TASKS")
# se llama al servicio
rv = client.get("/logger/getall")
# se deserializa el response
response = json.loads(rv.data.decode("utf-8"))
# si retorna 2 logs funciona
assert len(response) == 2
app.db.session.commit()
def delete_project(id_):
if request.method == "DELETE":
project = Project.query.get_or_404(id_)
try:
user_id = project.user_id
db.session.delete(project)
db.session.commit()
###########Agregando evento al logger###########################
add_event_logger(user_id, LoggerEvents.delete_project, MODULE)
################################################################
return jsonify({"server": "200"})
except:
return jsonify({"server": "ERROR"})
def reactivate_project(id_):
if request.method == "PATCH":
try:
project = Project.query.get_or_404(id_)
project.status = ProjectStatus.active
db.session.commit()
user_id = project.user_id
###########Agregando evento al logger#############################
add_event_logger(user_id, LoggerEvents.activate_project, MODULE)
##################################################################
return jsonify(project.serialize())
except:
return jsonify({"server": "ERROR"})
def add_tasks():
if request.method == "POST":
description = request.json.get("description")
sprint_id = request.json.get("sprint_id")
task_type = request.json.get("task_type")
task_status = request.json.get("task_status")
task_class = request.json.get("task_class")
# usuario que crea la tarea
user_id = request.json.get("user_id")
user_creator = UserA.query.get_or_404(user_id)
if user_creator.role not in ["Scrum Master", "Scrum Team"]:
return jsonify({"server": "Debe ser parte del equipo"}), 405
# usuarios a los que se las asignan
users = []
if len(request.json.get("users")) > 2:
return make_response(jsonify("maximo 2 usuarios permitidos"), 404)
elif len(request.json.get("users")) == 0:
pass
else:
for i in request.json.get("users"):
user = UserA.query.get_or_404(i)
users.append(user)
try:
task = Task(
description=description,
sprint_id=sprint_id,
task_type=task_type,
task_status=task_status,
task_class=task_class,
user_id=user_creator.id,
)
db.session.add(task)
db.session.commit()
task.asignners = users
db.session.commit()
###########Agregando evento al logger#######################
add_event_logger(user_id, LoggerEvents.add_task, MODULE)
############################################################
return jsonify(task.serialize())
except Exception as e:
print(e)
return jsonify({"server": "ERROR"})
def add_project():
if request.method == "POST":
description = request.form.get("description")
user_id = request.form.get("user_id")
try:
project = Project(description=description,
user_id=user_id,
status=ProjectStatus.active)
db.session.add(project)
db.session.commit()
###########Agregando evento al logger#######################
add_event_logger(user_id, LoggerEvents.add_project, MODULE)
############################################################
return jsonify(project.serialize())
except:
return jsonify({"server": "ERROR"})
def update_project(id_):
if request.method == "PUT":
project = Project.query.get_or_404(id_)
description = request.form.get("description")
user_id = request.form.get("user_id")
project.description = description
project.user_id = user_id
try:
db.session.commit()
###########Agregando evento al logger##########################
add_event_logger(user_id, LoggerEvents.update_project, MODULE)
###############################################################
return jsonify(project.serialize())
except:
return jsonify({"server": "ERROR"})
def update_test(test_id):
if request.method == "PUT":
test = AcceptanceTest.query.get_or_404(test_id)
if request.json.get("description"):
description = request.json.get("description")
test.description = description
if request.json.get("approved"):
approved = request.json.get("approved")
test.approved = approved
try:
db.session.commit()
###########Agregando evento al logger##########################
add_event_logger(test.user_id, LoggerEvents.update_test, MODULE)
###############################################################
return jsonify(test.serialize())
except:
return jsonify({"server": "ERROR"})
def update_sprint(sprint_id):
if request.method == "PUT":
sprint = Sprint.query.get_or_404(sprint_id)
if request.json.get("description"):
description = request.json.get("description")
sprint.description = description
if request.json.get("closed"):
print("closed")
closed = request.json.get("closed")
sprint.closed = closed
try:
db.session.commit()
###########Agregando evento al logger##########################
add_event_logger(sprint.user_id, LoggerEvents.update_sprint,
MODULE)
###############################################################
return jsonify(sprint.serialize())
except:
return jsonify({"server": "ERROR"})
def test_delete_log(client, init_database):
# se crea un log temporal
logger_0 = add_event_logger(1, LoggerEvents.add_project, "PROJECTS")
log_id = str(logger_0.split("=")[1])
# se llama al servicio
rv = client.get("/logger/delete/" + log_id)
# se deserializa el response
response_json = json.loads(rv.data.decode("utf-8"))
# se trata de hacer un get por ese id
deleted_log = Logger.query.get(log_id)
# se comprueba que el log no existe
assert deleted_log is None
app.db.session.commit()
def register():
request_link = False
if not request.is_json:
try:
username = request.args.get("username")
first_name = request.args.get("first_name")
last_name = request.args.get("last_name")
role = request.args.get("role")
password = request.args.get("password")
request_link = True
print(1)
except Exception as e:
return jsonify({"msg": "Missing JSON in request"}), 400
if request_link:
try:
print(2)
print(username, first_name)
user = UserA(
username=username,
first_name=first_name,
last_name=last_name,
role=role,
password=password,
)
print(3, user)
db.session.add(user)
db.session.commit()
############Agregando evento al logger#########################
add_event_logger(user.id, LoggerEvents.user_register, MODULE)
###############################################################
return jsonify(user.serialize()), 200
except Exception as e:
print(e)
return str(e)
else:
roles = ["Product Owner", "Scrum Master", "Scrum Team"]
parameters = {
"username": None,
"first_name": None,
"last_name": None,
"role": None,
"password": None,
}
parameters = {
param: request.json.get(param, None)
for param in parameters.keys()
}
for param, value in parameters.items():
if not value:
return jsonify({"msg": "Missing " + param + " parameter"}), 400
if UserA.query.filter_by(username=parameters["username"]).first():
return (
jsonify({
"msg":
"Username '" + parameters["username"] + "' already exist"
}),
400,
)
if not parameters["role"] in roles:
return jsonify(
{"msg": "Role '" + parameters["role"] + "' invalid"}), 400
try:
user = UserA(
username=parameters["username"],
first_name=parameters["first_name"],
last_name=parameters["last_name"],
role=parameters["role"],
password=parameters["password"],
)
db.session.add(user)
db.session.commit()
############Agregando evento al logger#########################
add_event_logger(user.id, LoggerEvents.user_register, MODULE)
###############################################################
return jsonify(user.serialize()), 200
except Exception as e:
return str(e)
