attributs.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#

""" Définition des classes permettant d'instancier les attributs LDAP. """

#
# Copyright (C) 2010-2013 Cr@ns <roots@crans.org>
# Authors: Antoine Durand-Gasselin <adg@crans.org>
#          Nicolas Dandrimont <olasd@crans.org>
#          Valentin Samir <samir@crans.org>
#          Vincent Le Gallic <legallic@crans.org>
#          Pierre-Elliott Bécue <becue@crans.org>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
# * Neither the name of the Cr@ns nor the names of its contributors may
#   be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT
# HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import re
import sys
import ssl
import netaddr
import time
import base64
import datetime
import functools
import smtplib
import random
import string
from unicodedata import normalize
from crans_utils import format_tel, format_mac, mailexist, validate_name, ip4_of_rid, ip6_of_mac, fetch_cert_info
from crans_utils import to_generalized_time_format, from_generalized_time_format
import itertools

sys.path.append("/usr/scripts")

import cranslib.deprecated
from gestion import config
from gestion import annuaires_pg

#: Serveur SMTP
smtpserv = "smtp.crans.org"

### Les droits
# en cas de typo, l'appel d'une variable plante, on préfèrera donc les utiliser en lieu et place
# des chaînes de caractères
#: Chaine de caractère des droits nounou
nounou = u"Nounou"
#: Droit cableur
cableur = u"Cableur"
#: Droit apprenti
apprenti = u"Apprenti"
#: Droit trésorier
tresorier = u"Tresorier"
#: Droit bureau
bureau = u"Bureau"
#: Droit imprimeur
imprimeur = u"Imprimeur"
#: Droit modérateur
moderateur = u"Moderateur"
#: Droit multimachine
multimachines = u"Multimachines"
#: Droit Webmaster
webmaster = u"Webmaster"
#: Droit Webradio
webradio = u"Webradio"
#: On peut faire subir des choses à un objet si on est son parent
parent = u"parent"
#: On peut faire subir des choses à un objet si on est cet objet
soi = u"soi"
#: Le responsable d'un club peut lui faire subir des choses
respo = u"responsable"

#: Liste de tous les droits
TOUS_DROITS = [nounou, apprenti, bureau, tresorier, imprimeur, moderateur, multimachines, cableur, webmaster, webradio]
#: Liste des droits forts
DROITS_ELEVES = [nounou, bureau, tresorier]
#: Liste des droits intérmédiaires
DROITS_MOYEN = [apprenti, moderateur]
#: Liste des droits moins sensibles
DROITS_FAIBLES = [cableur, imprimeur, multimachines]

#: Qui a le droit de modifier quels droits
DROITS_SUPERVISEUR = { nounou : TOUS_DROITS,
    bureau : DROITS_FAIBLES + [bureau, tresorier],
}

class SingleValueError(ValueError):
    """Erreur levée si on essaye de multivaluer un champ monovalué."""
    pass

class UniquenessError(EnvironmentError):
    """Erreur levée si on essaye de créer un objet dont le ``dn`` existe déjà."""
    pass

class OptionalError(EnvironmentError):
    """Erreur levée si on essaye de créer un objet sans fournir un attribut obligatoire."""
    pass


def attrify(val, attr, conn, Parent=None):
    """Transforme un n'importe quoi en :py:class:`Attr`.

    Doit effectuer les normalisations et sanity check si un str ou un
    unicode est passé en argument.
    Devrait insulter en cas de potentiel problème d'encodage.
    """
    if isinstance(val, Attr):
        return val
    else:
        attr_classe = AttributeFactory.get(attr, fallback=Attr)
        if not isinstance(val, unicode) and not (attr_classe.python_type and isinstance(val, attr_classe.python_type)):
            cranslib.deprecated.usage("attrify ne devrait être appelé qu'avec des unicode (%r)" % val, level=3)
            val = val.decode(config.in_encoding)
        return attr_classe(val, conn, Parent)

