# -*- 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.httpexceptions import (
    HTTPFound,
    HTTPNotFound,
    HTTPForbidden,
)

from datetime import *
from dateutil.relativedelta import *
from docutils.core import publish_parts

from sqlalchemy.exc import DBAPIError
from ..security import groupfinder

import json

from ..models.parametres import *
from ..models.default import *
from ..models.utils import *
from ..views.default import *
from ..views.dossier import *

@view_config(route_name='parametres', renderer='../templates/parametres/parametres.pt', permission='manage')
def parametres(request):
    logged_in = request.authenticated_userid.upper()

    return {
            'page_title': "Paramètres",
            'logged_in': logged_in,
        }



@view_config(route_name='users', renderer='../templates/parametres/users.pt', permission='manage')
def users(request):
    # lire les utilisateurs 
    items = get_member_by_id(request, '0')

    # construire la liste 
    liste=[]
    for item in items:           
        if item.actif == 0:
            etat = 'Inactif'
        else:
            etat = ''
                        
        d = (item.CD_UTI, item.NOM, item.email, item.agenda, item.libelle, item.societe, 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_member_by_id(request, '0')

    # construire la liste 
    liste=[]
    for item in items:
        # utilisateur a au moins une connexion ?
        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.ua_string)
            liste.append(d)

    return {
        'page_title': 'Liste des connexions',
        'dt_data': json.dumps(liste),
    }

@view_config(route_name='connecter_a', permission='manage')
def connecter_a(request):
    # paramètre fourni ?
    login = request.matchdict["login"]
    if len(login) > 0:
        request.session.invalidate()
        headers = forget(request)
        headers = remember(request, login)
        return HTTPFound(location="/", headers=headers)
    else:
        return HTTPFound(location="/")

@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 = get_p_acces(request)
    societes = ['PE','ME','PL','PO','CD'] 
    
    if cd_uti == '0':
        # nouveau
        individu = {}
        individu['CD_UTI'] = '0'
        individu['NOM'] = ''
        individu['email'] = ''
        individu['access'] = 0
        individu['actif'] = 1
        individu['agenda'] = ''
        individu['societe'] = ''
        page_title= 'Nouvelle Fiche'
        lienmdp = ''
    else:
        # lire la fiche de l'individu 
        individu = get_member_by_id(request, cd_uti)
        if not individu:
            request.session.flash(u"Utilisateur non trouvé : %s" % cd_uti, 'warning')
            return HTTPFound(location=request.route_url('users'))
        page_title= "Fiche de %s" %(individu.NOM)
        lienmdp = '%s/%s' % (individu.CD_UTI, date.today().strftime('%d%m%Y'))

    if 'form.submitted' in request.params:
        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

        if new_values:            
            update_membre(request, cd_uti, new_values)
            request.session.flash(u"La fiche a été mise à jour avec succès.", 'success')
            return HTTPFound(location=request.route_url('users'))

    if 'form.deleted' in request.params:
        delete_membre(request, cd_uti)
        request.session.flash(u"La fiche a été supprimée avec succès.", 'success')
        return HTTPFound(location=request.route_url('users'))
    
    return {
        'page_title': page_title,
        'url': url,
        'individu': individu,
        'access': access,
        'societes': societes,
        'message': message,
        'lienmdp': lienmdp,
    }

@view_config(route_name='dashboard', renderer='../templates/parametres/dashboard.pt', permission='manage')
def dashboard(request):
    
    # lire le log de nuit
    log_nuit = get_log_nuit(request)
    # lire les dernières modifs dans tables
    last_modified = get_last_modified(request)

    return {
        'page_title': "Tableau de bord",
        'log_nuit': log_nuit,
        'last_modified': last_modified,
        }

