def setDomainKey(self, listDomainKey):
"""Getter du domaine
:param listDomainKey: une liste conntenant l'emsemble des domaine à initialiser. Formate de la liste
{"domaine1" : "keydomain1", "domaine2" : "keydomain2"}
Example d'utilisation :
>>>con = BSSConnexion()
>>>con.setDomainKey({"domaine1" : "keydomain1", "domaine2" : "keydomain2"} )
"""
if not isinstance(listDomainKey, dict):
raise TypeError
for domain in listDomainKey:
if not utils.checkIsDomain(domain):
raise DomainException(domain +
" n'est pas un nom de domain valide")
self._key[domain] = listDomainKey[domain]
self._timestampOfLastToken[domain] = 0
self._token[domain] = ""
def getAllAccounts(domain, limit=100, offset=0, ldapQuery="", attrs="", sortBy="", sortAscending=1):
"""
Permet de rechercher tous les comptes mail d'un domain
:param domain: le domaine de la recherche
:param limit: le nombre de résultats renvoyés (optionnel)
:param offset: le nombre à partir duquel les comptes sont renvoyés (optionnel)
:param ldapQuery: un filtre ldap pour affiner la rechercher (optionnel)
:param sortBy: tri des résultat (mail, givenName, sn, displayName)
:param sortAscending: tri ascendant ou descendant (0 ou 1)
:param attrs: la liste des attributs demandés (par défaut: used , quota, admin, cos_name) (optionnel)
: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 n'est pas un domaine valide
"""
if not utils.checkIsDomain(domain):
raise DomainException(domain + " n'est pas un nom de domain valide")
data = {
"limit": limit,
"offset": offset,
"ldap_query": ldapQuery,
"attrs": attrs,
"sortby": sortBy,
"sortascending": sortAscending
}
response = callMethod(domain, "GetAllAccounts", data)
checkResponseStatus(response)
if len(response["accounts"]) == 1:
return []
else:
accounts = response["accounts"]["account"]
retAccounts = []
if isinstance(accounts, list):
for account in accounts:
retAccounts.append(fillAccount(account))
else:
retAccounts.append(fillAccount(accounts))
return retAccounts
def test_checkIsDomain_casFalseDomainAvecExtension1caractere():
assert not checkIsDomain("domain.f")
def test_checkIsDomain_casFalseDomainAvecExtension5caracteres():
assert not checkIsDomain("domain.franc")
def test_checkIsDomain_casTrueDomainAvecSousDomaine():
assert checkIsDomain("test.domain.fr")
def test_checkIsDomain_casTrueDomainAvecExtension4caracteres():
assert checkIsDomain("domain.fran")
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