class AttrsList(list):
    def __init__(self, Parent, attr, attr_list):
        super(AttrsList, self).__init__(attr_list)
        self._parent = Parent
        self._attr = attr

    def _start(self):
        if self._parent[self._attr] != self:
            raise ValueError("La variable que vous utilisez n'est pas à jour (modifications conccurentes ?)")

    def _commit(self):
        try:
            self._parent[self._attr] = self
        finally:
            super(AttrsList, self).__init__(self._parent[self._attr])

    def __delitem__(self, index):
        self._start()
        super(AttrsList, self).__delitem__(index)
        self._commit()

    def __setitem__(self, index, value):
        self._start()
        super(AttrsList, self).__setitem__(index, value)
        self._commit()

    def append(self, val):
        self._start()
        super(AttrsList, self).append(val)
        self._commit()

    def extend(self, vals):
        self._start()
        super(AttrsList, self).extend(vals)
        self._commit()

    def insert(self, pos, val):
        self._start()
        super(AttrsList, self).insert(pos, val)
        self._commit()

    def remove(self, val):
        self._start()
        super(AttrsList, self).remove(val)
        self._commit()

    def sort(self):
        self._start()
        super(AttrsList, self).sort()
        self._commit()

    def pop(self, index=None):
        self._start()
        ret = super(AttrsList, self).pop(index) if index else super(AttrsList, self).pop()
        self._commit()
        return ret

    def reverse(self):
        self._start()
        super(AttrsList, self).reverse()
        self._commit()

class AttrsDict(dict):
    def __init__(self, conn, uldif={}, Parent=None):
        super(AttrsDict, self).__init__(uldif)
        self._conn = conn
        self._parent = Parent
        self._iterator = None

    def __getitem__(self, attr):
        values = super(AttrsDict, self).__getitem__(attr)
        if not isinstance(values, list):
            values = [values]
        output = []
        for val in values:
            output.append(attrify(val, attr, self._conn, self._parent))
        self[attr] = output
        return output

    def __setitem__(self, attr, values):
        # ne devrait par arriver
        if not isinstance(values, list):
            values = [ values ]
        if self._parent.mode in ['w', 'rw']:
            if AttributeFactory.get(attr, fallback=Attr).singlevalue and len(values) > 1:
                raise SingleValueError("L'attribut %s doit être monovalué." % (attr,))
            super(AttrsDict, self).__setitem__(attr, values)
        else:
            super(AttrsDict, self).__setitem__(attr, values)

    def get(self, value, default_value):
        try:
            return self[value]
        except KeyError:
            return default_value

    def items(self):
        return [(key, self[key]) for key in self]

    def to_ldif(self):
        """
        Transforme le dico en ldif valide au sens openldap.
        Ce ldif est celui qui sera transmis à la base.
        """
        ldif = {}
        for attr, vals in self.items():
            ldif[attr] = [ str(val) for val in vals ]
        return ldif