@view_config(route_name='rappels_rdv', renderer='../templates/parametres/rappels_rdv.pt', permission='manage')
def rappels_rdv(request):

    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')

    if 'form.emailing' in request.params:
        notifier_rappels(request)
        request.session.flash(u"Les rappels ont été envoyés par email avec succès.", 'success')

    # lires les rappels générés
    items = get_rappels_rdv(request)

    # construire la liste des RDV
    nbRappels = 0
    liste=[]
    for item in items:
        if item.rdv_date:
            resa_date = item.rdv_date.strftime('%d-%m-%Y')
        else:
            resa_date = ""
            
        if item.envoye_le:
            envoye_le = item.envoye_le.strftime('%d-%m-%Y %H:%M')
        else:
            envoye_le = ""
            nbRappels += 1
                             
        d = (resa_date, '%s-%s' % (item.societe, item.nochantier), item.nompren, item.email, item.rdv_statut, envoye_le, item.cree_le.strftime('%d-%m-%Y %H:%M'))
        liste.append(d)

    return {
        'page_title': 'Derniers rappels de RDV',
        'dt_data': json.dumps(liste),
        'url': request.route_url('rappels_rdv'),
        'nbRappels': nbRappels,
    }


@view_config(route_name='rdf_causes', renderer='../templates/parametres/rdf_causes.pt', permission='manage')
def rdf_causes(request):
    
    # lire les causes des RDF 
    items = get_rdf_causes_by_id(request, '0')

    # construire la liste 
    liste=[]
    for item in items:
        modif_le = item.modif_le.strftime('%d/%m/%Y - %H:%M')
        d = (item.code, item.libelle, modif_le)
        liste.append(d)

    return {
        'page_title': 'RDF : Liste des causes de fuite',
        'dt_data': json.dumps(liste),
    }

@view_config(route_name='rdf_cause_edit', renderer='../templates/parametres/rdf_cause_edit.pt', permission='manage')
def rdf_cause_edit(request):
    
    logged_in = request.authenticated_userid    
    old_code = request.matchdict['code']
    url = request.route_url("rdf_cause_edit", code=old_code)

    message = ''
    if old_code == '0':
        # nouveau
        cause = {}
        cause['code'] = ''
        cause['libelle'] = ''
        cause['modif_le'] = datetime.now()
        page_title= 'Nouvelle cause de fuite'
    else:
        page_title= "Modification de %s" % (old_code)
        # lire la cause
        cause = get_rdf_causes_by_id(request, old_code)
        if not cause:
            request.session.flash(u"Cause non trouvée : %s" % old_code, 'warning')
            return HTTPFound(location=request.route_url('rdf_causes'))

    if 'form.submitted' in request.params:
        code = request.params['code']
        libelle = request.params['libelle']

        update_rdf_cause(request, old_code, code, libelle)
        request.session.flash(u"La cause a été mise à jour avec succès.", 'success')
        return HTTPFound(location=request.route_url('rdf_causes'))

    if 'form.deleted' in request.params:
        delete_rdf_cause(request, old_code)
        request.session.flash(u"La cause a été supprimée avec succès.", 'success')
        return HTTPFound(location=request.route_url('rdf_causes'))

    return {
        'page_title': page_title,
        'url': url,
        'old_code': old_code,
        'cause': cause,
        'message': message,
    }


@view_config(route_name='text_list', renderer='../templates/parametres/text_list.pt', permission='manage')
def text_list(request):

    # lire toutes les text 
    texts = get_texts(request, 0) 

    return {
            'page_title': "Liste des textes",
            'texts': texts,
        }

@view_config(route_name='text_edit', renderer='../templates/parametres/text_edit.pt', permission='manage')
def text_edit(request):
    text_id = request.matchdict['text_id']    
    url = request.route_url('text_edit',text_id=text_id)

    message = ""
    if text_id == '0':
        titre = "Nouvelle text"
        intitule = ""
        texte = ""
        theme = ""
    else:
        titre = "Modifier la text : %s" % str(text_id)
        text = get_texts(request, text_id)
        intitule = text.intitule
        texte = text.texte
        theme = text.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_text(request, text_id, intitule, texte, theme)
            if text_id == '0':
                # si creation text, retour à la liste des texts
                return HTTPFound(location=request.route_url('text_list'))
            else:
                return HTTPFound(location=request.route_url('text_view', text_id=text_id))
        else:
            message = "Veuillez saisir un intitule et un texte."

    if 'form.deleted' in request.params:
        if text_id != '0':
            delete_text(request, text_id)
            request.session.flash("'%s' a été supprimée avec succès." % intitule, 'success')
            return HTTPFound(location=request.route_url('text_list'))

    return {
        'page_title': titre,
        'url': url,
        'message': message,
        'text_id': text_id,
        'intitule': intitule,
        'texte': texte,
        'theme': theme,
        'themes': ["EMAIL","INTERNE"],
    }

