# -*- 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

from PIL import Image
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
            
    # lire les chantiers
    chantiers = get_chantiers_byName(request, societe, name)
    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)

    if len(name) == 0 :
        order_option = 'desc'
    else:
        order_option = 'asc'
        
    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,
        'order_option': order_option,
    }

@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': "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 = "Devis no : %s" % (nodossier)
    elif type_doc == 'FA':
        page_title = "Facture no : %s" % (nodossier)
    else:
        page_title = "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= "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': "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 download dans le dossier /tmp
        input_file = request.POST['filename'].file
        input_name = request.POST['filename'].filename
        ext_allowed = ['jpeg','jpg','png','pdf']
        temp_file = downloadFile2Temp(input_file, input_name, ext_allowed)
        if temp_file[:8] == 'ERREUR: ':
            request.session.flash(temp_file, 'danger')
            return HTTPFound(location=url)  
        
        # fabriquer le nom du document
        filename = '%s-DD%s-%s' % (societe, nochantier, input_name)
        tempFile2Dossier(request, societe, nochantier, '0', temp_file, filename, 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': "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):
    def photos_size(photos):
        # calculer la taille totale des photos
        sum_size = 0
        for photo in photos :
            # récupère la taille sans ' Ko'
            sum_size += int(photo.taillefichier[:-3])
        
        return '%s Mo' % round(sum_size / 1024, 1)
    
    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 download dans le dossier /tmp
        input_file = request.POST['filename'].file
        input_name = request.POST['filename'].filename  
        ext_allowed = ['jpeg','jpg','png']
        temp_file = downloadFile2Temp(input_file, input_name, ext_allowed)
        if temp_file[:8] == 'ERREUR: ':
            request.session.flash(temp_file, 'danger')
            return HTTPFound(location=url)            
        
        # fabriquer le nom du rapport
        filename = '%s-RDF%s-%s' % (societe, norapport, input_name)
        tempFile2Dossier(request, societe, nochantier, norapport, temp_file, filename, 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': "Gérer les photos",
        'url': url,
        'nochantier': nochantier,
        'norapport': norapport,
        'rapport': rapport,
        'photos': photos,
        'total_size' : photos_size(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:
        if 'signature_svg' in request.params: 
            if len(request.params['signature_svg']) > 7000:
                request.session.flash(u"La signature est trop grande !", 'danger')
                return HTTPFound(location=url)
            
        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': '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')
    
    societes = ['PE','ME','PL'] 
    societe = 'PE'
    # prendre en compte les paramètres de saisie
    if 'societe' in request.params:
        societe = request.params["societe"]

    # sélection du mailbox selon la societe
    if societe == 'PE':
        mbx_name = 'peinture-dumas@entreprise-dumas.com'
        mbx_pwd = 'sasdumas'
    elif societe == 'ME':
        mbx_name = 'menuiserie-dumas@entreprise-dumas.com'
        mbx_pwd = 'sasdumas'
    elif societe == 'PL':
        mbx_name = 'versanit-dumas@entreprise-dumas.com'
        mbx_pwd = 'sasdumas'
    else:
        mbx_name = 'polynet-dumas@entreprise-dumas.com'
        mbx_pwd = 'sasdumas'
    
    # lire les demandes d'interventions arrivées par email 
    mbx_search1 = 'FROM gestionsinistre@maif.fr SUBJECT "Missionnement r"' 
    mbx_search2 = 'FROM service.sinistres@domus-services.fr SUBJECT "Ordre de mission DOMUS - Dossier"' 
    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)
    
    # if 'form.submitted' in request.params:
        # traiter les demandes de la MAIF puis de DOMUS
        # demandes_generer(request, conn, societe, mbx_search1)
        # demandes_generer(request, conn, societe, mbx_search2)
        
    liste=[]
    # lire les demandes de la MAIF puis de DOMUS
    demandes_afficher(conn, mbx_name, mbx_search1, liste)            
    demandes_afficher(conn, mbx_name, mbx_search2, liste) 
    # messages lus
    msglus = bool(liste)
    conn.logout()
    
    return {
        'page_title': 'Liste des demandes pour la société ' + societe,
        'url': url,
        'societe': societe,
        'societes': societes,
        'dt_data': json.dumps(liste),
        'msglus': msglus,
    }

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, societe, mbx_search):
    
    def generer_mission(request, societe, mbx_search, extracted_file, temp_file_path):
        
        if 'maif.fr' in mbx_search:
            # extraire les infos de la demmande MAIF
            dem_info = get_pdf_infos1(extracted_file)
            if societe == 'PE':
                cd_cli = 2813
            elif societe == 'ME':
                cd_cli = 3428
            else:
                # VERSANIT
                cd_cli = 1743
        elif 'domus-services.fr' in mbx_search:
            # extraire les infos de la demmande DOMUS
            dem_info = get_pdf_infos2(extracted_file)
            if societe == 'PE':
                cd_cli = 8991
            elif societe == 'ME':
                cd_cli = 5276
            else:
                # VERSANIT
                cd_cli = 3209

        # extraction OK ? oui, créer une dem_devis et récupèrer son no_id
        if dem_info['c_nom'] != '':
            nochantier = insert_dossier(request, societe, cd_cli, dem_info['c_nom'], dem_info['c_adr'], dem_info['c_adr2'], \
                                        dem_info['c_cp'], dem_info['c_ville'], dem_info['c_telp'], dem_info['no_sinistre'], dem_info['c_obs'], dem_info['tx_trav'])
            nodossier = "%s-%s" % (societe, nochantier)
            
            # récupère le nom du fichier et ajouter le no de dossier
            filename = os.path.basename(temp_file_path)
            filename = '%s-DD%s-%s' % (societe, nochantier, filename)
            tempFile2Dossier(request, societe, nochantier, '0', temp_file_path, filename, 'AUTO')
             
        return
    
    def generer_annulation1(request, societe, extracted_file, temp_file_path):
        
        # extraire les infos de la demmande MAIF
        dem_info = get_pdf_infos1(extracted_file)
        import pdb;pdb.set_trace()
        # extraction OK ? oui, rechercher la dem_devis concerné
        if dem_info['c_nom'] != '':
            # oui, rechercher la dem_devis concerné par le no de sinistre
            dem_devis = get_dossier_by_sinistre(request,societe, nosin)
            nodossier = "%s-%s" % (societe, dem_devis.NO_ID)
            
            # récupère le nom du fichier et ajouter le no de dossier
            filename = '%s-DD%s-%s' % (societe, dem_devis.NO_ID, 'ANNULATION.pdf')
            tempFile2Dossier(request, societe, dem_devis.NO_ID, '0', temp_file_path, filename, 'AUTO')
            # insérer une ligne de suivi ANNULATION
            insert_suivi(request, nodossier, '!!MISSION ANNULEE PAR la MAIF')
        return

    def generer_annulation2(request, societe, nosin, temp_file_path):
        
        # oui, rechercher la dem_devis concerné par le no de sinistre
        dem_devis = get_dossier_by_sinistre(request,societe, nosin)
        nodossier = "%s-%s" % (societe, dem_devis.NO_ID)
        
        # récupère le nom du fichier et ajouter le no de dossier
        filename = '%s-DD%s-%s' % (societe, dem_devis.NO_ID, 'ANNULATION.pdf')
        tempFile2Dossier(request, societe, dem_devis.NO_ID, '0', temp_file_path, filename, 'AUTO')
        # insérer une ligne de suivi ANNULATION
        insert_suivi(request, nodossier, '!!MISSION ANNULEE PAR DOMUS')
        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)

        # get the message's body
        body = ''
        for part in email_message.walk():
            ctype = part.get_content_type()
            cdispo = str(part.get('Content-Disposition'))
    
            # skip any text/plain (txt) attachments
            if ctype == 'text/html' and 'attachment' not in cdispo:
                body = part.get_payload(decode=True)  # decode
                break
        # downloading attachment
        temp_file_path = download_pdf_to_tmp(email_message)

        # convertir le fichier pdf en texte
        texte, extracted_file = pdf_convert_to_txt(temp_file_path)
        
        # mission annulée ?
        if 'Objet : ANNULATION MISSION' in texte :
            # genere ANNULATION mission MAIF
            generer_annulation1(request, societe, extracted_file, temp_file_path)
        elif 'ANNULATION ORDRE DE MISSION' in texte:
            import pdb;pdb.set_trace()
            # genere ANNULATION mission DOMUS
            nosin = str(body)[84:95]
            generer_annulation2(request, societe, nosin, temp_file_path)
        else:
            # genere le dossier d'après le mail
            generer_mission(request, societe, mbx_search, extracted_file, temp_file_path)
    
    return 

