whos.py

#!/bin/bash /usr/scripts/python.sh
# -*- coding: utf-8 -*-

# Copyright (C) Frédéric Pauget
# Licence : GPLv2

u"""Ce script permet de recherche et d'afficher le détail d'une machine ou
d'un adhérent.

Usage: %(prog)s [options] <chaine de recherche>

La chaine de recherche peut être :
    * soit un terme unique, dans ce cas la recherche sera effectuée sur les
champs en bleu ci-dessous.
    * soit du type "champ1=valeur1&champ2!=valeur2 ...", les résultats seront
alors limités aux entrées correspondantes à tous les critères.

Les champs de recherche possibles sont :
%(champs_rech)s

Recherche sur prise possible (utiliser uniquement ce champ dans ce cas).

Les options de recherches sont :
   * limitations sur l'affichage :
        -a ou --adherent : limitation de l'affichage aux adhérents
        -m ou --machine : limitation de l'affichage aux machines
        -c ou --club : limitation de l'affichage aux clubs
        -b ou --bornes : limitation de l'affichage aux bornes wifi
        --crans : recherche uniquement les machines du crans
   * options d'affichage :
        -t ou --tech : affichages des infos techniques des machines
à la place des infos administratives dans les résumés.
        -i ou --ipsec : montre la clef wifi (anciennement ipsec) des machines wifi
        -l <num> ou --limit=<num> : limite du nombre de résultats pour utiliser
le mode d'affichage condensé au lieu du mode détaillé (défaut %(limit_aff_details)i)
        -L <num> ou --limit-historique=<num> : limitation du nombre de lignes
d'historique affichées (défaut %(limit_aff_historique)i)
        -d <num> ou --limit-blacklist=<num> : limitation du nombre de lignes
d'historique des déconnexions affichées (défaut %(limit_aff_blacklist)i)
        -s ou --ssh : affiche les fingerprint ssh des machines
        --servers : limite les résultats aux servers
        --adm : limite les résultats aux machines adm
        -6 ou --ipv6 : affiche les ipv6 dans l'affichage synthétique
"""

import commands
import getopt
import subprocess
import sys
from time import strftime, localtime, time

from affich_tools import *
from ldap_crans import is_actif, crans_ldap, AssociationCrans, hostname
from ldap_crans import MachineCrans, MachineWifi, BorneWifi
from ldap_crans import Adherent
from ldap_crans import datetimeFromGTF
from hptools import sw_chbre, ConversationError
import gestion.annuaires_pg as annuaires_pg
import gestion.config as config
import ridtools
import user_tests

base = None

limit_aff_details = 1
limit_aff_machines = 15
limit_aff_historique = 4
limit_aff_blacklist = 4
aff_ipsec = 0
aff_ssh = 0
aff_ipv6 = 0

################################################################################
### Fonctions utiles

def indicatif (num):
    """
    Sépare l'indicatif de nationalité du reste d'un numéro de téléphone
    """
    if num[0:2] != '00':
        return ('', num)
    if num[2] == '1':
        return ('1 '+num[3:6], num[6:])
    if num[2] in ['0','7']:
        return (num[2], num[3:])
    # indicatifs nationaux à 2 chiffres
    ids = [20, 27, 36, 86, 98]
    ids.extend(range(30, 35))
    ids.extend(range(39, 42))
    ids.extend(range(43, 50))
    ids.extend(range(51, 59))
    ids.extend(range(60, 67))
    ids.extend(range(81, 85))
    ids.extend(range(90, 96))
    if int(num[2:4]) in ids:
        return (num[2:4], num[4:])
    return (num[2:5], num[5:])

def format_tel (num):
    """
    Formate un numéro de téléphone
        * Remplace un éventuel "00" au début par un "+"
        * Insère des espaces pour que ce soit lisible
    """
    res = ''
    (indic, reste) = indicatif(num)
    if indic != '':
        res += '+' + indic + ' '
    l = len(reste)
    if l%2 == 1:
        res += reste[0] + ' '
    for i in range(l%2,l,2):
        res += reste[i:i+2] + ' '
    return res

################################################################################