@view_config(route_name='text_view', renderer='../templates/parametres/text_view.pt')
def text_view(request):
    text_id = request.matchdict['text_id']    
    current_route_path = request.current_route_path()

    text = get_texts(request, text_id)
    intitule = text.intitule
    # insèrer le path de static/img
    img_path = '%s/static/img/' % request.application_url

    texte = text.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,
        'text_id': text_id,
    }

@view_config(route_name='articles', renderer='../templates/parametres/articles.pt', permission='manage')
def articles(request):

    familles = ["Article", "Texte"]
    famille = 'ARticle'

    # si table a changé
    if 'famille' in request.params:
        famille = request.params["famille"]

    # lire les articles 
    items = get_articles_byFam(request, famille[0])
    
    # construire la liste 
    liste=[]
    for item in items:       
        d = (item.REF, item.LIBART, item.LIBCOMPL1, to_euro(item.PRIXHT1), to_euro(item.PRIXHT2), item.ref_cli1, item.ref_cli2)
        liste.append(d)

    return {
        'page_title': 'Liste des articles',
        'dt_data': json.dumps(liste),
        'familles': familles,
        'famille': famille,
    }

@view_config(route_name='article_edit', renderer='../templates/parametres/article_edit.pt', permission='manage')
def article_edit(request):
    ref = request.matchdict['ref']
    url = request.route_url('article_edit', ref=ref)
    logged_in = request.authenticated_userid.upper()
    # modification d'article temporairement désactivé
    # if logged_in != 'CAO':
    #     return HTTPFound(location=request.route_url('articles'))

    message = ''
    
    familles = ["Article", "Texte"]
    
    if ref == '0':
        # nouveau
        item = {}
        item['REF'] = '0'
        item['FAM'] = 'A'
        item['LIBART'] = ''
        item['PRIXHT1'] = 0
        item['PRIXHT2'] = 0
        item['ref_cli1'] = ''
        item['ref_cli2'] = ''
        item['LIBCOMPL1'] = ''
        item['LIBCOMPL2'] = ''
        item['LIBCOMPL3'] = ''
        item['LIBCOMPL4'] = ''
        page_title= 'Nouvel article'
    else:
        # lire l'article 
        item = get_article(request, ref)
        if not item:
            request.session.flash("article non trouvé : %s" % ref, 'warning')
            return HTTPFound(location=request.route_url('articles'))
        page_title= "article : %s - %s" %(item.REF, item.LIBART)
        
    if 'form.submitted' in request.params:
        new_ref = request.params["REF"]
        if new_ref == '0':
            message = "Veuillez saisir un code article 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_article(request, ref, new_values)
                request.session.flash("Le article a été mis à jour avec succès.", 'success')
                return HTTPFound(location=request.route_url('articles'))

    if 'form.deleted' in request.params:
        delete_article(request, ref)
        request.session.flash("Le article a été supprimé avec succès.", 'success')
        return HTTPFound(location=request.route_url('articles'))
    
    return {
        'page_title': page_title,
        'url': url,
        'message': message,
        'item': item,
        'familles': familles,
    }

@view_config(route_name='cabinets', renderer='../templates/parametres/cabinets.pt', permission='view')
def cabinets(request):
    
    # lire les CABINETS
    items = get_cabinets_by_id(request, '0')
    
    # construire la liste 
    liste=[]
    for item in items:
        modif_le = item.modif_le.strftime('%d/%m/%Y')
        d = (item.CODE, item.NOM, item.TEL1, item.TEL2, item.TELP, item.VILLE, str(item.afficher), modif_le)
        liste.append(d)


    return {
        'page_title': 'Liste des cabinets',
        'dt_data': json.dumps(liste),
    }

