def token(self, domain):
            """Getter du Token

                Arguments : Aucun

                Retour :
                    string : token pour connexion à l'API

                Exception:
                    BSSConnexion en cas d'Erreur lors de la récupération du token

                Example d'utilisation :
                    >>>con = BSSConnexion("domain.com","6b7ead4bd425836e8cf0079cd6c1a05acc127acd07c8ee4b61023e19250e929c")
                    >>>token = con.token
                    >>>try:
                    ... print(token) #doctest: +ELLIPSIS
                    ...except BSSConnexionException as err:
                    ... print("BSS Erreur: {0}".format(err))
                    ...
                Description :
                    Le token ayant une durée de vie de 5min on le regénère si il est plus vieux que 4min30s
                    Si l'ecart entre le timestamp actuel et le timestamp de l'obtention du dernier token est de moins de 270 secondes (4min30s)
                    on renvoie le token actuel. Au delà on génère un nouveau token
            """
            if isinstance(domain, str):
                if utils.checkIsDomain(domain):

                    self._domain = domain
                    """Le domaine sur lequel on souhaite travailler"""
                    if domain not in self._key:
                        raise DomainException(domain + " : Domaine non initialisé")
                    actualTimestamp = round(time())
                    if (actualTimestamp - self._timestampOfLastToken[domain]) < int( self._ttl * .9 ):
                        return self._token[domain]
                    else:
                        self._timestampOfLastToken[domain] = actualTimestamp
                        msg = domain + "|" + str(actualTimestamp)
                        preAuth = hmac.new(self._key[domain].encode("utf-8"), msg.encode("utf-8"), hashlib.sha1).hexdigest()
                        data = {
                            "domain": domain,
                            "timestamp": str(round(time())),
                            "preauth": preAuth
                        }
                        response = postBSS(self._url + "/Auth", data)
                        status_code = utils.changeToInt(response["status"])
                        message = response["message"]
                        if status_code == 0:
                            self._token[domain] = response["token"]
                        else:
                            raise BSSConnexionException(status_code, message)
                        return self._token[domain]
                else:
                    raise DomainException(domain+" n'est pas un nom de domain valide")
            else:
                raise TypeError
def callMethod(domain, methodName, data):
    """
    Méthode permettant d'appeler une méthode de l'API BSS

    :param domain: le nom de domaine
    :param methodName: le nom de la méthode à appeler
    :param data: le body de la requête
    :return: la réponse reçue de l'API BSS
    :raises ServiceException: Exception levée si la requête vers l'API à echoué. L'exception contient le code de l'erreur et le message
    :raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
    """
    con = BSSConnexion()
    return postBSS(con.url+"/"+methodName+"/"+con.token(domain), data)