def deluser(id_role):
"""
Route qui supprime un utilisateurs dont l'id est donné en paramètres dans l'url
Retourne une redirection vers la liste d'utilisateurs
"""
TRoles.delete(id_role)
return redirect(url_for('user.users'))
def membres(id_liste):
"""
Route affichant la liste des listes n'appartenant pas à la liste vis à vis de ceux qui appartiennent à celle-ci.
Avec pour paramètre un id de liste (id_liste)
Retourne un template avec pour paramètres:
- une entête des tableaux --> fLine
- le nom des colonnes de la base --> data
- liste des listes n'appartenant pas à la liste --> table
- liste des listes appartenant à la liste --> table2
"""
users_in_list = TRoles.test_group(TRoles.get_user_in_list(id_liste))
users_out_list = TRoles.test_group(TRoles.get_user_out_list(id_liste))
mylist = TListes.get_one(id_liste)
header = ["ID", "Nom"]
data = ["id_role", "full_name"]
if request.method == "POST":
data = request.get_json()
new_users_in_list = data["tab_add"]
new_users_out_list = data["tab_del"]
try:
CorRoleListe.add_cor(id_liste, new_users_in_list)
CorRoleListe.del_cor(id_liste, new_users_out_list)
except Exception as e:
return jsonify({"error": str(e)}), 500
return jsonify({"redirect": url_for("liste.lists")}), 200
return render_template(
"tobelong.html",
fLine=header,
data=data,
table=users_out_list,
table2=users_in_list,
info="Membres de la liste '" + mylist["nom_liste"] + "'",
)
def membres(id_groupe):
"""
Route affichant la liste des roles n'appartenant pas au groupe vis à vis de ceux qui appartiennent à celui ci.
Avec pour paramètre un id de groupe (id_role)
Retourne un template avec pour paramètres:
- une entête des tableaux --> fLine
- le nom des colonnes de la base --> data
- liste des roles n'appartenant pas au groupe --> table
- liste des roles appartenant au groupe --> table2
- variable qui permet a jinja de colorer une ligne si celui-ci est un groupe --> group
"""
users_in_group = TRoles.test_group(TRoles.get_user_in_group(id_groupe))
users_out_group = TRoles.test_group(TRoles.get_user_out_group(id_groupe))
group = TRoles.get_one(id_groupe)
header = ['ID', 'Nom']
data = ['id_role', 'full_name']
if request.method == 'POST':
data = request.get_json()
new_users_in_group = data["tab_add"]
new_users_out_group = data["tab_del"]
try:
CorRoles.add_cor(id_groupe, new_users_in_group)
CorRoles.del_cor(id_groupe, new_users_out_group)
except Exception as e:
return jsonify(str(e)), 500
return jsonify({'redirect': url_for('groupe.groups')}), 200
return render_template("tobelong.html",
fLine=header,
data=data,
table=users_out_group,
table2=users_in_group,
group='groupe',
info="Membres du groupe '" + group['nom_role'] +
"'")
def delete(id_groupe):
"""
Route qui supprime un groupe dont l'id est donné en paramètres dans l'url
Retourne une redirection vers la liste de groupe
"""
TRoles.delete(id_groupe)
return redirect(url_for("groupe.groups"))
def info(id_role):
group = TRoles.get_one(id_role)
members = TRoles.get_user_in_group(id_role)
lists = TRoles.get_user_lists(id_role)
rights = TRoles.get_user_app_profils(id_role)
return render_template("info_group.html",
group=group,
members=members,
lists=lists,
rights=rights,
pathU=config.URL_APPLICATION + '/group/update/')
def info(id_role):
user = TRoles.get_one(id_role)
organisme = Bib_Organismes.get_one(user['id_organisme'])
groups = TRoles.get_user_groups(id_role)
lists = TRoles.get_user_lists(id_role)
rights = TRoles.get_user_app_profils(id_role)
return render_template("info_user.html",
user=user,
organisme=organisme,
groups=groups,
lists=lists,
rights=rights,
pathU=config.URL_APPLICATION + '/user/update/')
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 updatepass(id_role=None):
"""
Route affichant un formulaire permettant de changer le pass des utilisateurs
L'envoie du formulaire permet la mise à jour du pass de l'utilisateur dans la base
Retourne un template accompagné du formulaire pré-rempli ou non selon le paramètre id_role
Une fois le formulaire validé on retourne une redirection vers la liste des utilisateurs
"""
form = t_rolesforms.UserPass()
myuser = TRoles.get_one(id_role)
if request.method == "POST":
if form.validate_on_submit() and form.validate():
form_user = pops(form.data, False)
form_user.pop("id_role")
# check if passwords are the same
if form.pass_plus.data:
try:
(
form_user["pass_plus"],
form_user["pass_md5"],
) = check_and_encrypt_password(
form.pass_plus.data,
form.mdpconf.data,
current_app.config["PASS_METHOD"] == "md5"
or current_app.config["FILL_MD5_PASS"],
)
except Exception as exp:
flash({"password": [exp]}, "error")
return render_template(
"user_pass.html",
form=form,
title="Changer le mot de passe de l'utilisateur '" +
myuser["nom_role"] + " " + myuser["prenom_role"] + "'",
id_role=id_role,
)
form_user["id_role"] = id_role
TRoles.update(form_user)
return redirect(url_for("user.users"))
else:
flash(strigify_dict(form.errors), "error")
return render_template(
"user_pass.html",
form=form,
title="Changer le mot de passe de l'utilisateur '" +
myuser["nom_role"] + " " + myuser["prenom_role"] + "'",
id_role=id_role,
)
def get_one_t_roles(id_role):
"""
Fonction qui retourne les données concernant un utilisateur
"""
role = TRoles.get_one(id_role)
return role
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 updatepass(id_role=None):
"""
Route affichant un formulaire permettant de changer le pass des utilisateurs
L'envoie du formulaire permet la mise à jour du pass de l'utilisateur dans la base
Retourne un template accompagné du formulaire pré-rempli ou non selon le paramètre id_role
Une fois le formulaire validé on retourne une redirection vers la liste des utilisateurs
"""
form = t_rolesforms.UserPass()
myuser = TRoles.get_one(id_role)
if request.method == 'POST':
if form.validate_on_submit() and form.validate():
form_user = pops(form.data, False)
form_user.pop('id_role')
# check if passwords are the same
if form.pass_plus.data:
try:
(form_user['pass_plus'],
form_user['pass_md5']) = TRoles.set_password(
form.pass_plus.data, form.mdpconf.data)
except Exception as exp:
flash({'password': [exp]}, 'error')
return render_template(
'user_pass.html',
form=form,
title="Changer le mot de passe de l'utilisateur '" +
myuser['nom_role'] + ' ' + myuser['prenom_role'] + "'",
id_role=id_role)
form_user['id_role'] = id_role
TRoles.update(form_user)
return redirect(url_for('user.users'))
else:
flash(strigify_dict(form.errors), 'error')
return render_template('user_pass.html',
form=form,
title="Changer le mot de passe de l'utilisateur '" +
myuser['nom_role'] + ' ' + myuser['prenom_role'] +
"'",
id_role=id_role)
def update_user():
"""
route pour changer des paramètres d'utilisateur
"""
req_data = request.get_json()
id_role = req_data.get("id_role", None)
if not id_role:
return {"msg": "Pas d'id_role"}, 400
role_data = {}
for att in req_data:
if hasattr(TRoles, att):
role_data[att] = req_data[att]
role = TRoles(**role_data)
db.session.merge(role)
db.session.commit()
role = db.session.query(TRoles).get(id_role)
return role.as_dict(recursif=True)
def info(id_organisme):
org = Bib_Organismes.get_one(id_organisme)
q = TRoles.get_all(
as_model=True,
params=[
{"col": "active", "filter": True},
{"col": "id_organisme", "filter": id_organisme},
],
order_by="nom_organisme",
)
users = [data.as_dict_full_name() for data in q]
return render_template("info_organisme.html", org=org, users=users)
def addorupdate(id_role=None):
"""
Route affichant un formulaire vierge ou non (selon l'url) pour ajouter ou mettre à jour un groupe
L'envoie du formulaire permet l'ajout ou la maj du groupe dans la base
Retourne un template accompagné d'un formulaire pré-rempli ou non selon le paramètre id_role
Une fois le formulaire validé on retourne une redirection vers la liste de groupe
"""
form = groupeforms.Group()
form.groupe.process_data(True)
if id_role == None:
if request.method == "POST":
if form.validate_on_submit() and form.validate():
form_group = pops(form.data)
form_group.pop("id_role")
# set the group as active default
form_group["active"] = True
TRoles.post(form_group)
return redirect(url_for("groupe.groups"))
else:
errors = form.errors
return render_template("group.html",
form=form,
title="Formulaire Groupe")
else:
group = TRoles.get_one(id_role)
if request.method == "GET":
form = process(form, group)
if request.method == "POST":
if form.validate_on_submit() and form.validate():
form_group = pops(form.data)
form_group["id_role"] = group["id_role"]
TRoles.update(form_group)
return redirect(url_for("groupe.groups"))
else:
errors = form.errors
flash(strigify_dict(errors), "error")
return render_template("group.html",
form=form,
title="Formulaire Groupe")
def users():
"""
Route qui affiche la liste des utilisateurs
Retourne un template avec pour paramètres :
- une entête de tableau --> fLine
- le nom des colonnes de la base --> line
- le contenu du tableau --> table
- le chemin de mise à jour --> pathU
- le chemin de suppression --> pathD
- le chemin d'ajout --> pathA
- le chemin de la page d'information --> pathI
- une clé (clé primaire dans la plupart des cas) --> key
- un nom (nom de la table) pour le bouton ajout --> name
- un nom de listes --> name_list
- ajoute une colonne pour accéder aux infos de l'utilisateur --> see
"""
fLine = [
'Id', 'Identifiant', 'Nom', 'Prenom', 'Email', 'Organisme',
'Remarques', 'Actif', 'pass'
] # noqa
columns = [
'id_role', 'identifiant', 'nom_role', 'prenom_role', 'email',
'nom_organisme', 'remarques', 'active', 'pass_plus'
] # noqa
filters = [{'col': 'groupe', 'filter': 'False'}]
contents = TRoles.get_all(columns, filters)
tab = []
for data in contents:
data['nom_organisme'] = data['organisme_rel'][
'nom_organisme'] if data.get('organisme_rel') else None
if data['pass_plus'] == '' or data['pass_plus'] is None:
data['pass_plus'] = 'Non'
else:
data['pass_plus'] = 'Oui'
tab.append(data)
return render_template("table_database.html",
fLine=fLine,
line=columns,
table=tab,
see="True",
key="id_role",
pathI=config.URL_APPLICATION + "/user/info/",
pathU=config.URL_APPLICATION + "/user/update/",
pathD=config.URL_APPLICATION + "/users/delete/",
pathA=config.URL_APPLICATION + "/user/add/new",
pathZ=config.URL_APPLICATION + "/user/pass/",
passCol='True',
name="un utilisateur",
name_list="Utilisateurs")
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)
def info(id_organisme):
org = Bib_Organismes.get_one(id_organisme)
q = TRoles.get_all(as_model=True,
params=[{
'col': 'active',
'filter': True
}, {
'col': 'id_organisme',
'filter': id_organisme
}])
users = [data.as_dict_full_name() for data in q]
# users = []
# for user in array_user:
# users.append(user['full_name'])
return render_template('info_organisme.html', org=org, users=users)
def groups():
"""
Route qui affiche la liste des groupes
Retourne un template avec pour paramètres :
- une entête de tableau --> fLine
- le nom des colonnes de la base --> line
- le contenu du tableau --> table
- le chemin de mise à jour --> pathU
- le chemin de suppression --> pathD
- le chemin d'ajout --> pathA
- le chemin des membres du groupe --> pathP
- une clé (clé primaire dans la plupart des cas) --> key
- un nom (nom de la table) pour le bouton ajout --> name
- un nom de listes --> name_list
- ajoute une colonne de bouton ('True' doit être de type string)--> otherCol
- nom affiché sur le bouton --> Members
"""
fLine = ["ID groupe", "nom", "description"]
columns = ["id_role", "nom_role", "desc_role"]
filters = [{"col": "groupe", "filter": "True"}]
contents = TRoles.get_all(columns, filters, order_by="identifiant")
return render_template(
"table_database.html",
fLine=fLine,
line=columns,
table=contents,
key="id_role",
pathI=URL_APPLICATION + "/group/info/",
pathU=URL_APPLICATION + "/group/update/",
pathD=URL_APPLICATION + "/group/delete/",
pathA=URL_APPLICATION + "/group/add/new",
pathP=URL_APPLICATION + "/group/members/",
name="un groupe",
name_list="Groupes",
otherCol="True",
Members="Membres",
see="True",
)
def profils_in_app(id_application):
"""
Route affichant la liste des roles ayant un profil pour une application
Retourne un template avec pour paramètres :
- une entête de tableau --> fLine
- le nom des colonnes de la base --> line
- le contenu du tableau --> table
- le chemin de mise à jour --> pathU
- le chemin de suppression --> pathD
- le chemin d'ajout --> pathA
- une clé (clé primaire dans la plupart des cas) --> key
- l'id_application pour construire l'url de redirection -> key2
- un nom (nom de la table) pour le bouton ajout --> name
- un nom de liste --> name_list
- ajoute une colonne de bouton ('True doit être de type string) --> permissions
- nom affiché sur le bouton --> Members
"""
users_in_app = TRoles.get_user_profil_in_app(id_application)
application = TApplications.get_one(id_application)
fLine = ["Id", "Role", "Profil"]
columns = ["id_role", "full_name", "profil"]
return render_template(
"table_database.html",
table=users_in_app,
fLine=fLine,
line=columns,
key="id_role",
key2=id_application,
pathU=config.URL_APPLICATION + "/application/update/role_profil/",
pathD=config.URL_APPLICATION + "/application/delete/role_profil/",
pathA=config.URL_APPLICATION + "/application/add/role_profil/",
name="un role pour l'application {}".format(
application["nom_application"]),
name_list="Role(s) de l'application {}".format(
application["nom_application"]),
)
def groups():
"""
Route qui affiche la liste des groupes
Retourne un template avec pour paramètres :
- une entête de tableau --> fLine
- le nom des colonnes de la base --> line
- le contenu du tableau --> table
- le chemin de mise à jour --> pathU
- le chemin de suppression --> pathD
- le chemin d'ajout --> pathA
- le chemin des membres du groupe --> pathP
- une clé (clé primaire dans la plupart des cas) --> key
- un nom (nom de la table) pour le bouton ajout --> name
- un nom de listes --> name_list
- ajoute une colonne de bouton ('True' doit être de type string)--> otherCol
- nom affiché sur le bouton --> Members
"""
fLine = ['ID groupe', 'nom', 'description']
columns = ['id_role', 'nom_role', 'desc_role']
filters = [{'col': 'groupe', 'filter': 'True'}]
contents = TRoles.get_all(columns, filters)
return render_template('table_database.html',
fLine=fLine,
line=columns,
table=contents,
key="id_role",
pathI=config.URL_APPLICATION + '/group/info/',
pathU=config.URL_APPLICATION + "/group/update/",
pathD=config.URL_APPLICATION + "/group/delete/",
pathA=config.URL_APPLICATION + '/group/add/new',
pathP=config.URL_APPLICATION + '/group/members/',
name="un groupe",
name_list="Groupes",
otherCol='True',
Members="Membres",
see="True")
def addorupdate(id_role=None):
"""
Route affichant un formulaire vierge ou non (selon l'url) pour ajouter ou mettre à jour un utilisateurs
L'envoie du formulaire permet l'ajout ou la mise à jour de l'utilisateur dans la base
Retourne un template accompagné du formulaire pré-rempli ou non selon le paramètre id_role
Une fois le formulaire validé on retourne une redirection vers la liste des utilisateurs
"""
form = t_rolesforms.Utilisateur()
form.id_organisme.choices = Bib_Organismes.choixSelect(
'id_organisme', 'nom_organisme')
form.a_groupe.choices = TRoles.choix_group('id_role',
'nom_role',
aucun=None)
if id_role is not None:
user = TRoles.get_one(id_role, as_model=True)
user_as_dict = user.as_dict_full_name()
# format group to prepfil the form
formated_groups = [
group.id_role for group in TRoles.get_user_groups(id_role)
]
if request.method == 'GET':
form = process(form, user_as_dict, formated_groups)
if request.method == 'POST':
if form.validate_on_submit() and form.validate():
groups = form.data['a_groupe']
form_user = pops(form.data)
form_user['groupe'] = False
form_user.pop('id_role')
# if a password is set
# check they are the same
if form.pass_plus.data:
try:
(form_user['pass_plus'],
form_user['pass_md5']) = TRoles.set_password(
form.pass_plus.data, form.mdpconf.data)
except Exception as exp:
flash(str(exp), 'error')
return render_template('user.html',
form=form,
title="Formulaire Utilisateur")
if id_role is not None:
#HACK a l'update on remet a la main les mdp
# car on les masque dans le form
form_user['pass_plus'] = user.pass_plus
form_user['pass_md5'] = user.pass_md5
form_user['id_role'] = user.id_role
new_role = TRoles.update(form_user)
else:
new_role = TRoles.post(form_user)
# set groups
if len(groups) > 0:
if id_role:
#first delete all groups of the user
cor_role_to_delete = CorRoles.get_all(params=[{
'col':
'id_role_utilisateur',
'filter':
id_role
}],
as_model=True)
print(cor_role_to_delete)
for cor_role in cor_role_to_delete:
db.session.delete(cor_role)
db.session.commit()
for group in groups:
# add new groups
new_group = CorRoles(id_role_groupe=group,
id_role_utilisateur=new_role.id_role)
db.session.add(new_group)
db.session.commit()
return redirect(url_for('user.users'))
else:
flash(strigify_dict(form.errors), 'error')
return render_template('user.html',
form=form,
title="Formulaire Utilisateur",
id_role=id_role)
def addorupdate(id_role=None):
"""
Route affichant un formulaire vierge ou non (selon l'url) pour ajouter ou mettre à jour un utilisateurs
L'envoie du formulaire permet l'ajout ou la mise à jour de l'utilisateur dans la base
Retourne un template accompagné du formulaire pré-rempli ou non selon le paramètre id_role
Une fois le formulaire validé on retourne une redirection vers la liste des utilisateurs
"""
form = t_rolesforms.Utilisateur()
form.id_organisme.choices = Bib_Organismes.choixSelect(
"id_organisme", "nom_organisme", order_by="nom_organisme")
form.a_groupe.choices = TRoles.choix_group("id_role",
"nom_role",
aucun=None)
if id_role is not None:
user = TRoles.get_one(id_role, as_model=True)
user_as_dict = user.as_dict_full_name()
# format group to prepfil the form
formated_groups = [
group.id_role for group in TRoles.get_user_groups(id_role)
]
if request.method == "GET":
form = process(form, user_as_dict, formated_groups)
if request.method == "POST":
if form.validate_on_submit() and form.validate():
groups = form.data["a_groupe"]
form_user = pops(form.data)
form_user["groupe"] = False
form_user.pop("id_role")
# if a password is set
# check they are the same
if form.pass_plus.data:
try:
(
form_user["pass_plus"],
form_user["pass_md5"],
) = check_and_encrypt_password(
form.pass_plus.data,
form.mdpconf.data,
current_app.config["PASS_METHOD"] == "md5"
or current_app.config["FILL_MD5_PASS"],
)
except Exception as exp:
flash(str(exp), "error")
return render_template("user.html",
form=form,
title="Formulaire Utilisateur")
if id_role is not None:
# HACK a l'update on remet a la main les mdp
# car on les masque dans le form
form_user["pass_plus"] = user.pass_plus
form_user["pass_md5"] = user.pass_md5
form_user["id_role"] = user.id_role
new_role = TRoles.update(form_user)
else:
new_role = TRoles.post(form_user)
# set groups
if len(groups) > 0:
if id_role:
# first delete all groups of the user
cor_role_to_delete = CorRoles.get_all(
params=[{
"col": "id_role_utilisateur",
"filter": id_role
}],
as_model=True,
)
for cor_role in cor_role_to_delete:
db.session.delete(cor_role)
db.session.commit()
for group in groups:
# add new groups
new_group = CorRoles(id_role_groupe=group,
id_role_utilisateur=new_role.id_role)
db.session.add(new_group)
db.session.commit()
return redirect(url_for("user.users"))
else:
flash(strigify_dict(form.errors), "error")
return render_template("user.html",
form=form,
title="Formulaire Utilisateur",
id_role=id_role)
def users():
"""
Route qui affiche la liste des utilisateurs
Retourne un template avec pour paramètres :
- une entête de tableau --> fLine
- le nom des colonnes de la base --> line
- le contenu du tableau --> table
- le chemin de mise à jour --> pathU
- le chemin de suppression --> pathD
- le chemin d'ajout --> pathA
- le chemin de la page d'information --> pathI
- une clé (clé primaire dans la plupart des cas) --> key
- un nom (nom de la table) pour le bouton ajout --> name
- un nom de listes --> name_list
- ajoute une colonne pour accéder aux infos de l'utilisateur --> see
"""
fLine = [
"Id",
"Identifiant",
"Nom",
"Prenom",
"Email",
"Organisme",
"Remarques",
"Actif",
"pass_plus",
"pass_md5",
] # noqa
columns = [
"id_role",
"identifiant",
"nom_role",
"prenom_role",
"email",
"nom_organisme",
"remarques",
"active",
"pass_plus",
"pass_md5",
] # noqa
filters = [{"col": "groupe", "filter": "False"}]
contents = TRoles.get_all(columns,
filters,
order_by="identifiant",
order="asc")
tab = []
for data in contents:
data["nom_organisme"] = (data["organisme_rel"]["nom_organisme"]
if data.get("organisme_rel") else None)
if data["pass_plus"] == "" or data["pass_plus"] is None:
data["pass_plus"] = "Non"
else:
data["pass_plus"] = "Oui"
if data["pass_md5"] == "" or data["pass_md5"] is None:
data["pass_md5"] = "Non"
else:
data["pass_md5"] = "Oui"
tab.append(data)
return render_template(
"table_database.html",
fLine=fLine,
line=columns,
table=tab,
see="True",
key="id_role",
pathI=config.URL_APPLICATION + "/user/info/",
pathU=config.URL_APPLICATION + "/user/update/",
pathD=config.URL_APPLICATION + "/users/delete/",
pathA=config.URL_APPLICATION + "/user/add/new",
pathZ=config.URL_APPLICATION + "/user/pass/",
passPlusCol="True",
passMd5Col="True",
name="un utilisateur",
name_list="Utilisateurs",
)