@view_config(route_name='cabinet_edit', renderer='../templates/parametres/cabinet_edit.pt', permission='view')
def cabinet_edit(request):
    
    logged_in = request.authenticated_userid    
    # lire la fiche de l'utilisateur
    member = get_member_by_id(request, logged_in)
    access = member.access 
    if access < 5:
        request.session.flash(u"Vous n'êtes pas autorisé à modifier les cabinets", 'danger')
        return HTTPFound(location=request.route_url('cabinets'))
    
    code = request.matchdict['code']
    url = request.route_url("cabinet_edit", code=code)

    message = ''
    if code == '0':
        # nouveau
        cabinet = {}
        cabinet['NOM'] = ''
        cabinet['TEL1'] = ''
        cabinet['TEL2'] = ''
        cabinet['TELP'] = ''
        cabinet['ADRESSE'] = ''
        cabinet['ADRESSE2'] = ''
        cabinet['VILLE'] = ''
        cabinet['afficher'] = 1
        cabinet['modif_le'] = datetime.now()
        page_title= 'Nouveau cabinet'
        code_postal = '69001 - LYON'
        experts = []
    else:
        # lire cabinets
        cabinet = get_cabinets_by_id(request, code)
        if not cabinet:
            request.session.flash(u"Cabinet non trouvé : %s" % code, 'warning')
            return HTTPFound(location=request.route_url('cabinets'))

        page_title= "Modification de %s" % (cabinet.NOM)
        code_postal = '%s - %s' % (cabinet.CP, cabinet.VILLE)
        experts = get_experts_by_id(request, cabinet.CODE, '0')

    if 'form.submitted' in request.params:
        new_values = {}
        for param, db_value in cabinet.items():
            if param in request.params and request.params[param] != db_value:
                new_values[param] = request.params[param]
                    
        # controle saisie code postal
        code_postal =  request.params['code_postal']
        cp = code_postal.split(' - ')
        if len(cp) < 2:
            message = 'Code postal invalide. Veuillez sélectionner un parmi la liste.'
        else:
            new_values['CP'] = cp[0]
            new_values['VILLE'] = cp[1]

        # afficher coché ?
        if 'afficher' in request.params: 
            new_values['afficher'] = 1
        else:
            new_values['afficher'] = 0
            
        if new_values:            
            update_cabinet(request, code, new_values)
            request.session.flash(u"Le cabinet a été mis à jour avec succès.", 'success')
            return HTTPFound(location=request.route_url('cabinets'))
        

    if 'form.deleted' in request.params:
        delete_cabinet(request, code)
        request.session.flash(u"Le cabinet a été supprimé avec succès.", 'success')
        return HTTPFound(location=request.route_url('cabinets'))

    return {
        'page_title': page_title,
        'url': url,
        'cabinet': cabinet,
        'code': code,
        'experts': experts,
        'code_postal': code_postal,
        'message': message,
    }

@view_config(route_name='expert_edit', renderer='../templates/parametres/expert_edit.pt', permission='view')
def expert_edit(request):
    
    logged_in = request.authenticated_userid    
    # lire la fiche de l'utilisateur
    member = get_member_by_id(request, logged_in)
    access = member.access 
    if access < 5:
        request.session.flash(u"Vous n'êtes pas autorisé à modifier les experts", 'danger')
        return HTTPFound(location=request.route_url('cabinets'))

    code_cab = request.matchdict['code_cab']
    code_exp = request.matchdict['code_exp']
    url = request.route_url("expert_edit", code_cab=code_cab, code_exp=code_exp)

    message = ''
    if code_exp == '0':
        # nouveau
        expert = {}
        expert['CODE_CAB'] = code_cab
        expert['CODE_EXP'] = code_exp
        expert['NOM'] = ''
        expert['TEL1'] = ''
        expert['TEL2'] = ''
        expert['email'] = ''
        expert['en_activite'] = 1
        expert['modif_le'] = datetime.now()
        page_title= 'Nouveau expert'
    else:
        # lire experts
        expert = get_experts_by_id(request, code_cab, code_exp)
        if not expert:
            request.session.flash(u"expert non trouvé : %s" % code_exp, 'warning')
            return HTTPFound(location=request.route_url("cabinet_edit", code=code_cab))

        page_title= "Modification de %s" % (expert.NOM)

    if 'form.submitted' in request.params:
        new_values = {}
        for param, db_value in expert.items():
            if param in request.params and request.params[param] != db_value:
                new_values[param] = request.params[param]

        # en_activite coché ?
        if 'en_activite' in request.params: 
            new_values['en_activite'] = 1
        else:
            new_values['en_activite'] = 0
            
        if new_values:            
            update_expert(request, code_cab, code_exp, new_values)
            request.session.flash(u"L'expert a été mis à jour avec succès.", 'success')
            return HTTPFound(location=request.route_url("cabinet_edit", code=code_cab))

    if 'form.deleted' in request.params:
        delete_expert(request, code_cab, code_exp)
        request.session.flash(u"L'expert a été supprimé avec succès.", 'success')
        return HTTPFound(location=request.route_url("cabinet_edit", code=code_cab))

    return {
        'page_title': page_title,
        'url': url,
        'expert': expert,
        'code_exp': code_exp,
        'message': message,
    }

