def change_application_right():
"""
Change les droits d'un utilisateur pour une application
"""
req_data = request.get_json()
id_application = req_data.get("id_application", None)
# Test assurant une rétrocompatibilité (à l'époque des niveaux de droits)
if req_data.get("id_droit", None):
code_profil = req_data.get("id_droit", None)
else:
code_profil = req_data.get("id_profil", None)
# Récupération de l'identifiant du profil à partir de son code
profil = TProfils.get_profil_in_app_with_code(id_application,
str(code_profil))
if not profil:
return (
{
"msg":
"pas de profil " + str(code_profil) +
"corespondant pour l'application" # noqa
},
500,
)
id_profil = profil.id_profil
id_role = req_data.get("id_role", None)
role = db.session.query(TRoles).filter(TRoles.id_role == id_role).first()
if not id_application or not id_role or not code_profil:
return {"msg": "Problème de paramètres POST"}, 400
cor = (db.session.query(CorRoleAppProfil).filter(
id_role == CorRoleAppProfil.id_role).filter(
id_application == CorRoleAppProfil.id_application).first())
if not cor:
cor = CorRoleAppProfil(
**{
"id_role": id_role,
"id_application": id_application,
"id_profil": id_profil,
})
else:
cor.id_profil = id_profil
db.session.commit()
return {
"id_role": id_role,
"id_profil": code_profil,
"id_droit": code_profil, # Retrocompatiblité pour l'OEASC
"id_application": id_application,
"role": role.as_dict(),
}
def delete_cor_role_app_profil(id_role, id_application):
try:
CorRoleAppProfil.delete(id_role, id_application)
except Exception:
flash("Une erreur s'est produite", "error")
flash("Profil supprimé avec succès")
return redirect(
url_for("application.profils_in_app", id_application=id_application))
def add_or_update_profil_for_role_in_app(id_application, id_role=None):
"""
add or update un profil sur une application
on part du principe qu'un role ne peut avoir qu'un profil dans une application
TODO: pour mettre plusieurs profil a un role dans une appli:
rajouter une clé primaire a cor_role_app_profil pour gérer l'update
"""
form = t_applicationsforms.AppProfil(id_application)
application = TApplications.get_one(id_application)
role = None
title = "Ajouter un profil l'application {}".format(
application["nom_application"])
if id_role:
role = TRoles.get_one(id_role, as_model=True).as_dict_full_name()
title = "Editer le profil de {} dans l'application {}".format(
role["full_name"], application["nom_application"])
# preremplissage du formulaire
profil_in_app = CorRoleAppProfil.get_one(id_role, id_application)
form.profil.process_data(profil_in_app.id_profil)
form.role.process_data(str(id_role))
# HACK ajout de l'utilisateur courant dans la liste déroulante
# sinon le formulaire ne passe pas
form.role.choices.append((id_role, role["full_name"]))
if request.method == "POST":
# set new id__profil
form.profil.process_data(request.form["profil"])
if form.validate() and form.validate_on_submit():
try:
if id_role:
# on supprime d'abbord le profil pour une app
CorRoleAppProfil.delete(id_role=id_role,
id_application=id_application)
# et on post
CorRoleAppProfil.post({
"id_role": form.data["role"],
"id_profil": form.data["profil"],
"id_application": id_application,
})
except Exception as e:
redirect(
url_for(
"application.add_or_update_profil_for_role_in_app",
id_application=id_application,
))
flash("Une erreur s'est produite, {}".format(e), "error")
flash("Profil ajouté/edité avec succès")
return redirect(
url_for("application.profils_in_app",
id_application=id_application))
return render_template(
"application_role_profil_form.html",
title=title,
form=form,
application=application,
id_role=id_role,
)
def valid_temp_user():
"""
route pour valider un compte temporaire
et en faire un utilisateur (requete a usershub)
"""
data_in = request.get_json()
token = data_in["token"]
id_application = data_in["id_application"]
# recherche de l'utilisateur temporaire correspondant au token
temp_user = db.session.query(TempUser).filter(
token == TempUser.token_role).first()
if not temp_user:
return {
"msg": "pas d'utilisateur trouvé avec le token user demandé"
}, 422
req_data = temp_user.as_dict()
# Récupération du groupe par défaut
id_grp = CorRoleAppProfil.get_default_for_app(id_application)
if not id_grp:
return {"msg": "pas de groupe par défaut pour l'application"}, 500
# set password correctly
req_data["pass_plus"] = req_data["password"]
req_data["pass"] = req_data["pass_md5"]
role_data = {"active": True}
for att in req_data:
if hasattr(TRoles, att):
# Patch pas beau pour corriger le db.Unicode de TRole pour id_organisme
if att == "id_organisme" and req_data[att] == "None":
role_data[att] = None
else:
role_data[att] = req_data[att]
role = TRoles(**role_data)
db.session.add(role)
db.session.commit()
# Ajout du role au profil
cor = CorRoles(id_role_groupe=id_grp.id_role,
id_role_utilisateur=role.id_role)
db.session.add(cor)
db.session.delete(temp_user)
db.session.commit()
return role.as_dict(recursif=True)
def add_application_right_to_role():
"""
Route permettant de d'ajouter des droits
pour une application a un utilisateur
soit en l'associant à un groupe
soit en lui affectant le profil "1"
"""
req_data = request.get_json()
identifiant = req_data.get("login", None)
pwd = req_data.get("password", None)
id_application = req_data.get("id_application", None)
if not identifiant or not pwd or not id_application:
return {"msg": "les parametres sont mal renseignés"}, 500
# Récupération du groupe par défaut
id_grp = CorRoleAppProfil.get_default_for_app(id_application)
if not id_grp:
return {"msg": "pas de groupe par défaut pour l'application"}, 500
role = db.session.query(TRoles).filter(
TRoles.identifiant == identifiant).first()
if not role:
return {
"msg": "pas d'user pour l'identifiant " + str(identifiant)
}, 500
id_role = role.id_role
# check pwd
pwd_hash = hashlib.md5(pwd.encode("utf-8")).hexdigest()
if not role.pass_md5 == pwd_hash:
return {"msg": "password false"}, 500
# Test si l'utilisateur n'est pas déjà associé au groupe
# par défaut
if not CorRoles.test_role_in_grp(id_role, id_grp.id_role):
cor = CorRoles(id_role_groupe=id_grp.id_role,
id_role_utilisateur=role.id_role)
db.session.add(cor)
db.session.commit()
return role.as_dict(recursif=True)
def insert_one_t_role():
'''
Route permettant de créer un utilisateur
curl --header "Content-Type: application/json" \
--request POST \
--data '{"email": "*****@*****.**", "groupe": false, "pn": true, "remarques": "utilisateur test api", "desc_role": null, "prenom_role": "test", "identifiant": "test_api", "id_unite": -1, "id_organisme": -1, "uuid_role": "c8f63c2d-e606-49c5-8865-edb0953c496f", "nom_role": "API", "password": "******", "password_confirmation": "123456", "applications":[{"id_app":2, "id_droit":1}]}' \
http://localhost:5001/api_register/role
'''
req_data = request.get_json()
role_data = {}
for att in req_data:
if hasattr(TRoles, att):
role_data[att] = req_data[att]
# Validation email
if re.search("[@.]", req_data['email']) is None:
return "email not valid", 500
role = TRoles(**role_data)
if req_data['password']:
role.fill_password(req_data['password'],
req_data['password_confirmation'])
db.session.add(role)
db.session.commit()
for app in req_data['applications']:
cor = CorRoleAppProfil(id_role=role.id_role,
id_profil=app['id_profil'],
id_application=app['id_app'])
db.session.add(cor)
db.session.commit()
return role.as_dict(recursif=True)