class Attr(object):
    """Objet représentant un attribut.

    **Paramètres :**

    * ``val``        : valeur de l'attribut
    * ``ldif``       : objet contenant l'attribut (permet de faire les validations sur l'environnement)
    """
    legend = "Human-readable description of attribute"
    singlevalue = False
    optional = True
    conn = None
    unique = False
    concurrent = True
    unique_exclue = []
    #: Le nom de l'attribut dans le schéma LDAP
    ldap_name = None
    python_type = None
    binary = False
    default = None

    """La liste des droits qui suffisent à avoir le droit de modifier la valeur"""
    can_modify = [nounou]

    """Qui peut voir l'attribut. Par défaut, les Nounous et les Apprentis
       peuvent tout voir. Par transparence, et par utilité, on autorise par
       défaut l'adhérent à voir les données le concernant."""
    can_view = [nounou, apprenti, soi, parent, respo]

    """Catégorie de l'attribut (pour affichage futur)"""
    category = 'other'

    def __init__(self, val, conn, Parent):
        """Crée un nouvel objet représentant un attribut."""
        self.value = None
        self.conn = conn
        assert isinstance(val, unicode) or (self.python_type and isinstance(val, self.python_type))
        self.parent = Parent
        self.parse_value(val)

    def __hash__(self):
        if not self.parent or self.parent.mode in ['w', 'rw']:
            raise TypeError("Mutable structure are not hashable, please use mode = 'ro' to do so")
        if hasattr(self.value, "__hash__") and self.value.__hash__ is not None:
            return self.value.__hash__()
        else:
            return str(self).__hash__()

    def __getattr__(self, name):
        return getattr(self.value, name)

    def __ne__(self, obj):
        return not self == obj

    def __eq__(self, item):
        if isinstance(item, self.__class__):
            return str(self) == str(item)
        elif isinstance(item, Attr) and item.python_type == self.python_type:
            return item.value == self.value
        elif self.python_type and isinstance(item, self.python_type):
            return self.value == item
        elif isinstance(item, str):
            return str(self) == item
        elif isinstance(item, unicode):
            return unicode(self) == item
        else:
            return False

    def __nonzero__(self):
        if self.value:
            return True
        else:
            return False

    def parse_value(self, val):
        """Transforme l'attribut pour travailler avec notre validateur
        Le ldif est en dépendance car à certains endroits, il peut servir
        (par exemple, pour l'ipv6, ou l'ipv4…"""
        self.value = val

    def __str__(self):
        return self.__unicode__().encode(config.out_encoding)

    def __repr__(self):
        return str(self.__class__) + " : " + repr(self.value)

    def __unicode__(self):
        if isinstance(self.value, unicode):
            return self.value
        else:
            return unicode(self.value)

    def check_uniqueness(self, liste_exclue):
        """Vérifie l'unicité dans la base de la valeur (``mailAlias``, ``chbre``,
        etc...)"""
        attr = self.__class__.__name__
        if unicode(self) in liste_exclue + self.unique_exclue:
            return
        if self.unique:
            res = self.conn.search(u'%s=%s' % (attr, str(self)))
            if res:
                raise UniquenessError("%s déjà existant" % attr, [r.dn for r in res])

    def is_modifiable(self, liste_droits):
        """
        L'attribut est-il modifiable par un des droits dans liste_droits ?
        """
        return not set(liste_droits).isdisjoint(self.can_modify)


class AttributeFactory(object):
    """Utilisée pour enregistrer toutes les classes servant à instancier un attribut LDAP.
       Elle sert à les récupérer à partir de leur nom LDAP.

       Cette classe n'est jamais instanciée.

       """
    _classes = {}

    @classmethod
    def register(cls, name, classe):
        """Enregistre l'association ``name`` -> ``classe``"""
        cls._classes[name] = classe

    @classmethod
    def get(cls, name, fallback=Attr):
        """Retourne la classe qui a ``name`` pour ``ldap_name``.

           Si elle n'existe pas, renvoie :py:class:`Attr` (peut être override en précisant ``fallback``)

           """
        return cls._classes.get(name, fallback)

def crans_attribute(classe):
    """Pour décorer les classes permettant d'instancier des attributs LDAP,
       afin de les enregistrer dans :py:class:`AttributeFactory`.

       """
    AttributeFactory.register(classe.ldap_name, classe)
    return classe

@crans_attribute
class objectClass(Attr):
    singlevalue = False
    optional = False
    legend = "entité"
    ldap_name = "objectClass"

    """ Personne ne doit modifier de classe """
    can_modify = []

    """ Internal purpose (et à fin pédagogique) """
    can_view = [nounou, apprenti]

    def parse_value(self, val):
        if val not in [ 'top', 'organizationalUnit', 'inetOrgPerson', 'posixAccount', 'shadowAccount',
                        'proprio', 'adherent', 'club', 'machine', 'machineCrans',
                        'borneWifi', 'machineWifi', 'machineFixe', 'x509Cert', 'TLSACert',
                        'baseCert', 'cransAccount', 'service', 'facture', 'freeMid', 'privateKey' ]:
            raise ValueError("Pourquoi insérer un objectClass=%r ?" % val)
        else:
            self.value = unicode(val)


class intAttr(Attr):

    python_type = int

    def __add__(self, obj):
        if isinstance(obj, self.__class__):
            return self.value.__add__(obj.value)
        else:
            return self.value.__add__(obj)

    def __sub__(self, obj):
        if isinstance(obj, self.__class__):
            return self.value.__sub__(obj.value)
        else:
            return self.value.__sub__(obj)

    def parse_value(self, val):
        if self.python_type(val) < 0:
            raise ValueError("Valeur entière invalide : %r" % val)
        self.value = self.python_type(val)

    def __unicode__(self):
        return unicode(self.value)