@view_config(route_name='societes', renderer='../templates/parametres/societes.pt', permission='manage')
def societes(request):
    
    # lire les societes
    items = get_societes(request, '0')
    
    # construire la liste 
    liste=[]
    for item in items:
        modif_le = item.modif_le.strftime('%d/%m/%Y')
        d = (item.societe, item.NOM, item.email_from, item.TEL, item.email_cci, item.iban, modif_le)
        liste.append(d)


    return {
        'page_title': 'Liste des societes',
        'dt_data': json.dumps(liste),
    }

@view_config(route_name='societe_edit', renderer='../templates/parametres/societe_edit.pt', permission='manage')
def societe_edit(request):
    
    logged_in = request.authenticated_userid    
    code = request.matchdict['societe']
    url = request.route_url("societe_edit", societe=code)

    message = ''

    # lire societe
    societe = get_societes(request, code)
    if not societe:
        request.session.flash(u"Societe non trouvé : %s" % code, 'warning')
        return HTTPFound(location=request.route_url('societes'))

    code_postal = '%s - %s' % (societe.CP, societe.VILLE)

    if 'form.submitted' in request.params:
        new_values = {}
        for param, db_value in societe.items():
            if param in request.params and request.params[param] != db_value:
                new_values[param] = request.params[param]
                    
        # controle saisie code postal
        code_postal =  request.params['code_postal']
        cp = code_postal.split(' - ')
        if len(cp) < 2:
            message = 'Code postal invalide. Veuillez sélectionner un parmi la liste.'
        else:
            new_values['CP'] = cp[0]
            new_values['VILLE'] = cp[1]
            
        if new_values:            
            update_societe(request, code, new_values)
            request.session.flash(u"La societe a été mise à jour avec succès.", 'success')
            return HTTPFound(location=request.route_url('societes'))
        
    return {
        'page_title': "Modification de %s" % (societe.NOM),
        'url': url,
        'societe': societe,
        'code': code,
        'code_postal': code_postal,
        'message': message,
    }

@view_config(route_name='tarifs', renderer='../templates/parametres/tarifs.pt', permission='manage')
def tarifs(request):

    groupe = request.matchdict['groupe']
    groupes = ["AXA", "MAIF", "IMH", "TEXTE"]

    # si table a changé
    if 'groupe' in request.params:
        groupe = request.params["groupe"]

    # lire les articles 
    items = get_tarifs_byGroupe(request, groupe)
    
    # construire la liste 
    liste=[]
    for item in items:       
        d = (item.ref, item.famille, item.libelle[:100], to_euro(item.prixht), item.unite, item.modif_le.strftime("%d-%m-%Y"))
        liste.append(d)

    return {
        'page_title': 'Liste des tarifs',
        'dt_data': json.dumps(liste),
        'groupes': groupes,
        'groupe': groupe,
    }

