1773 lines
62 KiB
Python
1773 lines
62 KiB
Python
# -*- coding: utf8 -*-
|
|
from pyramid.view import (
|
|
view_config,
|
|
)
|
|
from pyramid.httpexceptions import (
|
|
HTTPFound,
|
|
)
|
|
|
|
from datetime import datetime as dt, date
|
|
from dateutil.relativedelta import *
|
|
import time as tm
|
|
from docutils.core import publish_parts
|
|
from zeep import Client
|
|
from zeep.transports import Transport
|
|
from zeep.exceptions import Error
|
|
from requests import Session
|
|
from markdown2 import Markdown
|
|
|
|
import json
|
|
|
|
from ..models.parametres import *
|
|
from ..models.utils import *
|
|
from ..models.default import (
|
|
get_users_by_code,
|
|
get_agences,
|
|
get_moniteurs,
|
|
get_types_devis,
|
|
)
|
|
|
|
from ..models.parametres import get_formules as get_list_formules
|
|
from ..views.default import (
|
|
to_decimal,
|
|
to_euro,
|
|
to_date,
|
|
to_time,
|
|
to_int,
|
|
to_percent,
|
|
)
|
|
from ..views.utils import *
|
|
|
|
def ws_authentifier(client):
|
|
# authentifier au WS_AutoEcole
|
|
try:
|
|
idSession = client.service.authentifier(identifiant='mmonchanin',
|
|
motDePasse='M@rietton69670',
|
|
numeroAgrement='E0209008400')
|
|
except:
|
|
idSession = ''
|
|
|
|
return idSession
|
|
|
|
def ws_deconnecter(client, idSession):
|
|
# deconnecter du WS_AutoEcole
|
|
message = 'Déconnexion réussie'
|
|
try:
|
|
client.service.deconnecter(idSession)
|
|
except:
|
|
message = ''
|
|
|
|
return message
|
|
|
|
@view_config(route_name='parametres', renderer='../templates/parametres/parametres.pt', permission='manage')
|
|
def parametres(request):
|
|
logged_in = request.authenticated_userid.lower()
|
|
|
|
return {
|
|
'page_title': "Paramètres",
|
|
'logged_in': logged_in,
|
|
}
|
|
|
|
|
|
@view_config(route_name='faq_list', renderer='../templates/parametres/faq_list.pt', permission='manage')
|
|
def faq_list(request):
|
|
|
|
# lire toutes les faq
|
|
faqs = get_faqs(request, 0)
|
|
|
|
return {
|
|
'page_title': "Liste des FAQ",
|
|
'faqs': faqs,
|
|
}
|
|
|
|
@view_config(route_name='faq_edit', renderer='../templates/parametres/faq_edit.pt', permission='manage')
|
|
def faq_edit(request):
|
|
faq_id = request.matchdict['faq_id']
|
|
url = request.route_url('faq_edit',faq_id=faq_id)
|
|
|
|
message = ""
|
|
if faq_id == '0':
|
|
titre = "Nouvelle FAQ"
|
|
intitule = ""
|
|
texte = ""
|
|
theme = ""
|
|
else:
|
|
titre = "Modifier la FAQ : %s" % str(faq_id)
|
|
faq = get_faqs(request, faq_id)
|
|
intitule = faq.intitule
|
|
texte = faq.texte
|
|
theme = faq.theme
|
|
|
|
if 'form.submitted' in request.params:
|
|
intitule = request.params["intitule"]
|
|
texte = request.params["texte"]
|
|
theme = request.params["theme"]
|
|
|
|
if len(intitule) > 0 and len(texte) > 0:
|
|
update_faq(request, faq_id, intitule, texte, theme)
|
|
if faq_id == '0':
|
|
# si creation faq, retour à la liste des faqs
|
|
return HTTPFound(location=request.route_url('faq_list'))
|
|
else:
|
|
return HTTPFound(location=request.route_url('faq_view', faq_id=faq_id))
|
|
else:
|
|
message = "Veuillez saisir un intitule et un texte."
|
|
|
|
if 'form.deleted' in request.params:
|
|
if faq_id != '0':
|
|
delete_faq(request, faq_id)
|
|
request.session.flash("'%s' a été supprimée avec succès." % intitule, 'success')
|
|
return HTTPFound(location=request.route_url('faq_list'))
|
|
|
|
return {
|
|
'page_title': titre,
|
|
'url': url,
|
|
'message': message,
|
|
'faq_id': faq_id,
|
|
'intitule': intitule,
|
|
'texte': texte,
|
|
'theme': theme,
|
|
'themes': ["CONDUITE","EXAMEN","RESULTAT","INTERNE"],
|
|
}
|
|
|
|
@view_config(route_name='faq_view', renderer='../templates/parametres/faq_view.pt')
|
|
def faq_view(request):
|
|
faq_id = request.matchdict['faq_id']
|
|
current_route_path = request.current_route_path()
|
|
|
|
faq = get_faqs(request, faq_id)
|
|
intitule = faq.intitule
|
|
# insèrer le path de static/img
|
|
img_path = '%s/static/img/' % request.application_url
|
|
|
|
texte = faq.texte.replace('static/img/', img_path)
|
|
# convertir reST en HTML
|
|
texte = publish_parts(texte, writer_name='html')['html_body']
|
|
return {
|
|
'page_title': intitule,
|
|
'texte': texte,
|
|
'faq_id': faq_id,
|
|
}
|
|
|
|
|
|
@view_config(route_name='users', renderer='../templates/parametres/users.pt', permission='manage')
|
|
def users(request):
|
|
# lire les utilisateurs
|
|
items = get_users_by_code(request, '0')
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.dern_cnx_le:
|
|
der_cnx_le = item.dern_cnx_le.strftime('%d-%m-%Y %H:%M')
|
|
else:
|
|
der_cnx_le = ""
|
|
|
|
if item.actif == 0:
|
|
etat = 'Inactif'
|
|
else:
|
|
etat = 'Actif'
|
|
if item.tel :
|
|
tel = item.tel
|
|
else:
|
|
tel = ''
|
|
|
|
d = (item.cd_uti, item.nom, tel, item.email, item.cd_mon, item.access, der_cnx_le, etat)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des utilisateurs',
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='users_ua', renderer='../templates/parametres/users_ua.pt', permission='manage')
|
|
def users_ua(request):
|
|
# lire les utilisateurs
|
|
items = get_users_by_code(request, '0')
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.dern_cnx_le:
|
|
der_cnx_le = item.dern_cnx_le.strftime('%d-%m-%Y %H:%M')
|
|
|
|
d = (der_cnx_le, item.cd_uti, item.nom, item.access, item.ua_string)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Dernières connexions',
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='user_edit', renderer='../templates/parametres/user_edit.pt', permission='manage')
|
|
def user_edit(request):
|
|
cd_uti = request.matchdict['cd_uti']
|
|
url = request.route_url('user_edit', cd_uti=cd_uti)
|
|
message = ''
|
|
access = ["0 | Moniteur", "6 | Gestionnaire", "7 | Examens", "9 | Administrateur"]
|
|
agences = get_agences(request, 0)
|
|
|
|
if cd_uti == '0':
|
|
# nouveau
|
|
individu = {}
|
|
individu['cd_uti'] = '0'
|
|
individu['nom'] = ''
|
|
individu['email'] = ''
|
|
individu['secu'] = 0
|
|
individu['actif'] = 1
|
|
individu['cd_mon'] = ''
|
|
individu['cd_mon_B78'] = ''
|
|
individu['tel'] = ''
|
|
individu['agence'] = 6
|
|
individu['mobile'] = 0
|
|
page_title= 'Nouveau compte utilisateur'
|
|
else:
|
|
# lire la fiche de l'individu
|
|
individu = get_users_by_code(request, cd_uti)
|
|
if not individu:
|
|
request.session.flash("Utilisateur non trouvé : %s" % cd_uti, 'warning')
|
|
return HTTPFound(location=request.route_url('users'))
|
|
page_title= "Utilisateur : %s" %(individu.nom)
|
|
|
|
# lire les moniteurs
|
|
moniteurs = get_moniteurs(request, 0)
|
|
|
|
if 'form.submitted' in request.params:
|
|
code = request.params["cd_uti"]
|
|
if code == '0':
|
|
message = "Veuillez saisir un code moniteur valide."
|
|
else:
|
|
# si CREATION, controler que la fiche n'est pas déjà créée
|
|
fiche = get_users_by_code(request, code)
|
|
if cd_uti == '0' and fiche:
|
|
message = "Ce code moniteur existe déjà : %s" % code
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in individu.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
# actif coché ?
|
|
if 'actif' in request.params:
|
|
new_values['actif'] = 1
|
|
else:
|
|
new_values['actif'] = 0
|
|
# mobile coché ?
|
|
if 'mobile' in request.params:
|
|
new_values['mobile'] = 1
|
|
else:
|
|
new_values['mobile'] = 0
|
|
if new_values:
|
|
update_user(request, cd_uti, new_values)
|
|
request.session.flash("Le compte a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('users'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_user(request, cd_uti)
|
|
request.session.flash("Le compte a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('users'))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'individu': individu,
|
|
'access': access,
|
|
'agences': agences,
|
|
'moniteurs': moniteurs,
|
|
'message': message,
|
|
}
|
|
|
|
@view_config(route_name='moniteurs', renderer='../templates/parametres/moniteurs.pt', permission='view')
|
|
def moniteurs(request):
|
|
# lire les utilisateurs
|
|
logged_in = request.authenticated_userid
|
|
items = get_all_moniteurs(request)
|
|
member = get_users_by_code(request, logged_in)
|
|
code = member.secu
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
d = (item.CD_MON, item.NOM, item.PLANNING, item.obsolete)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des moniteurs',
|
|
'dt_data': json.dumps(liste),
|
|
'code' : code
|
|
}
|
|
|
|
@view_config(route_name='moniteurs_agence', renderer='../templates/parametres/moniteurs_agence.pt', permission='view')
|
|
def moniteurs_agence(request):
|
|
# lire les utilisateurs
|
|
logged_in = request.authenticated_userid
|
|
member = get_users_by_code(request, logged_in)
|
|
items = get_all_moniteur_aff(request)
|
|
agences = get_agences(request, 0)
|
|
code = member.secu
|
|
# construire la liste
|
|
liste=[]
|
|
agencefilter = member.agence
|
|
datefilter = datetime.now().strftime('%d/%m/%Y')
|
|
if len(items) > 0 :
|
|
agence = items[0].AGENCE
|
|
date = items[0].DATED.strftime('%d/%m/%Y') if items[0].DATED != None else datetime.now().strftime('%d/%m/%Y')
|
|
for item in items:
|
|
d = (
|
|
item.CD_MON,
|
|
item.INTITULE,
|
|
item.DATED.strftime('%d/%m/%Y') if item.DATED != None else None,
|
|
item.DATEF.strftime('%d/%m/%Y') if item.DATEF != None else None,
|
|
str(item.DMATIN)+'h - '+str(item.FMATIN)+'h',
|
|
str(item.DSOIR)+'h - '+str(item.FSOIR)+'h',
|
|
item.AGENCE,
|
|
item.no_ligne,
|
|
item.DATED.strftime('%Y%m%d') if item.DATED != None else None,
|
|
item.DATEF.strftime('%Y%m%d') if item.DATEF != None else None,
|
|
)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des moniteurs',
|
|
'agences' : agences,
|
|
'datefilter': datefilter,
|
|
'agencefilter' : agencefilter,
|
|
'dt_data': json.dumps(liste),
|
|
'code': code
|
|
}
|
|
|
|
@view_config(route_name='moniteur_edit', renderer='../templates/parametres/moniteur_edit.pt', permission='view')
|
|
def moniteur_edit(request):
|
|
logged_in = request.authenticated_userid
|
|
code = request.matchdict['cd_mon']
|
|
url = request.route_url('moniteur_edit', cd_mon=code)
|
|
message = ''
|
|
show_aff = False
|
|
affectations = []
|
|
plannings = ['2R', '2R+GL', 'B',' B+2R', 'B+GL', 'B78', 'GL']
|
|
member = get_users_by_code(request, logged_in)
|
|
codeu = member.secu
|
|
if code == '0':
|
|
# nouveau
|
|
individu = {}
|
|
individu['NOM'] = ''
|
|
individu['obsolete'] = 0
|
|
individu['CD_MON'] = ''
|
|
individu['PLANNING'] = ''
|
|
individu['no_autorisation'] = None
|
|
individu['cd_uti'] = 'X'
|
|
page_title= 'Nouveau compte moniteur'
|
|
cree_le = ""
|
|
modif_le = ""
|
|
else:
|
|
# lire la fiche de l'individu
|
|
individu = get_moniteur_by_code(request, code)
|
|
if not individu:
|
|
request.session.flash("Moniteur non trouvé : %s" % code, 'warning')
|
|
return HTTPFound(location=request.route_url('moniteurs'))
|
|
show_aff = True
|
|
items = get_moniteur_aff(request,code)
|
|
for item in items :
|
|
element = (item.no_ligne,item.AGENCE, item.DATED.strftime('%d/%m/%Y') if item.DATED != None else None ,item.DATEF.strftime('%d/%m/%Y') if item.DATEF != None else None,str(item.DMATIN)+'h - '+str(item.FMATIN)+'h',str(item.DSOIR)+'h - '+str(item.FSOIR)+'h',code)
|
|
affectations.append(element)
|
|
page_title= "Moniteur : %s" %(individu.NOM)
|
|
cree_le = individu.cree_le.strftime('%d/%m/%Y - %H:%M')
|
|
modif_le = individu.modif_le.strftime('%d/%m/%Y - %H:%M')
|
|
|
|
if 'form.submitted' in request.params:
|
|
# si CREATION, controler que la fiche n'est pas déjà créée
|
|
cd_mon = request.params['CD_MON']
|
|
fiche = get_moniteurs(request,cd_mon)
|
|
if code == '0' and fiche:
|
|
message = "Ce code moniteur existe déjà : %s" % cd_mon
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in individu.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
# actif coché ?
|
|
if 'obsolete' in request.params:
|
|
new_values['obsolete'] = -1
|
|
else:
|
|
new_values['obsolete'] = 0
|
|
new_values['cd_uti'] = member.cd_uti
|
|
# mobile coché ?
|
|
|
|
if new_values:
|
|
update_moniteur(request, code, new_values)
|
|
request.session.flash("Le moniteur a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('moniteurs'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_moniteur(request, code)
|
|
request.session.flash("Le moniteur a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('moniteurs'))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'code' : code,
|
|
'individu': individu,
|
|
'message': message,
|
|
'show_aff' : show_aff,
|
|
'plannings' : plannings,
|
|
'cree_le' : cree_le,
|
|
'modif_le':modif_le,
|
|
'dt_data' : json.dumps(affectations),
|
|
'codeu' : codeu
|
|
}
|
|
|
|
|
|
@view_config(route_name='moniteur_aff_edit', renderer='../templates/parametres/moniteur_aff_edit.pt', permission='view')
|
|
def moniteur_aff_edit(request):
|
|
logged_in = request.authenticated_userid
|
|
origin = int(request.GET['origin']) if 'origin' in request.GET else 0
|
|
member = get_users_by_code(request, logged_in)
|
|
code = member.secu
|
|
no_ligne = request.matchdict['no_ligne']
|
|
CD_MON = request.matchdict['cd_mon']
|
|
if origin == 1 :
|
|
redirect = 'moniteurs_agence'
|
|
else:
|
|
redirect = 'moniteur_edit/'+str(CD_MON)
|
|
url = request.route_url('moniteur_aff_edit',cd_mon=CD_MON, no_ligne=no_ligne)
|
|
message = ''
|
|
agences = get_agences(request, 0)
|
|
moniteur = get_moniteurs(request, CD_MON)
|
|
if not moniteur:
|
|
request.session.flash("Moniteur non trouvé : %s" % CD_MON, 'warning')
|
|
return HTTPFound(location=request.route_url('moniteurs'))
|
|
INTITULE = moniteur.NOM
|
|
|
|
if no_ligne == '0':
|
|
# nouveau
|
|
individu = {}
|
|
individu['CD_MON'] = CD_MON
|
|
individu['no_ligne'] = '0'
|
|
individu['AGENCE'] = '1'
|
|
individu['DATED'] = ''
|
|
individu['DATEF'] = ''
|
|
individu['DMATIN'] = 9
|
|
individu['FMATIN'] = 12
|
|
individu['DSOIR'] = 14
|
|
individu['FSOIR'] = 18
|
|
individu['REPOS1'] = 0
|
|
individu['REPOS2'] = 0
|
|
individu['REPOS3'] = 0
|
|
individu['REPOS4'] = 0
|
|
individu['REPOS5'] = 0
|
|
individu['REPOS6'] = 0
|
|
individu['cd_uti'] = 'X'
|
|
DATED = ''
|
|
DATEF = ''
|
|
cree_le = ''
|
|
modif_le = ''
|
|
|
|
page_title= 'Nouveau affectation du moniteur'
|
|
else:
|
|
# lire la fiche de l'individu
|
|
individu = get_moniteur_aff_by_no_ligne(request, no_ligne)
|
|
if not individu:
|
|
request.session.flash("Moniteur affectation non trouvé : %s" % no_ligne, 'warning')
|
|
return HTTPFound(location=request.route_url('moniteur_edit',cd_mon=CD_MON))
|
|
page_title= "Affectation du moniteur : %s" %(individu.CD_MON)
|
|
DATED = individu.DATED.strftime('%d/%m/%Y') if individu.DATED != None else None
|
|
DATEF = individu.DATEF.strftime('%d/%m/%Y') if individu.DATEF != None else None
|
|
cree_le = individu.cree_le.strftime('%d/%m/%Y - %H:%M')
|
|
modif_le = individu.modif_le.strftime('%d/%m/%Y - %H:%M')
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {}
|
|
if no_ligne != '0':
|
|
for param, db_value in individu.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
else:
|
|
for param, db_value in individu.items():
|
|
if param in request.params:
|
|
new_values[param] = request.params[param]
|
|
|
|
new_values['INTITULE'] = INTITULE
|
|
new_values['CD_MON'] = CD_MON
|
|
new_values['cd_uti'] = member.cd_uti
|
|
if 'DATED' in request.params:
|
|
new_values['DATED'] = datetime.strptime(request.params['DATED'], '%d/%m/%Y')
|
|
if 'DATEF' in request.params:
|
|
new_values['DATEF'] = datetime.strptime(request.params['DATEF'], '%d/%m/%Y')
|
|
if 'REPOS1' in request.params:
|
|
new_values['REPOS1'] = 1
|
|
else:
|
|
new_values['REPOS1'] = 0
|
|
if 'REPOS2' in request.params:
|
|
new_values['REPOS2'] = 1
|
|
else:
|
|
new_values['REPOS2'] = 0
|
|
if 'REPOS3' in request.params:
|
|
new_values['REPOS3'] = 1
|
|
else:
|
|
new_values['REPOS3'] = 0
|
|
if 'REPOS4' in request.params:
|
|
new_values['REPOS4'] = 1
|
|
else:
|
|
new_values['REPOS4'] = 0
|
|
if 'REPOS5' in request.params:
|
|
new_values['REPOS5'] = 1
|
|
else:
|
|
new_values['REPOS5'] = 0
|
|
if 'REPOS6' in request.params:
|
|
new_values['REPOS6'] = 1
|
|
else:
|
|
new_values['REPOS6'] = 0
|
|
if new_values:
|
|
new_values['no_ligne'] = no_ligne
|
|
update_moniteur_aff(request, no_ligne, new_values)
|
|
request.session.flash("L'affectation a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('moniteur_edit',cd_mon=CD_MON))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_moniteur_aff(request, no_ligne)
|
|
request.session.flash("L'affectation a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('moniteur_edit',cd_mon=CD_MON))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'individu': individu,
|
|
'agences': agences,
|
|
'message': message,
|
|
'DATED':DATED,
|
|
'DATEF' : DATEF,
|
|
'code' : code,
|
|
'CD_MON' : CD_MON,
|
|
'redirect' : redirect,
|
|
'modif_le' : modif_le,
|
|
'cree_le' : cree_le
|
|
}
|
|
|
|
@view_config(route_name='semaine_types', renderer='../templates/parametres/semaine_types.pt', permission='manage')
|
|
def semaine_types(request):
|
|
if not request.has_permission('manage'):
|
|
request.session.flash("Vous n'avez pas l'accés sur semaine-type.", 'warning')
|
|
return HTTPFound(location=request.route_url('parametres'))
|
|
logged_in = request.authenticated_userid
|
|
planning = ['B', 'B78', '2R','GL']
|
|
planning_default = 'B'
|
|
url = request.route_url('semaine_types')
|
|
semaines_type = []
|
|
|
|
if 'form.submitted' in request.params:
|
|
params = dict(request.params)
|
|
del params['form.submitted']
|
|
code = '0'
|
|
if params['CODE_SEM'] != '':
|
|
code = params['CODE_SEM']
|
|
del params['CODE_SEM']
|
|
update_semaine_type(request,code,params)
|
|
return HTTPFound(location=url)
|
|
|
|
items = get_all_semaines_type(request)
|
|
for item in items:
|
|
d = (item.LIBELLE,item.CODE_SEM,item.type_planning)
|
|
semaines_type.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste semaine-types',
|
|
'planning' : planning,
|
|
'dt_data' : json.dumps(semaines_type),
|
|
'planning_default' : planning_default
|
|
}
|
|
|
|
@view_config(route_name='semaine_type_view', renderer='../templates/parametres/semaine_type_view.pt', permission='manage')
|
|
def semaine_type_view(request):
|
|
logged_in = request.authenticated_userid
|
|
member = get_users_by_code(request, logged_in)
|
|
code = member.secu
|
|
code_sem = request.matchdict['code_sem']
|
|
url = request.route_url('semaine_type_view',code_sem=code_sem)
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {
|
|
'LIBELLE' : request.params["LIBELLE"]
|
|
}
|
|
update_semaine_type(request,code_sem,new_values)
|
|
request.session.flash("La semaine type a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=url)
|
|
|
|
if 'form.activity.deleted' in request.params:
|
|
no_ligne = int(request.params['no_ligne'])
|
|
delete_semaine_type_activity(request, no_ligne)
|
|
request.session.flash("Une activité a été supprimé avec succès.", 'warning')
|
|
return HTTPFound(location=url)
|
|
|
|
if 'form.duplicated' in request.params:
|
|
duplicate_semaine_type(request,code_sem,logged_in)
|
|
request.session.flash("La semaine type a été dupliqué avec succès.", 'success')
|
|
return HTTPFound(location=url)
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_semaine_type(request,code_sem)
|
|
request.session.flash("La semaine type a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('semaine_types'))
|
|
|
|
if 'form.activity.submitted' in request.params :
|
|
params = dict(request.params)
|
|
del params['form.activity.submitted']
|
|
del params['qte_j']
|
|
params['dh_debut'] = datetime.strptime(params['dh_debut'],'%d-%m-%Y %H:%M')
|
|
params['code_sem'] = code_sem
|
|
params['cd_uti'] = logged_in
|
|
update_semaine_type_activity(request,params)
|
|
request.session.flash("Une activité a été ajouté avec succès.", 'success')
|
|
return HTTPFound(location=url)
|
|
|
|
if 'form.activity.duplicated' in request.params :
|
|
params = dict(request.params)
|
|
del params['form.activity.duplicated']
|
|
params['dh_debut'] = datetime.strptime(params['dh_debut'],'%d-%m-%Y %H:%M')
|
|
weekday = params['dh_debut'].weekday()
|
|
params['cd_uti'] = logged_in
|
|
if params['no_ligne'] == '':
|
|
params['code_sem'] = int(code_sem)
|
|
|
|
qte_j = int (params['qte_j'])
|
|
del params['qte_j']
|
|
max_ = update_semaine_type_activity(request,params)
|
|
no_ligne = max_['no_ligne']
|
|
request.session.flash("Une activité a été creé et dupliqué avec succès..", 'success')
|
|
else :
|
|
no_ligne = params['no_ligne']
|
|
qte_j = int(params['qte_j'])
|
|
del params['qte_j']
|
|
update_semaine_type_activity(request,params)
|
|
request.session.flash("Une activité a été dupliqué avec succès..", 'success')
|
|
qte_j = min(5 - weekday,qte_j)
|
|
duplicate_semaine_type_activity(request,int(no_ligne),qte_j,logged_in)
|
|
return HTTPFound(location=url)
|
|
|
|
|
|
semaine_type,activities = get_semaine_type_activity(request,code_sem)
|
|
events = []
|
|
for row in activities:
|
|
json_event = {
|
|
'title': row.INTITULE,
|
|
'start': '%s %02d:00:00' % (row.dh_debut.strftime('%Y-%m-%d'), row.dh_debut.hour),
|
|
'end': '%s %02d:00:00' % (row.dh_debut.strftime('%Y-%m-%d'), row.dh_debut.hour + row.qte),
|
|
'description': '',
|
|
'allDay': 0,
|
|
'color': "LightBlue",
|
|
'textColor': '#000000',
|
|
'data' : json.dumps({
|
|
'no_ligne' : row.no_ligne,
|
|
'qte' : row.qte,
|
|
'ACTIVITE' : row.ACTIVITE,
|
|
'INTITULE' : row.INTITULE,
|
|
'code_sem': row.code_sem,
|
|
'dh_debut' : row.dh_debut.strftime('%d-%m-%Y %H:%M')
|
|
})
|
|
}
|
|
events.append(json_event)
|
|
return {
|
|
'page_title': 'Semaine-types %s' % (semaine_type.LIBELLE),
|
|
'semaine_type' : semaine_type,
|
|
'url' : url,
|
|
'calendar_events' : json.dumps(events),
|
|
'code': code
|
|
}
|
|
|
|
@view_config(route_name='activites', renderer='../templates/parametres/activites.pt', permission='view')
|
|
def activites(request):
|
|
# lire les utilisateurs
|
|
logged_in = request.authenticated_userid
|
|
member = get_users_by_code(request, logged_in)
|
|
items = get_all_activites(request)
|
|
code = member.secu
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
d = (
|
|
item.PERMIS_DEMANDE,
|
|
item.CD_CLI,
|
|
item.NOMPREN,
|
|
item.SOCIETE,
|
|
item.modif_le.strftime('%Y%m%d')
|
|
)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des éleves provisoires/activités',
|
|
'dt_data': json.dumps(liste),
|
|
'code' : code
|
|
}
|
|
|
|
@view_config(route_name='activite_edit', renderer='../templates/parametres/activite_edit.pt', permission='view')
|
|
def activite_edit(request):
|
|
# lire les utilisateurs
|
|
logged_in = request.authenticated_userid
|
|
cd_cli = request.matchdict['cd_cli']
|
|
member = get_users_by_code(request, logged_in)
|
|
code = member.secu
|
|
url = request.route_url('activite_edit',cd_cli=cd_cli)
|
|
permis = get_permis(request,'0')
|
|
message = ''
|
|
if cd_cli == '0':
|
|
individu = {}
|
|
individu['PERMIS_DEMANDE']=''
|
|
individu['CD_CLI']=''
|
|
individu['NOM']=''
|
|
individu['PRENOM']=''
|
|
individu['TR_P_OK'] = None
|
|
individu['NePasRelancer'] = None
|
|
else :
|
|
individu = get_activite_by_code(request,cd_cli)
|
|
|
|
if 'form.submitted' in request.params:
|
|
params = dict(request.params)
|
|
params['AGENCE'] = 0
|
|
del params['form.submitted']
|
|
if 'TR_P_OK' in params:
|
|
params['TR_P_OK'] = datetime.today()
|
|
else :
|
|
params['TR_P_OK'] = None
|
|
if 'NePasRelancer' in params:
|
|
params['NePasRelancer'] = 1
|
|
else :
|
|
params['NePasRelancer'] = 0
|
|
|
|
fiche = get_activite_by_code(request,params['CD_CLI'])
|
|
if fiche and int(cd_cli) == 0:
|
|
request.session.flash("Code déjà utilisé.", 'warning')
|
|
return HTTPFound(location=request.route_url('activites'))
|
|
else :
|
|
params['CD_UTI'] = member.cd_uti
|
|
update_activite(request,cd_cli,params)
|
|
request.session.flash("Une activité / éleve provisoire a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('activites'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
fiche = get_activite_by_code(request,cd_cli)
|
|
if not fiche or int(cd_cli) == 0:
|
|
request.session.flash("Code non trouvé.", 'warning')
|
|
return HTTPFound(location=request.route_url('activites'))
|
|
delete_activite(request,cd_cli)
|
|
request.session.flash("Une activité / éleve provisoire a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('activites'))
|
|
|
|
# construire la liste
|
|
|
|
return {
|
|
'page_title': 'Ajout éleve provisoire/activité',
|
|
'individu': individu,
|
|
'url' : url,
|
|
'permis' : permis,
|
|
'message' : '',
|
|
'code' : code
|
|
}
|
|
|
|
@view_config(route_name='ants_tables', renderer='../templates/parametres/ants_tables.pt', permission='manage')
|
|
def ants_tables(request):
|
|
logged_in = request.authenticated_userid
|
|
url = request.route_url('ants_tables')
|
|
message = ''
|
|
|
|
tables = ['DEPARTEMENTS','PAYS','AUTORITES']
|
|
table = 'DEPARTEMENTS'
|
|
|
|
# si table a changé
|
|
if 'table' in request.params:
|
|
table = request.params["table"]
|
|
|
|
if 'import.pays' in request.params:
|
|
table = 'PAYS'
|
|
if 'import.dept' in request.params:
|
|
table = 'DEPARTEMENTS'
|
|
|
|
idSession = ''
|
|
items = []
|
|
|
|
session = Session()
|
|
session.verify = False
|
|
transport = Transport(session=session)
|
|
client = Client('https://ws-autoecole-qlf.ants.gouv.fr/ws-auto-ecole-spd/services/AutoEcoleDemande?wsdl',
|
|
transport = transport)
|
|
|
|
ws_deconnecter(client, 'e89b03fd0fe0b656d04617886eaa779e120d4e189293178c61b9214d9da2d842')
|
|
# authentifier
|
|
idSession = ws_authentifier(client)
|
|
if len(idSession) == 0 :
|
|
message = 'ws_AutoEcole -> Authentification échouée'
|
|
else:
|
|
if table == 'PAYS' :
|
|
# Lister les pays
|
|
items = client.service.listerPays(idSession)
|
|
elif table == 'DEPARTEMENTS' :
|
|
# Lister les départements
|
|
items = client.service.listerDepartements(idSession)
|
|
else:
|
|
# Lister les autorités
|
|
items = client.service.listerAutorites(idSession, '69')
|
|
|
|
# se deconnecter
|
|
message = ws_deconnecter(client, idSession)
|
|
|
|
if 'import.pays' in request.params:
|
|
import_tables(request, 'PAYS', items, '')
|
|
message ="La table 'PAYS' est importée avec succès."
|
|
|
|
if 'import.dept' in request.params:
|
|
import_tables(request, 'DEPARTEMENTS', items, '')
|
|
message ="La table DEPARTEMENTS est importée avec succès."
|
|
|
|
if 'import.communes' in request.params:
|
|
# authentifier
|
|
idSession = ws_authentifier(client)
|
|
if len(idSession) == 0 :
|
|
message = 'ws_AutoEcole -> Authentification échouée'
|
|
else:
|
|
for dept in items:
|
|
communes = client.service.listerCommunes(idSession, dept.code)
|
|
import_tables(request, 'COMMUNES', communes, dept.code)
|
|
|
|
# se deconnecter
|
|
message = ws_deconnecter(client, idSession)
|
|
message ="La table COMMUNES est importée avec succès."
|
|
|
|
return {
|
|
'page_title': 'Tables ANTS',
|
|
'url': url,
|
|
'logged_in': logged_in,
|
|
'message': message,
|
|
'tables': tables,
|
|
'table': table,
|
|
'items': items,
|
|
}
|
|
|
|
@view_config(route_name='ants_demandes', renderer='../templates/parametres/ants_demandes.pt', permission='manage')
|
|
def ants_demandes(request):
|
|
url = request.route_url('ants_demandes')
|
|
message = ''
|
|
today = datetime.today()
|
|
dateDebut = today - relativedelta(days=90)
|
|
dateFin = today
|
|
liste=[]
|
|
|
|
idSession = ''
|
|
session = Session()
|
|
session.verify = False
|
|
transport = Transport(session=session)
|
|
client = Client('https://ws-autoecole-qlf.ants.gouv.fr/ws-auto-ecole-spd/services/AutoEcoleDemande?wsdl',
|
|
transport = transport)
|
|
|
|
ws_deconnecter(client, '8b990678760c607875c4245c8b41ec767bf9119c69b93d669838c4b08d1380fd')
|
|
# authentifier
|
|
|
|
idSession = ws_authentifier(client)
|
|
if len(idSession) == 0 :
|
|
message = 'ws_AutoEcole -> Authentification échouée'
|
|
else:
|
|
factory = client.type_factory('ns0')
|
|
|
|
periodeCreation = factory.periodeType(
|
|
dateDebut = dateDebut,
|
|
dateFin = dateFin
|
|
)
|
|
periodeMaj = factory.periodeType(
|
|
dateDebut = dateDebut,
|
|
dateFin = dateFin
|
|
)
|
|
filtres = factory.filtresType(
|
|
dateCreation = periodeCreation,
|
|
dateMaj = periodeMaj
|
|
)
|
|
|
|
# Lister demandes
|
|
try:
|
|
demandeDataOut = client.service.listerDemandes(
|
|
idSession = idSession,
|
|
filtres = filtres,
|
|
)
|
|
except Error as error:
|
|
message = 'ws_AutoEcole -> Lister demandes échoué'
|
|
else:
|
|
# construire la liste
|
|
liste=[]
|
|
for item in demandeDataOut:
|
|
date = datetime.strptime(item.dateCreation, '%Y%m%d')
|
|
cree_le = date.strftime('%d-%m-%Y')
|
|
date = datetime.strptime(item.dateMaJ, '%Y%m%d')
|
|
maj_le = date.strftime('%d-%m-%Y')
|
|
d = (item.idDemande, item.numDemande, item.nom + ' ' + item.prenoms, item.sousTypeDemande.code,
|
|
item.statut.code, cree_le, maj_le)
|
|
liste.append(d)
|
|
|
|
# se deconnecter
|
|
ws_deconnecter(client, idSession)
|
|
|
|
return {
|
|
'page_title': 'Demandes créées depuis %s' % dateDebut.strftime('%d-%m-%Y'),
|
|
'url': url,
|
|
'message': message,
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='last_emailing', renderer='../templates/parametres/last_emailing.pt', permission='view')
|
|
def last_emailing(request):
|
|
|
|
tables = ['RESERVATIONS','RAPPELS RDV']
|
|
table = 'RESERVATIONS'
|
|
|
|
# si table a changé
|
|
if 'table' in request.params:
|
|
table = request.params["table"]
|
|
|
|
# extractions des rdv pour rappels
|
|
if 'form.generate' in request.params:
|
|
update_rappels(request)
|
|
request.session.flash(u"Les rappels ont été générés avec succès.", 'success')
|
|
|
|
# notifier les rappels par email
|
|
if 'form.email_rappels' in request.params:
|
|
notifier_rappels(request)
|
|
request.session.flash(u"Les rappels ont été envoyés par email avec succès.", 'success')
|
|
|
|
# extractions des réservations pour confirmation
|
|
if 'form.confirm' in request.params:
|
|
confirm_reservations(request)
|
|
request.session.flash(u"Les réservations ont été confirmées avec succès.", 'success')
|
|
|
|
# notifier le réservations
|
|
if 'form.email_resa' in request.params:
|
|
nbLus, nbConfirmes, nbAnnules = notifier_reservations(request, 'HEURES')
|
|
request.session.flash("Fin ENVOI emails : %s résa lus, %s confirmées, %s annulées." % (str(nbLus), str(nbConfirmes), str(nbAnnules)), 'success')
|
|
|
|
# lire les emailing résa
|
|
items = get_last_emailing(request, table)
|
|
|
|
# construire la liste
|
|
nbRappels = 0
|
|
liste=[]
|
|
for item in items:
|
|
if table == 'RESERVATIONS':
|
|
if item.resa_date:
|
|
resa_date = item.resa_date.strftime('%d-%m-%Y')
|
|
else:
|
|
resa_date = ""
|
|
else:
|
|
if item.rdv_date:
|
|
resa_date = item.rdv_date.strftime('%d-%m-%Y %H:%M')
|
|
else:
|
|
resa_date = ""
|
|
|
|
if item.envoye_le:
|
|
envoye_le = item.envoye_le.strftime('%d-%m-%Y %H:%M')
|
|
else:
|
|
envoye_le = ""
|
|
nbRappels += 1
|
|
|
|
if table == 'RESERVATIONS':
|
|
statut = item.resa_statut
|
|
else:
|
|
statut = ""
|
|
|
|
d = (item.ref, resa_date, '%s - %s' % (item.cd_cli, item.nompren), item.email, statut, envoye_le, item.cree_le.strftime('%d-%m-%Y %H:%M'))
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des derniers emailing',
|
|
'dt_data': json.dumps(liste),
|
|
'tables': tables,
|
|
'table': table,
|
|
'nbRappels': nbRappels,
|
|
}
|
|
|
|
@view_config(route_name='pdfviewer', renderer='../templates/parametres/pdfviewer.pt', permission='view')
|
|
def pdfviewer(request):
|
|
# nom du fichier pdf
|
|
pdf_name = request.matchdict['pdf_name']
|
|
cd_cli = pdf_name[:6]
|
|
# calculer l'url absolu du fichier pdf
|
|
pdf_url = '%s%s/%s' % (request.static_url(request.registry.settings['aem_gestion.justifs_url']),cd_cli, pdf_name)
|
|
|
|
return {
|
|
'page_title': '',
|
|
'pdf_url': pdf_url,
|
|
}
|
|
|
|
@view_config(route_name='dashboard', renderer='../templates/parametres/dashboard.pt', permission='manage')
|
|
def dashboard(request):
|
|
|
|
# lire derniers paiements
|
|
connexions = get_last_7days_paymnt(request)
|
|
courbe_paiements=[]
|
|
courbe_paiements.append(('Date', 'Nbre'))
|
|
|
|
for item in connexions:
|
|
# construire la courbe connexions
|
|
d = (item.date.strftime('%d-%m'), item.nb)
|
|
courbe_paiements.append(d)
|
|
|
|
payments = get_last_payments(request)
|
|
|
|
# lire dernières connexions
|
|
connexions = get_last_7days_cnx(request)
|
|
courbe_connections=[]
|
|
courbe_connections.append(('Date', 'Nbre'))
|
|
|
|
for item in connexions:
|
|
# construire la courbe connexions
|
|
d = (item.date.strftime('%d-%m'), item.nb)
|
|
courbe_connections.append(d)
|
|
|
|
connections = get_eleves_by_last_connection(request, )
|
|
|
|
# lire le log de nuit
|
|
log_nuit = get_log_nuit(request)
|
|
|
|
return {
|
|
'page_title': "Tableau de bord",
|
|
'courbe_connections': json.dumps(courbe_connections),
|
|
'courbe_paiements': json.dumps(courbe_paiements),
|
|
'connections': connections,
|
|
'payments': payments,
|
|
'log_nuit': log_nuit,
|
|
}
|
|
|
|
@view_config(route_name='stats_pay', renderer='../templates/parametres/stats_pay.pt', permission='manage')
|
|
def stats_pay(request):
|
|
|
|
# lire les réglements année N-1
|
|
items = get_charts_data(request, 'modeRegl01', date.today().year - 1)
|
|
# construire la liste pour donut
|
|
donut_annee_1=[]
|
|
donut_annee_1.append(('Mode', 'Pourcent'))
|
|
title_1 = ''
|
|
for item in items:
|
|
title_1 = item.group1_lib
|
|
# construire la liste pour donut cible
|
|
d = (item.group2_lib, round(item.valeur))
|
|
donut_annee_1.append(d)
|
|
|
|
# lire les réglements année N
|
|
items = get_charts_data(request, 'modeRegl01',date.today().year)
|
|
donut_annee=[]
|
|
donut_annee.append(('Mode', 'Pourcent'))
|
|
title = ''
|
|
for item in items:
|
|
# construire la liste pour donut cible
|
|
title = item.group1_lib
|
|
d = (item.group2_lib, round(item.valeur))
|
|
donut_annee.append(d)
|
|
|
|
return {
|
|
'page_title': "Stats : Paiements",
|
|
'donut_annee_1': json.dumps(donut_annee_1),
|
|
'donut_annee': json.dumps(donut_annee),
|
|
'title': title,
|
|
'title_1': title_1,
|
|
}
|
|
|
|
@view_config(route_name='stats_exam1', renderer='../templates/parametres/stats_exam1.pt', permission='view')
|
|
def stats_exam1(request):
|
|
|
|
url = request.route_url('stats_exam1')
|
|
|
|
agence = '1'
|
|
# si agence a changé
|
|
if 'form.ag1' in request.params:
|
|
agence = '1'
|
|
elif 'form.ag2' in request.params:
|
|
agence = '2'
|
|
elif 'form.ag3' in request.params:
|
|
agence = '3'
|
|
elif 'form.ag4' in request.params:
|
|
agence = '4'
|
|
elif 'form.ag5' in request.params:
|
|
agence = '5'
|
|
elif 'form.ag6' in request.params:
|
|
agence = '6'
|
|
elif 'form.ag7' in request.params:
|
|
agence = '7'
|
|
elif 'form.ag8' in request.params:
|
|
agence = '8'
|
|
|
|
|
|
# lire les résultats examens sur un an
|
|
items = get_charts_exam1(request, agence)
|
|
barChart_annee=[]
|
|
barChart_annee.append(('Mois', 'Agence', {'role': 'annotation'}, { 'type':'string','role': 'tooltip'}, 'Marietton', {'type': 'string','role': 'tooltip'}))
|
|
title = ''
|
|
for item in items:
|
|
# construire la liste pour donut cible
|
|
title = 'AGENCE %s' % item.group2_lib
|
|
tooltip = 'Agence: '+item.group2_lib+'\nReussite: '+str(item.reussite)+'\nTotale: '+str(item.totale)+'\nTaux: '+str(round(item.valeur)) + ' %'
|
|
mar_tooltip = 'Marietton\nReussite: '+str(item.mar_reussite)+'\nTotale: '+str(item.mar_totale)+'\nTaux: '+str(round(item.moyenne)) + ' %'
|
|
d = (item.group1_lib[:4], round(item.valeur), '('+str(item.reussite)+'/'+str(item.totale)+')\xa0\xa0\xa0'+str(round(item.valeur)) + ' %',tooltip, round(item.moyenne),mar_tooltip)
|
|
barChart_annee.append(d)
|
|
|
|
return {
|
|
'page_title': "Historique par agence",
|
|
'url': url,
|
|
'barChart_annee': json.dumps(barChart_annee),
|
|
'title': title,
|
|
}
|
|
|
|
@view_config(route_name='stats_exam2', renderer='../templates/parametres/stats_exam2.pt', permission='view')
|
|
def stats_exam2(request):
|
|
|
|
url = request.route_url('stats_exam2')
|
|
|
|
datefin = date.today()
|
|
# debut = aujourd'hui - 12 mois
|
|
datedeb = datefin + relativedelta(months=-12)
|
|
|
|
# lire les moniteurs
|
|
moniteurs = get_charts_exam2_mon(request, datedeb, datefin)
|
|
# mémoriser le 1er de la liste
|
|
cd_mon = moniteurs[0].group2
|
|
|
|
# si cd_mon a été changé par le user
|
|
if 'cd_mon' in request.params:
|
|
cd_mon = request.params["cd_mon"]
|
|
|
|
# lire les résultats examens du moniteur
|
|
items = get_charts_exam2(request, datedeb, datefin, cd_mon)
|
|
barChart_annee=[]
|
|
barChart_annee.append(('Mois', 'Moniteur', {'role': 'annotation'}, { 'type':'string','role': 'tooltip'} ,'Marietton',{'type': 'string','role': 'tooltip'}))
|
|
title = ''
|
|
for item in items:
|
|
# construire la liste pour donut cible
|
|
title = '%s - %s' % (item.group2_lib, item.group2)
|
|
if item.valeur2 == 0:
|
|
pourcent = 0
|
|
else:
|
|
pourcent = round(item.valeur * 100 / item.valeur2)
|
|
tooltip = 'Agence: '+item.group2_lib+'\nReussite: '+str(round(item.valeur))+'\nTotale: '+str(round(item.valeur2))+'\nTaux: '+str(pourcent) + ' %'
|
|
mar_tooltip = 'Marietton\nReussite: '+str(item.mar_reussite)+'\nTotale: '+str(item.mar_totale)+'\nTaux: '+str(round(item.moyenne)) + ' %'
|
|
d = (item.group1_lib[:4], pourcent, '('+str(round(item.valeur))+'/'+str(round(item.valeur2))+')\xa0\xa0\xa0'+str(round(pourcent)) + ' %', tooltip,round(item.moyenne),mar_tooltip)
|
|
barChart_annee.append(d)
|
|
|
|
return {
|
|
'page_title': "Historique par moniteur",
|
|
'url': url,
|
|
'barChart_annee': json.dumps(barChart_annee),
|
|
'title': title,
|
|
'moniteurs': moniteurs,
|
|
'cd_mon': cd_mon,
|
|
}
|
|
|
|
@view_config(route_name='inscriptions', renderer='../templates/parametres/inscriptions.pt', permission='manage')
|
|
def inscriptions(request):
|
|
|
|
tables = ['B96','code','PAP','PASA2','PEM125']
|
|
table = 'PAP'
|
|
|
|
# si table a changé
|
|
if 'table' in request.params:
|
|
table = request.params["table"]
|
|
|
|
items = get_inscriptions(request, table)
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.fin_reservation:
|
|
fin_reservation = item.fin_reservation.strftime('%d-%m-%Y')
|
|
else:
|
|
fin_reservation = ""
|
|
|
|
d = ('%s' % item.debut.strftime("%d-%m-%Y %H:%M"),
|
|
'%s - %s' % (item.cd_cli, item.nom), to_euro(item.solde),
|
|
item.cree_le.strftime("%d-%m-%Y %H:%M"), item.cd_uti, fin_reservation)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': "Inscriptions web en cours",
|
|
'dt_data': json.dumps(liste),
|
|
'tables': tables,
|
|
'table': table,
|
|
}
|
|
|
|
@view_config(route_name='pass_rousseau', renderer='../templates/parametres/pass_rousseau.pt', permission='view')
|
|
def pass_rousseau(request):
|
|
# lire les pass rousseau
|
|
items = get_pass_rousseau(request)
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.vendu_le:
|
|
vendu_le = item.vendu_le.strftime('%d-%m-%Y')
|
|
else:
|
|
vendu_le = ""
|
|
if item.cd_cli:
|
|
cd_cli = '%s - %s' % (item.cd_cli, item.nom)
|
|
else:
|
|
cd_cli = ""
|
|
|
|
d = (item.cree_le.strftime("%d-%m-%Y"), item.identifiant, item.mdp, item.expire_le.strftime("%d-%m-%Y"),
|
|
vendu_le, cd_cli, item.code_postal)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des PASS Rousseau',
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='types_devis', renderer='../templates/parametres/types_devis.pt', permission='manage')
|
|
def types_devis(request):
|
|
|
|
# lire toutes les p_types_devis
|
|
types = get_types_devis(request, '0')
|
|
|
|
return {
|
|
'page_title': "Liste des types de devis",
|
|
'types': types,
|
|
}
|
|
|
|
@view_config(route_name='types_devis_frm', renderer='../templates/parametres/types_devis_frm.pt', permission='manage')
|
|
def types_devis_frm(request):
|
|
type_devis = request.matchdict['type_devis']
|
|
url = request.route_url('types_devis_frm',type_devis=type_devis)
|
|
|
|
message = ""
|
|
if type_devis == '0':
|
|
# nouveau
|
|
titre = "Nouveau TYPE de DEVIS"
|
|
types = {}
|
|
types['type_devis'] = 'nouveau'
|
|
types['libelle'] = ''
|
|
types['montantTTC'] = 0.00
|
|
types['montantHT'] = 0.00
|
|
types['nb_heures'] = 0
|
|
types['dispo']= 1
|
|
else:
|
|
titre = "Modifier le TYPE : %s" % type_devis
|
|
types = get_types_devis(request, type_devis)
|
|
|
|
if 'form.submitted' in request.params:
|
|
typed = request.params["type_devis"]
|
|
if typed == '0':
|
|
message = "Veuillez saisir un type de devis valide."
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in types.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
# dispo coché ?
|
|
if 'dispo' in request.params:
|
|
new_values['dispo'] = 1
|
|
else:
|
|
new_values['dispo'] = 0
|
|
if new_values:
|
|
update_type_devis(request, type_devis, new_values)
|
|
request.session.flash("Le type de devis a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('types_devis'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
if type_devis != '0':
|
|
delete_type_devis(request, type_devis)
|
|
request.session.flash("'%s' a été supprimé avec succès." % type_devis, 'success')
|
|
return HTTPFound(location=request.route_url('types_devis'))
|
|
|
|
return {
|
|
'page_title': titre,
|
|
'url': url,
|
|
'message': message,
|
|
'types': types,
|
|
'type_devis': type_devis,
|
|
}
|
|
|
|
@view_config(route_name='tarifs', renderer='../templates/parametres/tarifs.pt', permission='manage')
|
|
def tarifs(request):
|
|
|
|
familles = ["Autre", "Forfait", "Heure", "Présentation", "Stage"]
|
|
famille = 'Heure'
|
|
|
|
# si table a changé
|
|
if 'famille' in request.params:
|
|
famille = request.params["famille"]
|
|
|
|
# lire les tarifs
|
|
items = get_tarifs_byFam(request, famille[0])
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
|
|
if item.obsolete != 0:
|
|
etat = 'Inactif'
|
|
else:
|
|
etat = 'Actif'
|
|
if item.rappel_md :
|
|
rappel = 'OUI'
|
|
else:
|
|
rappel = ''
|
|
if item.delai_rappel :
|
|
rappel += ': %s j' % str(item.delai_rappel)
|
|
|
|
d = (item.REF, item.LIB, to_euro(item.PUTTC), rappel, item.type_examen, etat)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des tarifs',
|
|
'dt_data': json.dumps(liste),
|
|
'familles': familles,
|
|
'famille': famille,
|
|
}
|
|
|
|
@view_config(route_name='tarif_edit', renderer='../templates/parametres/tarif_edit.pt', permission='manage')
|
|
def tarif_edit(request):
|
|
ref = request.matchdict['ref']
|
|
url = request.route_url('tarif_edit', ref=ref)
|
|
logged_in = request.authenticated_userid
|
|
message = ''
|
|
|
|
markdowner = Markdown()
|
|
types_exa = ["2R", "B", "B78", "GL", "PAP", "X"]
|
|
familles = ["Autre", "Forfait", "Heure", "Présentation", "Stage"]
|
|
tvas = get_p_tables(request, 'P_TVA')
|
|
comptes = get_p_tables(request, 'P_COMPTES')
|
|
confirmation_html = ''
|
|
|
|
if ref == '0':
|
|
# nouveau
|
|
item = {}
|
|
item['REF'] = '0'
|
|
item['LIB'] = ''
|
|
item['CTVA'] = 0
|
|
item['PUTTC'] = 0
|
|
item['COMPTE'] = 0
|
|
item['FAM'] = ''
|
|
item['type_examen'] = ''
|
|
item['obsolete'] = 0
|
|
item['delai_rappel'] = 0
|
|
item['delai_reservation'] = 0
|
|
item['rappel_md']= ''
|
|
item['rappel_html']= ''
|
|
item['confirmation_md'] = ''
|
|
page_title= 'Nouveau tarif'
|
|
else:
|
|
# lire la fiche du tarif
|
|
item = get_tarifs(request, ref)
|
|
if not item:
|
|
request.session.flash("Tarif non trouvé : %s" % ref, 'warning')
|
|
return HTTPFound(location=request.route_url('tarifs'))
|
|
page_title= "Tarif : %s - %s" %(item.REF, item.LIB)
|
|
|
|
# convertir confirmation de mardown en HTML
|
|
if item.confirmation_md:
|
|
confirmation_html = markdowner.convert(item.confirmation_md)
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_ref = request.params["REF"]
|
|
if new_ref == '0':
|
|
message = "Veuillez saisir un code tarif valide."
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in item.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
# obsolete coché ?
|
|
if 'obsolete' in request.params:
|
|
new_values['obsolete'] = 1
|
|
else:
|
|
new_values['obsolete'] = 0
|
|
|
|
if new_values:
|
|
# convertir rappel de mardown en HTML
|
|
new_values['rappel_html'] = markdowner.convert(request.params["rappel_md"])
|
|
|
|
new_values['cd_uti'] = logged_in
|
|
update_tarif(request, ref, new_values)
|
|
request.session.flash("Le tarif a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(url)
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_tarif(request, ref)
|
|
request.session.flash("Le tarif a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('tarifs'))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'message': message,
|
|
'item': item,
|
|
'types_exa': types_exa,
|
|
'familles': familles,
|
|
'tvas': tvas,
|
|
'comptes': comptes,
|
|
'confirmation_html': confirmation_html,
|
|
}
|
|
|
|
@view_config(route_name='permis', renderer='../templates/parametres/permis.pt', permission='manage')
|
|
def permis(request):
|
|
|
|
# lire les permis
|
|
items = get_permis(request, '0')
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
d = (item.CAT, item.LIB, item.type_examen, to_euro(item.EnCours), to_euro(item.plafond_resa))
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des permis',
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='permis_edit', renderer='../templates/parametres/permis_edit.pt', permission='manage')
|
|
def permis_edit(request):
|
|
cat = request.matchdict['cat']
|
|
url = request.route_url('permis_edit', cat=cat)
|
|
logged_in = request.authenticated_userid
|
|
message = ''
|
|
|
|
types_exa = ["2R", "B", "B78", "GL", "PAP", "X"]
|
|
justifs = []
|
|
justifs_add = []
|
|
|
|
if cat == '0':
|
|
# nouveau
|
|
item = {}
|
|
item['CAT'] = '0'
|
|
item['LIB'] = ''
|
|
item['EnCours'] = 0
|
|
item['plafond_resa'] = 0
|
|
item['type_examen'] = ''
|
|
item['HCODE'] = 0
|
|
item['AgeCode'] = 0
|
|
item['AgeCond'] = 0
|
|
item['AgeCondAAC'] = 0
|
|
item['VCODE'] = 0
|
|
item['HEVAL'] = 0
|
|
item['HCOND']= 0
|
|
item['NECHECP']= 0
|
|
page_title= 'Nouveau Permis'
|
|
else:
|
|
# lire la fiche du permis
|
|
item = get_permis(request, cat)
|
|
if not item:
|
|
request.session.flash("Permis non trouvé : %s" % cat, 'warning')
|
|
return HTTPFound(location=request.route_url('tarifs'))
|
|
page_title= "Tarif : %s - %s" %(item.CAT, item.LIB)
|
|
|
|
# lire ses justifs
|
|
justifs = get_permis_justifs(request, cat, '0')
|
|
# lire ses justifs à ajouter
|
|
justifs_add = get_permis_justifs_manquant(request, cat)
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_cat = request.params["CAT"]
|
|
if new_cat == '0':
|
|
message = "Veuillez saisir une catégorie valide."
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in item.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
if new_values:
|
|
update_permis(request, cat, new_values)
|
|
request.session.flash("Le permis a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('permis'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_permis(request, cat)
|
|
request.session.flash("Le permis a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('permis'))
|
|
|
|
if 'form.justif_added' in request.params:
|
|
code_add = request.params["code_add"]
|
|
insert_permis_justif(request, cat, code_add)
|
|
request.session.flash("'%s' a été ajouté avec succès." % code_add, 'success')
|
|
return HTTPFound(location=url)
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'message': message,
|
|
'item': item,
|
|
'types_exa': types_exa,
|
|
'justifs': justifs,
|
|
'justifs_add': justifs_add,
|
|
'code_add': '',
|
|
}
|
|
|
|
@view_config(route_name='permis_justif', renderer='../templates/parametres/permis_justif.pt', permission='manage')
|
|
def permis_justif(request):
|
|
|
|
cat = request.matchdict['cat']
|
|
code = request.matchdict['code']
|
|
url = request.route_url('permis_justif', cat = cat, code = code)
|
|
|
|
# lire le le justif du permis
|
|
item = get_permis_justifs(request, cat, code)
|
|
|
|
if 'form.submitted' in request.params:
|
|
no_tri = request.params["no_tri"]
|
|
update_permis_justif(request, cat, code, no_tri)
|
|
request.session.flash("Le justif '%s' a été supprimé avec succès." % code, 'success')
|
|
return HTTPFound(location=request.route_url('permis_edit', cat=cat)+'#justifs')
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_permis_justif(request, cat, code)
|
|
request.session.flash("Le justif '%s' a été supprimé avec succès." % code, 'success')
|
|
return HTTPFound(location=request.route_url('permis_edit', cat=cat)+'#justifs')
|
|
|
|
return {
|
|
'page_title': 'Justificatif : %s' % item.CODE,
|
|
'url': url,
|
|
'item': item,
|
|
}
|
|
|
|
@view_config(route_name='justifs_list', renderer='../templates/parametres/justifs_list.pt', permission='manage')
|
|
def justifs_list(request):
|
|
|
|
types = ["JUST", "DOC"]
|
|
type = 'JUST'
|
|
# si table a changé
|
|
if 'type' in request.params:
|
|
type = request.params["type"]
|
|
|
|
# lire toutes les p_justifs
|
|
justifs = get_justifsByType(request, type)
|
|
|
|
return {
|
|
'page_title': "Liste des documents types",
|
|
'justifs': justifs,
|
|
'types': types,
|
|
'type': type,
|
|
}
|
|
|
|
@view_config(route_name='justif_edit', renderer='../templates/parametres/justif_edit.pt', permission='manage')
|
|
def justif_edit(request):
|
|
code = request.matchdict['code']
|
|
url = request.route_url('justif_edit',type = type, code = code)
|
|
|
|
types = ["JUST", "DOC"]
|
|
message = ""
|
|
if code == '0':
|
|
# nouveau
|
|
titre = "Nouveau document"
|
|
justif = {}
|
|
justif['CODE'] = '0'
|
|
justif['LIBELLE'] = ''
|
|
justif['TYPE'] = ''
|
|
justif['conditions'] = ''
|
|
else:
|
|
titre = "Modifier le document : %s" % code
|
|
justif = get_justifs(request, code)
|
|
|
|
if 'form.submitted' in request.params:
|
|
coded = request.params["CODE"]
|
|
if coded == '0':
|
|
message = "Veuillez saisir un code valide."
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in justif.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
if new_values:
|
|
update_justif(request, code, new_values)
|
|
request.session.flash("Le document a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('justifs_list'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
if code != '0':
|
|
delete_justif(request, code)
|
|
request.session.flash("'%s' a été supprimé avec succès." % code, 'success')
|
|
return HTTPFound(location=request.route_url('justifs_list'))
|
|
|
|
return {
|
|
'page_title': titre,
|
|
'url': url,
|
|
'message': message,
|
|
'types': types,
|
|
'justif': justif,
|
|
}
|
|
|
|
@view_config(route_name='formules', renderer='../templates/parametres/formules.pt', permission='manage')
|
|
def formules(request):
|
|
|
|
validites = ['EN-COURS','TOUTES']
|
|
validite = 'EN-COURS'
|
|
|
|
# si validite a changé
|
|
if 'validite' in request.params:
|
|
validite = request.params["validite"]
|
|
# lire les formules
|
|
items = get_list_formules(request, '0', validite)
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.STAGE == 0:
|
|
stage = ''
|
|
else:
|
|
stage = 'oui'
|
|
d = (item.FORMULE, item.LIBELLE, stage, item.DateFin.strftime('%d-%m-%Y'), item.FILIERE)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': 'Liste des formules',
|
|
'validites': validites,
|
|
'validite': validite,
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='formule_edit', renderer='../templates/parametres/formule_edit.pt', permission='manage')
|
|
def formule_edit(request):
|
|
formule = request.matchdict['formule']
|
|
url = request.route_url('formule_edit', formule=formule)
|
|
logged_in = request.authenticated_userid
|
|
message = ''
|
|
|
|
types_exa = ["2R", "B", "B78", "GL", "PAP", "X"]
|
|
filieres = get_p_tables(request, 'P_FILIERES')
|
|
today = date.today()
|
|
|
|
if formule == '0':
|
|
# nouveau
|
|
item = {}
|
|
item['FORMULE'] = '0'
|
|
item['LIBELLE'] = ''
|
|
item['STAGE'] = 0
|
|
item['forfait_code'] = 0
|
|
item['DateDeb'] = today
|
|
item['DateFin'] = today
|
|
item['INS1'] = ''
|
|
item['INS2'] = ''
|
|
item['INS3'] = ''
|
|
item['INS4'] = ''
|
|
item['INS5'] = ''
|
|
item['MTVAL1'] = 0
|
|
item['MTVAL2'] = 0
|
|
item['MTVAL3'] = 0
|
|
item['MTVAL4'] = 0
|
|
item['MTVAL5'] = 0
|
|
item['NBPTGRATUIT'] = 0
|
|
item['NBPPGRATUIT'] = 0
|
|
item['NBHCGRATUIT'] = 0
|
|
item['NBCCGRATUIT'] = 0
|
|
item['NBHRGRATUIT'] = 0
|
|
item['NBTAGRATUIT'] = 0
|
|
item['NBRPGRATUIT'] = 0
|
|
item['VAL_TAG'] = 0
|
|
item['VAL_HCG'] = 0
|
|
item['VAL_CCG'] = 0
|
|
item['VAL_HRG'] = 0
|
|
item['VAL_RPG'] = 0
|
|
item['HSeance'] = 0
|
|
item['TFISC']= ''
|
|
item['P_THEOS']= ''
|
|
item['P_PRATS1']= ''
|
|
item['P_PRATS']= ''
|
|
item['HCONDUIT']= ''
|
|
item['DUREE_CODE'] = 0
|
|
item['DUREE_COND'] = 0
|
|
item['CONTRAT1']= ''
|
|
item['CONTRAT2']= ''
|
|
item['type_examen']= ''
|
|
item['FILIERE']= ''
|
|
|
|
page_title= 'Nouvelle Formule'
|
|
else:
|
|
# lire la fiche du permis
|
|
item = get_list_formules(request, formule, '')
|
|
if not item:
|
|
request.session.flash("Formule non trouvée : %s" % formule, 'warning')
|
|
return HTTPFound(location=request.route_url('formules'))
|
|
page_title= "Formule : %s" % (item.FORMULE)
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_code = request.params["FORMULE"]
|
|
if new_code == '0':
|
|
message = "Veuillez saisir une formule valide."
|
|
else:
|
|
new_values = {}
|
|
for param, db_value in item.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
|
|
# STAGE coché ?
|
|
if 'STAGE' in request.params:
|
|
new_values['STAGE'] = 1
|
|
else:
|
|
new_values['STAGE'] = 0
|
|
# STAGE coché ?
|
|
if 'forfait_code' in request.params:
|
|
new_values['forfait_code'] = 1
|
|
else:
|
|
new_values['forfait_code'] = 0
|
|
|
|
# formater date
|
|
DateDeb = dt.strptime(request.params['DateDeb'], '%d-%m-%Y')
|
|
new_values['DateDeb'] = DateDeb.strftime("%Y-%m-%d")
|
|
|
|
DateFin = dt.strptime(request.params['DateFin'] , '%d-%m-%Y')
|
|
new_values['DateFin'] = DateFin.strftime("%Y-%m-%d")
|
|
new_values['cd_uti'] = logged_in
|
|
|
|
update_formule(request, formule, new_values)
|
|
request.session.flash("La formule a été mise à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('formules'))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_permis(request, formule)
|
|
request.session.flash("La formule a été supprimée avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('formules'))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'url': url,
|
|
'message': message,
|
|
'item': item,
|
|
'types_exa': types_exa,
|
|
'filieres': filieres,
|
|
}
|
|
|
|
@view_config(route_name='agences', renderer='../templates/parametres/agences.pt', permission='manage')
|
|
def agences(request):
|
|
# lire les agences
|
|
items = get_agences(request, 0)
|
|
|
|
return {
|
|
'page_title': 'Liste des agences',
|
|
'items': items,
|
|
}
|
|
|
|
@view_config(route_name='agence_edit', renderer='../templates/parametres/agence_edit.pt', permission='manage')
|
|
def agence_edit(request):
|
|
code = request.matchdict['code']
|
|
url = request.route_url('agence_edit', code=code)
|
|
message = ''
|
|
agences = get_agences(request, 0)
|
|
|
|
# lire la fiche de l'agence
|
|
item = get_agences(request, code)
|
|
if not item:
|
|
request.session.flash("Agence non trouvé : %s" % code, 'warning')
|
|
return HTTPFound(location=request.route_url('agences'))
|
|
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {}
|
|
for param, db_value in item.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
|
|
if new_values:
|
|
update_agence(request, code, new_values)
|
|
request.session.flash("L'agence a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('agences'))
|
|
|
|
return {
|
|
'page_title': item.LIBELLE,
|
|
'url': url,
|
|
'item': item,
|
|
'message': message,
|
|
}
|