def resize_photos(image_file):
    # using the Python Image Library (PIL) to resize an image
    img_org = Image.open(image_file)
    # get the size of the original image
    width_org, height_org = img_org.size
    # set the resizing factor so the aspect ratio can be retained
    # factor > 1.0 increases size
    # factor < 1.0 decreases size
    factor = 1
    width = int(width_org * factor)
    height = int(height_org * factor)
    # best down-sizing filter
    img_anti = img_org.resize((width, height), Image.ANTIALIAS)
    # split image filename into name and extension
    name, ext = os.path.splitext(image_file)
    # create a new file name for saving the result
    img_anti.save(image_file)

    return 

def downloadFile2Temp(input_file, input_name, ext_allowed):
    # récupère son extension
    input_extension = input_name.split('.')[-1]  
    
    # extensions autorisées ?
    if input_extension.lower() not in ext_allowed :
        return "ERREUR: Le format du fichier n'est pas valide. Téléchargement impossible."
    
    # Finally write the data to a temporary file
    temp_file_path = os.path.join('/tmp/', input_name)
    # supprimer le fichier s'il existe déjà
    if os.path.exists(temp_file_path):
        os.remove(temp_file_path)

    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)            
        return "ERREUR: La taille du fichier dépasse la limite autorisée. Téléchargement impossible."
    
    if input_extension in ['jpeg','jpg','png']:
        # using the Python Image Library (PIL) to resize an image
        resize_photos(temp_file_path)
                
    return temp_file_path