@view_config(route_name='tarif_edit', renderer='../templates/parametres/tarif_edit.pt', permission='manage')
def tarif_edit(request):
    groupe = request.matchdict['groupe']
    ref = request.matchdict['ref']
    url = request.route_url('tarif_edit', groupe=groupe, ref=ref)
    logged_in = request.authenticated_userid
    message = ''
        
    if ref == '0':
        # nouveau
        item = {}
        item['groupe'] = groupe
        item['ref'] = '0'
        item['libelle'] = ''
        item['prixht'] = 0
        page_title= 'Nouveau tarif'
    else:
        # lire le tarif 
        item = get_tarif(request, groupe, ref)
        if not item:
            request.session.flash("Tarif non trouvé : %s" % ref, 'warning')
            return HTTPFound(location=request.route_url('tarifs', groupe=groupe))
        
        page_title= "Tarif : %s" %(item.ref)
        
    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]
                        
            if new_values:
                new_values['groupe'] = groupe
                update_tarif(request, ref, new_values)
                request.session.flash("Le tarif a été mis à jour avec succès.", 'success')
                return HTTPFound(location=request.route_url('tarifs', groupe=groupe))

    if 'form.deleted' in request.params:
        delete_tarif(request, ref)
        request.session.flash("Le article a été supprimé avec succès.", 'success')
        return HTTPFound(location=request.route_url('tarifs', groupe=groupe))
    
    return {
        'page_title': page_title,
        'url': url,
        'message': message,
        'item': item,
    }