def aff(qqch,mtech=0) :
    """ Affichage de qqch.
    qqch peut être une liste d'instances des classes adhérent ou machine
    (un seul type dans la liste) dans ce cas :
        * si la longueur de la liste est inférieure à limit_aff_details
    affiche les propriétés détaillées de chaque élément.
        * sinon résume dans un tabeau des principales propriétés
    si qqch est une instance seul la traité comme une liste à une élément
    Si mtech = 1 affiches les infomations techniques des machines plutot
    qu'administratives dans le tableau des propriétés
    """
    if type(qqch) != list :
        qqch = [ qqch ]

    if len(qqch) > limit_aff_details :
        t = qqch[0].idn
        if t == 'aid':
            cprint(adhers_brief(qqch))
        elif t == 'mid':
            if mtech:
                cprint(list_machines(qqch))
            else:
                cprint(machines_brief(qqch))
        elif t == 'cid':
            cprint(clubs_brief(qqch))
        elif t == 'fid':
            cprint(factures_brief(qqch))
    else :
        i = 0
        for c in qqch :
            t = c.idn
            if i: cprint(u'='*80, 'cyan')
            i = 1
            if t == 'aid':
                cprint(adher_details(c).strip())
            elif t == 'mid':
                cprint(machine_details(c).strip())
            elif t == 'cid':
                cprint(club_details(c).strip())
            elif t == 'fid':
                cprint(facture_details(c).strip())

    # affiche le nombre de résultats
    if len(qqch) > 1:
        cprint(u"Total: %d" % len(qqch))

def adhers_brief(adhers) :
    """
    Formatage sous forme de tableau des infos sur la liste d'adhérent fournie :
        * aid
        * prénom nom
        * chambre
        * machines
    """
    data = []

    # Copie locale triée par (nom, prenom)
    adhers = adhers[:]
    adhers.sort(lambda x, y: cmp((x.nom(), x.prenom()), (y.nom(), y.prenom())))

    for a in adhers:
        ## État administratif
        ok = u'\x1b[1;32mo\x1b[1;0m'
        ook = u'\x1b[1;32mO\x1b[1;0m'
        nok = u'\x1b[1;31mn\x1b[1;0m'
        # Paiement
        if a.adhesion() > time():
            if 'p' in a.controle(): paid = ook
            else: paid = ok
        else: paid = nok

        machines = ''
        # Récupération des machines
        if len(adhers) <= limit_aff_machines:
            for machine in a.machines() :
                nom = machine.nom().split('.')[0]
                if machine.blacklist_actif() : k = 'rouge'
                elif isinstance(machine, MachineWifi): k = 'cyan'
                else : k= ''
                if machines : machines += ', ' + coul(nom,k)
                else : machines = coul(nom,k)
        else:
            machines = None
        # Données
        if len(adhers) <= limit_aff_machines:
            data.append([a.id(), a.Nom(), a.chbre(), paid, machines])
        else:
            data.append([a.id(), a.Nom(), a.chbre(), paid])

    if len(adhers) <= limit_aff_machines:
        return u"Machines en rouge = machines avec limitation de services\n" + \
               u"P : paiement année en cours, le fond vert indique le précâblage (G bleu = inscription gratuite)\n" + \
               u"C : carte d'étudiant année en cours\n" + \
               tableau(data,
                       titre = [u'aid', u'Prénom Nom', u'Chbre', u'P', u'Machines'],
                       largeur = [5, 30, 5, 1, '*'],
                       alignement = ['d', 'c', 'g', 'c', 'c'])
    else:
        return u"Machines en rouge = machines avec limitation de services\n" + \
               u"P : paiement année en cours, le fond vert indique le précâblage (G bleu = inscription gratuite)\n" + \
               u"C : carte d'étudiant année en cours\n" + \
               tableau(data,
                       titre = [u'aid', u'Prénom Nom', u'Chbre', u'P'],
                       largeur = [5, '*', 5, 1],
                       alignement = ['d', 'c', 'g', 'c'])