class floatAttr(Attr):

    python_type = float

    def __add__(self, obj):
        if isinstance(obj, self.__class__):
            return self.value.__add__(obj.value)
        else:
            return self.value.__add__(obj)

    def __sub__(self, obj):
        if isinstance(obj, self.__class__):
            return self.value.__sub__(obj.value)
        else:
            return self.value.__sub__(obj)

    def parse_value(self, val):
        self.value = self.python_type(val)

    def __unicode__(self):
        return unicode(self.value)

class boolAttr(Attr):

    python_type = bool

    def parse_value(self, val):
        if isinstance(val, self.python_type):
            self.value = val
        elif val.lower() in [u'true', u'ok']:
            self.value = True
        elif val.lower() == u'false':
            self.value = False
        else:
            raise ValueError("%r doit être un booléen !" % val)

    def __unicode__(self):
        return unicode(self.value).upper()

@crans_attribute
class aid(intAttr):
    singlevalue = True
    optional = True
    legend = u"Identifiant de l'adhérent"
    category = 'id'
    unique = True
    ldap_name = "aid"

    """ Personne ne devrait modifier un attribut d'identification """
    can_modify = []

    can_view = [nounou, apprenti, cableur]

    def parse_value(self, aid):
        self.value = int(aid)

@crans_attribute
class uid(Attr):
    singlevalue = True
    option = False
    legend = u"L'identifiant canonique de l'adhérent"
    category = 'perso'
    unique = True
    can_modify = [nounou]
    ldap_name = "uid"

@crans_attribute
class preferedLanguage(Attr):
    singlevalue = True
    option = True
    legend = u"La langue préférée de l'adhérent"
    category = 'perso'
    unique = False
    ldap_name = "preferedLanguage"

@crans_attribute
class nom(Attr):
    singlevalue = True
    optional = False
    legend = "Nom"
    category = 'perso'
    can_modify = [nounou, cableur]
    ldap_name = "nom"

    def parse_value(self, nom):
        if self.parent != None:
            if u'club' in [o.value for o in self.parent['objectClass']]:
                self.value = validate_name(nom,"0123456789\[\]")
            else:
                self.value = validate_name(nom)
        else:
            self.value = validate_name(nom)

@crans_attribute
class prenom(Attr):
    singlevalue = True
    optional = False
    legend = u"Prénom"
    category = 'perso'
    can_modify = [nounou, cableur]
    ldap_name = "prenom"

    def parse_value(self, prenom):
        self.value = validate_name(prenom)

@crans_attribute
class compteWiki(Attr):
    singlevalue = False
    optional = True
    legend = u"Compte WiKi"
    category = 'perso'
    can_modify = [nounou, cableur, soi]
    ldap_name = "compteWiki"

    #def parse_value(self, compte):
        #self.value = validate_name(compte)
        # TODO: validate with mdp for user definition here ?

@crans_attribute
class tel(Attr):
    singlevalue = True
    optional = False
    legend = u"Téléphone"
    category = 'perso'
    can_modify = [soi, nounou, cableur]
    ldap_name = "tel"

    def parse_value(self, tel):
        self.value = format_tel(tel)
        if len(self.value) == 0:
            raise ValueError("Numéro de téléphone invalide (%r)" % tel)

class yearAttr(intAttr):
    singlevalue = False
    optional = True

    def parse_value(self, annee):
        annee = self.python_type(annee)
        if annee < 1998:
            raise ValueError("Année invalide (%r)" % annee)
        self.value = annee

@crans_attribute
class paiement(yearAttr):
    legend = u"Paiement"
    can_modify = [cableur, nounou, tresorier]
    category = 'perso'
    ldap_name = "paiement"

@crans_attribute
class carteEtudiant(Attr):
    legend = u"Carte d'étudiant"
    category = 'perso'
    can_modify = [cableur, nounou, tresorier]
    ldap_name = "carteEtudiant"

    def parse_value(self, data):
        self.value = data

