929 lines
37 KiB
Python
929 lines
37 KiB
Python
# -*- coding: utf8 -*-
|
|
from pyramid.response import Response
|
|
from pyramid.renderers import render, get_renderer
|
|
from pyramid.view import (
|
|
view_config,
|
|
forbidden_view_config,
|
|
)
|
|
from pyramid.security import (
|
|
remember,
|
|
forget,
|
|
)
|
|
from pyramid.httpexceptions import (
|
|
HTTPFound,
|
|
HTTPNotFound,
|
|
HTTPForbidden,
|
|
)
|
|
from pyramid_mailer import get_mailer
|
|
from pyramid_mailer.message import Message, Attachment
|
|
from datetime import *
|
|
|
|
from sqlalchemy.exc import DBAPIError
|
|
from ..security import groupfinder
|
|
|
|
import os
|
|
import io
|
|
import shutil
|
|
import pdfkit
|
|
import imaplib
|
|
import base64
|
|
import email
|
|
|
|
from pdfminer3.layout import LAParams, LTTextBox, LTTextLine
|
|
from pdfminer3.pdfpage import PDFPage
|
|
from pdfminer3.pdfparser import PDFParser
|
|
from pdfminer3.pdfdocument import PDFDocument
|
|
from pdfminer3.pdfdevice import PDFDevice
|
|
from pdfminer3.pdfinterp import PDFResourceManager, PDFPageInterpreter
|
|
from pdfminer3.converter import PDFPageAggregator
|
|
|
|
from ..views.default import *
|
|
from ..models.default import *
|
|
from ..models.dossier import *
|
|
|
|
@view_config(route_name='dossier_lookup', renderer='../templates/dossier/dossier_lookup.pt', permission='view')
|
|
@view_config(route_name='dossier_select', renderer='../templates/dossier/dossier_lookup.pt', permission='view')
|
|
def dossier_lookup(request):
|
|
|
|
if 'dossier_select' in request.current_route_path() :
|
|
# récupérer les paramètres de l'appel de la view
|
|
datePlan = request.matchdict['date']
|
|
# sélectionner dossier -> goto planning
|
|
goto_url = '/dossier_selected/agenda/%s/' % datePlan
|
|
url = request.route_url('dossier_select', date=datePlan)
|
|
else:
|
|
# recherche dossier -> goto fiche dossier
|
|
goto_url = '/dossier_selected/dossier_view/%s/' % date.today().strftime('%Y-%m-%d')
|
|
url = request.route_url('dossier_lookup')
|
|
|
|
logged_in = request.authenticated_userid.upper()
|
|
message = ''
|
|
societes = ['PE','ME','PL','PO','CD']
|
|
member = get_member_by_id(request, logged_in)
|
|
societe_defaut = member.societe
|
|
societe = societe_defaut
|
|
access_defaut = member.access
|
|
liste=[]
|
|
name = ''
|
|
cb_tous = "non"
|
|
|
|
if 'form.submitted' in request.params:
|
|
name = request.params['name']
|
|
societe = request.params['societe']
|
|
if access_defaut > 0:
|
|
societe = request.params['societe']
|
|
else:
|
|
societe = societe_defaut
|
|
|
|
# si afficher tous les fiches ?
|
|
if 'cb_tous' in request.params:
|
|
cb_tous = "oui"
|
|
chantiers = get_chantiers_byName(request, societe, name, True)
|
|
else:
|
|
cb_tous = "non"
|
|
chantiers = get_chantiers_byName(request, societe, name, False)
|
|
if len(chantiers) == 0:
|
|
message = "Chantier non trouvé : %s" % name
|
|
# construire la liste
|
|
for item in chantiers:
|
|
d = ('%s-%s' % (societe, item.numero),item.date.strftime('%d-%m-%Y'), item.nomcli, item.chantier, to_euro(item.montant),
|
|
item.nosin, item.status)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': "Rechercher un chantier",
|
|
'url': url,
|
|
'goto_url': goto_url,
|
|
'message': message,
|
|
'dt_data': json.dumps(liste),
|
|
'societes': societes,
|
|
'societe': societe,
|
|
'name': name,
|
|
'cb_tous': cb_tous,
|
|
}
|
|
|
|
@view_config(route_name='dossier_view', renderer='../templates/dossier/dossier_view.pt', permission='view')
|
|
def dossier_view(request):
|
|
nodossier = request.matchdict['nodossier']
|
|
societe = nodossier[0:2]
|
|
logged_in = request.authenticated_userid.upper()
|
|
|
|
url = request.route_url("dossier_view", nodossier=nodossier)
|
|
|
|
dossier = get_dossier_by_no(request, nodossier)
|
|
if dossier is None:
|
|
request.session.flash(u"Le dossier no %s est introuvable" % (nodossier), 'danger')
|
|
return HTTPFound(location=request.route_url("dossier_lookup"))
|
|
# lire tous le suivi du dossier
|
|
details = get_dossier_rdv_by_no(request, nodossier, '0')
|
|
# lire toutes les dossiers du chantiers
|
|
documents = get_documents_byChantier(request, nodossier)
|
|
# lire toutes les dossiers similaires
|
|
similaires = get_similaires_byChantier(request, dossier.societe, dossier.C_NOM, dossier.C_ADR, dossier.C_CP, dossier.C_VILLE)
|
|
# lire tous les documents attachés
|
|
docs_attaches = get_docs_attaches(request, nodossier, 0, '')
|
|
if nodossier.startswith('PL'):
|
|
# lire rapport de rdf
|
|
rapports = get_rapport_by_no(request, nodossier, '')
|
|
else:
|
|
rapports = []
|
|
# select background color according to society
|
|
bg_color = "bg-%s" % societe
|
|
|
|
return {
|
|
'page_title': u"Dossier : %s" % (nodossier),
|
|
'nodossier': nodossier,
|
|
'dossier': dossier,
|
|
'details': details,
|
|
'rapports': rapports,
|
|
'documents': documents,
|
|
'similaires': similaires,
|
|
'docs_attaches': docs_attaches,
|
|
'docs_url': request.static_url(request.registry.settings['mondumas.devfac_url']),
|
|
'bg_color': bg_color,
|
|
}
|
|
|
|
@view_config(route_name='devis_view', renderer='../templates/dossier/devis_view.pt', permission='view')
|
|
def devis_view(request):
|
|
nodossier = request.matchdict['nodossier']
|
|
societe = nodossier[0:2]
|
|
url = request.route_url("devis_view", nodossier=nodossier)
|
|
|
|
type_doc = nodossier[3:5]
|
|
if type_doc == 'DE':
|
|
page_title = u"Devis no : %s" % (nodossier)
|
|
elif type_doc == 'FA':
|
|
page_title = u"Facture no : %s" % (nodossier)
|
|
else:
|
|
page_title = u"Proforma no : %s" % (nodossier)
|
|
|
|
dossier = get_devis_by_no(request, nodossier)
|
|
if dossier is None:
|
|
request.session.flash(u"Le document no %s est introuvable" % (nodossier), 'danger')
|
|
return HTTPFound(location=request.route_url("dossier_lookup"))
|
|
# lire tous les lignes du devis
|
|
details = get_devis_lig_by_no(request, nodossier)
|
|
# select background color according to society
|
|
bg_color = "bg-%s" % societe
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'nodossier': nodossier,
|
|
'dossier': dossier,
|
|
'details': details,
|
|
'bg_color': bg_color,
|
|
}
|
|
|
|
@view_config(route_name='dossier_selected', permission='view')
|
|
def dossier_selected(request):
|
|
|
|
# récupérer les paramètres de l'appel de la view
|
|
goto = request.matchdict['goto']
|
|
datePlan = request.matchdict['date']
|
|
nodossier = request.matchdict['nodossier']
|
|
|
|
# fiche dossier
|
|
dossier = get_dossier_by_no(request, nodossier)
|
|
# memorize nodossier et nom dossier
|
|
request.session['mem_nodossier'] = nodossier
|
|
request.session['mem_nomdossier'] = '%s %s' % (dossier.C_QUALITE, dossier.C_NOM)
|
|
if goto == 'dossier_view':
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
else:
|
|
return HTTPFound(location=request.route_url('agenda', date=datePlan))
|
|
|
|
@view_config(route_name='suivi_edit', renderer='../templates/dossier/suivi_edit.pt', permission='view')
|
|
def suivi_edit(request):
|
|
|
|
logged_in = request.authenticated_userid.upper()
|
|
nodossier = request.matchdict['nodossier']
|
|
nolig = request.matchdict['nolig']
|
|
url = request.route_url("suivi_edit", nodossier=nodossier, nolig=nolig)
|
|
|
|
message = ''
|
|
if nolig == '0':
|
|
# nouveau
|
|
suivi = {}
|
|
suivi['COMMENT'] = ''
|
|
suivi['USERMAJ'] = logged_in
|
|
suivi['DATEMAJ'] = datetime.now()
|
|
page_title= 'Nouveau suivi'
|
|
else:
|
|
# lire le suivi
|
|
suivi = get_dossier_rdv_by_no(request, nodossier, nolig)
|
|
if not suivi:
|
|
request.session.flash(u"Suivi non trouvé : %s" % nodossier, 'warning')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
page_title= u"Modification du suivi %s" % (nolig)
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {}
|
|
for param, db_value in suivi.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
if new_values:
|
|
new_values['USERMAJ'] = logged_in
|
|
new_values['DATE'] = date.today()
|
|
|
|
update_suivi(request, nodossier, nolig, new_values)
|
|
request.session.flash(u"Le suivi a été mis à jour avec succès.", 'success')
|
|
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
if 'form.deleted' in request.params:
|
|
delete_rdv(request, nodossier, nolig)
|
|
request.session.flash(u"Le suivi a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
return {
|
|
'page_title': page_title,
|
|
'logged_in': logged_in,
|
|
'url': url,
|
|
'nodossier': nodossier,
|
|
'nolig': nolig,
|
|
'suivi': suivi,
|
|
'message': message,
|
|
}
|
|
|
|
@view_config(route_name='dossier_edit', renderer='../templates/dossier/dossier_edit.pt', permission='view')
|
|
def dossier_edit(request):
|
|
logged_in = request.authenticated_userid
|
|
nodossier = request.matchdict['nodossier']
|
|
url = request.route_url('dossier_edit', nodossier=nodossier)
|
|
|
|
dossier = get_dossier_by_no(request, nodossier)
|
|
if not dossier:
|
|
request.session.flash(u"Le dossier no %s est introuvable" % (nodossier), 'danger')
|
|
return HTTPFound(location=request.route_url('dossier_lookup'))
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {}
|
|
for param, db_value in dossier.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
|
|
if new_values:
|
|
update_dossier(request, nodossier, new_values)
|
|
request.session.flash(u"Le dossier a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
return {
|
|
'page_title': u"Modifier le dossier : %s" % nodossier,
|
|
'url': url,
|
|
'dossier': dossier,
|
|
'nodossier': nodossier,
|
|
}
|
|
|
|
@view_config(route_name='upload_doc', renderer='../templates/dossier/upload_doc.pt', permission='view')
|
|
def upload_doc(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
nodossier = request.matchdict['nodossier']
|
|
societe = nodossier[0:2]
|
|
nochantier = nodossier[3:]
|
|
|
|
url = request.route_url("upload_doc", nodossier=nodossier)
|
|
message = ""
|
|
|
|
dossier = get_dossier_by_no(request, nodossier)
|
|
if dossier is None:
|
|
request.session.flash(u"Le dossier no %s est introuvable" % (nodossier), 'danger')
|
|
return HTTPFound(location=request.route_url("dossier_lookup"))
|
|
|
|
# lire tous les documents attachés
|
|
docs_attaches = get_docs_attaches(request, nodossier, 0, '')
|
|
|
|
if 'form.submitted' in request.params:
|
|
# récupère le fichier lui-même
|
|
input_file = request.POST['filename'].file
|
|
# récupère son nom
|
|
input_name = request.POST['filename'].filename
|
|
# récupère son extension
|
|
input_ext = input_name.split('.')[-1]
|
|
|
|
# controler l'extension
|
|
ext_allowed = ['jpeg','jpg','png','pdf']
|
|
if input_ext.lower() not in ext_allowed :
|
|
request.session.flash("Le format de ce fichier n'est pas valide. Téléchargement impossible.", 'warning')
|
|
else:
|
|
# récupère le nom du fichier et ajouter le no de dossier
|
|
filename = '%s-DD%s-%s' % (societe, nochantier, request.POST['filename'].filename)
|
|
# créer le répertoire du chantier s'il n'existe pas encore
|
|
path = '%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'],societe,nochantier)
|
|
os.makedirs(path, exist_ok=True)
|
|
|
|
file_path = os.path.join(path, filename)
|
|
# We first write to a temporary file to prevent incomplete files
|
|
temp_file_path = file_path + '~'
|
|
|
|
# Finally write the data to a temporary file
|
|
input_file.seek(0)
|
|
with open(temp_file_path, 'wb') as output_file:
|
|
shutil.copyfileobj(input_file, output_file)
|
|
|
|
# controler la taille du fichier < 4 Mo
|
|
filesize = round(os.path.getsize(temp_file_path) / 1024)
|
|
if filesize > 4096 :
|
|
os.remove(temp_file_path)
|
|
request.session.flash("La taille de ce fichier dépasse la limite autorisée. Téléchargement impossible.", 'warning')
|
|
else:
|
|
# Now that we know the file has been fully saved to disk move it into place.
|
|
try:
|
|
os.rename(temp_file_path, file_path)
|
|
except OSError:
|
|
os.remove(temp_file_path)
|
|
request.session.flash('%s : Ce fichier existe déjà dans le rapport.' % input_name, 'danger')
|
|
else:
|
|
insert_dossier_attaches(request, nodossier, 0, filename, '%s Ko' % str(filesize), logged_in)
|
|
request.session.flash('%s : Ce fichier est téléchargé avec succès.' % input_name, 'success')
|
|
# lire tous les documents attachés
|
|
docs_attaches = get_docs_attaches(request, nodossier, 0, '')
|
|
|
|
return {
|
|
'page_title': u"Télécharger un document",
|
|
'url': url,
|
|
'nodossier': nodossier,
|
|
'dossier': dossier,
|
|
'docs_attaches': docs_attaches,
|
|
'docs_url': request.static_url(request.registry.settings['mondumas.devfac_url']),
|
|
}
|
|
|
|
@view_config(route_name='upload_img', renderer='../templates/dossier/upload_img.pt', permission='view')
|
|
def upload_img(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
norapport = request.matchdict['norapport']
|
|
|
|
url = request.route_url("upload_img", norapport=norapport)
|
|
message = ""
|
|
|
|
rapport = get_rapport_by_no_id(request, norapport)
|
|
if rapport is None:
|
|
request.session.flash(u"Le rapport no %s est introuvable" % (norapport), 'danger')
|
|
return HTTPFound(location=request.route_url("rdf_list"))
|
|
|
|
societe = rapport.societe
|
|
nochantier = rapport.nochantier
|
|
# lire tous les photos attachées
|
|
photos = get_photos(request, nochantier, norapport)
|
|
|
|
if 'form.submitted' in request.params:
|
|
# récupère le fichier lui-même
|
|
input_file = request.POST['filename'].file
|
|
# récupère son nom
|
|
input_name = request.POST['filename'].filename
|
|
# récupère son extension
|
|
input_ext = input_name.split('.')[-1]
|
|
|
|
# controler l'extension
|
|
ext_allowed = ['jpeg','jpg','png']
|
|
if input_ext.lower() not in ext_allowed :
|
|
request.session.flash("Le format de ce fichier n'est pas valide. Téléchargement impossible.", 'warning')
|
|
else:
|
|
# récupère le nom du fichier et ajouter le no de rapport
|
|
filename = '%s-RDF%s-%s' % (societe, norapport, request.POST['filename'].filename)
|
|
# créer le répertoire du chantier s'il n'existe pas encore
|
|
path = '%s/%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'], societe, nochantier, norapport)
|
|
os.makedirs(path, exist_ok=True)
|
|
|
|
file_path = os.path.join('%s/%s' % (path, filename))
|
|
# We first write to a temporary file to prevent incomplete files
|
|
temp_file_path = file_path + '~'
|
|
|
|
# Finally write the data to a temporary file
|
|
input_file.seek(0)
|
|
with open(temp_file_path, 'wb') as output_file:
|
|
shutil.copyfileobj(input_file, output_file)
|
|
|
|
# controler la taille du fichier < 4 Mo
|
|
filesize = round(os.path.getsize(temp_file_path) / 1024)
|
|
if filesize > 4096 :
|
|
os.remove(temp_file_path)
|
|
request.session.flash("La taille de ce fichier dépasse la limite autorisée. Téléchargement impossible.", 'warning')
|
|
else:
|
|
# Now that we know the file has been fully saved to disk move it into place.
|
|
try:
|
|
os.rename(temp_file_path, file_path)
|
|
except OSError:
|
|
os.remove(temp_file_path)
|
|
request.session.flash('%s : Ce fichier existe déjà dans le rapport.' % input_name, 'danger')
|
|
else:
|
|
insert_dossier_attaches(request, 'PL-%s' % nochantier, norapport, filename, '%s Ko' % str(filesize), logged_in)
|
|
request.session.flash('%s : Ce fichier est téléchargé avec succès.' % input_name, 'success')
|
|
# lire tous les photos attachées
|
|
photos = get_photos(request, nochantier, norapport)
|
|
|
|
return {
|
|
'page_title': u"Gérer les photos",
|
|
'url': url,
|
|
'nochantier': nochantier,
|
|
'norapport': norapport,
|
|
'rapport': rapport,
|
|
'photos': photos,
|
|
'docs_url': request.static_url(request.registry.settings['mondumas.devfac_url']),
|
|
}
|
|
|
|
@view_config(route_name='rdf_edit', renderer='../templates/dossier/rdf_edit.pt', permission='view')
|
|
def rdf_edit(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
nodossier = request.matchdict['nodossier']
|
|
date_inter = request.matchdict['date_inter']
|
|
|
|
if date_inter == 'new':
|
|
date_inter = date.today().strftime('%Y-%m-%d')
|
|
rapport = get_rapport_by_no(request, nodossier, date_inter)
|
|
if not rapport:
|
|
# creer un nouveau rapport
|
|
insert_rapport(request, nodossier, logged_in)
|
|
# lire le rapport
|
|
rapport = get_rapport_by_no(request, nodossier, date_inter)
|
|
url = request.route_url('rdf_edit', nodossier=nodossier, date_inter=date_inter)
|
|
|
|
caracteristiques = ["Maison individuelle", "Immeuble collectif", "Copropriété", "Commerce", "Bureaux"]
|
|
equipements = get_rdf_causes(request, 'C01')
|
|
reseaux_int = get_rdf_causes(request, 'C02')
|
|
reseaux_ext = get_rdf_causes(request, 'C03')
|
|
reseaux_local = get_rdf_causes(request, 'C04')
|
|
elements_clos = get_rdf_causes(request, 'C05')
|
|
elements_couvert = get_rdf_causes(request, 'C06')
|
|
voisins = get_rdf_causes(request, 'C07')
|
|
tierce_personnes = get_rdf_causes(request, 'C08')
|
|
|
|
if 'form.submitted' in request.params:
|
|
new_values = {}
|
|
for param, db_value in rapport.items():
|
|
if param in request.params and request.params[param] != db_value:
|
|
new_values[param] = request.params[param]
|
|
# case à cocher ?
|
|
if 'sonde_capa' in request.params:
|
|
new_values['sonde_capa'] = 1
|
|
else:
|
|
new_values['sonde_capa'] = 0
|
|
if 'sonde_cond' in request.params:
|
|
new_values['sonde_cond'] = 1
|
|
else:
|
|
new_values['sonde_cond'] = 0
|
|
if 'test_mano' in request.params:
|
|
new_values['test_mano'] = 1
|
|
else:
|
|
new_values['test_mano'] = 0
|
|
if 'test_gaz' in request.params:
|
|
new_values['test_gaz'] = 1
|
|
else:
|
|
new_values['test_gaz'] = 0
|
|
if 'visu_camera' in request.params:
|
|
new_values['visu_camera'] = 1
|
|
else:
|
|
new_values['visu_camera'] = 0
|
|
if 'visu_endoscope' in request.params:
|
|
new_values['visu_endoscope'] = 1
|
|
else:
|
|
new_values['visu_endoscope'] = 0
|
|
if 'visu_tele' in request.params:
|
|
new_values['visu_tele'] = 1
|
|
else:
|
|
new_values['visu_tele'] = 0
|
|
if 'rech_magnetique' in request.params:
|
|
new_values['rech_magnetique'] = 1
|
|
else:
|
|
new_values['rech_magnetique'] = 0
|
|
if 'rech_accoustique' in request.params:
|
|
new_values['rech_accoustique'] = 1
|
|
else:
|
|
new_values['rech_accoustique'] = 0
|
|
if 'test_accoustique' in request.params:
|
|
new_values['test_accoustique'] = 1
|
|
else:
|
|
new_values['test_accoustique'] = 0
|
|
if 'test_mise_en_eau' in request.params:
|
|
new_values['test_mise_en_eau'] = 1
|
|
else:
|
|
new_values['test_mise_en_eau'] = 0
|
|
if 'test_fumigenes' in request.params:
|
|
new_values['test_fumigenes'] = 1
|
|
else:
|
|
new_values['test_fumigenes'] = 0
|
|
|
|
if new_values:
|
|
update_rapport(request, nodossier, date_inter, new_values)
|
|
request.session.flash(u"Le dossier a été mis à jour avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
return {
|
|
'page_title': "Rapport de RDF : %s du %s" % (nodossier, rapport.date_inter.strftime('%d-%m-%Y')),
|
|
'url': url,
|
|
'logged_in': logged_in,
|
|
'rapport': rapport,
|
|
'nodossier': nodossier,
|
|
'caracteristiques': caracteristiques,
|
|
'equipements': equipements,
|
|
'reseaux_int': reseaux_int,
|
|
'reseaux_ext': reseaux_ext,
|
|
'reseaux_local': reseaux_local,
|
|
'elements_clos': elements_clos,
|
|
'elements_couvert': elements_couvert,
|
|
'voisins':voisins,
|
|
'tierce_personnes': tierce_personnes,
|
|
}
|
|
|
|
@view_config(route_name='rdf_list', renderer='../templates/dossier/rdf_list.pt', permission='view')
|
|
def rdf_list(request):
|
|
# lire les rapports de RDF
|
|
items = get_rapport_rdf(request)
|
|
|
|
# construire la liste
|
|
liste=[]
|
|
for item in items:
|
|
if item.date_relu :
|
|
date_relu = item.date_relu.strftime('%d-%m-%Y')
|
|
else:
|
|
date_relu = ''
|
|
if item.date_rapport :
|
|
date_rapport = item.date_rapport.strftime('%d-%m-%Y')
|
|
else:
|
|
date_rapport = ''
|
|
|
|
d = (item.no_id, item.date_inter.strftime('%d-%m-%Y'), date_relu, date_rapport, '%s - %s %s' % (item.nochantier, item.C_QUALITE, item.C_NOM), item.NOMCLI, item.NOSIN,
|
|
item.auteur_code)
|
|
liste.append(d)
|
|
|
|
return {
|
|
'page_title': u'Liste des rapports de RDF',
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
@view_config(route_name='rdf_view', renderer='../templates/dossier/rdf_view.pt', permission='view')
|
|
def rdf_view(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
norapport = request.matchdict['no_id']
|
|
url = request.route_url('rdf_view', no_id=norapport)
|
|
|
|
# lire le rapport
|
|
rapport = get_rapport_by_no_id(request, norapport)
|
|
nodossier = 'PL-' + str(rapport.nochantier)
|
|
if rapport.date_relu:
|
|
date_relu = rapport.date_relu.strftime('%d-%m-%Y')
|
|
else:
|
|
date_relu = ''
|
|
if rapport.date_rapport:
|
|
date_rapport = rapport.date_rapport.strftime('%d-%m-%Y')
|
|
else:
|
|
date_rapport = ''
|
|
|
|
# lire tous les photos attachées
|
|
photos = get_photos(request, rapport.nochantier, norapport)
|
|
|
|
if 'form.generate' in request.params:
|
|
options = {
|
|
'page-size': 'A4',
|
|
'margin-top': '0.65in',
|
|
'margin-right': '0.75in',
|
|
'margin-bottom': '0.65in',
|
|
'margin-left': '0.75in',
|
|
}
|
|
|
|
# créer le répertoire du rapport s'il n'existe pas encore
|
|
path = '%s/%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'], 'PL', rapport.nochantier, norapport)
|
|
os.makedirs(path, exist_ok=True)
|
|
# générer le rapport en PDF
|
|
filename = "PL-DD%s-rapport_RDF_no_%s.pdf" % (str(rapport.nochantier), norapport)
|
|
dest = "mondumas/static/DEVFAC/DOCS_ATTACHES/PL/%s/%s" % (str(rapport.nochantier), filename)
|
|
|
|
# developpement ou production
|
|
if request.registry.settings["mail.host"] == "smtp.orange.fr":
|
|
origin = 'https://gestion.entreprise-dumas.com/rdf_rapport/%s' % norapport
|
|
pdfkit.from_url(origin, dest, options=options)
|
|
else:
|
|
origin = request.route_url('rdf_rapport', no_id=norapport)
|
|
config = pdfkit.configuration(wkhtmltopdf="C:\\Program Files\\wkhtmltopdf\\bin\\wkhtmltopdf.exe")
|
|
pdfkit.from_url(origin, dest, configuration=config, options=options)
|
|
|
|
insert_dossier_attaches(request, nodossier, 0, filename, '160 Ko', logged_in)
|
|
# si generation pdf, maj de la date du rapport
|
|
new_values = {}
|
|
new_values['date_rapport'] = date.today()
|
|
update_rapport(request, nodossier, rapport.date_inter.strftime('%Y-%m-%d'), new_values)
|
|
|
|
request.session.flash(u"Le rapport a été génré avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
if 'form.validate' in request.params:
|
|
validate_rapport(request, norapport)
|
|
request.session.flash(u"Le rapporta été validé avec succès.", 'success')
|
|
|
|
if 'form.delete' in request.params:
|
|
delete_rapport(request, norapport)
|
|
request.session.flash(u"Le rapport a été supprimé avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
return {
|
|
'page_title': "Rapport no %s du %s" % (norapport, rapport.date_inter.strftime('%d-%m-%Y')),
|
|
'url': url,
|
|
'pt_name': 'rdf_view',
|
|
'logged_in': logged_in,
|
|
'rapport': rapport,
|
|
'nodossier': nodossier,
|
|
'nochantier': rapport.nochantier,
|
|
'norapport': norapport,
|
|
'date_rapport': date_rapport,
|
|
'date_relu': date_relu,
|
|
'photos': photos,
|
|
'docs_url': request.static_url(request.registry.settings['mondumas.devfac_url']),
|
|
}
|
|
|
|
@view_config(route_name='rdf_rapport', renderer='../templates/dossier/rdf_view.pt')
|
|
def rdf_rapport(request):
|
|
norapport = request.matchdict['no_id']
|
|
|
|
# lire le rapport
|
|
rapport = get_rapport_by_no_id(request, norapport)
|
|
nodossier = 'PL-' + str(rapport.nochantier)
|
|
|
|
if rapport.date_rapport:
|
|
date_rapport = rapport.date_rapport.strftime('%d-%m-%Y')
|
|
else:
|
|
date_rapport = ''
|
|
|
|
if rapport.date_relu:
|
|
date_relu = rapport.date_relu.strftime('%d-%m-%Y')
|
|
else:
|
|
date_relu = ''
|
|
|
|
# lire tous les photos attachées
|
|
photos = get_photos(request, rapport.nochantier, norapport)
|
|
|
|
return {
|
|
'page_title': '',
|
|
'url': '',
|
|
'pt_name': 'rdf_rapport',
|
|
'rapport': rapport,
|
|
'nodossier': nodossier,
|
|
'nochantier': rapport.nochantier,
|
|
'norapport': norapport,
|
|
'date_rapport': date_rapport,
|
|
'date_relu': date_relu,
|
|
'photos': photos,
|
|
'docs_url': request.static_url(request.registry.settings['mondumas.devfac_url']),
|
|
}
|
|
|
|
@view_config(route_name='rdf_imgdel', permission='view')
|
|
def rdf_imgdel(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
nochantier = request.matchdict['nochantier']
|
|
norapport = request.matchdict['norapport']
|
|
nomfic = request.matchdict['nomfic']
|
|
|
|
# supprimer le fichier
|
|
file_path = '%s/PL/%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'], nochantier, norapport, nomfic)
|
|
if os.path.exists(file_path):
|
|
os.remove(file_path)
|
|
|
|
delete_photos(request, nochantier, norapport, nomfic)
|
|
request.session.flash(u"La photo %s a été supprimé avec succès" % (nomfic), 'success')
|
|
return HTTPFound(location=request.route_url("upload_img", norapport=norapport))
|
|
|
|
@view_config(route_name='rdf_bill', renderer='../templates/dossier/rdf_bill.pt', permission='view')
|
|
def rdf_bill(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
norapport = request.matchdict['no_id']
|
|
url = request.route_url('rdf_bill', no_id=norapport)
|
|
|
|
# lire le rapport
|
|
rapport = get_rapport_by_no_id(request, norapport)
|
|
nodossier = 'PL-' + str(rapport.nochantier)
|
|
|
|
if not rapport.date_rapport:
|
|
request.session.flash(u"Le rapport n'a été encore généré. Facturation impossible", 'danger')
|
|
return HTTPFound(location=request.route_url('rdf_view', no_id=norapport))
|
|
|
|
# lire tous les articles RDF
|
|
articles = get_articles_by_fam(request, 'RDF')
|
|
article = 'RDF1'
|
|
|
|
if 'form.submitted' in request.params:
|
|
# lire article à facturer
|
|
article = request.params['article']
|
|
insert_facture_rdf(request, 'PL', rapport.nochantier, logged_in, article, rapport.date_rapport.strftime('%d-%m-%Y'))
|
|
|
|
request.session.flash("Le rapport a été généré avec succès.", 'success')
|
|
return HTTPFound(location=request.route_url('dossier_view', nodossier=nodossier))
|
|
|
|
return {
|
|
'page_title': "Générer une facture pour le rapport du %s" % (rapport.date_inter.strftime('%d-%m-%Y')),
|
|
'url': url,
|
|
'pt_name': 'rdf_view',
|
|
'logged_in': logged_in,
|
|
'rapport': rapport,
|
|
'nodossier': nodossier,
|
|
'nochantier': rapport.nochantier,
|
|
'norapport': norapport,
|
|
'articles': articles,
|
|
'article' : article,
|
|
}
|
|
|
|
@view_config(route_name='demandes', renderer='../templates/dossier/demandes.pt', permission='view')
|
|
def demandes(request):
|
|
logged_in = request.authenticated_userid.upper()
|
|
url = request.route_url('demandes')
|
|
|
|
# lire les demandes d'interventions arrivées par email
|
|
mbx_name = 'peinture-dumas@entreprise-dumas.com'
|
|
mbx_pwd = 'sasdumas'
|
|
conn = imaplib.IMAP4_SSL('imap.entreprise-dumas.com')
|
|
try:
|
|
# se connecter à la mailbox
|
|
conn.login(mbx_name, mbx_pwd)
|
|
except imaplib.IMAP4.error:
|
|
request.session.flash("ERREUR connexion au compte %s" % mbx_name, 'danger')
|
|
return HTTPFound(location=request.route_url('home'))
|
|
|
|
# lire le INBOX
|
|
rv, data = conn.select('INBOX', readonly =True)
|
|
|
|
liste=[]
|
|
# lire demandes de la MAIF
|
|
mbx_search = 'FROM gestionsinistre@maif.fr SUBJECT "Missionnement r"'
|
|
if 'form.submitted' in request.params:
|
|
demandes_generer(request, conn, mbx_name, mbx_search, liste, logged_in)
|
|
demandes_afficher(conn, mbx_name, mbx_search, liste)
|
|
|
|
# lire demandes de DOMUS
|
|
# mbx_search = 'FROM service.sinistres@domus-services.fr SUBJECT "Ordre de mission DOMUS - Dossier"'
|
|
# demandes_afficher(conn, mbx_name, mbx_search, liste)
|
|
|
|
conn.logout()
|
|
|
|
return {
|
|
'page_title': 'Liste des demandes pour la PEINTURE',
|
|
'url': url,
|
|
'dt_data': json.dumps(liste),
|
|
}
|
|
|
|
def demandes_afficher(conn, mbx_name, search_criteria, liste):
|
|
# créer la liste des entêtes des messages à afficher
|
|
rv, data = conn.search(None, search_criteria)
|
|
if rv != 'OK':
|
|
request.session.flash("ERREUR de lecture de la boîte de réception", 'danger')
|
|
return HTTPFound(location=request.route_url('home'))
|
|
|
|
mail_ids = data[0]
|
|
for num in mail_ids.split():
|
|
rv, msg_data = conn.fetch(num, '(RFC822)')
|
|
if rv != 'OK':
|
|
request.session.flash("ERREUR de lecture du message %s" % num, 'danger')
|
|
return HTTPFound(location=request.route_url('home'))
|
|
|
|
msg = email.message_from_bytes(msg_data[0][1])
|
|
hdr = email.header.make_header(email.header.decode_header(msg['Subject']))
|
|
email_subject = str(hdr)
|
|
email_from = email.utils.parseaddr(msg['from'])[1]
|
|
# Now convert to local date-time
|
|
date_tuple = email.utils.parsedate_tz(msg['Date'])
|
|
if date_tuple:
|
|
email_date = datetime.fromtimestamp(email.utils.mktime_tz(date_tuple))
|
|
else:
|
|
email_date = datetime.now()
|
|
|
|
d = (str(int(num)), email_date.strftime('%d-%m-%Y %H:%M:%S'), email_from, mbx_name.replace('entreprise-dumas.com', ''), email_subject)
|
|
liste.append(d)
|
|
return liste
|
|
|
|
def demandes_generer(request, conn, mbx_name, mbx_search, liste, logged_in):
|
|
|
|
def download_pdf_to_tmp(email_message):
|
|
# downloading attachments
|
|
for part in email_message.walk():
|
|
# this part comes from the snipped I don't understand yet...
|
|
if part.get_content_maintype() == 'multipart':
|
|
continue
|
|
if part.get('Content-Disposition') is None:
|
|
continue
|
|
fileName = part.get_filename()
|
|
if bool(fileName):
|
|
# copier le fichier PDF dans le dossier /tmp
|
|
filePath = os.path.join('/tmp/', fileName)
|
|
if not os.path.isfile(filePath) :
|
|
fp = open(filePath, 'wb')
|
|
fp.write(part.get_payload(decode=True))
|
|
fp.close()
|
|
return filePath
|
|
|
|
def convert_pdf_to_txt(path):
|
|
resource_manager = PDFResourceManager()
|
|
laparams = LAParams()
|
|
converter = PDFPageAggregator(resource_manager, laparams=laparams)
|
|
page_interpreter = PDFPageInterpreter(resource_manager, converter)
|
|
|
|
extracted_text = ""
|
|
with open(path, 'rb') as fh:
|
|
|
|
for page in PDFPage.get_pages(fh,
|
|
caching=True,
|
|
check_extractable=True):
|
|
page_interpreter.process_page(page)
|
|
# The converter renders the layout from interpreter
|
|
layout = converter.get_result()
|
|
# Out of the many LT objects within layout, we are interested in LTTextBox and LTTextLine
|
|
for lt_obj in layout:
|
|
if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):
|
|
extracted_text += lt_obj.get_text()
|
|
|
|
# close open handles
|
|
converter.close()
|
|
# ecrire le texte dans un fichier
|
|
extracted_file = '/tmp/log_file.txt'
|
|
with open(extracted_file, "w") as my_log:
|
|
my_log.write(extracted_text)
|
|
my_log.close()
|
|
|
|
return extracted_text, extracted_file
|
|
|
|
def generer_dossier(request, mbx_name, mbx_search, filepath, logged_in):
|
|
# parcourir les lignes pour retrouver les infos utiles
|
|
with open(filepath) as fp:
|
|
cnt = 1
|
|
line = fp.readline()
|
|
c_obs = ''
|
|
tx_trav = ''
|
|
while line:
|
|
if line.find('Nos références') == 0:
|
|
line = fp.readline()
|
|
line = fp.readline()
|
|
no_sinistre = line[:-1]
|
|
if line.find('Bénéficiaire des travaux :') == 0:
|
|
elt = line.split(' : ')
|
|
c_nom = elt[1][:-1]
|
|
line = fp.readline()
|
|
line = fp.readline()
|
|
line = fp.readline()
|
|
c_adr = line[:-1]
|
|
line = fp.readline()
|
|
c_adr2 = line[:-1]
|
|
line = fp.readline()
|
|
c_adr3 = line[:-1]
|
|
# début 3ème ligne adr est un code postal ?
|
|
if to_int(c_adr3[0:5]) > 0 :
|
|
# oui, mémoriser le code postal et la ville
|
|
c_cp = c_adr3[0:5]
|
|
c_ville = c_adr3[6:]
|
|
else:
|
|
# non, le code postal et la ville se trouvent dans la 2è ligne
|
|
c_cp = c_adr2[0:5]
|
|
c_ville = c_adr2[6:]
|
|
c_adr2 = ''
|
|
if line.find('N° de téléphone :') == 0:
|
|
# les 10 derniers caratères
|
|
c_tel1 = line[-11:-1]
|
|
if 'une franchise de ' in line:
|
|
i1 = line.find('franchise de ')
|
|
i2 = line.find(' € ')
|
|
c_obs = line[i1:i2+2]
|
|
if ' pour un montant de ' in line:
|
|
i1 = line.find('pour un montant de ')
|
|
tx_trav = line[i1:-2].replace(',', '.')
|
|
|
|
# lire ligne suivante
|
|
line = fp.readline()
|
|
cnt += 1
|
|
|
|
# créer un dem_devis
|
|
insert_dossier(request, mbx_name, mbx_search, logged_in, c_nom, c_adr, c_adr2, c_cp, c_ville, c_tel1, no_sinistre, c_obs, tx_trav)
|
|
|
|
return
|
|
|
|
# rechercher les emails de demandes dans le INBOX
|
|
rv, data = conn.search(None, mbx_search)
|
|
if rv != 'OK':
|
|
request.session.flash("ERREUR de lecture de la boîte de réception", 'danger')
|
|
return HTTPFound(location=request.route_url('home'))
|
|
|
|
mail_ids = data[0]
|
|
for num in mail_ids.split():
|
|
rv, msg_data = conn.fetch(num, '(RFC822)')
|
|
if rv != 'OK':
|
|
request.session.flash("ERREUR de lecture du message %s" % num, 'danger')
|
|
return HTTPFound(location=request.route_url('home'))
|
|
|
|
raw_email = msg_data[0][1]
|
|
# converts byte literal to string removing b''
|
|
raw_email_string = raw_email.decode('utf-8')
|
|
email_message = email.message_from_string(raw_email_string)
|
|
|
|
email_subject = email_message['subject']
|
|
# demande annulée ?
|
|
if email_subject.find('Annulation ') < 0:
|
|
# downloading attachment
|
|
filePath = download_pdf_to_tmp(email_message)
|
|
|
|
# convertir le fichier pdf en texte
|
|
texte, extracted_file = convert_pdf_to_txt(filePath)
|
|
# mission annulée
|
|
if 'Objet : ANNULATION MISSION' in texte:
|
|
# supprime le pdf
|
|
os.remove(filePath)
|
|
else:
|
|
# genere le dossier d'après
|
|
generer_dossier(request, mbx_name, mbx_search, extracted_file, logged_in)
|
|
|
|
return
|