def machines_brief(machines) :
    """
    Formatage sous forme d'un tableau des propriétés de la liste de machine :
        * mid
        * rid
        * type (serveur, adm, fil, wifi, adm, borne)
        * nom
        * adresse IP
        * adresse MAC
        * si blacklistée
    """
    data = []

    # Copie locale triée par nom
    machines = machines[:]
    machines.sort(lambda x, y: cmp(x.nom(), y.nom()))

    for m in machines :
        t, bl = __bases_machines(m)

        # Propriétaire
        a = m.proprietaire()
        p = a.Nom()

        # A jour administrativement
        if not a.paiement_ok():
            p = coul(p,'rouge')

        # Données
        data.append([m.id(), m.rid() , t, m.nom().split('.')[0], p, a.chbre(), bl])

    return u"Le propriétaire en rouge signale un problème administratif, en bleu une inscription gratuite\n" + \
            tableau(data,
                    titre = [u'mid', u'rid', u'Type', u'Nom de machine', u'Propriétaire', u'Chbre', u'Limitation'],
                    largeur = [5, 5, 13, 18, '*', 5, 10],
                    alignement = ['d', 'd', 'c', 'c', 'c', 'g', 'c'])

def factures_brief(factures) :
    """
    Formatage sous forme d'un tableau des propriétés de la liste de machine :
        * fid
        * priorio
        * articles
        * modePaiement
        * recuPaiement
        * controle
        * total
    """
    data = []

    # Copie locale triée par nom
    factures = [] + factures
    factures.sort(lambda x, y: cmp(int(x.id()), int(y.id())))

    for facture in factures:
        # Propriétaire
        a = facture.proprietaire()
        p = a.Nom()

        # Contrôle
        controle = facture.controle()
        if controle == "TRUE":
            controle = coul(u"Validée", "vert")
        elif controle == "FALSE":
            controle = coul(u"Invalide", "rouge")
        else:
            controle = u"N/A"

        # Données
        data.append([
            facture.id(),
            p,
            facture.modePaiement(),
            coul(datetimeFromGTF(facture.recuPaiement()).strftime("%d/%m/%Y %H:%M:%S"), "vert") if facture.recuPaiement() else coul("NON", "rouge"),
            controle,
            ', '.join(article['code'] for article in facture.articles()),
            unicode(facture.total()) + u" €",
            ])

    return u"Le propriétaire en rouge signale un problème administratif.\n" + \
        tableau(data,
            titre = [u'fid', u'Propriétaire', u'Mode de paiement', u'Reçu', u"Contrôle", u'Articles', u"Total"],
            largeur = [5, 18, 8, 19, 10, '*', 8],
            alignement = ['d', 'g', 'g', 'c', 'c', 'g', 'd']
        )

def clubs_brief(clubs) :
    """
    Formatage sous forme de tableau des infos sur la liste de clubs fournie :
        * cid
        * nom
        * local
        * machines
    """
    data = []

    # Copie locale triée par Nom
    clubs = clubs[:]
    clubs.sort(lambda x, y: cmp(x.Nom(), y.Nom()))

    for c in clubs :
        ## État administratif
        ok = u'\x1b[1;32mo\x1b[1;0m'
        ook = u'\x1b[1;32mO\x1b[1;0m'
        nok = u'\x1b[1;31mn\x1b[1;0m'
        # Paiement
        if c.paiement_ok():
            # TODO
            #if 'p' in c.controle(): paid = ook
            #else: paid = ok
            paid = ok
        else : paid = nok

        # Précablage
        # TODO

        machines = ''
        # Récupération des machines
        for machine in c.machines() :
            nom = machine.nom().split('.')[0]
            if machine.blacklist_actif() : k = 'rouge'
            else : k= ''
            if machines : machines += ', ' + coul(nom,k)
            else : machines = coul(nom,k)

        # Responsable
        try:
            resp = c.responsable().Nom()
        except ValueError, e:
            resp = e

        # Données
        data.append([c.id() , c.Nom(), c.local(), paid, resp, machines])

    return u"Machines en rouge = machines avec limitation de services\n" + \
           u"P : signature charte année en cours, le fond vert indique le précâblage\n" + \
           tableau(data,
                   titre = [u'cid', u'Nom ', u'Local', u'P', u'Responsable', u'Machines'],
                   largeur = [5, '*', 6, 1, 21, 15],
                   alignement = ['d', 'c', 'g', 'c', 'c', 'c'])