@crans_attribute
class derniereConnexion(intAttr):
    legend = u"Dernière connexion"
    can_modify = [nounou, cableur, soi] # il faut bien pouvoir le modifier pour le mettre à jour
    ldap_name = "derniereConnexion"

class generalizedTimeFormat(Attr):
    """Classe définissant un ensemble de données pour manipuler
    une donnée de temps suivant la RFC 4517

    """
    default = "19700101000000Z"

    def __float__(self):
        return self._stamp

    def __int__(self):
        return int(self._stamp)

    def __eq__(self, othertime):
        if isinstance(othertime, generalizedTimeFormat):
            return self._stamp == othertime._stamp
        else:
            resource = generalizedTimeFormat(othertime, conn=None, Parent=None)
            return self._stamp == resource._stamp

    def __neq__(self, othertime):
        return not (self == othertime)

    def __lt__(self, othertime):
        if isinstance(othertime, generalizedTimeFormat):
            return self._stamp < othertime._stamp
        else:
            resource = generalizedTimeFormat(othertime, conn=None, Parent=None)
            return self._stamp < resource._stamp

    def __le__(self, othertime):
        return not (self > othertime)

    def __ge__(self, othertime):
        return not (self < othertime)

    def __gt__(self, othertime):
        return not (self < othertime) and not (self == othertime)

    def parse_value(self, gtf):
        if isinstance(gtf, str) or isinstance(gtf, unicode):
            if not ('Z' in gtf or '+' in gtf or '-' in gtf):
                self._stamp = gtf
                self.value = to_generalized_time_format(float(gtf))
            else:
                self._stamp = from_generalized_time_format(gtf)
                self.value = gtf
        elif isinstance(gtf, float):
            self._stamp = gtf
            self.value = to_generalized_time_format(gtf)

@crans_attribute
class debutAdhesion(generalizedTimeFormat):
    legend = u"Date de début de l'adhésion"
    category = 'Adh'
    can_modify = [cableur, nounou]
    ldap_name = 'debutAdhesion'


@crans_attribute
class finAdhesion(generalizedTimeFormat):
    legend = u"Date de fin de l'adhésion"
    category = 'Adh'
    can_modify = [cableur, nounou]
    ldap_name = 'finAdhesion'

@crans_attribute
class debutConnexion(generalizedTimeFormat):
    legend = u"Date de début de la connexion"
    category = 'Adh'
    can_modify = [cableur, nounou]
    ldap_name = 'debutConnexion'

@crans_attribute
class finConnexion(generalizedTimeFormat):
    legend = u"Date de fin de la connexion"
    category = 'Adh'
    can_modify = [cableur, nounou]
    ldap_name = 'finConnexion'

@crans_attribute
class mail(Attr):
    singlevalue = False
    optional = False
    unique = True
    legend = u"Adresse mail de l'adhérent"
    can_modify = [soi, nounou, cableur]
    category = 'mail'
    ldap_name = "mail"

    def is_modifiable(self, liste_droits):
        """
        Une adresse mail n'est modifiable que si on a au moins autant de droits
        que la personne à qui est l'adresse mail
        """
        modifiables = set()
        for i in liste_droits:
            if i in DROITS_SUPERVISEUR:
                modifiables = modifiables.union(DROITS_SUPERVISEUR[i])
        modifiables = list(modifiables)

        for droit in self.parent.get('droits', []):
            if droit not in modifiables and droit in TOUS_DROITS:
                return False
        return super(mail, self).is_modifiable(liste_droits)


    def check_uniqueness(self, liste_exclue):
        attr = self.__class__.__name__
        if str(self) in liste_exclue:
            return
        if attr in ["mailAlias", "canonicalAlias", 'mail']:
            mail, end = str(self).split('@', 1)
            if end.startswith('crans'):
                try:
                    smtp = smtplib.SMTP(smtpserv)
                    smtp.putcmd("vrfy", mail)
                    res = smtp.getreply()[0] in [250, 252]
                    smtp.close()
                except:
                    raise ValueError('Serveur de mail injoignable')

                if res:
                    raise ValueError("Le mail %s est déjà pris." % (str(self)))
            else:
                check = self.conn.search(u'mail=%s' % mail)
                if len(check) >= 1:
                    raise ValueError("Le mail %s est déjà pris." % (str(self)))

    def parse_value(self, mail):
        if not re.match(u'^[-_.0-9A-Za-z]+@([A-Za-z0-9]{1}[A-Za-z0-9-_]+[.])+[a-z]{2,6}$', mail):
            raise ValueError("%s invalide %r" % (self.legend, mail))
        self.value = mail


