def get_ft_ger_statut_util(_req, _form) :
# Imports
from app.functions import init_form
from django.template.context_processors import csrf
# Initialisation des champs
form = init_form(_form)
return '''
<form action="?action={0}-statut-agent" method="post" name="form_{1}_statut_util" onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{2}">
{3}
{4}
<div class="row">
<div class="col-sm-6">{5}</div>
<div class="col-sm-6">{6}</div>
</div>
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format(
'modifier' if _form.instance.get_pk() else 'ajouter',
'modif' if _form.instance.get_pk() else 'ajout',
csrf(_req)['csrf_token'],
form['zsc_pk'],
form['statut_util'],
form['mois_deb_statut_util'],
form['num_annee']
)
def modif_compte(_req):
# Imports
from app.forms.gest_compte import ModifierCompte
from app.functions import init_fm
from app.functions import init_form
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
# Affichage du template
output = render(
_req, './gest_compte/modif_compte.html', {
'form_modif_compte': init_form(
ModifierCompte(instance=obj_util)),
'tab_fm': [init_fm('modif_compte', 'Modifier mon compte')],
'title': 'Modifier mon compte',
'u': obj_util
})
else:
# Soumission du formulaire
form_modif_compte = ModifierCompte(_req.POST, instance=obj_util)
if form_modif_compte.is_valid():
# Modification d'une instance TUtilisateur
obj_util_valid = form_modif_compte.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'Votre compte a été mis à jour avec succès.',
'redirect': reverse('consult_compte')
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(form_modif_compte.errors),
content_type='application/json')
return output
def chois_verif_abs(_req):
# Imports
from app.forms.gest_abs import FiltrerVerificationAbsences
from app.functions import init_form
from app.functions import prep_dtab
from app.models import TUtilisateur
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
# Initialisation du formulaire
form_filtr_verif_abs = FiltrerVerificationAbsences(kw_util=obj_util)
# Affichage du template
output = render(
_req, './gest_abs/chois_verif_abs.html', {
'dtab_filtr_verif_abs': form_filtr_verif_abs.init_dtab(_req),
'form_filtr_verif_abs': init_form(form_filtr_verif_abs),
'title': 'Choisir une absence en attente'
})
else:
# Soumission du formulaire
form_filtr_verif_abs = FiltrerVerificationAbsences(_req.POST,
kw_util=obj_util)
# Rafraîchissement de la datatable ou affichage des erreurs
if form_filtr_verif_abs.is_valid():
output = prep_dtab(form_filtr_verif_abs.init_dtab(_req))
else:
output = HttpResponse(json.dumps(form_filtr_verif_abs.errors),
content_type='application/json')
return output
def chois_agent(_req):
# Imports
from app.forms.gest_agents import FiltrerAgents
from app.functions import init_form
from app.functions import prep_dtab
from app.models import TUtilisateur
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
if _req.method == 'GET':
# Initialisation du formulaire
form_filtr_agents = FiltrerAgents()
# Affichage du template
output = render(
_req, './gest_agents/chois_agent.html', {
'dtab_filtr_agents': form_filtr_agents.init_dtab(_req),
'form_filtr_agents': init_form(form_filtr_agents),
'title': 'Choisir un agent'
})
else:
# Soumission du formulaire
form_filtr_agents = FiltrerAgents(_req.POST)
# Rafraîchissement de la datatable ou affichage des erreurs
if form_filtr_agents.is_valid():
output = prep_dtab(form_filtr_agents.init_dtab(_req))
else:
output = HttpResponse(json.dumps(form_filtr_agents.errors),
content_type='application/json')
return output
def get_mess(_req):
# Imports
from app.forms.mess import SelectionnerMessages
from app.functions import affich_dem_suppr
from app.functions import init_fm
from app.functions import init_form
from app.models import TMessagesUtilisateur
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_select_mess_bdr = 'SelectionnerMessagesBdR'
pref_select_mess_arch = 'SelectionnerMessagesArchives'
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
if 'action' in _req.GET:
# Suppression des messages sélectionnés
if _req.GET['action'] == 'supprimer-messages-etape-2':
# Stockage des messages à supprimer
qs_mess_a_suppr = TMessagesUtilisateur.objects.filter(
pk__in=_req.session['tab_mess_a_suppr'])
# Suppression de la variable de session stockant les identifiants des instances TMessagesUtilisateur à
# supprimer
del _req.session['tab_mess_a_suppr']
# Préparation du message de succès
if qs_mess_a_suppr.count() > 1:
mess = 'Les messages sélectionnés ont été supprimés avec succès.'
else:
mess = 'Le message sélectionné a été supprimé avec succès.'
# Suppression de certaines instances TMessagesUtilisateur
for mu in qs_mess_a_suppr:
mu.delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': mess,
'redirect': reverse('get_mess')
}
}),
content_type='application/json')
else:
# Initialisation de chaque formulaire
form_select_mess_bdr = SelectionnerMessages(
prefix=pref_select_mess_bdr, kw_util=obj_util)
form_select_mess_arch = SelectionnerMessages(
prefix=pref_select_mess_arch,
kw_util=obj_util,
kw_est_arch=True)
# Initialisation de la variable de session stockant les identifiants des instances TMessagesUtilisateur à
# supprimer
_req.session['tab_mess_a_suppr'] = []
# Initialisation des fenêtres modales
tab_fm = [
init_fm(
'suppr_mess',
'Êtes-vous sûr de vouloir supprimer définitivement les messages sélectionnés ?'
)
]
# Affichage du template
output = render(
_req, './mess/get_mess.html', {
'form_select_mess_arch':
init_form(form_select_mess_arch),
'form_select_mess_bdr':
init_form(form_select_mess_bdr),
'qs_mess_util_arch__count':
obj_util.get_mess_util_set__count(True),
'qs_mess_util_bdr__count':
obj_util.get_mess_util_set__count(False),
'tab_fm':
tab_fm,
'title':
'Messages'
})
else:
if 'action' in _req.GET:
get_action = _req.GET['action']
# Déplacement des messages sélectionnés
if get_action == 'deplacer-vers':
if 'ou' in _req.GET:
get_ou = _req.GET['ou']
# Préparation de paramètres
tab_params = None
if get_ou == 'messages-archives':
tab_params = [pref_select_mess_bdr, False, True]
if get_ou == 'boite-de-reception':
tab_params = [pref_select_mess_arch, True, False]
if tab_params:
# Soumission du formulaire
form_select_mess = SelectionnerMessages(
_req.POST,
prefix=tab_params[0],
kw_util=obj_util,
kw_est_arch=tab_params[1])
if form_select_mess.is_valid():
# Stockage des données du formulaire
cleaned_data = form_select_mess.cleaned_data
val_mess_util = cleaned_data.get('zcc_mess_util')
# Mise à jour de certaines instances TMessagesUtilisateur
TMessagesUtilisateur.objects.filter(
pk__in=val_mess_util).update(
est_arch=tab_params[2])
# Affichage du message de succès
output = HttpResponse(
json.dumps({
'success': {
'redirect': reverse('get_mess')
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(tab_params[0], cle): val
for cle, val in
form_select_mess.errors.items()
}
output = HttpResponse(
json.dumps(tab_errs),
content_type='application/json')
# Affichage d'une demande de suppression des messages sélectionnés
if get_action == 'supprimer-messages-etape-1':
if 'depuis' in _req.GET:
get_depuis = _req.GET['depuis']
# Préparation de paramètres
tab_params = None
if get_depuis == 'boite-de-reception':
tab_params = [pref_select_mess_bdr, False]
if get_depuis == 'messages-archives':
tab_params = [pref_select_mess_arch, True]
if tab_params:
# Soumission du formulaire.
form_select_mess = SelectionnerMessages(
_req.POST,
prefix=tab_params[0],
kw_util=obj_util,
kw_est_arch=tab_params[1])
if form_select_mess.is_valid():
# Stockage des données du formulaire
cleaned_data = form_select_mess.cleaned_data
val_mess_util = cleaned_data.get('zcc_mess_util')
# Préparation de la variable de session stockant les identifiants des instances
# TMessagesUtilisateur à supprimer
_req.session['tab_mess_a_suppr'] = val_mess_util
# Affichage de la demande de suppression des messages sélectionnés
output = HttpResponse(json.dumps({
'success': {
'content':
affich_dem_suppr(
'?action=supprimer-messages-etape-2',
'suppr_mess')
}
}),
content_type=
'application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(tab_params[0], cle): val
for cle, val in
form_select_mess.errors.items()
}
output = HttpResponse(
json.dumps(tab_errs),
content_type='application/json')
return output
def consult_compte(_req):
# Imports
from app.forms.gest_agents import TrierTransactionsCetAgent
from app.functions import init_consult
from app.functions import init_fm
from app.functions import init_form
from app.functions import prep_dtab
from app.functions import transform_bool
from app.models import TUtilisateur
from datetime import date
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
if 'action' in _req.GET:
# Téléchargement de la fiche CET d'un agent
if _req.GET['action'] == 'telecharger-cet-agent' and 'mode-de-tri' in _req.GET and \
'historique' in _req.GET :
hist_trans_cet_util = _req.GET['historique']
if hist_trans_cet_util:
hist_trans_cet_util = int(hist_trans_cet_util)
output = obj_util.get_fiche_cet(_req.GET['mode-de-tri'],
hist_trans_cet_util)
# Affichage des absences autorisées ou en attente
if _req.GET[
'action'] == 'consulter-absences' and 'annee' in _req.GET:
output = prep_dtab(obj_util.get_tabl_abs(_req.GET['annee']), {
'modal_id': '#fm_consult_abs',
'modal_id_action': 'show'
})
else:
# Préparation des attributs disponibles en consultation
tab_attrs_util = {
'courr_second_util': {
'label': 'Courriel secondaire',
'value': obj_util.get_courr_second_util()
},
'email': {
'label': 'Courriel principal',
'value': obj_util.get_email()
},
'email_auto_courr_princ': {
'label':
'Les notifications sont-elles envoyées sur le courriel principal ?',
'value':
transform_bool(obj_util.get_email_auto_courr_princ())
},
'email_auto_courr_second': {
'label':
'Les notifications sont-elles envoyées sur le courriel secondaire ?',
'value':
transform_bool(obj_util.get_email_auto_courr_second())
},
'en_act': {
'label': 'Êtes-vous en activité ?',
'value': transform_bool(obj_util.get_en_act())
},
'first_name': {
'label': 'Prénom',
'value': obj_util.get_first_name()
},
'gpe_util': {
'label':
'Groupes d\'utilisateur',
'value':
', '.join(
[str(gu) for gu in obj_util.get_gpe_util().all()])
},
'last_name': {
'label': 'Nom de famille',
'value': obj_util.get_last_name()
},
'solde_cet_util': {
'label': 'Solde restant sur le compte épargne temps (CET)',
'value': obj_util.get_solde_cet_restant_util__str()
},
'type_util': {
'label':
'Quels sont les rôles assignés au compte ?',
'value':
', '.join(
[str(tu) for tu in obj_util.get_type_util().all()])
},
'username': {
'label': 'Nom d\'utilisateur',
'value': obj_util.get_username()
}
}
# Initialisation des statuts agent
tab_statut_util = []
for su in obj_util.get_statut_util_set().all():
# Détermination du statut agent actuel
statut_util_actuel = False
if date.today() > date(su.get_annee().get_pk(),
su.get_mois_deb_statut_util(), 1):
statut_util_actuel = True
for elem in tab_statut_util:
if elem['class']: elem['class'] = None
tab_statut_util.append({
'class':
'to-highlight' if statut_util_actuel == True else None,
'period_deb_statut_util':
su.get_period_deb_statut_util(),
'pk':
su.get_pk(),
'statut_util':
su.get_statut_util__str()
})
# Initialisation des décomptes agent
tab_decompt_util = [{
'annee':
du.get_annee(),
'nbre_j_cp_autor':
du.get_util().get_nbre_j_autor__str(True,
du.get_annee().get_pk()),
'nbre_j_cp_base':
du.get_nbre_j_cp_base__str(),
'nbre_j_cp_rest':
du.get_util().get_nbre_j_rest__str(True,
du.get_annee().get_pk()),
'nbre_j_cp_transf':
du.get_util().get_nbre_j_transf__str(True,
du.get_annee().get_pk()),
'nbre_j_rtt_autor':
du.get_util().get_nbre_j_autor__str(False,
du.get_annee().get_pk()),
'nbre_j_rtt_base':
du.get_nbre_j_rtt_base__str(),
'nbre_j_rtt_rest':
du.get_util().get_nbre_j_rest__str(False,
du.get_annee().get_pk()),
'nbre_j_rtt_transf':
du.get_util().get_nbre_j_transf__str(False,
du.get_annee().get_pk()),
} for du in obj_util.get_decompt_util_set().reverse()]
# Initialisation du formulaire de tri des transactions d'un CET
form_tri_trans_cet_util = TrierTransactionsCetAgent(
kw_consult=True, kw_util=obj_util)
# Affichage du template
output = render(
_req, './gest_compte/consult_compte.html', {
'dtab_tri_trans_cet_util':
form_tri_trans_cet_util.init_dtab(_req),
'form_tri_trans_cet_util':
init_form(form_tri_trans_cet_util),
'tab_attrs_util':
init_consult(tab_attrs_util),
'tab_decompt_util':
tab_decompt_util,
'tab_fm': [
init_fm(
'consult_abs',
'Consulter les absences autorisées ou en attente',
obj_util.get_tabl_abs())
],
'tab_statut_util':
tab_statut_util,
'title':
'Consulter mon compte',
})
else:
# Traitement du cas où je dois rafraîchir la fiche CET d'un agent (altération du mode de tri)
if _req.GET['action'] == 'trier-transactions-cet-agent':
# Soumission du formulaire
form_tri_trans_cet_util = TrierTransactionsCetAgent(
_req.POST, kw_consult=True, kw_util=obj_util)
# Rafraîchissement de la datatable ou affichage des erreurs
if form_tri_trans_cet_util.is_valid():
output = prep_dtab(form_tri_trans_cet_util.init_dtab(_req))
else:
output = HttpResponse(json.dumps(
form_tri_trans_cet_util.errors),
content_type='application/json')
return output
def filtr_abs(_req, _gby) :
# Imports
from app.forms.real_etats import FiltrerAbsences
from app.functions import gener_cdc
from app.functions import init_fm
from app.functions import init_form
from app.functions import prep_dtab
from app.functions import transform_bool
from app.models import TAbsence
from app.models import TUtilisateur
from django.http import HttpResponse
from django.shortcuts import render
from django.template.context_processors import csrf
import csv
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_filtr_abs = 'FiltrerAbsences'
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk = _req.user.pk)
if _req.method == 'GET' :
if 'action' in _req.GET :
if _req.GET['action'] == 'exporter-csv' and 'group-by' in _req.GET \
and _req.GET['group-by'] in ['off', 'on'] :
# Génération d'un fichier au format CSV
output = HttpResponse(content_type = 'text/csv', charset = 'cp1252')
output['Content-Disposition'] = 'attachment; filename="{0}.csv"'.format(gener_cdc())
# Accès en écriture
writer = csv.writer(output, delimiter = ';')
# Initialisation des données
tab_lg = _req.session['filtr_abs'] if 'filtr_abs' in _req.session else []
# Définition de l'en-tête
if _gby == False :
header = [
'Agent ayant émis l\'absence',
'Date d\'émission de l\'absence',
'Agent concerné',
'Type de l\'absence',
'Année',
'Date de l\'absence',
'Justificatif d\'absence',
'Commentaire (phase de pré-validation)',
'Agent ayant vérifié l\'absence',
'Date de vérification de l\'absence',
'L\'absence est-elle autorisée ?',
'Type final de l\'absence',
'Commentaire (phase de post-validation)'
]
else :
header = [
'Nom complet de l\'agent/des agents',
'Type de l\'absence',
'Année de l\'absence',
'État de l\'absence',
'Nombre d\'absences',
'Nombre de jours d\'absence'
]
# Ajout de l'en-tête
writer.writerow(header)
for elem in tab_lg :
# Définition des données de la nouvelle ligne
if _gby == False :
# Obtention d'une instance TAbsence
obj_abs = TAbsence.objects.get(pk = elem[0])
# Ajout des données "pré-validation"
body = [
obj_abs.get_util_connect().get_nom_complet() if obj_abs.get_util_connect() else None,
obj_abs.get_dt_emiss_abs__str(),
obj_abs.get_util_emett().get_nom_complet(),
obj_abs.get_type_abs(),
obj_abs.get_annee(),
obj_abs.get_dt_abs__fr_str(),
_req.build_absolute_uri(str(obj_abs.get_pj_abs())) if obj_abs.get_pj_abs() else None,
obj_abs.get_comm_abs()
]
# Ajout des données "post-validation" si définies
if obj_abs.get_verif_abs() :
body += [
obj_abs.get_verif_abs().get_util_verif().get_nom_complet() \
if obj_abs.get_verif_abs().get_util_verif() else None,
obj_abs.get_verif_abs().get_dt_verif_abs__str(),
transform_bool(obj_abs.get_verif_abs().get_est_autor()),
obj_abs.get_verif_abs().get_type_abs_final(),
obj_abs.get_verif_abs().get_comm_verif_abs()
]
else :
body = elem
# Ajout d'une nouvelle ligne
writer.writerow(body)
else :
# Initialisation du formulaire et de ses attributs
form_filtr_abs = FiltrerAbsences(prefix = pref_filtr_abs, kw_gby = _gby, kw_util = obj_util)
_form_filtr_abs = init_form(form_filtr_abs)
# Définition de l'attribut <title/>
if _gby == False :
title = 'Réalisation d\'états en sélectionnant des absences'
else :
title = 'Réalisation d\'états en regroupant des absences'
# Initialisation des fenêtres modales
tab_fm = [init_fm(
'filtr_abs',
'Filtrer les absences par',
'''
<form action="" method="post" name="form_select_abs" onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{0}">
{1}
<div class="row">
<div class="col-sm-6">{2}</div>
<div class="col-sm-6">{3}</div>
</div>
<span class="theme-color">Période de début d'absence</span>
<div class="row">
<div class="col-sm-6">{4}</div>
<div class="col-sm-6">{5}</div>
</div>
{6}
{7}
{8}
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format(
csrf(_req)['csrf_token'],
_form_filtr_abs['zcc_util'],
_form_filtr_abs['zl_type_abs'],
_form_filtr_abs['zl_annee'],
_form_filtr_abs['zd_dt_deb_abs'],
_form_filtr_abs['zd_dt_fin_abs'],
_form_filtr_abs['zl_etat_abs'],
_form_filtr_abs['rb_gby'] if 'rb_gby' in _form_filtr_abs else '',
_form_filtr_abs['zcc_ajout_select_exist']
)
)]
# Affichage du template
output = render(_req, './real_etats/filtr_abs.html', {
'dtab_filtr_abs' : form_filtr_abs.init_dtab(_req),
'form_filtr_abs' : init_form(form_filtr_abs),
'gby' : 'off' if _gby == False else 'on',
'tab_fm' : tab_fm,
'title' : title
})
else :
# Soumission du formulaire
form_filtr_abs = FiltrerAbsences(_req.POST, prefix = pref_filtr_abs, kw_gby = _gby, kw_util = obj_util)
# Rafraîchissement de la datatable ou affichage des erreurs
if form_filtr_abs.is_valid() :
output = prep_dtab(form_filtr_abs.init_dtab(_req), {
'modal_id' : '#fm_filtr_abs', 'modal_id_action' : 'hide'
})
else :
tab_errs = { '{0}-{1}'.format(pref_filtr_abs, cle) : val for cle, val in form_filtr_abs.errors.items() }
output = HttpResponse(json.dumps(tab_errs), content_type = 'application/json')
return output
def ger_agent(_req, _inst=False):
# Imports
from app.forms.gest_agents import GererAgent
from app.functions import init_fm
from app.functions import init_form
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.http import Http404
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
from django.template.context_processors import csrf
import json
output = None
# Tentative d'obtention d'une instance TUtilisateur (si page de modification en cours)
if _inst == False:
obj_util = None
else:
if 'id' in _req.GET:
obj_util = get_object_or_404(TUtilisateur, pk=_req.GET['id'])
else:
raise Http404
# Initialisation du préfixe de chaque formulaire
pref_ger_agent = 'GererAgent'
pref_modif_mdp_agent = 'ModifierMotDePasseAgent'
if _req.method == 'GET':
# Initialisation de chaque formulaire
form_ger_agent = GererAgent(prefix=pref_ger_agent, instance=obj_util)
if _inst == True:
form_modif_mdp_agent = init_form(
GererAgent(prefix=pref_modif_mdp_agent,
instance=obj_util,
kw_modif_mdp_agent=True))
# Initialisation des fenêtres modales
tab_fm = [
init_fm(
'ger_agent',
'Ajouter un agent' if _inst == False else 'Modifier un agent')
]
if _inst == True:
tab_fm += [
init_fm(
'modif_mdp', 'Modifier le mot de passe', '''
<form action="{0}" method="post" name="form_modif_mdp" onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{1}">
<div class="row">
<div class="col-sm-6">{2}</div>
<div class="col-sm-6">{3}</div>
</div>
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format('?id={}&action=modifier-mot-de-passe'.format(obj_util.get_pk()),
csrf(_req)['csrf_token'], form_modif_mdp_agent['zs_password'],
form_modif_mdp_agent['zs_password_bis']))
]
# Affichage du template
output = render(
_req, './gest_agents/ger_agent.html', {
'a':
obj_util,
'form_ger_agent':
init_form(form_ger_agent),
'tab_fm':
tab_fm,
'title':
'Ajouter un agent' if _inst == False else 'Modifier un agent'
})
else:
# Préparation de paramètres
tab_params = None
if 'action' in _req.GET:
if _req.GET['action'] == 'modifier-mot-de-passe':
obj_util_auth = TUtilisateur.objects.get(
pk=_req.user.pk) if _req.user.is_authenticated() else None
tab_params = [
pref_modif_mdp_agent, True,
'Le mot de passe de l\'agent __USERNAME__ a été modifié avec succès.',
['index', []] if obj_util == obj_util_auth else
['consult_agent', ['__PK__']]
]
else:
tab_params = [
pref_ger_agent, False,
'L\'agent __USERNAME__ a été {} avec succès.'.format(
'ajouté' if _inst == False else 'modifié'),
['consult_agent', ['__PK__']]
]
if tab_params:
# Soumission du formulaire
form_ger_agent = GererAgent(_req.POST,
prefix=tab_params[0],
instance=obj_util,
kw_modif_mdp_agent=tab_params[1])
if form_ger_agent.is_valid():
# Création/modification d'une instance TUtilisateur
obj_util_valid = form_ger_agent.save()
# Mise à jour des paramètres
if len(tab_params[3]
[1]) > 0 and tab_params[3][1][0] == '__PK__':
tab_params[3][1] = [obj_util_valid.get_pk()]
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
tab_params[2].replace('__USERNAME__',
str(obj_util_valid)),
'redirect':
reverse(tab_params[3][0], args=tab_params[3][1])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(tab_params[0], cle): val
for cle, val in form_ger_agent.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
def consult_agent(_req, _a):
# Imports
from app.forms.gest_agents import TrierTransactionsCetAgent
from app.form_templates import get_ft_ger_statut_util
from app.form_templates import get_ft_ger_trans_cet_util
from app.forms.gest_agents import GererStatutAgent
from app.forms.gest_agents import GererTransactionCetAgent
from app.functions import affich_dem_suppr
from app.functions import init_consult
from app.functions import init_fm
from app.functions import init_form
from app.functions import prep_dtab
from app.functions import transform_bool
from app.models import TStatutsUtilisateur
from app.models import TTransactionsCetUtilisateur
from app.models import TUtilisateur
from datetime import date
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
from django.template.context_processors import csrf
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_ajout_statut_agent = 'AjouterStatutAgent'
pref_ajout_trans_cet_agent = 'AjouterTransactionCetAgent'
pref_modif_statut_agent = 'ModifierStatutAgent'
pref_modif_trans_cet_agent = 'ModifierTransactionCetAgent'
# Tentative d'obtention d'une instance TUtilisateur
obj_util = get_object_or_404(TUtilisateur, pk=_a)
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
if 'action' in _req.GET:
# Initialisation du formulaire de mise à jour d'un statut agent
if _req.GET[
'action'] == 'initialiser-formulaire-modification-statut-agent' and 'id' in _req.GET:
# Initialisation du formulaire
form_ger_statut_util = GererStatutAgent(
prefix=pref_modif_statut_agent,
instance=TStatutsUtilisateur.objects.get(
pk=_req.GET['id']),
kw_util=obj_util)
# Affichage du formulaire
output = HttpResponse(json.dumps({
'success': {
'content':
get_ft_ger_statut_util(_req, form_ger_statut_util)
}
}),
content_type='application/json')
# Affichage d'une demande de suppression d'un statut agent
if _req.GET[
'action'] == 'supprimer-statut-agent-etape-1' and 'id' in _req.GET:
# Stockage en session du statut agent à supprimer
_req.session['statut_util__pk'] = _req.GET['id']
# Affichage de la demande de suppression du statut agent
output = HttpResponse(json.dumps({
'success': {
'content':
affich_dem_suppr(
'?action=supprimer-statut-agent-etape-2',
'suppr_statut_util')
}
}),
content_type='application/json')
# Suppression d'un statut agent
if _req.GET[
'action'] == 'supprimer-statut-agent-etape-2' and 'statut_util__pk' in _req.session:
# Suppression d'une instance TStatutsUtilisateur
obj_util.get_statut_util_set().get(
pk=_req.session['statut_util__pk']).delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'agent {} a été modifié avec succès.'.format(
obj_util),
'redirect':
reverse('consult_agent', args=[obj_util.get_pk()])
}
}),
content_type='application/json')
# Initialisation du formulaire de mise à jour d'une transaction sur un CET
if _req.GET['action'] == 'initialiser-formulaire-modification-transaction-entrante-cet-agent' and \
'id' in _req.GET :
# Initialisation du formulaire
form_ger_trans_cet_util = GererTransactionCetAgent(
prefix=pref_modif_trans_cet_agent,
instance=TTransactionsCetUtilisateur.objects.get(
pk=_req.GET['id']),
kw_util=obj_util,
kw_util_connect=obj_util_connect)
# Affichage du formulaire
output = HttpResponse(json.dumps({
'success': {
'content':
get_ft_ger_trans_cet_util(_req,
form_ger_trans_cet_util)
}
}),
content_type='application/json')
# Affichage d'une demande de suppression d'une transaction entrante sur le CET
if _req.GET[
'action'] == 'supprimer-transaction-entrante-cet-agent-etape-1' and 'id' in _req.GET:
# Stockage en session du statut agent à supprimer
_req.session['trans_cet_util__pk'] = _req.GET['id']
# Affichage de la demande de suppression d'une transaction entrante sur le CET
output = HttpResponse(json.dumps({
'success': {
'content':
affich_dem_suppr(
'?action=supprimer-transaction-entrante-cet-agent-etape-2',
'suppr_trans_cet_util')
}
}),
content_type='application/json')
# Suppression d'une transaction entrante sur le CET
if _req.GET['action'] == 'supprimer-transaction-entrante-cet-agent-etape-2' and \
'trans_cet_util__pk' in _req.session :
# Suppression d'une instance TTransactionsCetUtilisateur
obj_util.get_trans_cet_util_set().get(
pk=_req.session['trans_cet_util__pk']).delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'''
Le compte épargne temps de l'agent {} a été modifié avec succès.
'''.format(obj_util),
'redirect':
reverse('consult_agent', args=[obj_util.get_pk()])
}
}),
content_type='application/json')
# Téléchargement de la fiche CET d'un agent
if _req.GET['action'] == 'telecharger-cet-agent' and 'mode-de-tri' in _req.GET and \
'historique' in _req.GET :
hist_trans_cet_util = _req.GET['historique']
if hist_trans_cet_util:
hist_trans_cet_util = int(hist_trans_cet_util)
output = obj_util.get_fiche_cet(_req.GET['mode-de-tri'],
hist_trans_cet_util)
# Affichage des absences autorisées ou en attente
if _req.GET[
'action'] == 'consulter-absences' and 'annee' in _req.GET:
output = prep_dtab(obj_util.get_tabl_abs(_req.GET['annee']), {
'modal_id': '#fm_consult_abs',
'modal_id_action': 'show'
})
else:
# Préparation des attributs disponibles en consultation
tab_attrs_util = {
'courr_second_util': {
'label': 'Courriel secondaire',
'value': obj_util.get_courr_second_util()
},
'email': {
'label': 'Courriel principal',
'value': obj_util.get_email()
},
'email_auto_courr_princ': {
'label':
'Les notifications sont-elles envoyées sur le courriel principal ?',
'value':
transform_bool(obj_util.get_email_auto_courr_princ())
},
'email_auto_courr_second': {
'label':
'Les notifications sont-elles envoyées sur le courriel secondaire ?',
'value':
transform_bool(obj_util.get_email_auto_courr_second())
},
'en_act': {
'label': 'L\'agent est-il en activité ?',
'value': transform_bool(obj_util.get_en_act())
},
'first_name': {
'label': 'Prénom',
'value': obj_util.get_first_name()
},
'gpe_util': {
'label':
'Groupes d\'utilisateur',
'value':
', '.join(
[str(gu) for gu in obj_util.get_gpe_util().all()])
},
'is_active': {
'label': 'Le compte est-il actif ?',
'last_child': True,
'value': transform_bool(obj_util.get_is_active())
},
'last_name': {
'label': 'Nom de famille',
'value': obj_util.get_last_name()
},
'solde_cet_util': {
'label': 'Solde restant sur le compte épargne temps (CET)',
'value': obj_util.get_solde_cet_restant_util__str()
},
'type_util': {
'label':
'Quels sont les rôles assignés au compte ?',
'value':
', '.join(
[str(tu) for tu in obj_util.get_type_util().all()])
},
'username': {
'label': 'Nom d\'utilisateur',
'value': obj_util.get_username()
}
}
# Initialisation des statuts agent
tab_statut_util = []
for su in obj_util.get_statut_util_set().all():
# Détermination du statut agent actuel
statut_util_actuel = False
if date.today() > date(su.get_annee().get_pk(),
su.get_mois_deb_statut_util(), 1):
statut_util_actuel = True
for elem in tab_statut_util:
if elem['class']: elem['class'] = None
tab_statut_util.append({
'class':
'to-highlight' if statut_util_actuel == True else None,
'period_deb_statut_util':
su.get_period_deb_statut_util(),
'pk':
su.get_pk(),
'statut_util':
su.get_statut_util__str()
})
# Initialisation des décomptes agent
tab_decompt_util = [{
'annee':
du.get_annee(),
'nbre_j_cp_autor':
du.get_util().get_nbre_j_autor__str(True,
du.get_annee().get_pk()),
'nbre_j_cp_base':
du.get_nbre_j_cp_base__str(),
'nbre_j_cp_rest':
du.get_util().get_nbre_j_rest__str(True,
du.get_annee().get_pk()),
'nbre_j_cp_transf':
du.get_util().get_nbre_j_transf__str(True,
du.get_annee().get_pk()),
'nbre_j_rtt_autor':
du.get_util().get_nbre_j_autor__str(False,
du.get_annee().get_pk()),
'nbre_j_rtt_base':
du.get_nbre_j_rtt_base__str(),
'nbre_j_rtt_rest':
du.get_util().get_nbre_j_rest__str(False,
du.get_annee().get_pk()),
'nbre_j_rtt_transf':
du.get_util().get_nbre_j_transf__str(False,
du.get_annee().get_pk()),
} for du in obj_util.get_decompt_util_set().reverse()]
# Initialisation du formulaire de tri des transactions d'un CET
form_tri_trans_cet_util = TrierTransactionsCetAgent(
kw_util=obj_util)
# Initialisation des fenêtres modales
tab_fm = [
init_fm(
'ajout_trans_cet_util', 'Ajouter une transaction entrante',
get_ft_ger_trans_cet_util(
_req,
GererTransactionCetAgent(
prefix=pref_ajout_trans_cet_agent,
kw_util=obj_util,
kw_util_connect=obj_util_connect))),
init_fm(
'ajout_statut_util', 'Ajouter un statut agent',
get_ft_ger_statut_util(
_req,
GererStatutAgent(prefix=pref_ajout_statut_agent,
kw_util=obj_util))),
init_fm('consult_abs',
'Consulter les absences autorisées ou en attente',
obj_util.get_tabl_abs()),
init_fm('modif_statut_util', 'Modifier un statut agent'),
init_fm('modif_trans_cet_util',
'Modifier une transaction entrante'),
init_fm(
'suppr_statut_util',
'Êtes-vous sûr de vouloir supprimer définitivement le statut agent ?'
),
init_fm(
'suppr_trans_cet_util',
'Êtes-vous sûr de vouloir supprimer définitivement la transaction entrante ?'
)
]
# Affichage du template
output = render(
_req, './gest_agents/consult_agent.html', {
'a':
obj_util,
'dtab_tri_trans_cet_util':
form_tri_trans_cet_util.init_dtab(_req),
'form_tri_trans_cet_util':
init_form(form_tri_trans_cet_util),
'tab_attrs_util':
init_consult(tab_attrs_util),
'tab_decompt_util':
tab_decompt_util,
'tab_fm':
tab_fm,
'tab_statut_util':
tab_statut_util,
'title':
'Consulter un agent'
})
else:
if 'action' in _req.GET:
# Définition du préfixe du formulaire de gestion des statuts agent
if _req.GET['action'] == 'ajouter-statut-agent':
prefix = pref_ajout_statut_agent
elif _req.GET['action'] == 'modifier-statut-agent':
prefix = pref_modif_statut_agent
else:
prefix = None
if prefix:
# Stockage des données du formulaire
val_pk = _req.POST.get('{}-zsc_pk'.format(prefix))
# Soumission du formulaire
form_ger_statut_util = GererStatutAgent(
_req.POST,
instance=TStatutsUtilisateur.objects.get(
pk=val_pk) if val_pk else None,
prefix=prefix,
kw_util=obj_util)
if form_ger_statut_util.is_valid():
# Création/modification d'une instance TStatutsUtilisateur
obj_statut_util_valid = form_ger_statut_util.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'''
L'agent {} a été modifié avec succès.
'''.format(obj_statut_util_valid.get_util()),
'redirect':
reverse(
'consult_agent',
args=[
obj_statut_util_valid.get_util().get_pk()
])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(prefix, cle): val
for cle, val in form_ger_statut_util.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
# Définition du préfixe du formulaire de gestion des transactions entrantes sur le CET agent
if _req.GET['action'] == 'ajouter-transaction-entrante-cet-agent':
prefix = pref_ajout_trans_cet_agent
elif _req.GET[
'action'] == 'modifier-transaction-entrante-cet-agent':
prefix = pref_modif_trans_cet_agent
else:
prefix = None
if prefix:
# Stockage des données du formulaire
val_pk = _req.POST.get('{}-zsc_pk'.format(prefix))
# Soumission du formulaire
form_ger_trans_cet_util = GererTransactionCetAgent(
_req.POST,
instance=TTransactionsCetUtilisateur.objects.get(
pk=val_pk) if val_pk else None,
prefix=prefix,
kw_util=obj_util,
kw_util_connect=obj_util_connect)
if form_ger_trans_cet_util.is_valid():
# Création/modification d'une instance TTransactionsCetUtilisateur
obj_trans_cet_util_valid = form_ger_trans_cet_util.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'''
Le compte épargne temps de l'agent {} a été modifié avec succès.
'''.format(obj_trans_cet_util_valid.get_util()),
'redirect':
reverse('consult_agent',
args=[
obj_trans_cet_util_valid.get_util().
get_pk()
])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(prefix, cle): val
for cle, val in form_ger_trans_cet_util.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
# Traitement du cas où je dois rafraîchir la fiche CET d'un agent (altération du mode de tri)
if _req.GET['action'] == 'trier-transactions-cet-agent':
# Soumission du formulaire
form_tri_trans_cet_util = TrierTransactionsCetAgent(
_req.POST, kw_util=obj_util)
# Rafraîchissement de la datatable ou affichage des erreurs
if form_tri_trans_cet_util.is_valid():
output = prep_dtab(form_tri_trans_cet_util.init_dtab(_req))
else:
output = HttpResponse(json.dumps(
form_tri_trans_cet_util.errors),
content_type='application/json')
return output
def verif_abs(_req, _a):
# Imports
from app.forms.gest_abs import VerifierAbsence
from app.functions import get_obj_dt
from app.functions import init_consult
from app.functions import init_fm
from app.functions import init_form
from app.functions import transform_bool
from app.models import TAbsence
from app.models import TDatesAbsence
from app.models import TUtilisateur
from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_verif_abs = 'VerifierAbsence'
# Tentative d'obtention d'une instance TAbsence
obj_abs = get_object_or_404(TAbsence, pk=_a)
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
# Vérification des droits d'accès
if obj_abs not in obj_util.get_abs_a_verif__list(): raise PermissionDenied
'''
Obtention du nombre de jours d'absence déjà autorisés pour le type d'absence lié à une absence
_obj : Instance TAbsence
_code : Par mois ou par année ?
Retourne un tableau associatif
'''
def calc_nbre_j(_obj, _code):
# Import
from app.models import TDatesAbsence
output = {}
# Initialisation du tableau des dates d'absence
tab_dt_abs = [[da.get_dt_abs(),
da.get_indisp_dt_abs()]
for da in _obj.get_dt_abs_set().all()]
# Groupement d'objets "date"
if _code == 'MOIS':
tab_dt_abs__group_by = [[
j for j in tab_dt_abs
if '{0}_{1}'.format(j[0].month, j[0].year) == i
] for i in set(
map(lambda l: '{0}_{1}'.format(l[0].month, l[0].year),
tab_dt_abs))]
elif _code == 'ANNEE':
tab_dt_abs__group_by = [[
j for j in tab_dt_abs if j[0].year == i
] for i in set(map(lambda l: l[0].year, tab_dt_abs))]
else:
tab_dt_abs__group_by = []
for elem in tab_dt_abs__group_by:
# Stockage du mois et de l'année
mois = elem[0][0].month
annee = elem[0][0].year
# Définition des conditions de la requête
if _code == 'MOIS':
tab_filter = {
'dt_abs__month': mois,
'dt_abs__year': annee,
'id_abs__id_util_emett': _obj.get_util_emett()
}
else:
tab_filter = {
'id_abs__num_annee': annee,
'id_abs__id_util_emett': _obj.get_util_emett()
}
# Initialisation du nombre de jours déjà autorisés
nbre_j = 0
# Cumul du nombre de jours déjà autorisés
for da in TDatesAbsence.objects.filter(**tab_filter):
obj_verif_abs = da.get_abs().get_verif_abs()
if obj_verif_abs:
if obj_verif_abs.get_type_abs_final() == _obj.get_type_abs(
):
if da.get_abs().get_etat_abs() == 1:
if da.get_indisp_dt_abs() == 'WD':
nbre_j += 1
else:
nbre_j += 0.5
# Empilement du tableau de sortie
output['{0}_{1}'.format(mois, annee) if _code ==
'MOIS' else str(annee)] = nbre_j
return output
if _req.method == 'GET':
# Préparation des attributs disponibles en consultation (onglet 1)
tab_attrs_abs = {
'comm_abs': {
'label': 'Commentaire',
'last_child': True,
'value': obj_abs.get_comm_abs()
},
'dt_abs': {
'label': 'Date de l\'absence',
'value': obj_abs.get_dt_abs__fr_str()
},
'pj_abs': {
'label': 'Consulter le justificatif d\'absence',
'value': obj_abs.get_pj_abs__path(),
'pdf': True
},
'id_util_emett': {
'label': 'Agent concerné',
'value': obj_abs.get_util_emett().get_nom_complet()
},
'id_type_abs': {
'label': 'Type de l\'absence',
'value': obj_abs.get_type_abs()
},
'num_annee': {
'label': 'Année',
'value': obj_abs.get_annee()
}
}
# Préparation des données relatives au nombre de jours d'absence déjà autorisés
tab_nbre_j_abs_annee = [[
int(cle), val
] for cle, val in calc_nbre_j(obj_abs, 'ANNEE').items()]
tab_nbre_j_abs_mois = [[
int(cle.split('_')[0]),
get_obj_dt('MONTHS')[int(cle.split('_')[0]) - 1],
int(cle.split('_')[1]), val
] for cle, val in calc_nbre_j(obj_abs, 'MOIS').items()]
# Vérification d'un quelconque conflit entre plusieurs absences
conflit = False
for daa in obj_abs.get_dt_abs_set().all():
for da in TDatesAbsence.objects.filter(
dt_abs=daa.get_dt_abs(),
id_abs__id_util_emett=obj_abs.get_util_emett()):
if da.get_abs().get_etat_abs() == 1:
if da.get_indisp_dt_abs() == 'WD':
conflit = True
elif da.get_indisp_dt_abs() == 'AM':
if daa.get_indisp_dt_abs() != 'PM': conflit = True
elif da.get_indisp_dt_abs() == 'PM':
if daa.get_indisp_dt_abs() != 'AM': conflit = True
# Préparation des attributs disponibles en consultation (onglet 2)
tab_attrs_aide = {
'conflit_abs': {
'label':
'Une absence est-elle déjà autorisée pendant cette absence ?',
'last_child': True,
'value': transform_bool(conflit)
},
'descr_nds_type_abs': {
'label':
'''
Extrait de la note de service pour le type d'absence suivant : « {} »
'''.format(obj_abs.get_type_abs()),
'value':
obj_abs.get_type_abs().get_descr_nds_type_abs()
},
'nbre_j_abs_annee': {
'datatable':
True,
'datatable_header':
'Année|Nombre de jours déjà autorisés',
'label':
'''
Nombre de jours déjà autorisés par année pour le type d'absence suivant : « {} »
'''.format(obj_abs.get_type_abs()),
'value':
list(sorted(tab_nbre_j_abs_annee, key=lambda l: l[0]))
},
'nbre_j_abs_mois': {
'datatable':
True,
'datatable_header':
'Mois|Année|Nombre de jours déjà autorisés',
'label':
'''
Nombre de jours déjà autorisés par période pour le type d'absence suivant : « {} »
'''.format(obj_abs.get_type_abs()),
'value': [
elem[1:] for elem in list(
sorted(tab_nbre_j_abs_mois, key=lambda l:
(l[2], l[0])))
]
}
}
# Ajout d'un attribut d'aide en cas de vérification d'une absence dont le groupe de type d'absence est "CET"
if obj_abs.get_type_abs().get_gpe_type_abs().get_pk(
) == settings.DB_PK_DATAS['CET_PK']:
tab_attrs_aide['solde_cet_restant_util'] = {
'label':
'Solde restant prévisionnel sur le compte épargne temps (CET)',
'value':
obj_abs.get_util_emett().get_solde_cet_restant_util__str(
obj_abs.get_util_emett().get_solde_cet_util() -
obj_abs.get_nbre_dt_abs())
}
# Initialisation du formulaire
form_verif_abs = VerifierAbsence(prefix=pref_verif_abs)
# Initialisation des fenêtres modales
tab_fm = [init_fm('verif_abs', 'Vérifier une absence')]
# Affichage du template
output = render(
_req, './gest_abs/verif_abs.html', {
'form_verif_abs': init_form(form_verif_abs),
'tab_attrs_abs': init_consult(tab_attrs_abs),
'tab_attrs_aide': init_consult(tab_attrs_aide),
'tab_fm': tab_fm,
'title': 'Vérifier une absence'
})
else:
# Soumission du formulaire
form_verif_abs = VerifierAbsence(_req.POST,
prefix=pref_verif_abs,
kw_abs=obj_abs,
kw_req=_req,
kw_util_connect=obj_util)
if form_verif_abs.is_valid():
# Création d'une instance TVerificationAbsence
obj_verif_abs_valid = form_verif_abs.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'absence a été vérifiée avec succès.',
'redirect':
reverse('consult_abs', args=[obj_verif_abs_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_verif_abs, cle): val
for cle, val in form_verif_abs.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
def ger_abs(_req):
# Imports
from app.forms.gest_abs import GererAbsence
from app.functions import init_fm
from app.functions import init_form
from app.models import TAbsence
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_ger_abs = 'GererAbsence'
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
if _req.method == 'GET':
# Initialisation de chaque formulaire
form_ger_abs = GererAbsence(prefix=pref_ger_abs, kw_util=obj_util)
# Initialisation des fenêtres modales
tab_fm = [init_fm('ger_abs', 'Ajouter une absence')]
# Affichage du template
output = render(
_req, './gest_abs/ger_abs.html', {
'form_ger_abs': init_form(form_ger_abs),
'tab_fm': tab_fm,
'title': 'Ajouter une absence'
})
else:
# Soumission du formulaire
form_ger_abs = GererAbsence(
_req.POST,
_req.FILES,
prefix=pref_ger_abs,
kw_dt_abs_tranche=int(
_req.POST.get('{}-rb_dt_abs_tranche'.format(pref_ger_abs))),
kw_req=_req,
kw_type_abs=_req.POST.get('{}-zl_type_abs'.format(pref_ger_abs)),
kw_util=obj_util)
if form_ger_abs.is_valid():
# Création/modification d'une instance TAbsence
obj_abs_valid = form_ger_abs.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'absence a été émise avec succès.',
'redirect':
reverse('consult_abs', args=[obj_abs_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_ger_abs, cle): val
for cle, val in form_ger_abs.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
def consult_abs(_req, _a):
# Imports
from app.forms.gest_abs import InsererPieceJustificativeAbsence
from app.forms.gest_abs import ModifierTypeAbsenceFinal
from app.functions import affich_dem_suppr
from app.functions import init_consult
from app.functions import init_fm
from app.functions import init_form
from app.functions import transform_bool
from app.models import TAbsence
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
from django.template.context_processors import csrf
import json
# Initialisation du préfixe de chaque formulaire
pref_inser_pj_abs = 'InsererPieceJustificativeAbsence'
pref_modif_type_abs_final = 'ModifierTypeAbsenceFinal'
output = None
# Tentative d'obtention d'une instance TUtilisateur
obj_abs = get_object_or_404(TAbsence, pk=_a)
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
# Vérification du droit d'accès
obj_abs.can_read(obj_util, False)
# Stockage de booléens
can_update_type_abs_final = obj_abs.can_update_type_abs_final(
obj_util, True)
if _req.method == 'GET':
if 'action' in _req.GET:
# Affichage d'une demande de suppression d'une absence
if _req.GET['action'] == 'supprimer-absence-etape-1':
output = HttpResponse(json.dumps({
'success': {
'content':
affich_dem_suppr('?action=supprimer-absence-etape-2',
'suppr_abs')
}
}),
content_type='application/json')
# Suppression d'une absence
if _req.GET['action'] == 'supprimer-absence-etape-2':
# Vérification du droit de suppression
obj_abs.can_delete(obj_util, False)
# Suppression d'une instance TAbsence
obj_abs.delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'L\'absence a été supprimée avec succès.',
'redirect': reverse('chois_abs')
}
}),
content_type='application/json')
else:
# Instance TVerificationAbsence
o_verif_abs = obj_abs.get_verif_abs()
# Préparation des attributs disponibles en consultation
tab_attrs_abs = {
'comm_abs': {
'label': 'Commentaire',
'value': obj_abs.get_comm_abs()
},
'comm_verif_abs': {
'label':
'Commentaire',
'last_child':
True,
'value':
o_verif_abs.get_comm_verif_abs() if o_verif_abs else None
},
'dt_abs': {
'label': 'Date de l\'absence',
'value': obj_abs.get_dt_abs__fr_str()
},
'dt_emiss_abs': {
'label': 'Date d\'émission de l\'absence',
'value': obj_abs.get_dt_emiss_abs__str()
},
'dt_verif_abs': {
'label':
'Date de vérification de l\'absence',
'value':
o_verif_abs.get_dt_verif_abs__str()
if o_verif_abs else None
},
'est_autor': {
'label':
'L\'absence est-elle autorisée ?',
'value':
transform_bool(o_verif_abs.get_est_autor())
if o_verif_abs else None
},
'pj_abs': {
'label': 'Consulter le justificatif d\'absence',
'value': obj_abs.get_pj_abs__path(),
'pdf': True
},
'id_util_connect': {
'label':
'Agent ayant émis l\'absence',
'value':
obj_abs.get_util_connect().get_nom_complet()
if obj_abs.get_util_connect() else None
},
'id_util_emett': {
'label': 'Agent concerné',
'value': obj_abs.get_util_emett().get_nom_complet()
},
'id_util_verif': {
'label':
'Agent ayant vérifié l\'absence',
'value':
o_verif_abs.get_util_verif().get_nom_complet()
if o_verif_abs and o_verif_abs.get_util_verif() else None
},
'id_type_abs': {
'label': 'Type de l\'absence',
'value': obj_abs.get_type_abs()
},
'id_type_abs_final': {
'label':
'Type final de l\'absence',
'value':
o_verif_abs.get_type_abs_final() if o_verif_abs else None
},
'num_annee': {
'label': 'Année',
'value': obj_abs.get_annee()
}
}
# Initialisation des fenêtres modales
tab_fm = [
init_fm(
'suppr_abs',
'Êtes-vous sûr de vouloir supprimer définitivement l\'absence ?'
)
]
# Initialisation des actions supplémentaires
tab_act = []
if obj_abs.can_update_pj_abs(obj_util, True) == True:
# Initialisation du formulaire
form_inser_pj_abs = init_form(
InsererPieceJustificativeAbsence(prefix=pref_inser_pj_abs,
instance=obj_abs))
# Empilement des actions supplémentaires
tab_act.append('''
<span class="icon-with-text iwt-c-white pdf-icon" data-target="#fm_inser_pj_abs" data-toggle="modal">
Insérer le justificatif d'absence
</span>
''')
# Agrandissement du tableau des fenêtres modales
tab_fm += [
init_fm(
'inser_pj_abs', 'Insérer le justificatif d\'absence',
'''
<form action="?action=inserer-piece-justificative-absence" enctype="multipart/form-data"
method="post" name="form_inser_pj_abs" onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{0}">
{1}
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format(csrf(_req)['csrf_token'], form_inser_pj_abs['zu_pj_abs']))
]
if can_update_type_abs_final == True:
# Initialisation du formulaire
form_modif_type_abs_final = init_form(
ModifierTypeAbsenceFinal(prefix=pref_modif_type_abs_final,
instance=o_verif_abs))
# Agrandissement du tableau des fenêtres modales
tab_fm += [
init_fm(
'modif_type_abs_final',
'Modifier le type final de l\'absence', '''
<form action="?action=modifier-type-absence-final" method="post" name="form_modif_type_abs_final"
onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{0}">
{1}
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format(
csrf(_req)['csrf_token'],
form_modif_type_abs_final['zl_type_abs_final']))
]
if obj_abs.can_delete(obj_util, True) == True:
# Empilement des actions supplémentaires
tab_act.append('''
<span action="?action=supprimer-absence-etape-1" class="delete-icon icon-with-text iwt-c-white"
onclick="trait_get(event, 'suppr_abs');">
Supprimer
</span>
''')
# Affichage du template
output = render(
_req, './gest_abs/consult_abs.html', {
'a': obj_abs,
'can_update_type_abs_final': can_update_type_abs_final,
'tab_act': tab_act,
'tab_attrs_abs': init_consult(tab_attrs_abs),
'tab_fm': tab_fm,
'title': 'Consulter une absence'
})
else:
if 'action' in _req.GET:
# Insertion de la pièce justificative de l'absence
if _req.GET['action'] == 'inserer-piece-justificative-absence':
# Application du droit de modification
obj_abs.can_update_pj_abs(obj_util, False)
# Soumission du formulaire
form_inser_pj_abs = InsererPieceJustificativeAbsence(
_req.POST,
_req.FILES,
prefix=pref_inser_pj_abs,
instance=obj_abs)
if form_inser_pj_abs.is_valid():
# Mise à jour d'une instance TAbsence
obj_abs_valid = form_inser_pj_abs.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'absence a été mise à jour avec succès.',
'redirect':
reverse('consult_abs',
args=[obj_abs_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_inser_pj_abs, cle): val
for cle, val in form_inser_pj_abs.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
# Modification du type final d'une absence
if _req.GET['action'] == 'modifier-type-absence-final':
# Application du droit de modification
obj_abs.can_update_type_abs_final(obj_util, False)
# Soumission du formulaire
form_modif_type_abs_final = ModifierTypeAbsenceFinal(
_req.POST,
prefix=pref_modif_type_abs_final,
instance=obj_abs.get_verif_abs())
if form_modif_type_abs_final.is_valid():
# Mise à jour d'une instance TVerificationAbsence
obj_verif_abs_valid = form_modif_type_abs_final.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'absence a été mise à jour avec succès.',
'redirect':
reverse('consult_abs',
args=[obj_verif_abs_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_modif_type_abs_final, cle): val
for cle, val in
form_modif_type_abs_final.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
def cal_abs(_req, _status):
# Imports
from app.forms.cal_abs import FiltrerCalendrierAbsences
from app.functions import get_obj_dt
from app.functions import init_fm
from app.functions import init_form
from app.models import TDatesAbsence
from app.models import TGroupeUtilisateur
from app.models import TUtilisateur
from datetime import date
from datetime import datetime
from django.http import HttpResponse
from django.shortcuts import render
from django.template.context_processors import csrf
import calendar
import dateutil.relativedelta
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_filtr_cal_abs = 'FiltrerCalendrierAbsences'
# Obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(pk=_req.user.pk)
'''
Initialisation d'un calendrier
_mois : Mois
_annee : Année
_util : Utilisateurs
Retourne une chaîne de caractères
'''
def init_cal_mois(_mois, _annee, _util, _obj):
# Imports
from app.functions import est_ouvr
from app.models import TAnnee
from datetime import date
import dateutil.relativedelta
# Initialisation des jours de la semaine au format français (abréviations)
tab_j_sem = get_obj_dt('WEEKDAYS', True)
# Obtention de l'indice du premier jour du mois ainsi que le nombre de jours composant celui-ci
tab_mr = calendar.monthrange(_annee, _mois)
ind_prem_j_mois = tab_mr[0]
nbre_j_mois = tab_mr[1]
# Initialisation du jeu de données des utilisateurs concernés par le calendrier
if isinstance(_util, str) == True:
if _util == '__all__':
qs_util = TUtilisateur.objects.filter(en_act=True)
else:
qs_util = TUtilisateur.objects.filter(
en_act=True, pk__in=_util
) if len(_util) > 0 else TUtilisateur.objects.none()
# Début d'initialisation de la balise <thead/>
compt = ind_prem_j_mois
tab_elem_lg2 = ['']
for i in range(nbre_j_mois):
tab_elem_lg2.append('{0} {1}'.format(tab_j_sem[compt % 7], i + 1))
compt += 1
tab_thead_lg2 = ['<th>{}</th>'.format(elem) for elem in tab_elem_lg2]
# Initialisation des numéros de semaine du mois
tab_elem_lg1 = [
date(_annee, _mois, i + 1).isocalendar()[1]
for i in range(nbre_j_mois)
]
tab_num_sem_mois = [[j for j in tab_elem_lg1 if j == i]
for i in set(map(lambda l: l, tab_elem_lg1))]
tab_num_sem_mois = {i[0]: i for i in tab_num_sem_mois}
# Fin d'initialisation de la balise <thead/>
tab_thead_lg1 = ['<th></th>']
cpt_j_mois = 1
while cpt_j_mois <= nbre_j_mois:
# Récupération du numéro de semaine du jour lié avec le compteur
num_sem_j_mois = date(_annee, _mois, cpt_j_mois).isocalendar()[1]
tab_thead_lg1.append('<th colspan="{0}">{1}</th>'.format(
len(tab_num_sem_mois[num_sem_j_mois]), num_sem_j_mois))
# Mise à jour du compteur
cpt_j_mois += len(tab_num_sem_mois[num_sem_j_mois])
# Détermination du profil de visualisation du calendrier des absences (si non-secrétaire, alors l'agent ne peut
# savoir le type d'absence)
coul = True if 'S' in obj_util.get_type_util__list() else False
# Initialisation des lignes de la balise <tbody/>
tab_tbody = []
for a in qs_util:
tab_elem = [[a.get_nom_complet(), '']]
for i in range(nbre_j_mois):
# Stockage de la date du jour
dt_jour = date(_annee, _mois, i + 1)
# Initialisation du contenu de la balise <td/>
cont_td = ''
# Initialisation des types d'indisponibilités pour une journée
indisponibilities = []
for dta in TDatesAbsence.objects.filter(
dt_abs=dt_jour, id_abs__id_util_emett=a):
# Définition des statuts de validation d'absence à prendre ne compte sur le calendrier
valid_statuses = [1] if _status == 'val' else [0, 1]
if dta.get_abs().get_etat_abs() in valid_statuses:
# Définition des styles CSS pour chaque cas d'absence (matin, après-midi ou journée entière)
tab_css_div = {
'AM':
'display: inline-block; float: left; width: 50%;',
'PM':
'display: inline-block; float: right; width: 50%;',
'WD': 'width: 100%;'
}
# Détermination des styles CSS et de l'intitulé complet du groupe de type d'absence
donn_cal_abs = dta.get_donn_cal_abs()
set_style = tab_css_div[dta.indisp_dt_abs]
set_title = ''
if (coul == True) or (a == obj_util) or (
donn_cal_abs['abrev_gpe_type_abs'] == 'TLT'):
set_style += ' background-color: {};'.format(
donn_cal_abs['coul_gpe_type_abs'])
set_title = ' title="{}"'.format(
donn_cal_abs['int_dt_abs'])
# Mise en forme de la balise <td/>
if dta.indisp_dt_abs not in indisponibilities:
cont_td += '<div class="mc-absence" style="{0}"{1}></div>'.format(
set_style, set_title)
# Empilement des types d'indisponibilités afin de ne pas perturber le CSS du calendrier en
# cas de doublon d'absences en attente de validation
indisponibilities.append(dta.indisp_dt_abs)
tab_elem.append([
cont_td, '' if est_ouvr(dt_jour) == True else
'background-color: #E9F2DC;'
])
tab_tbody.append('<tr>{}</tr>'.format(''.join([
'<td style="{0}">{1}</td>'.format(elem[1], elem[0])
for elem in tab_elem
])))
# Initialisation des bornes d'affichage des boutons "Mois précédent" et "Mois suivant"
tab_bornes_dt = [
date(TAnnee.objects.last().get_pk(), 1, 1),
date(TAnnee.objects.first().get_pk() + 1, 5, 31)
]
# Obtention d'un objet "date" relatif au premier jour du mois courant
obj_dt = date(_annee, _mois, 1)
return '''
<div class="custom-well">
<span class="clone-title">Calendrier des absences {0} - {1}</span>
</div>
<div style="text-align: right;">
<span class="filter-icon icon-with-text" data-target="#fm_filtr_cal_abs" data-toggle="modal">
Filtrer le calendrier des absences par
</span>
</div>
<span class="clone-body">
<div class="month-calendar">
<table border="1" bordercolor="#DDD">
<colgroup>
<col style="width: 160px;">
</colgroup>
<thead>
<tr>{2}</tr>
<tr>{3}</tr>
</thead>
<tbody>{4}</tbody>
</table>
</div>
</span>
<span action="?action=initialiser-calendrier&mois=precedent" class="icon-with-text previous-icon"
onclick="trait_get(event, null);" style="{5}">Mois précédent</span>
<div style="float: right; display: inline;">
<span action="?action=initialiser-calendrier&mois=suivant" class="icon-with-text next-icon"
onclick="trait_get(event, null);" style="{6}">Mois suivant</span>
</div>
'''.format(
'validées' if _status == 'val' else 'prévisionnelles',
'{0} {1}'.format(get_obj_dt('MONTHS')[_mois - 1], _annee),
''.join(tab_thead_lg1),
''.join(tab_thead_lg2),
''.join(tab_tbody),
'display: none;' if obj_dt -
dateutil.relativedelta.relativedelta(months=1) < tab_bornes_dt[0]
else '',
'display: none;' if obj_dt +
dateutil.relativedelta.relativedelta(months=1) > tab_bornes_dt[1]
else '',
)
if _req.method == 'GET':
# Initialisation du calendrier (mois précédent ou suivant)
if 'action' in _req.GET and _req.GET[
'action'] == 'initialiser-calendrier':
if 'mois' in _req.GET:
# Conversion vers le type "date"
obj_dt = datetime.strptime(_req.session['mois_cal'],
'%Y-%m-%d')
# Calcul de la date avec un intervalle de +/- 1 mois
if _req.GET['mois'] == 'precedent':
dt = obj_dt - dateutil.relativedelta.relativedelta(
months=1)
if _req.GET['mois'] == 'suivant':
dt = obj_dt + dateutil.relativedelta.relativedelta(
months=1)
# Affichage du contenu
output = HttpResponse(json.dumps({
'success': {
'content':
init_cal_mois(dt.month, dt.year,
_req.session['tab_util_cal'], obj_util),
'selector':
'#za_cal_abs'
}
}),
content_type='application/json')
# Rafraîchissement des variables de session
_req.session['mois_cal'] = str(dt.strftime('%Y-%m-%d'))
else:
# Initialisation de chaque formulaire
form_filtr_cal_abs = init_form(
FiltrerCalendrierAbsences(prefix=pref_filtr_cal_abs))
# Initialisation des variables de session
_req.session['mois_cal'] = str(date.today())
_req.session['tab_util_cal'] = '__all__'
# Initialisation des fenêtres modales
tab_fm = [
init_fm('agrand_cal_abs', ''),
init_fm(
'filtr_cal_abs', 'Filtrer le calendrier des absences par',
'''
<form action="" method="post" name="form_filtr_cal_abs" onsubmit="trait_post(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{0}">
<div class="row">
<div class="col-sm-6">{1}</div>
<div class="col-sm-6">{2}</div>
</div>
{3}
{4}
<button class="center-block custom-btn green-btn" type="submit">Valider</button>
</form>
'''.format(
csrf(_req)['csrf_token'],
form_filtr_cal_abs['zl_mois'],
form_filtr_cal_abs['zl_annee'],
form_filtr_cal_abs['zcc_gpe_util'],
form_filtr_cal_abs['zcc_util']))
]
# Affichage du template
output = render(
_req, './cal_abs/main.html', {
'cal':
init_cal_mois(date.today().month,
date.today().year, '__all__', obj_util),
'tab_fm':
tab_fm,
'title':
'Calendrier des absences ' +
('validées' if _status == 'val' else 'prévisionnelles'),
})
else:
# Soumission du formulaire
form_filtr_cal_abs = FiltrerCalendrierAbsences(
_req.POST, prefix=pref_filtr_cal_abs)
if form_filtr_cal_abs.is_valid():
# Stockage des données du formulaire
cleaned_data = form_filtr_cal_abs.cleaned_data
val_mois = cleaned_data.get('zl_mois')
val_annee = cleaned_data.get('zl_annee')
val_gpe_util = cleaned_data.get('zcc_gpe_util')
val_util = cleaned_data.get('zcc_util')
# Initialisation des utilisateurs concernés par le calendrier
tab_util = [
TUtilisateur.objects.get(pk=u).get_pk() for u in val_util
]
for gu in val_gpe_util:
for u in TGroupeUtilisateur.objects.get(
pk=gu).get_util_set().all():
tab_util.append(u.get_pk())
# Affichage du contenu
output = HttpResponse(json.dumps({
'success': {
'mf_content':
init_cal_mois(int(val_mois), int(val_annee), tab_util,
obj_util),
'selector':
'#za_cal_abs'
}
}),
content_type='application/json')
# Rafraîchissement des variables de session
_req.session['mois_cal'] = str(
date(int(val_annee), int(val_mois), 1))
_req.session['tab_util_cal'] = tab_util
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_filtr_cal_abs, cle): val
for cle, val in form_filtr_cal_abs.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
def index(_req):
# Imports
from app.apps import AppConfig
from app.forms.index import Authentifier
from app.functions import get_menu
from app.functions import init_fm
from app.functions import init_form
from app.functions import init_menu_vign
from app.functions import init_vign
from app.models import TUtilisateur
from django.contrib.auth import authenticate
from django.contrib.auth import login
from django.contrib.auth import logout
from django.core.urlresolvers import reverse
from django.http import HttpResponse
from django.shortcuts import render
import json
output = None
# Initialisation du préfixe de chaque formulaire
pref_auth = 'Authentifier'
# Tentative d'obtention d'une instance TUtilisateur
obj_util = TUtilisateur.objects.get(
pk=_req.user.pk) if _req.user.is_authenticated() else None
if _req.method == 'GET':
if 'action' in _req.GET:
# Déconnexion de la plateforme
if _req.GET['action'] == 'logout':
# Désactivation du mode super-secrétaire
if obj_util:
setattr(obj_util, 'est_super_secr', False)
obj_util.save()
# Nettoyage des variables de session
for cle in list(_req.session.keys()):
del _req.session[cle]
# Fermeture de la session active
logout(_req)
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'Merci pour votre connexion sur la plateforme {}.'.
format(AppConfig.verbose_name),
'redirect':
reverse('index')
}
}),
content_type='application/json')
# Activation du mode super-secrétaire
if _req.GET['action'] == 'activer-mode-super-secretaire':
if obj_util and 'S' in obj_util.get_type_util__list():
# Mise à jour de l'instance
setattr(obj_util, 'est_super_secr', True)
obj_util.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'Vous venez d\'activer le mode super-secrétaire.',
'redirect': '__reload__'
}
}),
content_type='application/json')
# Désactivation du mode super-secrétaire
if _req.GET['action'] == 'desactiver-mode-super-secretaire':
if obj_util:
# Mise à jour de l'instance
setattr(obj_util, 'est_super_secr', False)
obj_util.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'Vous venez de désactiver le mode super-secrétaire.',
'redirect': '__reload__'
}
}),
content_type='application/json')
else:
# Initialisation de chaque formulaire
form_auth = Authentifier(prefix=pref_auth)
# Mise en forme du menu principal à vignettes
menu = init_menu_vign([
init_vign(elem, ['mod_href', 'mod_img', 'mod_name'])
for elem in get_menu(_req).values()
], 3)
# Initialisation des fenêtres modales
if _req.user.is_authenticated():
tab_fm = []
else:
tab_fm = [
init_fm(
'login', 'Connexion à la plateforme {}'.format(
AppConfig.verbose_name))
]
# Affichage du template
output = render(
_req, './index.html', {
'form_auth':
init_form(form_auth),
'menu':
menu,
'tab_fm':
tab_fm,
'title':
'Accueil'
if _req.user.is_authenticated() else 'Identification'
})
else:
# Connexion à la plateforme
if 'action' in _req.GET and _req.GET['action'] == 'login':
# Soumission du formulaire
form_auth = Authentifier(_req.POST, prefix=pref_auth)
if form_auth.is_valid():
# Stockage des données du formulaire
cleaned_data = form_auth.cleaned_data
val_username = cleaned_data.get('zs_username')
val_password = cleaned_data.get('zs_password')
# Déclaration de la session
login(
_req,
authenticate(username=val_username, password=val_password))
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'Bienvenue sur la plateforme {}.'.format(
AppConfig.verbose_name),
'redirect':
reverse('index')
}
}),
content_type='application/json')
else:
# Affichage des erreurs
tab_errs = {
'{0}-{1}'.format(pref_auth, cle): val
for cle, val in form_auth.errors.items()
}
output = HttpResponse(json.dumps(tab_errs),
content_type='application/json')
return output