def list_machines(machines) :
    """
    Formatage sous forme d'un tableau des propriétés de la liste de machine :
        * mid
        * type (fixe ou wifi)
        * nom
        * adresse IP
        * adresse MAC
        * si blacklistée
    """
    data = []

    # Copie locale triée par nom
    machines = machines[:]
    machines.sort(lambda x, y: cmp(x.nom(), y.nom()))

    for m in machines :
        t, bl = __bases_machines(m)

        # Données
        if not aff_ipv6:
            data.append([m.id(), m.rid(), t, m.nom().split('.')[0], m.ip(), m.mac(), bl])
            larg = 15
        else:
            larg = 22
            data.append([m.id(), m.rid(), t, m.nom().split('.')[0], m.ipv6(), m.mac(), bl])

    return tableau(data,
                titre = [u'mid', u'rid', u'Type', u'Nom de machine', u'Adresse IP', u'Adresse MAC', u'Limitation'],
                largeur = [5, 5, 9, '*', larg, 17, 10],
                alignement = ['d', 'd', 'c', 'c', 'c', 'c', 'c'])

def list_factures(factures) :
    """
    Formatage sous forme d'un tableau des propriétés de la liste de facture :
        * fid
        * mode de paiement
        * payé
        * codes article
        * total
    """
    data = []

    # Copie locale triée par fid
    factures = factures[:]
    factures.sort(lambda x, y: cmp(x.id(), y.id()))

    for f in factures :
        controle = f.controle()
        if controle == "TRUE":
            controle = coul(u"Validée", "vert")
        elif controle == "FALSE":
            controle = coul(u"Invalide", "rouge")
        else:
            controle = u"N/A"
        data.append([
           f.id(),
           f.modePaiement(),
           coul(datetimeFromGTF(f.recuPaiement()).strftime("%d/%m/%Y %H:%M:%S"), "vert") if f.recuPaiement() else coul("NON", "rouge"),
           controle,
           ', '.join(a['code'] for a in f.articles()),
           u"%s€" % sum([float(a['pu'])*int(a['nombre']) for a in f.articles()])
        ])

    return tableau(data,
                titre = [u'fid', u'Mode de paiement', u'Reçu', u"Contrôle", u'Articles', u"Total"],
                largeur = [5, 16, 19, 10, '*', 8],
                alignement = ['d', 'g', 'c', 'c', 'g', 'd'])

def list_spec(machines) :
    """
    Formatage sous forme d'un tableau des propriétés de la liste de machines spéciales :
        * mid
        * rid
        * nom
        * adresse IPv4/IPv6
        * adresse MAC

        Pour les bornes :
            * État
            * puissance
            * canal
            * lieu (la première remarque en fait)
        Pour le reste :
            * ??
    """
    data = []

    # Copie locale triée par nom
    machines = machines[:]
    machines.sort(lambda x, y: cmp(x.nom(), y.nom()))

    for b in machines:
        t, bl = __bases_machines(b)

        # Données
        if t == 'borne':
            try :
                l = [x for x in b.info() if not x[0]=='<'][0]
                if len(l) > 11 :
                    l = l[0:11]
            except :
                l = u'????'

            if '-' in b.puissance() :
                puiss = coul(b.puissance(),'rouge')
            else :
                puiss = b.puissance()

            if aff_ipv6:
                data.append([b.id(), b.rid(), b.nom().split('.')[0], b.ipv6(), b.mac(), b.canal(), puiss, b.prise(), l])
            else:
                data.append([b.id(), b.rid(), b.nom().split('.')[0], b.ip(), b.mac(), b.canal(), puiss, b.prise(), l])

            titre = [u'mid', u'rid', u'Nom', u'Adresse IP', u'Adresse MAC', u'Can', u'P', u'Pris', u'Lieu']
            largeur = [5, 5, 16, 22, 17, 1, 5, 3, 4, '*']
            alignement = ['d', 'd', 'c', 'c', 'c', 'c', 'c', 'c', 'g', 'c']

        else:
            if aff_ipv6:
                data.append([b.id(), b.rid(), t, b.nom().split('.')[0], b.ipv6(), b.mac()])
            else:
                data.append([b.id(), b.rid(), t, b.nom().split('.')[0], b.ip(), b.mac()])

            titre = [u'mid', u'rid', u'Type', u'Nom', u'Adresse IP', u'Adresse MAC']
            largeur = [5, 5, 10, 20, '*', 17]
            alignement = ['d', 'd', 'd', 'c', 'c', 'c']

    output = tableau(data, titre=titre, largeur=largeur, alignement=alignement)

    return output

