# -*- 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 pyramid_mailer.message import Message, Attachment
from datetime import *
from dateutil.relativedelta import *
from docutils.core import publish_parts
import hashlib

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 *

@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='infrastructure', renderer='../templates/parametres/infrastructure.pt', permission='manage')
def infrastructure(request):
    logged_in = request.authenticated_userid.lower()

    return {
            'page_title': "Infrastructure",
            '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 = ''
            
        if item.access == 5:
            role = 'Gestion'
        elif item.access == 8:
            role = 'Compta'
        elif item.access == 9:
            role = 'Admin'
        else:
            role = 'Production'
            
        d = (item.CD_UTI, item.NOM, item.email, item.agenda, role, 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 = ["0 | Production", "5 | Gestion", "8 | Comptabilité", "9 | Administration"]
    societes = ['PE','ME','PL','PO','CD'] 
    
    if cd_uti == '0':
        # nouveau
        individu = {}
        individu['CD_UTI'] = '0'
        individu['NOM'] = ''
        individu['email'] = ''
        individu['access'] = '0 | Production'
        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)

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

@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='stats_dd', renderer='../templates/parametres/stats_dd.pt', permission='view')
def stats_dd(request):

    societe = request.matchdict['societe']
    url = request.route_url('stats_dd', societe=societe)
    message = ''
    societes = ['PE','ME','PL','PO','CD'] 
    
    # prendre en compte les paramètres de saisie
    if 'societe' in request.params:
        societe = request.params["societe"]
        url = request.route_url('stats_dd', societe=societe)

    # lire les stats globales des demandes de devis
    stats_dd = get_stats_dd(request, societe)

    liste=[]
    # construire la liste 
    for item in stats_dd:
        d = (str(item.Annee), str(item.Created), str(item.Devis), str(item.Commande), str(item.Facture), str(item.ReglePart), 
             str(item.Regle), str(item.Total))
        liste.append(d)
            
    return {
        'page_title': "Stats : Demandes de devis",
        'url': url,
        'message': message,
        'dt_data': json.dumps(liste),
        'societes': societes,
        'societe': societe,
    }

@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
    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', 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='stats_delais', renderer='../templates/parametres/stats_delais.pt', permission='view')
def stats_delais(request):

    societe = request.matchdict['societe']
    url = request.route_url('stats_delais', societe = societe)

    datefin = date.today()
    # debut = aujourd'hui - 11 mois
    datedeb = datefin + relativedelta(months=-11)
    
    societes = ['PE','ME','PL']
    # si societe a été changé par le user
    if 'societe' in request.params:
        societe = request.params["societe"]
    
    # lire les groupes
    groupes = get_stats_delai_groupe(request, societe, datedeb, datefin)    
    
    # mémoriser le 1er de la liste
    groupe = groupes[0].group2
    
    # si groupe a été changé par le user
    if 'groupe' in request.params:
        groupe = request.params["groupe"]

    # lire les délais CONTACT du groupe
    items = get_stats_delais(request, societe, datedeb, datefin, groupe, 'delai_contact')
    barChart_annee1 = []
    barChart_annee1.append(('Mois', 'Moy. ' + groupe, {'role': 'annotation'}, { 'type':'string','role': 'tooltip'} , 'Moy. Dumas'))
    title1 = '1er CONTACT' 
    for item in items:
        # construire la liste pour donut cible
        tooltip = item.group1_lib + '\nMoyennne: -'+str(round(item.moyenne))+' j\nDossiers: '+str(round(item.population))        
        # ('+str(item.population)+')/n'
        d = (item.group1_lib[:3], round(item.moyenne), str(round(item.moyenne))+'j', tooltip, round(item.moy_ref))
        barChart_annee1.append(d)

    # lire les délais RENDEZ-VOUS du groupe
    items = get_stats_delais(request, societe, datedeb, datefin, groupe, 'delai_rdv')
    barChart_annee2=[]
    barChart_annee2.append(('Mois', 'Moy. ' + groupe, {'role': 'annotation'}, { 'type':'string','role': 'tooltip'} , 'Moy. Dumas'))
    title2 = '1er RENDEZ-VOUS' 
    for item in items:
        # construire la liste pour donut cible
        tooltip = item.group1_lib + '\nMoyennne: -'+str(round(item.moyenne))+' j\nDossiers: '+str(round(item.population))        
        # ('+str(item.population)+')/n'
        d = (item.group1_lib[:3], round(item.moyenne), str(round(item.moyenne))+'j', tooltip, round(item.moy_ref))
        barChart_annee2.append(d)
        
    # lire les délais DEVIS du groupe
    items = get_stats_delais(request, societe, datedeb, datefin, groupe, 'delai_devis')
    barChart_annee3=[]
    barChart_annee3.append(('Mois', 'Moy. ' + groupe, {'role': 'annotation'}, { 'type':'string','role': 'tooltip'} , 'Moy. Dumas'))
    title3 = '1er DEVIS' 
    for item in items:
        # construire la liste pour donut cible
        tooltip = item.group1_lib + '\nMoyennne: -'+str(round(item.moyenne))+' j\nDossiers: '+str(round(item.population))        
        # ('+str(item.population)+')/n'
        d = (item.group1_lib[:3], round(item.moyenne), str(round(item.moyenne))+'j', tooltip, round(item.moy_ref))
        barChart_annee3.append(d)

    # lire les délais FACTURE du groupe
    items = get_stats_delais(request, societe, datedeb, datefin, groupe, 'delai_facture')
    barChart_annee4 = []
    barChart_annee4.append(('Mois', 'Moy. ' + groupe, {'role': 'annotation'}, { 'type':'string','role': 'tooltip'} , 'Moy. Dumas'))
    title4 = '1ère FACTURE' 
    for item in items:
        # construire la liste pour donut cible
        tooltip = item.group1_lib + '\nMoyennne: -'+str(round(item.moyenne))+' j\nDossiers: '+str(round(item.population))        
        # ('+str(item.population)+')/n'
        d = (item.group1_lib[:3], round(item.moyenne), str(round(item.moyenne))+'j', tooltip, round(item.moy_ref))
        barChart_annee4.append(d)

    return {
        'page_title': "Indices de performances",
        'url': url,
        'barChart_annee1': json.dumps(barChart_annee1),
        'barChart_annee2': json.dumps(barChart_annee2),
        'barChart_annee3': json.dumps(barChart_annee3),
        'barChart_annee4': json.dumps(barChart_annee4),
        'title1': title1,
        'title2': title2,
        'title3': title3,
        'title4': title4,
        'societes': societes,
        'societe': societe,
        'groupes': groupes,
        'groupe': groupe,
        }

@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.bic, 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,
    }