def tempFile2Dossier(request, societe, nochantier, norapport, temp_file, filename, logged_in):
    # créer le répertoire du chantier 
    if norapport == '0':
        path = '%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'], societe, nochantier)
    else:
        path = '%s/%s/%s/%s' % (request.registry.settings['mondumas.devfac_dir'], societe, nochantier, norapport)
    os.makedirs(path, exist_ok=True)
    
    filepath = os.path.join('%s/%s' % (path, filename))
    # supprimer le fichier s'il existe déjà
    if os.path.exists(filepath):
        os.remove(filepath)
    
    # Finally move the temporary file to folder
    shutil.move(temp_file, filepath)
        
    filesize = round(os.path.getsize(filepath) / 1024)
    insert_dossier_attaches(request, '%s-%s' % (societe, nochantier), norapport, filename, '%s Ko' % str(filesize), 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
            temp_file_path = os.path.join('/tmp/', fileName)
            if not os.path.isfile(temp_file_path) :
                fp = open(temp_file_path, 'wb')
                fp.write(part.get_payload(decode=True))
                fp.close()
    return temp_file_path

def pdf_convert_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()
    fh.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 get_pdf_infos1(extracted_file):
    # à partir du fichier texte du pdf
    # parcourir les lignes pour retrouver les infos utiles
    with open(extracted_file) as fp:
        cnt = 1
        line = fp.readline()
        # première ligne doit être "MAIF"
        if line[:-1] != 'MAIF':
            return {'c_nom': ''}
        
        c_obs = ''
        tx_trav = ''
        c_telp = ''
        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 ' téléphone : ' in line:
                # 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 montsant de ')
                tx_trav = line[i1:-2].replace(',', '.')
                
            # lire ligne suivante
            line = fp.readline()
            cnt += 1
            
    fp.close()
    return {'c_nom': c_nom,
            'c_adr': c_adr,
            'c_adr2': c_adr2,
            'c_cp': c_cp,			
            'c_ville': c_ville,			
            'c_telp': c_telp,
            'c_obs': c_obs,
            'tx_trav': tx_trav,
            'no_sinistre': no_sinistre,			
            }

def get_pdf_infos2(extracted_file):
    # à partir du fichier texte du pdf de DOMUS
    # parcourir les lignes pour retrouver les infos utiles
    with open(extracted_file) as fp:
        cnt = 1
        line = fp.readline()
        import pdb;pdb.set_trace()
        # première ligne doit être :
        if line[:-1] != 'ORDRE DE MISSION':
            fp.close()
            return {'c_nom': ''}
        
        c_obs = ''
        tx_trav = ''
        c_telp = ''
        while line:
            if line.find('SINISTRE N°') == 0:
                line = fp.readline()
                line = fp.readline()
                no_sinistre = line[:-1]
            if line.find('Adresse du sinistre :') == 0:
                line = fp.readline()
                c_nom = line[:-1]
                line = fp.readline()
                c_adr = line[:-1]
                line = fp.readline()
                c_adr2 = line[:-1]
                # début 2ème ligne adr est un code postal ?
                if to_int(c_adr2) > 0 :
                    # oui, mémoriser le code postal et la ville
                    c_cp = c_adr2
                    line = fp.readline()
                    c_ville = line[:-1]
                    c_adr2 = ''
                else:
                    # non, le code postal et la ville se trouvent dans la 3è ligne
                    line = fp.readline()
                    c_cp = line[:-1]
                    c_ville = line[:-1]
                line = fp.readline()
            if 'Gsm : ' in line:
                # les 10 derniers caratères
                c_telp = line[-11:-1]
                
            # lire ligne suivante
            line = fp.readline()
            cnt += 1
            
    fp.close()
    return {'c_nom': c_nom,
            'c_adr': c_adr,
            'c_adr2': c_adr2,
            'c_cp': c_cp[:5],			
            'c_ville': c_ville,			
            'c_telp': c_telp,
            'c_obs': c_obs,
            'tx_trav': tx_trav,
            'no_sinistre': no_sinistre,			
            }