def adher_details(adher) :
    """
    Affichage du détail des propriétés d'un adhérent
    """
    f=u''
    # Aid
    f+= coul(u'aid=%s   ' % adher.id() ,'bleu')
    # Nom, prenom
    f += coul(u'Nom : ','gras') + "%s\n" % adher.Nom()

    # Mail
    GL = RMH = u''
    if adher.mail() == '' or adher.compte() == '':
        f += coul(u'Adresse mail : ','gras')
        if adher.mail() == '':
            f += coul('INCONNUE','rouge')
        elif adher.mail_invalide():
            f += coul(adher.mail(),'rouge')
        else:
            f += adher.mail()
        f += "\n"
    else :
        f += coul(u'Login : ','gras')
        if adher.mail_invalide():
            f += coul(adher.compte(),'rouge')
        else:
            f += adher.compte()
        if not adher.active():
            f += " " + coul(u"(Compte désactivé)", "rouge")
        f += "\t"
        # controurneGreylisting
        if not adher.contourneGreylist():
            GL = u' (%s)'%coul(u'GreyList','gris')
        if adher.rewriteMailHeaders():
            RMH = u' (%s)'%coul(u'réécriture en-têtes mail','gris')

        alias = u', '.join([adher.canonical_alias()] + adher.alias())
        if alias:
            if alias[0] == u',':
                # Canonical étéait vide
                alias = alias[2:]
            f += coul(u'Alias : ','gras') + alias
        f += GL
        f += RMH
        f += u'\n'
        if adher.email_exterieur():
            f += coul(u'Mail extérieur : ', 'gras')
            f += adher.email_exterieur()
            f += u'\n'
        # Réservé aux comptes Crans.
        if len(adher.gpgFingerprint()) > 0:
            f += u"\n".join([coul(u'Fingerprint GPG : ', 'gras') + u"%s" % (i) for i in adher.gpgFingerprint()])+"\n"
        try:
            forward = file(os.path.join(adher.home(), ".forward")).readlines()
            if len(forward) > 1:
                forward = forward[0].strip() + u" ...\n"
            elif len(forward) == 1:
                forward = forward[0].strip() + u"\n"
            if forward:
                f += coul(u'Redirection : ', 'gras') + forward
        except IOError, e:
            # Pas de .forward, ou .forward privé... on laisse tomber
            pass
        f += coul(u'Dernière connexion : ', 'gras')
        timestamp = adher.derniereConnexion()
        if timestamp == 0:
            f += coul(u'Jamais', 'rouge')
        else:
            f += coul(strftime('%d/%m/%Y %H:%M', localtime(timestamp)),
                      time()-timestamp > 32*24*3600 and 'rouge' or '')
        f += u"\n"

    # État administratif
    f += coul(u"Date d'inscription : ", "gras")
    f += strftime('%d/%m/%Y %H:%M:%S', localtime(adher.dateInscription()))
    f += coul(u'\nÉtat administratif : ','gras')
    jour = True
    if adher.adhesion() <= time():
        if not jour: f += ' et '
        f += coul(u"non adhérent actuellement",'violet')
        jour = False
    if not adher.paiement_ok():
        if not jour: f += ' et '
        f += coul(u"pas d'accès Internet ", "violet")

    if jour:
        f += coul(u"à jour",'vert')
    f += "\n"

    # Telephone
    tel = adher.tel()
    if tel != 'inconnu' :
        f += coul(u'Numéro de téléphone : ','gras') + "%s\n" % format_tel(tel).ljust(12)

    # Adresse
    chbre = adher.chbre()
    if chbre == 'EXT' :
        # Adhérent extérieur
        addr = adher.adresse()
        if addr[0] :
            f += coul(u'Adresse : ','gras')
            f += addr[0] + u'\n'
            if addr[1] != ' ' : f += u'          ' + addr[1] + u'\n'
            f+= u'          ' + addr[2] + u' ' + addr[3] + '\n'
    elif chbre == '????' :
        f += coul(u'Chambre invalide\n','violet')
    else :
        # Chambre + prise (d'après annuaire)
        etat, vlans, cablage = prise_etat(adher.chbre())
        f += coul(u'Chambre : ','gras') + u"%s " % chbre
        f += u'(%s)' % etat
        f += u'\n'
        # VLAN
        if vlans :
            f += coul(u'VLAN : ','gras') + u'%s' % vlans
            f += u'\n'

    # Études
    if adher.etudes(1).isdigit() :
        f += coul(u'Études : ','gras')+ "%s %s%s\n" % \
        ( adher.etudes(0), adher.etudes(1), adher.etudes(2) )
    elif adher.etudes(0) :
        f += coul(u'Études : ','gras')+ "%s %s %s\n" % \
        ( adher.etudes(0), adher.etudes(1), adher.etudes(2) )

    # Solde
    solde = adher.solde()
    if solde :
        f += coul(u'Solde : ','gras')
        if solde < 0 :
            f+= coul(str(solde).replace('.',','),'rouge')
        else :
            f += str(solde).replace('.',',')
        f += u" Euros\n"

    # Role dans l'assoce
    d = adher.droits()
    if d :
        f += coul(u"Droits sur les serveurs : ",'gras') + ', '.join(d)
        if adher.droitsGeles():
            f +=  coul(u" (droits gelés car pas cotisé cette année)",'bleu')
        f += u'\n'

    # Adhésion
    if adher.adhesion() > time():
        f += coul(u"Adhésion jusqu'au %s" % strftime("%d/%m/%Y %H:%M:%S", localtime(adher.adhesion())), "vert")
        f += u"\n"
    elif config.periode_transitoire and (config.debut_periode_transitoire <= min(adher.adhesion(), adher.connexion()) <= config.fin_periode_transitoire):
        f += coul(u"Fin d'adhésion, mais en sursis jusqu'au %s" % (strftime("%d/%m/%Y %H:%M:%S", localtime(config.fin_periode_transitoire)),), "rouge")
        f += u"\n"

    # Paiement
    if adher.connexion() > time():
        f += coul(u"Connexion jusqu'au %s" % strftime("%d/%m/%Y %H:%M:%S", localtime(min(adher.connexion(), adher.adhesion()))), "vert")
        if adher.adhesion() < adher.connexion():
            f += coul(u"(Théoriquement %s, sous réserve de réadhésion)" % (strftime("%d/%m/%Y %H:%M:%S", localtime(adher.connexion())),), "rouge")
        f += u'\n'

    f += _blacklist(adher)
    f += _info(adher)
    f += _hist(adher)

    # Formatage des machines aussi
    f += coul(u'Machine(s) : ','gras')
    m = adher.machines()
    if m :
        f += u'\n' + list_machines(m)
    else :
        f += u'aucune'

    f += u"\n"
    f += coul(u'Facture(s) : ','gras')
    m = adher.factures()
    if m :
        f += u'\n' + list_factures(m)
    else :
        f += u'aucune'

    return f