@crans_attribute
class canonicalAlias(mail):
    singlevalue = True
    optional = True
    unique = True
    legend = u"Alias mail canonique"
    category = 'mail'
    ldap_name = "canonicalAlias"

# à spécifier pour les nouvelles valeurs
#    def parse_value(self, mail):
#        mail = u".".join([ a.capitalize() for a in mail.split(u'.', 1) ])
#        super(canonicalAlias, self).parse_value(mail)

@crans_attribute
class mailAlias(mail):
    singlevalue = False
    optional = True
    unique = True
    legend = u"Alias mail"
    can_modify = [soi, cableur, nounou]
    category = 'mail'
    ldap_name = "mailAlias"

@crans_attribute
class mailExt(mail):
    singlevalue = False
    optional = True
    unique = True
    legend = u"Mail de secours"
    can_modify = [soi, cableur, nounou]
    category = 'mail'
    ldap_name = "mailExt"

    def parse_value(self, mail):
        # comme on utilise mailExt comme mail de secours si l'utilisateur
        # à perdu ses id crans, ça ne sert à rien de mettre ne adresse crans
        if mail.endswith("@crans.org"):
            raise ValueError("%s ne devrait pas être une adresse crans." % str(self.legend))
        super(mailExt, self).parse_value(mail)

@crans_attribute
class mailInvalide(boolAttr):
    optional = True
    legend = u"Mail invalide"
    can_modify = [bureau, nounou]
    ldap_name = "mailInvalide"

@crans_attribute
class contourneGreylist(boolAttr):
    optionnal = True
    legend = u"Contourner la greylist"
    category = 'mail'
    can_modify = [soi]
    ldap_name = "contourneGreylist"

    def __unicode__(self):
        return u"OK"

@crans_attribute
class etudes(Attr):
    singlevalue = False
    optional = True
    legend = u"Études"
    can_modify = [soi, cableur, nounou]
    category = 'perso'
    ldap_name = "etudes"

@crans_attribute
class chbre(Attr):
    singlevalue = True
    optional = False
    unique = True
    unique_exclue = [u'????', u'EXT']
    legend = u"Chambre sur le campus"
    can_modify = [soi, cableur, nounou]
    category = 'perso'
    ldap_name = "chbre"

    def parse_value(self, chambre):
        if self.parent != None and u'club' in [str(o) for o in self.parent['objectClass']]:
                if chambre in annuaires_pg.locaux_clubs():
                    self.value = chambre
                else:
                    raise ValueError("Club devrait etre en XclN, pas en %r" % chambre)
        elif chambre in (u"EXT", u"????"):
            self.value = chambre
        else:
            annuaires_pg.chbre_prises(chambre[0], chambre[1:])
            self.value = chambre

@crans_attribute
class droits(Attr):
    singlevalue = False
    optional = True
    legend = u"Droits sur les serveurs"
    can_modify = [nounou, bureau]
    category = 'perso'
    ldap_name = "droits"

    def parse_value(self, droits):
#        if val.lower() not in [i.lower() for i in TOUS_DROITS]:
#            raise ValueError("Ces droits n'existent pas (%r)" % val)
        self.value = droits.capitalize()

    def is_modifiable(self, liste_droits):
        """
        Le droit est-il modifiable par un des droits dans liste_droits ?
        L'idée étant que pour modifier un droit, il faut avoir un droit plus fort
        """
        modifiables = set()
        for i in liste_droits:
            if i in DROITS_SUPERVISEUR:
                modifiables = modifiables.union(DROITS_SUPERVISEUR[i])
        modifiables = list(modifiables)

        return self.value in modifiables and super(droits, self).is_modifiable(liste_droits)

@crans_attribute
class solde(floatAttr):