def set_consts(_req) :
# Import
from app.apps import AppConfig
from app.functions.modal_init import sub as modal_init
from app.models import TUtilisateur
from django.template.defaultfilters import safe
# Tentative d'obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
# Déclaration des fenêtres modales permanentes
if obj_util_connect :
modals = [
modal_init(
'ger_mode_superadmin',
'{} le mode super-administrateur'.format(
'Activer' if obj_util_connect.get_est_superadmin() < 1 else 'Désactiver'
)
),
modal_init('logout', 'Déconnexion de la plateforme {}'.format(AppConfig.verbose_name))
]
else :
modals = []
return {
'app_name' : AppConfig.verbose_name,
'connected_user' : TUtilisateur.get_util_connect(_req),
'permanent_modals' : safe(''.join(modals))
}
def _args_wrapper(_req, *args, **kwargs):
# Imports
from app.models import TUtilisateur
from django.core.exceptions import PermissionDenied
# Tentative d'obtention d'une instance TUtilisateur
obj_util = TUtilisateur.get_util_connect(_req)
# Jaugeage de l'éventualité d'une erreur 403
erreur_403 = False
if not obj_util:
erreur_403 = True
else:
if _mod and _mod not in obj_util.get_menu(): erreur_403 = True
# Exécution de la vue ou erreur 403
if erreur_403 == False:
return _vf(_req, *args, **kwargs)
else:
raise PermissionDenied
def chois_projet(_req):
# Imports
from app.forms.gest_projets import FiltrerProjet
from app.functions.datatable_reset import sub as datatable_reset
from app.functions.form_init import sub as form_init
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_projet = FiltrerProjet(
kw_org=TUtilisateur.get_util_connect(_req).get_org())
# Affichage du template
output = render(
_req, './gest_projets/chois_projet.html', {
'dtable_filtr_projet': form_filtr_projet.get_datatable(_req),
'form_filtr_projet': form_init(form_filtr_projet),
'title': 'Choisir un projet'
})
else:
# Soumission du formulaire
form_filtr_projet = FiltrerProjet(_req.POST)
# Réinitialisation de la datatable ou affichage des erreurs
if form_filtr_projet.is_valid():
output = datatable_reset(form_filtr_projet.get_datatable(_req))
else:
output = HttpResponse(json.dumps(form_filtr_projet.errors),
content_type='application/json')
return output
def chois_anim(_req):
# Imports
from app.forms.gest_anim import FiltrerAnimation
from app.functions.form_init import sub as form_init
from app.functions.modal_init import sub as modal_init
from app.models import TAnimation
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_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET':
if 'action' in _req.GET:
# Affichage d'une partie d'une animation
if _req.GET['action'] == 'consulter-animation' and 'id' in _req.GET:
# Obtention d'une instance TAnimation
obj_anim = TAnimation.objects.get(pk=_req.GET['id'])
# Initialisation des attributs de l'animation
attrs_anim = obj_anim.get_attrs_anim()
contenu = '''
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
{}
{}
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
<a href="{}" class="icon-with-text inform-icon">Consulter l'animation</a>
'''.format(attrs_anim['prest'], attrs_anim['projet'],
attrs_anim['dt_heure_anim'], attrs_anim['nat_anim'],
attrs_anim['lieu_anim'], attrs_anim['comm'],
reverse('consult_anim', args=[obj_anim.get_pk()]))
# Affichage
output = HttpResponse(json.dumps(
{'success': {
'modal_content': contenu
}}),
content_type='application/json')
else:
# Initialisation du formulaire
form_filtr_anim = FiltrerAnimation(kw_util=obj_util_connect)
# Affichage du template
output = render(
_req, './gest_anim/chois_anim.html', {
'cal_filtr_anim':
form_filtr_anim.get_calendar(_req),
'form_filtr_anim':
form_init(form_filtr_anim),
'modals': [
modal_init('consult_anim',
'Consulter une partie d\'une animation')
],
'title':
'Choisir une animation'
})
else:
# Soumission du formulaire
form_filtr_anim = FiltrerAnimation(_req.POST, kw_util=obj_util_connect)
# Mise à jour du calendrier ou affichage des erreurs
if form_filtr_anim.is_valid():
output = HttpResponse(json.dumps({
'success': {
'elements':
[['#za_cal_anim',
form_filtr_anim.get_calendar(_req)]]
}
}),
content_type='application/json')
else:
output = HttpResponse(json.dumps(form_filtr_anim.errors),
content_type='application/json')
return output
def handle(self, *args, **kwargs):
# Imports
from app.apps import AppConfig
from app.models import TClasse
from app.models import TDroitsUtilisateur
from app.models import TOrganisme
from app.models import TStructure
from app.models import TTypeIntervention
from app.models import TTypePublic
from app.models import TTypeUtilisateur
from app.models import TUtilisateur
from decouple import config
from django.db import connection
from smmaranim.custom_settings import CSV_ROOT
import csv
import os
# Initialisation des données attributaires de chaque type d'utilisateur
attrs_type_util = [{
'pk': 'A',
'int_type_util': 'Administrateur'
}, {
'pk': 'PCDA',
'int_type_util': 'Peut créer des animations'
}, {
'pk': 'PR',
'int_type_util': 'Peut réserver'
}]
# Création des instances TTypeUtilisateur
for attrs in attrs_type_util:
if TTypeUtilisateur.objects.filter(pk=attrs['pk']).count() == 0:
TTypeUtilisateur.objects.create(**attrs)
# Initialisation des données attributaires de l'organisme SMMAR
attrs_org = {'est_prest': False, 'nom_org': 'SMMAR'}
# Création d'une instance TOrganisme
if TOrganisme.objects.filter(
nom_org=attrs_org['nom_org']).count() == 0:
TOrganisme.objects.create(**attrs_org)
# Initialisation des données attributaires du compte utilisateur principal
attrs_util = {
'email': config('MAIN_ACCOUNT_EMAIL'),
'first_name': config('MAIN_ACCOUNT_FIRSTNAME'),
'id_org': TOrganisme.objects.get(nom_org=attrs_org['nom_org']),
'is_staff': True,
'is_superuser': True,
'last_name': config('MAIN_ACCOUNT_LASTNAME'),
'username': config('MAIN_ACCOUNT_USERNAME')
}
# Création du compte utilisateur principal (instance TUtilisateur)
if TUtilisateur.objects.filter(
username=attrs_util['username']).count() == 0:
obj_util = TUtilisateur(**attrs_util)
obj_util.set_password('password')
obj_util.save()
# Assignation de chaque type d'utilisateur
for tu in TTypeUtilisateur.objects.all():
TDroitsUtilisateur.objects.create(code_type_util=tu,
id_util=obj_util)
# Initialisation des données attributaires de chaque type d'intervention
attrs_type_interv = [{
'pk': 'AP',
'int_type_interv': 'Animation ponctuelle'
}, {
'pk': 'PP',
'int_type_interv': 'Programme pédagogique'
}]
# Création des instances TTypeIntervention
for attrs in attrs_type_interv:
if TTypeIntervention.objects.filter(pk=attrs['pk']).count() == 0:
TTypeIntervention.objects.create(**attrs)
# Initialisation des données attributaires de chaque structure
attrs_struct = [{
'int_struct': 'Autre',
'ordre_ld_struct': 3
}, {
'int_struct': 'Collectivité',
'ordre_ld_struct': 2
}, {
'int_struct': 'Établissement scolaire',
'ordre_ld_struct': 1
}]
# Création des instances TStructure
for attrs in attrs_struct:
if TStructure.objects.filter(
int_struct=attrs['int_struct']).count() == 0:
TStructure.objects.create(**attrs)
# Initialisation des données attributaires de chaque type de public
attrs_type_public = [
'Agriculteurs', 'Élus', 'Entreprises', 'Handicapés',
'Grand public', 'Jeune public extra-scolaire',
'Jeune public scolaire', 'Personnes agées'
]
# Création des instances TTypePublic
for attrs in attrs_type_public:
if TTypePublic.objects.filter(int_type_public=attrs).count() == 0:
TTypePublic.objects.create(int_type_public=attrs)
# Initialisation des données attributaires de chaque classe
attrs_classe = [{
'int_classe': 'CE1',
'ordre_ld_classe': 3
}, {
'int_classe': 'CE2',
'ordre_ld_classe': 4
}, {
'int_classe': 'Cinquième',
'ordre_ld_classe': 8
}, {
'int_classe': 'CM1',
'ordre_ld_classe': 5
}, {
'int_classe': 'CM2',
'ordre_ld_classe': 6
}, {
'int_classe': 'CP',
'ordre_ld_classe': 2
}, {
'int_classe': 'Maternelle',
'ordre_ld_classe': 1
}, {
'int_classe': 'Post Bac',
'ordre_ld_classe': 14
}, {
'int_classe': 'Première',
'ordre_ld_classe': 12
}, {
'int_classe': 'Quatrième',
'ordre_ld_classe': 9
}, {
'int_classe': 'Seconde',
'ordre_ld_classe': 11
}, {
'int_classe': 'Sixième',
'ordre_ld_classe': 7
}, {
'int_classe': 'Terminale',
'ordre_ld_classe': 13
}, {
'int_classe': 'Troisième',
'ordre_ld_classe': 10
}]
# Création des instances TClasse
for attrs in attrs_classe:
if TClasse.objects.filter(
int_classe=attrs['int_classe']).count() == 0:
TClasse.objects.create(**attrs)
# Injection de données via des fichiers CSV
for fichier in os.listdir(CSV_ROOT):
# Stockage du chemin du fichier CSV courant
path = '{}/{}'.format(CSV_ROOT, fichier)
# Ouverture du fichier CSV en lecture
fichier_csv = open(path, 'r', encoding='cp1252')
reader = csv.reader(fichier_csv, delimiter=';')
# Rédaction de la requête SQL
sql = '''
COPY {}({})
FROM '{}'
WITH DELIMITER ';'
CSV HEADER
ENCODING 'WIN1252';
'''.format(fichier[:-4], ', '.join(next(reader)), path)
# Exécution de la requête SQL
with connection.cursor() as cursor:
try:
cursor.execute(sql)
except:
pass
del cursor
print('La base de données {} a été initialisée avec succès.'.format(
AppConfig.verbose_name))
def index(_req) :
# Imports
from app.apps import AppConfig
from app.forms.index import Authentifier
from app.functions.form_init import sub as form_init
from app.functions.menu_init import sub as menu_init
from app.functions.modal_init import sub as modal_init
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
# Tentative d'obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET' :
if 'action' in _req.GET :
# Déconnexion de la plateforme
if _req.GET['action'] == 'logout' :
# Nettoyage des variables de session
for cle in list(_req.session.keys()) : del _req.session[cle]
# Désactivation du mode super-administrateur
if obj_util_connect and obj_util_connect.get_en_mode_superadmin() == True :
obj_util_connect.en_mode_superadmin = False; obj_util_connect.save()
# Fermeture de la session
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-administrateur
if _req.GET['action'] == 'activer-mode-super-administrateur' :
if obj_util_connect and obj_util_connect.get_est_superadmin() == 0 :
# Mise à jour de l'instance
obj_util_connect.en_mode_superadmin = True; obj_util_connect.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Vous venez d\'activer le mode super-administrateur.',
'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
# Désactivation du mode super-administrateur
if _req.GET['action'] == 'desactiver-mode-super-administrateur' :
if obj_util_connect and obj_util_connect.get_est_superadmin() == 1 :
# Mise à jour de l'instance
obj_util_connect.en_mode_superadmin = False; obj_util_connect.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Vous venez de désactiver le mode super-administrateur.',
'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Initialisation du formulaire
form_auth = Authentifier()
# Déclaration des fenêtres modales
modals = [modal_init('login', 'Connexion à la plateforme {}'.format(AppConfig.verbose_name))]
# Affichage du template
output = render(_req, './index.html', {
'form_auth' : form_init(form_auth),
'menu' : menu_init(_req, '__ALL__', 3),
'modals' : modals,
'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)
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' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(json.dumps(form_auth.errors), content_type = 'application/json')
return output
def consult_compte(_req) :
# Imports
from app.forms.gest_marches import GererTransactionDemiJournees
from app.forms.index import GererUtilisateur
from app.functions.attributes_init import sub as attributes_init
from app.functions.form_init import sub as form_init
from app.functions.modal_init import sub as modal_init
from app.models import TPrestatairesMarche
from app.models import TUtilisateur
from django.forms import formset_factory
from django.http import HttpResponse
from django.shortcuts import render
from django.template.context_processors import csrf
from functools import partial
from functools import wraps
import json
output = None
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET' :
if 'action' in _req.GET :
# Initialisation du formset relatif aux demi-journées de préparation et de réalisation
if _req.GET['action'] == 'initialiser-formset-transactions-demi-journees' and 'id' in _req.GET :
# Obtention d'une instance TPrestatairesMarche
obj_pm = TPrestatairesMarche.objects.get(pk = _req.GET['id'], id_prest = obj_util_connect.get_org())
# Mise en session de l'identifiant du couple prestataire/marché
_req.session['ttransactiondemijournees__id_pm__update'] = obj_pm.get_pk()
output = GererTransactionDemiJournees(kw_pm = obj_pm).get_datatable(_req)
else :
# Initialisation des balises <tr/> de la datatable des marchés
trs = []
for pm in obj_util_connect.get_org().get_pm().all() :
tds = [
pm.get_marche(),
pm.get_nbre_dj_ap_pm__str(),
pm.get_nbre_dj_progr_pm('AP'),
pm.get_nbre_dj_ap_rest_pm(),
pm.get_nbre_dj_pp_pm__str(),
pm.get_nbre_dj_progr_pm('PP'),
pm.get_nbre_dj_prep_real_pm(True),
pm.get_nbre_dj_prep_real_pm(False),
pm.get_nbre_dj_pp_rest_pm(False),
pm.get_nbre_dj_pp_rest_pm(True),
'''
<span action="?action=initialiser-formset-transactions-demi-journees&id={}"
class="half-icon icon-without-text" modal-suffix="ger_tdj" onclick="ajax(event);"
title="Gérer les demi-journées de préparation et de réalisation"></span>
'''.format(pm.get_pk())
]
trs.append('<tr>{}</tr>'.format(''.join(['<td>{}</td>'.format(td) for td in tds])))
# Initialisation des attributs utilisateur
attrs_util = {
'email' : { 'label' : 'Courriel', 'value' : obj_util_connect.get_email() },
'nom_complet' : { 'label' : 'Nom complet', 'value' : obj_util_connect.get_nom_complet() },
'org' : { 'label' : 'Organisme', 'value' : obj_util_connect.get_org() }
}
# Initialisation du formulaire
form_modif_util = form_init(GererUtilisateur(instance = obj_util_connect))
# Déclaration des fenêtres modales
modals = [
modal_init(
'ger_tdj',
'Gérer les demi-journées de préparation et de réalisation',
'''
<form action="?action=gerer-transactions-demi-journees" method="post" name="form_ger_tdj"
onsubmit="ajax(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{}">
{}
<button class="center-block custom-button main-button" type="submit">Valider</button>
</form>
{}
'''.format(
csrf(_req)['csrf_token'], *GererTransactionDemiJournees(kw_init = True).get_datatable(_req)
)
),
modal_init(
'modif_compte',
'Modifier mon compte',
'''
<form action="" method="post" name="form_modif_compte" onsubmit="ajax(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{}">
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
{}
<button class="center-block custom-button main-button" type="submit">Valider</button>
</form>
'''.format(
csrf(_req)['csrf_token'],
form_modif_util['last_name'],
form_modif_util['first_name'],
form_modif_util['email']
)
)
]
# Affichage du template
output = render(_req, './extras/consult_compte.html', {
'attrs_util' : attributes_init(attrs_util),
'modals' : modals,
'tbody' : ''.join(trs),
'title' : 'Consulter mon compte',
'u' : obj_util_connect
})
else :
if 'action' in _req.GET :
# Gestion des demi-journées de préparation et de réalisation
if _req.GET['action'] == 'gerer-transactions-demi-journees' :
# Obtention d'une instance TPrestatairesMarche
obj_pm = TPrestatairesMarche.objects.get(
pk = _req.session.get('ttransactiondemijournees__id_pm__update')
)
# Soumission du formset
_GererTransactionDemiJournees = formset_factory(
wraps(GererTransactionDemiJournees)(partial(GererTransactionDemiJournees, kw_pm = obj_pm))
)
formset_ger_tdj = _GererTransactionDemiJournees(_req.POST)
# Initialisation des erreurs
erreurs = {}
if not formset_ger_tdj.is_valid() :
for form in formset_ger_tdj :
for cle, val in form.errors.items() : erreurs['{}-{}'.format(form.prefix, cle)] = val
if len(erreurs) == 0 :
# Suppression de la variable de session si définie
if 'ttransactiondemijournees__id_pm__update' in _req.session :
del _req.session['ttransactiondemijournees__id_pm__update']
# Suppression de toutes les instances TTransactionDemiJournees liées à une instance
# TPrestatairesMarche
obj_pm.get_tdj().all().delete()
# Création d'une instance TTransactionDemiJournees
for form in formset_ger_tdj : form.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Le marché a été modifié avec succès.', 'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(json.dumps(erreurs), content_type = 'application/json')
else :
# Soumission du formulaire
form_modif_util = GererUtilisateur(_req.POST, instance = obj_util_connect)
if form_modif_util.is_valid() :
# Modification de l'instance TUtilisateur
form_modif_util.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Le compte a été modifié avec succès.', 'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(json.dumps(form_modif_util.errors), content_type = 'application/json')
return output
def set_alerts(_req) :
# Import
from app.models import TReservation
from app.models import TUtilisateur
from datetime import date
from django.core.urlresolvers import reverse
from smmaranim.custom_settings import PKS
from smmaranim.custom_settings import SMMAR_SUPPORT
alertes = []
# Initialisation des niveaux d'alertes
niveaux = {
1 : 'background-color: #FDEE00;',
2 : 'background-color: #F8B862;',
3 : 'background-color: #FF0921;'
}
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if obj_util_connect :
for pm in obj_util_connect.get_org().get_pm().all() :
# Renvoi d'une alerte en cas de dépassement du marché en animations ponctuelles
if pm.get_nbre_dj_ap_rest_pm(False) < 0 :
# Calcul du taux de dépassement
taux = (abs(pm.get_nbre_dj_ap_rest_pm(False)) / pm.get_nbre_dj_ap_pm()) * 100
# Stockage du niveau d'alerte
if taux > 20 :
niveau = 3
elif taux > 10 :
niveau = 2
else :
niveau = 1
alertes.append({
'descr_alert' : '''
Le nombre de demi-journées prévues en animations ponctuelles a été dépassé de {} % pour le marché
suivant : {}.
'''.format('{0:g}'.format(taux), pm.get_marche()),
'lien_alert' : '#',
'nat_alert' : 'Dépassement du marché en animations ponctuelles',
'niveau_alert' : [niveau, niveaux[niveau]]
})
# Renvoi d'une alerte en cas de dépassement du marché en programmes pédagogiques
for elem in [pm.get_nbre_dj_pp_rest_pm(False, False), pm.get_nbre_dj_pp_rest_pm(True, False)] :
if elem < 0 :
# Calcul du taux de dépassement
taux = (abs(elem) / pm.get_nbre_dj_pp_pm()) * 100
# Stockage du niveau d'alerte
if taux > 20 :
niveau = 3
elif taux > 10 :
niveau = 2
else :
niveau = 1
alertes.append({
'descr_alert' : '''
Le nombre de demi-journées prévues en programmes pédagogiques a été dépassé de {} % pour le
marché suivant : {}.
'''.format('{0:g}'.format(taux), pm.get_marche()),
'lien_alert' : '#',
'nat_alert' : 'Dépassement du marché en programmes pédagogiques',
'niveau_alert' : [niveau, niveaux[niveau]]
})
# Sortie de la boucle si une alerte est déjà générée pour ce marché
break
if obj_util_connect.get_org().get_pk() == PKS['id_org__smmar'] and SMMAR_SUPPORT == True :
# Stockage de la date du jour
today = date.today()
for r in TReservation.objects.all() :
# Empilement des actions
actions = []
if r.get_doit_chercher() == True :
actions.append(['chercher', r.get_quand_chercher()])
if r.get_doit_demonter() == True :
actions.append(['démonter', r.get_quand_demonter()])
if r.get_doit_livrer() == True :
actions.append(['livrer', r.get_quand_livrer()])
if r.get_doit_monter() == True :
actions.append(['monter', r.get_quand_monter()])
# Renvoi d'une alerte en cas d'actions à venir
for elem in actions :
if elem[1].date() >= today :
# Stockage de la différence absolue entre la date du jour et la date de l'action
diff = abs((today - elem[1].date()).days)
# Stockage du niveau d'alerte
if diff < 8 :
niveau = 3
elif diff < 16 :
niveau = 2
elif diff < 32 :
niveau = 1
else :
niveau = None
if niveau :
alertes.append({
'descr_alert' : '''
Attention, le SMMAR doit {} l'outil suivant : {} (sauf si refus du SMMAR d'exécuter la
tâche souhaitée par le demandeur).
'''.format(elem[0], r.get_outil()),
'lien_alert' : reverse('consult_reserv', args = [r.get_pk()]),
'nat_alert' : 'Aides proposées par le SMMAR',
'niveau_alert' : [niveau, niveaux[niveau]]
})
return {
'alerts_list' : sorted(alertes, key = lambda l : (-l['niveau_alert'][0], l['nat_alert'])),
'badge_color' : '#FF0921' if len(alertes) > 0 else '#82C46C'
}
def set_menus(_req) :
# Imports
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
output = {}
# Initialisation du menu utilisateur
obj_util = TUtilisateur.get_util_connect(_req)
menu = obj_util.get_menu() if obj_util else {}
# Préparation du menu principal
elems = []
for elem in menu.values() :
# Mise en forme de l'élément
if len(elem['mod_items']) > 0 :
li = '''
<li class="dropdown">
<a class="dropdown-toggle" data-toggle="dropdown" href="#">
{}
<span class="caret"></span>
</a>
<ul class="dropdown-menu">{}</ul>
</li>
'''.format(
elem['mod_name'],
''.join(['<li><a href="{}">{}</a></li>'.format(
'#' if not elem_2['item_url_name'] else \
elem_2['item_url_name'].replace('__ABS__', '') if \
elem_2['item_url_name'].startswith('__ABS__') else \
reverse(elem_2['item_url_name']),
elem_2['item_name']
) for elem_2 in elem['mod_items'].values()])
)
else :
li = '''
<li><a href="{}">{}</a></li>
'''.format(reverse(elem['mod_url_name']) if elem['mod_url_name'] else '#', elem['mod_name'])
elems.append(li)
output['top_menu'] = '<ul class="nav navbar-nav">{}</ul>'.format(''.join(elems))
# Préparation du menu latéral
elems = []
for cle, val in menu.items() :
# Début de paramétrage du panel
params = {
'mod_img' : val['mod_img'],
'mod_href' : reverse(val['mod_url_name']) if val['mod_url_name'] else '#',
'mod_name' : val['mod_name']
}
if len(val['mod_items']) > 0 :
# Mise en forme du panel si sous-éléments
panel = '''
<div class="panel">
<div class="panel-heading">
<span class="panel-title">
<a href="#pnl_{mod_key}" data-parent="#side-menu" data-toggle="collapse">
<img src="{mod_img}">
{mod_name}
</a>
</span>
</div>
<div class="collapse panel-collapse" id="pnl_{mod_key}">
<div class="panel-body">
<table>{mod_items}</table>
</div>
</div>
</div>
'''
# Fin de paramétrage du panel
params['mod_key'] = cle
params['mod_items'] = ''.join(['<tr><td><a href="{}">{}</a></td></tr>'.format(
'#' if not elem['item_url_name'] else \
elem['item_url_name'].replace('__ABS__', '') if elem['item_url_name'].startswith('__ABS__') else \
reverse(elem['item_url_name']),
elem['item_name']
) for elem in val['mod_items'].values()])
else :
# Mise en forme du panel si aucun sous-élément
panel = '''
<div class="panel">
<div class="panel-heading">
<span class="panel-title">
<a href="{mod_href}">
<img src="{mod_img}">
{mod_name}
</a>
</span>
</div>
</div>
'''
# Fin de paramétrage du panel
params['mod_href'] = reverse(val['mod_url_name']) if val['mod_url_name'] else '#'
elems.append(panel.format(**params))
output['side_menu'] = '<div class="panel-group" id="side-menu">{}</div>'.format(''.join(elems))
return output
def handle(self, *args, **kwargs):
# Imports
from app.apps import AppConfig
from app.models import TAnnee
from app.models import TGroupeTypeAbsence
from app.models import TRolesUtilisateur
from app.models import TTypeAbsence
from app.models import TTypeUtilisateur
from app.models import TUtilisateur
from datetime import date
from decouple import config
from django.conf import settings
# Initialisation des types d'utilisateur
tab_type_util = [['A', 'Agent'], ['D', 'Direction'],
['S', 'Secrétaire']]
for elem in tab_type_util:
if TTypeUtilisateur.objects.filter(pk=elem[0]).count() == 0:
TTypeUtilisateur.objects.create(pk=elem[0],
int_type_util=elem[1])
# Création du compte agent principal
set_username = config('MAIN_ACCOUNT_USERNAME')
if TUtilisateur.objects.filter(username=set_username).count() == 0:
# Création d'une instance TUtilisateur
obj_util = TUtilisateur(
email=config('MAIN_ACCOUNT_EMAIL'),
first_name=config('MAIN_ACCOUNT_FIRSTNAME'),
is_staff=True,
is_superuser=True,
last_name=config('MAIN_ACCOUNT_LASTNAME'),
username=set_username)
obj_util.set_password('password')
obj_util.save()
# Lien avec la table t_roles_utilisateur
for elem in tab_type_util:
TRolesUtilisateur.objects.create(
code_type_util=TTypeUtilisateur.objects.get(pk=elem[0]),
id_util=obj_util)
# Initialisation des années
for i in range(settings.SMMAR_YEAR_CREATION, date.today().year + 1):
if TAnnee.objects.filter(pk=i).count() == 0: TAnnee.create(i)
# Initialisation des groupes de type d'absence ainsi que des types d'absence
tab_gpe_type_abs = [{
'abrev_gpe_type_abs':
'C',
'est_disp':
True,
'int_gpe_type_abs':
'Congés',
'ordre_zl_gpe_type_abs':
1,
'code_type_util':
TTypeUtilisateur.objects.get(pk='D')
}, {
'abrev_gpe_type_abs':
'RTT',
'est_disp':
True,
'int_gpe_type_abs':
'RTT',
'ordre_zl_gpe_type_abs':
1,
'code_type_util':
TTypeUtilisateur.objects.get(pk='S')
}, {
'abrev_gpe_type_abs':
'CET',
'est_disp':
True,
'int_gpe_type_abs':
'Compte épargne temps',
'ordre_zl_gpe_type_abs':
1,
'code_type_util':
TTypeUtilisateur.objects.get(pk='S')
}]
for elem in tab_gpe_type_abs:
if TGroupeTypeAbsence.objects.filter(
int_gpe_type_abs=elem['int_gpe_type_abs']).count() == 0:
obj_gpe_type_abs = TGroupeTypeAbsence.objects.create(**elem)
TTypeAbsence.objects.create(
int_type_abs=elem['int_gpe_type_abs'],
pj_abs_req=False,
id_gpe_type_abs=obj_gpe_type_abs)
print('La base de données {} a été initialisée avec succès.'.format(
AppConfig.verbose_name))
def ger_reserv(_req, _inst) :
# Imports
from app.forms.gest_reserv import GererReservation
from app.functions.form_init import sub as form_init
from app.functions.modal_init import sub as modal_init
from app.models import TReservation
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 smmaranim.custom_settings import ALERTS
from smmaranim.custom_settings import SMMAR_SUPPORT
import json
output = None
# Tentative d'obtention d'une instance TReservation (si page de modification en cours)
if _inst == False :
obj_reserv = None
else :
if 'id' in _req.GET :
obj_reserv = get_object_or_404(TReservation, pk = _req.GET['id'])
else :
raise Http404
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
# Vérification du droit d'accès
if obj_reserv : obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
if _req.method == 'GET' :
# Initialisation du formulaire
form_ger_reserv = GererReservation(instance = obj_reserv)
# Définition du contenu de la balise <title/> (également utile à d'autres endroits)
title = 'Modifier une réservation' if obj_reserv else 'Ajouter une réservation'
# Affichage du template
output = render(_req, './gest_reserv/ger_reserv.html', {
'aides_smmar' : ALERTS['aides_smmar'],
'form_ger_reserv' : form_init(form_ger_reserv),
'modals' : [modal_init('ger_reserv', title)],
'r' : obj_reserv,
'support' : SMMAR_SUPPORT,
'title' : title
})
else :
# Soumission du formulaire
form_ger_reserv = GererReservation(
_req.POST,
instance = obj_reserv,
kw_dt_reserv = int(_req.POST.get('rb_dt_reserv')),
kw_doit_chercher = 0 if not _req.POST.get('doit_chercher') else int(_req.POST.get('doit_chercher')),
kw_doit_demonter = 0 if not _req.POST.get('doit_demonter') else int(_req.POST.get('doit_demonter')),
kw_doit_livrer = 0 if not _req.POST.get('doit_livrer') else int(_req.POST.get('doit_livrer')),
kw_doit_monter = 0 if not _req.POST.get('doit_monter') else int(_req.POST.get('doit_monter')),
kw_util = obj_util_connect
)
if form_ger_reserv.is_valid() :
# Création/modification d'une instance TReservation
obj_reserv_valid = form_ger_reserv.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'La réservation a été {} avec succès.'.format('modifiée' if obj_reserv else 'ajoutée'),
'redirect' : reverse('consult_reserv', args = [obj_reserv_valid.get_pk()])
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(json.dumps(form_ger_reserv.errors), content_type = 'application/json')
return output
def consult_reserv(_req, _r) :
# Imports
from app.form_templates.gest_reserv import ger_expos
from app.form_templates.gest_reserv import ger_rr
from app.forms.gest_reserv import GererExposition
from app.forms.gest_reserv import GererReferentReservation
from app.functions.attributes_init import sub as attributes_init
from app.functions.modal_init import sub as modal_init
from app.functions.yes_or_no import sub as yes_or_no
from app.models import TExposition
from app.models import TReferentReservation
from app.models import TReservation
from app.models import TUtilisateur
from django.http import HttpResponse
from django.core.urlresolvers import reverse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
from smmaranim.custom_settings import ALERTS
from smmaranim.custom_settings import SMMAR_SUPPORT
import json
output = None
# Initialisation du préfixe de chaque formulaire
prefix_ajout_rr = 'AjouterReferentReservation'
prefix_modif_rr = 'ModifierReferentReservation'
prefix_ajout_expos = 'AjouterExposition'
prefix_modif_expos = 'ModifierExposition'
# Tentative d'obtention d'une instance TReservation
obj_reserv = get_object_or_404(TReservation, pk = _r)
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET' :
if 'action' in _req.GET :
# Initialisation du formulaire de modification d'un couple réservation/contact référent
if _req.GET['action'] == 'initialiser-formulaire-modification-referent-reservation' and 'id' in _req.GET :
# Obtention d'une instance TReferentReservation
obj_rr = TReferentReservation.objects.get(pk = _req.GET['id'], id_reserv = obj_reserv)
# Mise en session de l'identifiant du couple réservation/contact référent
_req.session['treferentreservation__pk__update'] = obj_rr.get_pk()
# Affichage du formulaire
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : ger_rr(_req, { 'instance' : obj_rr, 'prefix' : prefix_modif_rr })
}}),
content_type = 'application/json'
)
# Affichage d'une demande de suppression d'un couple réservation/contact référent
if _req.GET['action'] == 'supprimer-referent-reservation-etape-1' and 'id' in _req.GET :
# Obtention d'une instance TReferentReservation
obj_rr = TReferentReservation.objects.get(pk = _req.GET['id'], id_reserv = obj_reserv)
# Mise en session de l'identifiant du couple réservation/contact référent
_req.session['treferentreservation__pk__delete'] = obj_rr.get_pk()
# Affichage de la demande de suppression
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : yes_or_no(
'?action=supprimer-referent-reservation-etape-2',
'suppr_rr',
[['Lieu(x) d\'exposition', obj_rr.get_expos().count()]]
)
}}),
content_type = 'application/json'
)
# Suppression d'un couple réservation/contact référent
if _req.GET['action'] == 'supprimer-referent-reservation-etape-2' \
and 'treferentreservation__pk__delete' in _req.session :
# Vérification du droit d'accès
obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
# Suppression d'une instance TReferentReservation
TReferentReservation.objects.get(pk = _req.session.get('treferentreservation__pk__delete')).delete()
# Suppression de la variable de session si définie
if 'treferentreservation__pk__delete' in _req.session :
del _req.session['treferentreservation__pk__delete']
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Le contact référent a été supprimé avec succès.', 'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
# Consultation d'un lieu d'exposition
if _req.GET['action'] == 'consulter-exposition' and 'id' in _req.GET :
# Obtention d'une instance TExposition
obj_expos = TExposition.objects.get(pk = _req.GET['id'], id_reserv = obj_reserv)
# Initialisation des attributs du lieu d'exposition
attrs_expos = attributes_init({
'comm' : { 'label' : 'Commune accueillant l\'exposition', 'value' : obj_expos.get_comm() },
'comm_expos' : { 'label' : 'Commentaire', 'value' : obj_expos.get_comm_expos() },
'courr_rr' : {
'label' : 'Courriel du contact référent', 'value' : obj_expos.get_rr().get_courr_rr()
},
'dt_expos' : { 'label' : 'Date(s) d\'exposition', 'value' : obj_expos.get_dt_expos__fr_str() },
'lieu_expos' : { 'label' : 'Lieu d\'exposition', 'value' : obj_expos.get_lieu_expos() },
'nom_complet_rr' : { 'label' : 'Nom complet du contact référent', 'value' : obj_expos.get_rr() },
'outil' : { 'label' : 'Outil exposé', 'value' : obj_expos.get_reserv().get_outil() },
'struct' : { 'label' : 'Structure d\'accueil', 'value' : obj_expos.get_struct() },
'tel_rr' : {
'label' : 'Numéro de téléphone du contact référent',
'value' : obj_expos.get_rr().get_tel_rr__deconstructed()
},
})
# Affichage des attributs
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : '''
<div class="attributes-wrapper">
{}
{}
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
{}
{}
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
{}
</div>
'''.format(
attrs_expos['outil'],
attrs_expos['struct'],
attrs_expos['lieu_expos'],
attrs_expos['comm'],
attrs_expos['dt_expos'],
attrs_expos['nom_complet_rr'],
attrs_expos['courr_rr'],
attrs_expos['tel_rr'],
attrs_expos['comm_expos']
)
}}),
content_type = 'application/json'
)
# Initialisation du formulaire de modification d'un lieu d'exposition
if _req.GET['action'] == 'initialiser-formulaire-modification-exposition' and 'id' in _req.GET :
# Obtention d'une instance TExposition
obj_expos = TExposition.objects.get(pk = _req.GET['id'], id_reserv = obj_reserv)
# Mise en session de l'identifiant de l'exposition
_req.session['texposition__pk__update'] = obj_expos.get_pk()
# Affichage du formulaire
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : ger_expos(
_req, {
'instance' : obj_expos,
'prefix' : prefix_modif_expos,
'kw_reserv' : obj_expos.get_reserv()
}
)
}}),
content_type = 'application/json'
)
# Affichage d'une demande de suppression d'un lieu d'exposition
if _req.GET['action'] == 'supprimer-exposition-etape-1' and 'id' in _req.GET :
# Obtention d'une instance TExposition
obj_expos = TExposition.objects.get(pk = _req.GET['id'], id_reserv = obj_reserv)
# Mise en session de l'identifiant du lieu d'exposition
_req.session['texposition__pk__delete'] = obj_expos.get_pk()
# Affichage de la demande de suppression
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : yes_or_no('?action=supprimer-exposition-etape-2', 'suppr_expos')
}}),
content_type = 'application/json'
)
# Suppression d'un lieu d'exposition
if _req.GET['action'] == 'supprimer-exposition-etape-2' and 'texposition__pk__delete' in _req.session :
# Vérification du droit d'accès
obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
# Suppression d'une instance TExposition
TExposition.objects.get(pk = _req.session.get('texposition__pk__delete')).delete()
# Suppression de la variable de session si définie
if 'texposition__pk__delete' in _req.session : del _req.session['texposition__pk__delete']
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'Le lieu d\'exposition a été supprimé avec succès.', 'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
# Affichage d'une demande d'annulation de la réservation
if _req.GET['action'] == 'annuler-reservation-etape-1' :
# Affichage de la demande d'annulation
output = HttpResponse(
json.dumps({ 'success' : {
'modal_content' : yes_or_no('?action=annuler-reservation-etape-2', 'annul_reserv')
}}),
content_type = 'application/json'
)
# Annulation d'une réservation
if _req.GET['action'] == 'annuler-reservation-etape-2' :
# Vérification du droit d'accès
obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
# Suppression d'une instance TReservation
obj_reserv.delete()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : 'La réservation a été annulée avec succès.', 'redirect' : reverse('chois_reserv')
}}),
content_type = 'application/json'
)
# Impression de la réservation
if _req.GET['action'] == 'imprimer-reservation' :
output = render(_req, './gest_reserv/imprim_reserv.html', {
'aides_smmar' : ALERTS['aides_smmar'],
'attrs_reserv' : obj_reserv.get_attrs_reserv(True),
'support' : SMMAR_SUPPORT,
'title' : 'Imprimer une réservation'
})
else :
# Déclaration des fenêtres modales
modals = [
modal_init(
'ajout_expos',
'Ajouter un lieu d\'exposition',
ger_expos(_req, { 'prefix' : prefix_ajout_expos, 'kw_reserv' : obj_reserv })
),
modal_init('ajout_rr', 'Ajouter un contact référent', ger_rr(_req, { 'prefix' : prefix_ajout_rr })),
modal_init('annul_reserv', 'Êtes-vous sûr de vouloir annuler définitivement la réservation ?'),
modal_init('consult_expos', 'Consulter un lieu d\'exposition'),
modal_init('modif_rr', 'Modifier un contact référent'),
modal_init('modif_expos', 'Modifier un lieu d\'exposition'),
modal_init('suppr_expos', 'Êtes-vous sûr de vouloir supprimer définitivement le lieu d\'exposition ?'),
modal_init('suppr_rr', 'Êtes-vous sûr de vouloir supprimer définitivement le contact référent ?')
]
# Affichage du template
output = render(_req, './gest_reserv/consult_reserv.html', {
'aides_smmar' : ALERTS['aides_smmar'],
'attrs_reserv' : obj_reserv.get_attrs_reserv(),
'can_access' : obj_util_connect.can_access(obj_reserv.get_util().get_org()),
'modals' : modals,
'r' : obj_reserv,
'support' : SMMAR_SUPPORT,
'title' : 'Consulter une réservation'
})
else :
if 'action' in _req.GET :
# Initialisation des paramètres du formulaire de gestion d'un couple réservation/contact référent
if _req.GET['action'] == 'ajouter-referent-reservation' :
params = { 'instance' : None, 'prefix' : prefix_ajout_rr }
elif _req.GET['action'] == 'modifier-referent-reservation' :
params = {
'instance' : TReferentReservation.objects \
.get(pk = _req.session.get('treferentreservation__pk__update')),
'prefix' : prefix_modif_rr
}
else :
params = None
if params :
# Vérification du droit d'accès
obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
# Soumission du formulaire
form_ger_rr = GererReferentReservation(
_req.POST, instance = params['instance'], prefix = params['prefix'], kw_reserv = obj_reserv
)
if form_ger_rr.is_valid() :
# Suppression de la variable de session si définie
if 'treferentreservation__pk__update' in _req.session :
del _req.session['treferentreservation__pk__update']
# Création/modification d'une instance TReferentReservation
obj_rr_valid = form_ger_rr.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : '''
Le contact référent a été {} avec succès.
'''.format('modifié' if params['instance'] else 'ajouté'),
'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(
json.dumps({
'{}-{}'.format(form_ger_rr.prefix, cle) : val for cle, val in form_ger_rr.errors.items()
}),
content_type = 'application/json'
)
# Initialisation des paramètres du formulaire de gestion des lieux d'exposition
if _req.GET['action'] == 'ajouter-exposition' :
params = { 'instance' : None, 'prefix' : prefix_ajout_expos }
elif _req.GET['action'] == 'modifier-exposition' :
params = {
'instance' : TExposition.objects \
.get(pk = _req.session.get('texposition__pk__update')),
'prefix' : prefix_modif_expos
}
else :
params = None
if params :
# Vérification du droit d'accès
obj_util_connect.can_access(obj_reserv.get_util().get_org(), False)
# Soumission du formulaire
form_ger_expos = GererExposition(
_req.POST,
instance = params['instance'],
prefix = params['prefix'],
kw_dt_expos = int(_req.POST.get('{}-rb_dt_expos'.format(params['prefix']))),
kw_reserv = obj_reserv
)
if form_ger_expos.is_valid() :
# Suppression de la variable de session si définie
if 'texposition__pk__update' in _req.session : del _req.session['texposition__pk__update']
# Création/modification d'une instance TExposition
obj_expos_valid = form_ger_expos.save()
# Affichage du message de succès
output = HttpResponse(
json.dumps({ 'success' : {
'message' : '''
Le lieu d'exposition a été {} avec succès.
'''.format('modifié' if params['instance'] else 'ajouté'),
'redirect' : '__RELOAD__'
}}),
content_type = 'application/json'
)
else :
# Affichage des erreurs
output = HttpResponse(
json.dumps({'{}-{}'.format(
form_ger_expos.prefix, cle
) : val for cle, val in form_ger_expos.errors.items()}),
content_type = 'application/json'
)
return output
def ger_projet(_req, _inst):
# Imports
from app.forms.gest_projets import GererProjet
from app.functions.form_init import sub as form_init
from app.functions.modal_init import sub as modal_init
from app.models import TProjet
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 smmaranim.custom_settings import PKS
import json
output = None
# Tentative d'obtention d'une instance TProjet (si page de modification en cours)
if _inst == False:
obj_projet = None
else:
if 'id' in _req.GET:
obj_projet = get_object_or_404(TProjet, pk=_req.GET['id'])
else:
raise Http404
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
# Vérification du droit d'accès
if obj_projet: obj_util_connect.can_access(obj_projet.get_org(), False)
if _req.method == 'GET':
# Initialisation du formulaire
form_ger_projet = GererProjet(instance=obj_projet,
kw_util=obj_util_connect)
# Définition du contenu de la balise <title/> (également utile à d'autres endroits)
title = 'Modifier un projet' if obj_projet else 'Ajouter un projet'
# Définition du message d'avertissement
f = None
if obj_projet:
if obj_projet.get_type_public().get_pk(
) == PKS['id_type_public__jps']:
f = 'classes'
elif obj_projet.get_type_public().get_pk(
) == PKS['id_type_public__jpes']:
f = 'tranches d\'âge'
if f:
message = '''
Attention, si vous changez le type de public visé, alors les {} précédemment ajoutées seront supprimées.
'''.format(f)
else:
message = ''
# Affichage du template
output = render(
_req, './gest_projets/ger_projet.html', {
'form_ger_projet': form_init(form_ger_projet),
'message': message,
'modals': [modal_init('ger_projet', title)],
'p': obj_projet,
'title': title
})
else:
# Soumission du formulaire
form_ger_projet = GererProjet(_req.POST,
instance=obj_projet,
kw_util=obj_util_connect)
if form_ger_projet.is_valid():
# Création/modification d'une instance TProjet
obj_projet_valid = form_ger_projet.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'Le projet a été {} avec succès.'.format(
'modifié' if obj_projet else 'ajouté'),
'redirect':
reverse('consult_projet', args=[obj_projet_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(form_ger_projet.errors),
content_type='application/json')
return output
def consult_projet(_req, _p):
# Imports
from app.forms.gest_projets import GererClassesEcoleProjet
from app.forms.gest_projets import GererTrancheAge
from app.functions.modal_init import sub as modal_init
from app.functions.yes_or_no import sub as yes_or_no
from app.models import TProjet
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.forms import formset_factory
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
from functools import partial
from functools import wraps
from smmaranim.custom_settings import PKS
import json
output = None
# Tentative d'obtention d'une instance TProjet
obj_projet = get_object_or_404(TProjet, pk=_p)
# Initialisation du préfixe de chaque formulaire
prefix_ajout_cep = 'AjouterClassesEcoleProjet'
prefix_modif_cep = 'ModifierClassesEcoleProjet'
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET':
if 'action' in _req.GET:
# Affichage d'une demande de suppression d'un projet
if _req.GET['action'] == 'supprimer-projet-etape-1':
# Ajout d'une protection
if obj_projet.get_anim().count() == 0:
modal_content = yes_or_no(
'?action=supprimer-projet-etape-2', 'suppr_projet')
else:
modal_content = '''
<span class="very-important">Attention, avant de pouvoir supprimer le projet, veuillez d'abord
supprimer toutes les animations liées à celui-ci.</span>
'''
output = HttpResponse(json.dumps(
{'success': {
'modal_content': modal_content
}}),
content_type='application/json')
# Suppression d'un projet
if _req.GET['action'] == 'supprimer-projet-etape-2':
# Vérification du droit d'accès
obj_util_connect.can_access(obj_projet.get_org(), False)
# Suppression d'une instance TProjet
obj_projet.delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'Le projet a été supprimé avec succès.',
'redirect': reverse('chois_projet')
}
}),
content_type='application/json')
# Impression du projet
if _req.GET['action'] == 'imprimer-projet':
# Initialisation des animations du projet
anims = []
for a in obj_projet.get_anim().all():
# Stockage des attributs du bilan
attrs_bilan = None
if a.get_bilan__object():
if a.get_bilan__object().get_ba():
attrs_bilan = a.get_bilan__object().get_ba(
).get_attrs_ba(True)
else:
attrs_bilan = a.get_bilan__object(
).get_attrs_bilan(True)
anims.append({
'a__object': a,
'a__attrs': a.get_attrs_anim(True),
'b__object': a.get_bilan__object(),
'b__attrs': attrs_bilan
})
output = render(
_req, './gest_projets/imprim_projet.html', {
'anims': anims,
'attrs_projet': obj_projet.get_attrs_projet(True),
'title': 'Imprimer un projet'
})
else:
# Stockage des indicateurs d'affichage des onglets liés au jeune public
onglets = {
'ongl_cep':
True if obj_projet.get_type_public().get_pk()
== PKS['id_type_public__jps'] else False,
'ongl_ta':
True if obj_projet.get_type_public().get_pk()
== PKS['id_type_public__jpes'] else False,
}
# Déclaration des fenêtres modales
modals = [
modal_init(
'suppr_projet',
'Êtes-vous sûr de vouloir supprimer définitivement le projet ?'
)
]
if onglets['ongl_cep'] == True:
modals.append(
modal_init(
'ger_cep', 'Gérer les classes', '''
<form action="?action=gerer-classes-ecole-projet" method="post" name="form_ger_cep"
onsubmit="ajax(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{}">
{}
<button class="center-block custom-button main-button" type="submit">Valider</button>
</form>
{}
'''.format(
csrf(_req)['csrf_token'],
*GererClassesEcoleProjet(
kw_projet=obj_projet).get_datatable(_req))))
if onglets['ongl_ta'] == True:
modals.append(
modal_init(
'ger_ta', 'Gérer les tranches d\'âge', '''
<form action="?action=gerer-tranche-age" method="post" name="form_ger_ta"
onsubmit="ajax(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{}">
{}
<button class="center-block custom-button main-button" type="submit">Valider</button>
</form>
{}
'''.format(
csrf(_req)['csrf_token'],
*GererTrancheAge(
kw_projet=obj_projet).get_datatable(_req))))
# Affichage du template
output = render(
_req, './gest_projets/consult_projet.html', {
'attrs_projet': obj_projet.get_attrs_projet(),
'can_access': obj_util_connect.can_access(
obj_projet.get_org()),
'modals': modals,
'onglets': onglets,
'p': obj_projet,
'title': 'Consulter un projet'
})
else:
if 'action' in _req.GET:
# Définition des paramètres
if _req.GET['action'] == 'gerer-classes-ecole-projet':
params = [GererClassesEcoleProjet, obj_projet.get_cep().all()]
elif _req.GET['action'] == 'gerer-tranche-age':
params = [GererTrancheAge, obj_projet.get_ta().all()]
else:
params = None
if params:
# Vérification du droit d'accès
obj_util_connect.can_access(obj_projet.get_org(), False)
# Soumission du formset
formset = formset_factory(
wraps(params[0])(partial(params[0],
kw_projet=obj_projet)))(_req.POST)
# Initialisation des erreurs
erreurs = {}
if not formset.is_valid():
for form in formset:
for cle, val in form.errors.items():
erreurs['{}-{}'.format(form.prefix, cle)] = val
if len(erreurs) == 0:
# Suppression de toutes les instances liées à une instance TProjet
params[1].delete()
# Création d'une instance
for form in formset:
form.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'Le projet a été modifié avec succès.',
'redirect': '__RELOAD__'
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(erreurs),
content_type='application/json')
return output
def consult_anim(_req, _a):
# Imports
from app.form_templates.gest_anim import ger_bilan
from app.forms.gest_anim import ClonerBilan
from app.forms.gest_anim import GererBilan
from app.forms.gest_anim import GererBilanAnimation
from app.forms.gest_anim import GererPoint
from app.functions.modal_init import sub as modal_init
from app.functions.yes_or_no import sub as yes_or_no
from app.models import TAnimation
from app.models import TBilan
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.forms import formset_factory
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import render
from functools import partial
from functools import wraps
import json
output = None
# Tentative d'obtention d'une instance TAnimation
obj_anim = get_object_or_404(TAnimation, pk=_a)
# Tentative d'obtention d'une instance TBilan
obj_bilan = obj_anim.get_bilan__object()
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET':
if 'action' in _req.GET:
# Affichage d'une demande de suppression d'un bilan
if _req.GET['action'] == 'supprimer-bilan-etape-1':
output = HttpResponse(json.dumps({
'success': {
'modal_content':
yes_or_no('?action=supprimer-bilan-etape-2',
'suppr_bilan')
}
}),
content_type='application/json')
# Suppression d'un bilan
if _req.GET['action'] == 'supprimer-bilan-etape-2':
# Vérification du droit d'accès
obj_util_connect.can_access(obj_bilan.get_util().get_org(),
False)
# Suppression d'instances TBilan/TBilanAnimation
obj_anim.get_bilan().all().delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'Le bilan a été supprimé avec succès.',
'redirect': '__RELOAD__'
}
}),
content_type='application/json')
# Affichage d'une demande de suppression d'une animation
if _req.GET['action'] == 'supprimer-animation-etape-1':
output = HttpResponse(json.dumps({
'success': {
'modal_content':
yes_or_no('?action=supprimer-animation-etape-2',
'suppr_anim')
}
}),
content_type='application/json')
# Suppression d'une animation
if _req.GET['action'] == 'supprimer-animation-etape-2':
# Vérification du droit d'accès
obj_util_connect.can_access(obj_anim.get_projet().get_org(),
False)
# Suppression d'une instance TAnimation
obj_anim.delete()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message': 'L\'animation a été supprimée avec succès.',
'redirect': reverse('chois_anim')
}
}),
content_type='application/json')
else:
# Stockage du titre de la fenêtre modale de gestion d'un bilan
mt_ger_bilan = '{} le bilan'.format(
'Modifier' if obj_bilan else 'Ajouter')
# Stockage des attributs du bilan
attrs_bilan = None
if obj_bilan:
attrs_bilan = obj_bilan.get_ba().get_attrs_ba(
) if obj_bilan.get_ba() else obj_bilan.get_attrs_bilan()
# Déclaration des fenêtres modales
modals = [
modal_init(
'ger_bilan', mt_ger_bilan,
ger_bilan(_req, {
'kw_anim': obj_anim,
'instance': obj_bilan
})),
modal_init(
'suppr_anim',
'Êtes-vous sûr de vouloir supprimer définitivement l\'animation ?'
),
modal_init(
'suppr_bilan',
'Êtes-vous sûr de vouloir supprimer définitivement le bilan de l\'animation ?'
)
]
# Affichage du template
output = render(
_req, './gest_anim/consult_anim.html', {
'a':
obj_anim,
'b':
obj_bilan,
'attrs_anim':
obj_anim.get_attrs_anim(),
'attrs_bilan':
attrs_bilan,
'can_access':
obj_util_connect.can_access(
obj_anim.get_projet().get_org()),
'modals':
modals,
'mt_ger_bilan':
mt_ger_bilan,
'title':
'Consulter une animation'
})
else:
if 'action' in _req.GET:
# Gestion du bilan
if _req.GET['action'] == 'gerer-bilan':
# Vérification du droit d'accès
obj_util_connect.can_access(obj_anim.get_projet().get_org(),
False)
# Initialisation des erreurs
erreurs = {}
if obj_anim.get_est_anim() == True:
# Soumission du formulaire
form_ger_bilan = GererBilanAnimation(
_req.POST,
_req.FILES,
instance=obj_bilan.get_ba() if obj_bilan else None,
kw_anim=obj_anim,
kw_util=obj_util_connect)
# Soumission du formset
_GererPoint = formset_factory(
wraps(GererPoint)(partial(
GererPoint,
kw_ba=obj_bilan.get_ba() if obj_bilan else None)))
formset_ger_point = _GererPoint(_req.POST)
# Empilement des erreurs du formset
if not formset_ger_point.is_valid():
for form in formset_ger_point:
for cle, val in form.errors.items():
erreurs['{}-{}'.format(form.prefix, cle)] = val
else:
# Soumission du formulaire
form_ger_bilan = GererBilan(_req.POST,
instance=obj_bilan,
kw_anim=obj_anim,
kw_util=obj_util_connect)
# Empilement des erreurs du formulaire
if not form_ger_bilan.is_valid():
for cle, val in form_ger_bilan.errors.items():
erreurs[cle] = val
if len(erreurs) == 0:
# Création/modification d'une instance TBilan ou TBilanAnimation
obj_bilan_valid = form_ger_bilan.save()
# Suppression, puis création d'instances TPoint
if obj_anim.get_est_anim() == True:
obj_bilan_valid.get_point().all().delete()
for form in formset_ger_point:
obj_point_valid = form.save(commit=False)
obj_point_valid.id_ba = obj_bilan_valid
form.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'''
Le bilan de l'animation a été {} avec succès.
'''.format('modifié' if obj_bilan else 'ajouté'),
'redirect':
'__RELOAD__'
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(erreurs),
content_type='application/json')
# CLonage du bilan
if _req.GET['action'] == 'cloner-bilan':
# Soumission du formulaire
form_clon_bilan = ClonerBilan(_req.POST,
kw_anim=obj_anim,
prefix='ClonerBilan')
if form_clon_bilan.is_valid():
# Stockage des données du formulaire
cleaned_data = form_clon_bilan.cleaned_data
val_bilan = cleaned_data.get('zl_bilan')
# Obtention d'une instance TBilan + tentative d'obtention d'une instance TBilanAnimation
obj_bilan_clone = TBilan.objects.get(pk=val_bilan)
obj_ba_clone = obj_bilan_clone.get_ba()
# Initialisation des clones
clonings = [{
'field_id':
'#id_nom_refer_bilan',
'field_value':
obj_bilan_clone.get_nom_refer_bilan(),
'type':
'text'
}, {
'field_id':
'#id_prenom_refer_bilan',
'field_value':
obj_bilan_clone.get_prenom_refer_bilan(),
'type':
'text'
}, {
'field_id':
'#id_fonct_refer_bilan',
'field_value':
obj_bilan_clone.get_fonct_refer_bilan(),
'type':
'text'
}, {
'field_id':
'#id_struct_refer_bilan',
'field_value':
obj_bilan_clone.get_struct_refer_bilan(),
'type':
'text'
}, {
'field_id': '#id_comm_bilan',
'field_value': obj_bilan_clone.get_comm_bilan(),
'type': 'text'
}]
# Initialisation des formsets à réinitialiser
formsets = []
if obj_ba_clone:
# Suite de l'initialisation des clones
extra_clonings = [{
'field_id':
'#id_titre_ba',
'field_value':
obj_ba_clone.get_titre_ba(),
'type':
'text'
}, {
'field_id':
'#id_nbre_pers_pres_ba',
'field_value':
obj_ba_clone.get_nbre_pers_pres_ba(),
'type':
'text'
}, {
'field_id':
'#id_themat_abord_ba',
'field_value':
obj_ba_clone.get_themat_abord_ba(),
'type':
'text'
}, {
'field_id':
'#id_deroul_ba',
'field_value':
obj_ba_clone.get_deroul_ba(),
'type':
'text'
}, {
'field_id':
'en_inter',
'field_value':
str(obj_ba_clone.get_en_inter()),
'type':
'radio'
}, {
'field_id':
'en_exter',
'field_value':
str(obj_ba_clone.get_en_exter()),
'type':
'radio'
}, {
'field_id':
'eval_ba',
'field_value':
obj_ba_clone.get_eval_ba(),
'type':
'radio'
}, {
'field_id':
'zcc_plaq',
'field_value': [
p.get_pk()
for p in obj_ba_clone.get_plaq().all()
],
'type':
'checkbox'
}]
# Suite de l'initialisation des clones (prise en compte des points positifs/négatifs)
for index, p in enumerate(
obj_ba_clone.get_point().all()):
extra_clonings += [{
'field_id':
'#id_form-{}-int_point'.format(index),
'field_value':
p.get_int_point(),
'type':
'text'
}, {
'field_id':
'#id_form-{}-comm_neg_point'.format(index),
'field_value':
p.get_comm_neg_point(),
'type':
'text'
}, {
'field_id':
'#id_form-{}-comm_pos_point'.format(index),
'field_value':
p.get_comm_pos_point(),
'type':
'text'
}]
# Fin d'initialisation des clones
clonings += extra_clonings
# Empilement des formsets à réinitialiser
formsets.append([
'#formset_ger_point',
obj_ba_clone.get_point().count()
])
# Clonage du formulaire
output = HttpResponse(json.dumps({
'success': {
'clonings': clonings,
'reinit_formsets': formsets
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps({
'{}-{}'.format(form_clon_bilan.prefix, cle): val
for cle, val in form_clon_bilan.errors.items()
}),
content_type='application/json')
return output
def ger_anim(_req, _inst):
# Imports
from app.forms.gest_anim import GererAnimation
from app.forms.gest_projets import GererProjet
from app.functions.form_init import sub as form_init
from app.functions.modal_init import sub as modal_init
from app.models import TAnimation
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 TAnimation (si page de modification en cours)
if _inst == False:
obj_anim = None
else:
if 'id' in _req.GET:
obj_anim = get_object_or_404(TAnimation, pk=_req.GET['id'])
else:
raise Http404
# Obtention d'une instance TUtilisateur
obj_util_connect = TUtilisateur.get_util_connect(_req)
if _req.method == 'GET':
# Initialisation du formulaire
form_ger_anim = GererAnimation(instance=obj_anim,
kw_org=obj_util_connect.get_org())
# Définition du contenu de la balise <title/> (également utile à d'autres endroits)
title = 'Modifier une animation' if obj_anim else 'Ajouter une animation'
# Déclaration des fenêtres modales
modals = [modal_init('ger_anim', title)]
if not obj_anim:
# Initialisation du formulaire et de ses attributs
form_ger_projet = form_init(GererProjet(kw_util=obj_util_connect))
modals.append(
modal_init(
'ajout_projet', 'Ajouter un projet', '''
<form action="?action=ajouter-projet" method="post" name="form_ajout_projet" onsubmit="ajax(event);">
<input name="csrfmiddlewaretoken" type="hidden" value="{}">
{}
{}
{}
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
<div class="row">
<div class="col-sm-6">{}</div>
<div class="col-sm-6">{}</div>
</div>
<button class="center-block custom-button main-button" type="submit">Valider</button>
</form>
'''.format(
csrf(_req)['csrf_token'], form_ger_projet['zl_pm']
if 'zl_pm' in form_ger_projet else '',
form_ger_projet['int_projet'],
form_ger_projet['id_type_public'],
form_ger_projet['nom_refer_projet'],
form_ger_projet['prenom_refer_projet'],
form_ger_projet['courr_refer_projet'],
form_ger_projet['tel_refer_projet'])))
# Affichage du template
output = render(
_req, './gest_anim/ger_anim.html', {
'form_ger_anim': form_init(form_ger_anim),
'a': obj_anim,
'b': obj_anim.get_bilan__object() if obj_anim else None,
'modals': modals,
'title': title
})
else:
if 'action' in _req.GET:
if _req.GET['action'] == 'ajouter-projet':
# Soumission du formulaire
form_ger_projet = GererProjet(_req.POST,
kw_util=obj_util_connect)
if form_ger_projet.is_valid():
# Création/modification d'une instance TProjet
obj_projet_valid = form_ger_projet.save()
# Rafraichissement de la liste des projets et sélection automatique du nouveau projet créé
_form_ger_anim = GererAnimation(
kw_org=obj_util_connect.get_org())
_form_ger_anim.fields[
'zl_projet'].initial = obj_projet_valid.get_pk()
_form_ger_anim = form_init(_form_ger_anim)
# Désaffichage du formulaire d'ajout d'un projet
output = HttpResponse(json.dumps({
'success': {
'elements':
[['#fw_zl_projet', _form_ger_anim['zl_projet']]],
'modal_status':
'hide',
'reset':
True
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(form_ger_projet.errors),
content_type='application/json')
else:
# Vérification du droit d'accès
if obj_anim:
obj_util_connect.can_access(obj_anim.get_projet().get_org(),
False)
# Soumission du formulaire
form_ger_anim = GererAnimation(_req.POST,
instance=obj_anim,
kw_org=obj_util_connect.get_org())
if form_ger_anim.is_valid():
# Création/modification d'une instance TAnimation
obj_anim_valid = form_ger_anim.save()
# Affichage du message de succès
output = HttpResponse(json.dumps({
'success': {
'message':
'L\'animation a été {} avec succès.'.format(
'modifiée' if obj_anim else 'ajoutée'),
'redirect':
reverse('consult_anim', args=[obj_anim_valid.get_pk()])
}
}),
content_type='application/json')
else:
# Affichage des erreurs
output = HttpResponse(json.dumps(form_ger_anim.errors),
content_type='application/json')
return output
def sub(_req, _mod, _lim) :
# Imports
from app.models import TUtilisateur
from django.core.urlresolvers import reverse
from django.template.defaultfilters import safe
# Obtention du menu utilisateur
obj_util = TUtilisateur.get_util_connect(_req)
menu = obj_util.get_menu() if obj_util else {}
# Mise en forme d'une vignette
thumbnail = '''
<a class="custom-thumbnail" href="{}">
<img src="{}">
<div>{}</div>
</a>
'''
# Initialisation des vignettes
thumbnails = []
if _mod == '__ALL__' :
for elem in menu.values() :
thumbnails.append(thumbnail.format(
reverse(elem['mod_url_name']) if elem['mod_url_name'] else '#', elem['mod_img'], elem['mod_name']
))
else :
if _mod in menu.keys() :
for elem in menu[_mod]['mod_items'].values() :
thumbnails.append(thumbnail.format(
'#' if not elem['item_url_name'] else \
elem['item_url_name'].replace('__ABS__', '') if elem['item_url_name'].startswith('__ABS__') else \
reverse(elem['item_url_name']),
elem['item_img'] or menu[_mod]['mod_img'],
elem['item_name']
))
# Stockage du nombre de vignettes
nbre_thumbnails = len(thumbnails)
# Initialisation des lignes de vignettes
rows = []
# Préparation des lignes de vignettes complètes
for i in range(nbre_thumbnails // _lim) :
rows.append('<div class="row">{}</div>'.format(
''.join(['<div class="col-sm-{}">{}</div>'.format(
'{0:g}'.format(12 / _lim), thumbnails[i * _lim + j]
) for j in range(_lim)]
)))
# Préparation de la ligne de vignettes incomplète
nbre_thumbnails_manq = nbre_thumbnails % _lim
if nbre_thumbnails_manq > 0 :
rows.append('<div class="row">{}</div>'.format(
''.join(['<div class="col-sm-{}">{}</div>'.format(
'{0:g}'.format(12 / nbre_thumbnails_manq), thumbnails[i]
) for i in range(nbre_thumbnails - nbre_thumbnails_manq, nbre_thumbnails)])
))
return safe('<div class="thumbnails-row">{}</div>'.format(''.join(rows)) if len(rows) > 0 else '')