def facture_details(facture) :
    """
    Affichage du détail des propriétés d'une facture
    """

    controle = facture.controle()
    if controle == "TRUE":
        controle = coul(u"Validée", "vert")
    elif controle == "FALSE":
        controle = coul(u"Invalide", "rouge")
    else:
        controle = u"N/A"

    f=u''
    # Fid
    f+= coul(u'fid=%s   ' % facture.id() ,'bleu')
    # Proprio
    f += coul(u'Proprio : ','gras') + "%s (%s %s)\n" % (facture.proprietaire().Nom(), facture.proprietaire().idn, facture.proprietaire().id())

    # Articles
    f += coul(u"Articles :", "gras") + u"\n"
    f += list_articles(facture)
    f += u"\n"
    f += coul(u"Total : ", "gras") + u"%s €" % facture.total()
    f += "\n"

    # Mode de paiement
    f += coul(u"Mode de paiement : ", "gras")
    f += facture.modePaiement()
    f += u"        "
    f += coul(u"Paiement reçu : ", "gras")
    f += coul(datetimeFromGTF(facture.recuPaiement()).strftime("%d/%m/%Y %H:%M:%S"), "vert") if facture.recuPaiement() else coul(u"Non", "rouge")
    f += u"\n"
    f += coul(u"Contrôle : ", "gras")
    f += controle
    f += u"\n"
    f += _hist(facture)

    return f