@view_config(route_name='tarifs_import', renderer='../templates/parametres/tarifs_import.pt', permission='view')
def tarifs_import(request):
    """ 
    UPLOAD d'un tarif en fichier EXCEL
    
    """    
    import xlrd

    logged_in = request.authenticated_userid.upper()
    
    url = request.route_url("tarifs_import")
    message = ''

    groupes = ['AXA','MAIF', 'IMH']
    groupe = 'AXA'


    if 'form.submitted' in request.params:
        groupe = request.params["groupe"]
        
        # récupère le fichier download dans le dossier /tmp
        input_file = request.POST['filename'].file
        input_name = request.POST['filename'].filename
        ext_allowed = ['xls', 'xlsx']
        temp_file = downloadFile2Temp(input_file, input_name, ext_allowed)
        if temp_file[:8] == 'ERREUR: ':
            request.session.flash(temp_file, 'danger')
            return HTTPFound(location=url)  
        
        # readxl returns a pylightxl database that holds all worksheets and its data
        book = xlrd.open_workbook(temp_file)

        if groupe == "AXA":
            # lire la 1ère feuille et contôler que c'est fichier AXA
            sh = book.sheet_by_index(0)
            ctl_cellA1 = sh.cell_value(rowx=0, colx=0)
            if ctl_cellA1 != 'PEN_2_MISEEN':
                request.session.flash(temp_file + " -> Ce fichier ne semble pas être un tarif AXA", 'danger')
                return HTTPFound(location=url)  
                
            # import pdb;pdb.set_trace()
            for nsheet in range(book.nsheets):
                # pour chaque feuille dans le tableau XLS
                sh = book.sheet_by_index(nsheet)
                for rx in range(sh.nrows):
                    ref = sh.cell_value(rx, 0).strip()
                    # ligne ayant un ref de tarifs ?
                    if len(ref) >= 12 and len(ref) < 15 and ref[3]=='_':
                        new_values = {}
                        new_values['groupe'] = groupe
                        new_values['ref'] = ref
                        new_values['famille'] = ref[0:3]
                        libelle = sh.cell_value(rx, 1)
                        new_values['libelle'] = libelle.replace(' F+P    M²', '').replace('  F+P     U', '')
                        new_values['prixht'] = sh.cell_value(rx, 5)
                        # col Unité renseigné ?
                        if len(sh.cell_value(rx, 3)) > 0:
                            unite = sh.cell_value(rx, 3)
                        else:
                            if sh.cell_value(rx, 1).find(' M2'):
                                unite = 'M²'
                            else:
                                unite = 'U'
                        new_values['unite'] = unite           
                        update_tarif(request, '0', new_values)
        elif groupe == "MAIF":
            # lire la 1ère feuille et contôler que c'est fichier MAIF
            sh = book.sheet_by_index(0)
            ctl_cellA6 = sh.cell_value(rowx=5, colx=0)
            if ctl_cellA6 != 'PEN_01':
                request.session.flash(temp_file + " -> Ce fichier ne semble pas être un tarif MAIF", 'danger')
                return HTTPFound(location=url)  
                
            # import pdb;pdb.set_trace()
            for nsheet in range(book.nsheets):
                # pour chaque feuille dans le tableau XLS
                sh = book.sheet_by_index(nsheet)
                for rx in range(sh.nrows):
                    ref = sh.cell_value(rx, 0).strip()
                    # ligne ayant un ref de tarifs ?
                    if len(ref) >= 6 and len(ref) < 15 and ref[3]=='_':
                        new_values = {}
                        new_values['groupe'] = groupe
                        new_values['ref'] = ref
                        new_values['famille'] = ref[0:3]
                        libelle = sh.cell_value(rx, 1)
                        new_values['libelle'] = libelle.replace(' F+P    M²', '').replace('  F+P     U', '')
                        if sh.cell_type(rx, 5) == 2:
                            new_values['prixht'] = sh.cell_value(rx, 5)
                        # col Unité renseigné ?
                        if sh.cell_type(rx, 3) != 0:
                            unite = sh.cell_value(rx, 3)
                        else:
                            if sh.cell_value(rx, 1).find(' m2'):
                                unite = 'M²'
                            else:
                                unite = 'U'
                        new_values['unite'] = unite           
                        update_tarif(request, '0', new_values)
        elif groupe == "IMH":
            # lire la 1ère feuille et contôler que c'est fichier IMH
            sh = book.sheet_by_index(0)
            ctl_cellA1 = sh.cell_value(rowx=0, colx=0)
            if ctl_cellA1 != 'CO-FORI0':
                request.session.flash(temp_file + " -> Ce fichier ne semble pas être un tarif IMH", 'danger')
                return HTTPFound(location=url)  
                
            # import pdb;pdb.set_trace()
            for nsheet in range(book.nsheets):
                # pour chaque feuille dans le tableau XLS
                sh = book.sheet_by_index(nsheet)
                libCol, prixCol, unitCol = 1, 5, 2

                if nsheet > 73:
                    libCol, prixCol, unitCol = 2, 4, 3

                for rx in range(sh.nrows):
                    ref = ""
                    if sh.cell_type(rx, 0) != 2:
                        ref = sh.cell_value(rx, 0).strip()
                    # ligne ayant un ref de tarifs ?
                    if len(ref) >= 8 and len(ref) < 15 and (ref[2] == '-' or ref[3] == '-'):
                        new_values = {}
                        new_values['groupe'] = groupe
                        new_values['ref'] = ref

                        if ref[2] == '-':
                            new_values['famille'] = ref[0:2]
                        else:
                            new_values['famille'] = ref[0:3]

                        if '\n' in sh.cell_value(rx, libCol) and nsheet < 73:
                            libelleSP = sh.cell_value(rx, libCol).split('\n') # split string with \n as separator if it exists

                            if libelleSP[1][0] == '(':
                                libelle = ' '.join(libelleSP[2:]) # if the first character of the second elt is '(' then we remove it
                            else:
                                libelle = ' '.join(libelleSP[1:])
                        else:
                            libelle = sh.cell_value(rx, libCol)
                        
                        if len(libelle) > 400:
                            new_values['libelle'] = 'DATA TOO LONG ! SEE THE ADMIN FOR FURTHER INFOS'
                        else:
                            new_values['libelle'] = libelle

                        unit = sh.cell_value(rx, unitCol)
                        if unit == 'DEVIS' or 'FORFAIT URGENCE' in unit: 
                            new_values['prixht'] = 0
                        else:
                            if sh.cell_type(rx, prixCol) != 2:
                                new_values['prixht'] = 0
                            else:
                                new_values['prixht'] = sh.cell_value(rx, prixCol)
                        # col Unité renseigné ?
                        if 'FORFAIT URGENCE' in unit:
                            unit = 'F. URG.'
                        new_values['unite'] = unit
                        update_tarif(request, '0', new_values)

        
        request.session.flash("Le fichier PDF a été importé avec succès.", 'success')
        return HTTPFound(location=url)
                
    return {
        'page_title': 'Importer un fichier Tarifs en Excel',
        'url': url,
        'message': message,
        'groupes': groupes,
        'groupe': groupe,
    }