def list_articles(facture):
    """Liste en détail des articles d'une facture

    """

    data = [[article['code'], article['designation'], article['nombre'], article['pu']] for article in facture.articles()]

    return tableau(data,
                titre = [u'Code', u'Désignation', u'Nombre', u"Prix unitaire"],
                largeur = [10, '*', 10, 13],
                alignement = ['c', 'g', 'c', 'c'])


clients_ipsec = None
def ipsec_ok(machine) :
    """Indique si une machine est correctement authentifiée"""
    return False

def machine_details(machine) :
    """
    Formatage du détail des propriétés d'une machine
    """
    f = ''
    f+= coul(u'mid=%s   ' % machine.id(),'bleu')

    # Type de machine
    if isinstance(machine, MachineWifi): a = 'Machine wifi'
    elif isinstance(machine, BorneWifi): a = 'Borne wifi'
    else: a = 'Machine fixe'
    f += coul(a + ' : ', 'gras')

    f+= "%s   " % machine.nom()

    if machine.rid() != '':
        f+= coul(u'rid=%s    '% machine.rid(), 'bleu')

    f+= "\n"

    # Alias ?
    alias = machine.alias()
    if alias :
        f += coul(u'Alias : ' ,'gras') + ', '.join(alias)
        f+= '\n'

    f+= coul(u'IP : ','gras') + "%s\t\t" %machine.ip()
    f+= coul(u'MAC : ','gras') + "%s\n" %machine.mac()
    if machine.ipv6() != None:
        f+= coul(u'IPv6 : ','gras') + "%s\n" %machine.ipv6()

    if len(machine.sshFingerprint()) > 0 and aff_ssh:
        f += u"\n".join([coul(u'Fingerprint SSH : ', 'gras') + u"%s" % (i) for i in machine.sshFingerprint()])+"\n"

    # Propriétaire
    f+= coul(u'Propriétaire : ','gras')
    try :
        f += machine.proprio + coul(' (adhérent détruit)', 'jaune')
        a = AssociationCrans()
    except :
        a = machine.proprietaire()
        f += "%s" % a.Nom()
        if a.chbre() in ['EXT', '????']:
            f += ' (%s = %s)' % (a.idn, a.id())
        elif a.chbre() != 'CRA':
            f += " (%s)" % a.chbre()
        else :
            f += coul(u'\t\tPrise : ','gras') + machine.prise()
    f+= '\n'

    if isinstance(machine, MachineCrans):
        n = machine.nombrePrises()
        if n >= 0:
            f += coul(u'Nombre de prises : ', 'gras')
            f += "%d\n" % n

    # Adhérent blacklisté ?
    bl = a.blacklist_actif()
    if bl :
        f += coul(u'Restrictions sur adhérent : ','gras')
        f +=  coul(u', '.join(bl),'rouge')
        f += '\n'

    # Borne wifi
    if isinstance(machine, BorneWifi):
        f += coul(u'Hotspot : ', 'gras')
        f += machine.hotspot() and 'oui' or 'non'
        position = machine.position()
        if position:
            f += coul(u'\t\t\tCoordonnées : ', 'gras')
            f += u'%s°N, %s°E\n' % position
        else:
            f += '\n'

        if (machine.prise() != 'N/A'):
            try:
                f += coul(u'VLANs : ', 'gras')
                from hptools import sw_prise
                f += ', '.join(sw_prise(machine.prise()).vlans())
                f += '\n'
            except:
                pass

        f += coul(u'Puissance : ','gras') + u"%4.d" % int(machine.puissance())
        f += coul(u'\tCanaux : ', 'gras') + machine.canal()
        f += coul(u'\tÉtat : ', 'gras')
        if borne_etat(machine.nom()):
            f += coul(u'borne active', 'vert')
            f += '\n'
            canal_clients = borne_clients_canal(machine.nom())
            clients = canal_clients["mac-rssi"]
            canal = canal_clients["canal"]
            f += coul(u'\t         Canal courant : ', 'gras') + u"%d" % canal
            f += "\n"
            # S'il y a des clients, on les liste
            if clients and base:
                f += coul(u'Clients : \n','gras')
                for (client, rssi) in clients:
                    # On va chercher le nom correspondant à l'adresse MAC
                    res = base.search("mac=%s" % client)['machine']
                    authentification=""
                    if not res:
                        client_nom = '????'
                        client_chbre = '????'