def getGroup(name, full_info=False):
"""
Lit les informations concernant un groupe.
:param name: l'adresse mail du groupe ou de la liste de distribution
:param full_info: une requête additionnelle permettant de lister \
les expéditeurs autorisés doit-elle être effectuée ?
:raises NameException: l'adresse de groupe spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
:return: le groupe, sous la forme d'une instance du modèle, ou bien None \
si aucun groupe ne correspond au nom spécifié
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail {} n'est pas valide".format(name))
data = {'name': name}
domain = services.extractDomain(name)
response = callMethod(domain, 'GetGroup', data)
try:
checkResponseStatus(response)
except NotFoundException:
return None
group = Group.from_bss(response['group'])
if full_info:
getSendAsGroup(group)
return group
def createAccountExt(account, password):
"""
Méthode permettant de créer un compte via l'API BSS en lui passant en
paramètre les informations concernant un compte ainsi qu'une empreinte de
mot de passe.
:param Account account: l'objet contenant les informations du compte \
utilisateur
:param str password: l'empreinte du mot de passe de l'utilisateur
:raises ServiceException: la requête vers l'API a echoué. L'exception \
contient le code de l'erreur et le message.
:raises NameException: le nom du compte n'est pas une adresse mail valide, \
ou le mot de passe spécifié n'est pas une empreinte.
:raises DomainException: le domaine de l'adresse mail n'est pas un domaine \
valide.
"""
if not re.search(r'^\{\S+\}', password):
raise NameException(
"Le format de l'empreinte du mot de passe " +
"n'est pas correcte ; format attendu : {algo}empreinte")
data = account.toData()
data.update({
'password': '',
'userPassword': password,
})
response = callMethod(services.extractDomain(account.name),
'CreateAccount', data)
if not utils.checkResponseStatus(response['status']):
raise ServiceException(response['status'], response['message'])
def RemoveRootShare(account, recipients=[]):
"""
Cet appel permet de retirer un partage root d'une boites de service d'un ou plusieurs utilisateurs
:param account: Adresse email du compte qui fournit le partage root
:param recipients: un tableau contenant les adresses des comptes à qui supprimer le partage.
:raises NameError: si l'adresse du partage à créer est invalide
"""
data = {}
# Si la liste est vide
if not (recipients):
raise TypeError
# On vérifie si le mail est valide
if not utils.checkIsMailAddress(account):
raise NameException(
"L'adresse mail {} n'est pas valide".format(account))
else:
# Préparation des attributs
data.update({"account": account, "recipients[]": recipients})
response = callMethod(services.extractDomain(account),
"/account/RemoveRootShare", data)
checkResponseStatus(response)
def deleteGroup(name_or_group):
"""
Supprime un groupe.
:param name_or_group: le nom du groupe, ou bien l'instance de modèle \
correspondante.
:raises NameException: l'adresse de groupe spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
if isinstance(name_or_group, Group):
if name_or_group.name is None:
raise NameException("L'adresse mail n'est pas renseignée")
data = {'name': name_or_group.name}
else:
if not isinstance(name_or_group, str):
raise TypeError
data = {'name': name_or_group}
if not utils.checkIsMailAddress(data['name']):
raise NameException("L'adresse mail {} n'est pas valide".format(n))
domain = services.extractDomain(data['name'])
response = callMethod(domain, 'DeleteGroup', data)
checkResponseStatus(response)
def addRootShare(account, recipients=[], rights=["sendAs"]):
"""
Ajoute les droits de partage sur une boite fonctionnelle
:param account: le nom de la boite (adresse mail).
:param recipients: un tableau contenant les adresses des comptes à qui autoriser le partage.
:param rights: Les droit donnés pour l'envoi de mail:\
sendAs="en tant que", sendOnBehalfOf="de la part de"
:raises TypeError: si la liste recipients est vide
:raises NameError: si l'adresse du partage à créer est invalide
"""
data = {}
# Si la liste est vide
if not (recipients):
raise TypeError
# On vérifie si le mail est valide
if not utils.checkIsMailAddress(account):
raise NameException(
"L'adresse mail {} n'est pas valide".format(account))
else:
# Préparation des attributs
data.update({
"account": account,
"recipients[]": recipients,
"rights[]": rights
})
response = callMethod(services.extractDomain(account),
"/account/AddRootShare", data)
checkResponseStatus(response)
def setPassword(name, newPassword):
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
data = {"name": name, "password": newPassword}
response = callMethod(services.extractDomain(name), "SetPassword", data)
if not utils.checkResponseStatus(response["status"]):
raise ServiceException(response["status"], response["message"])
def RemoveRecipientsFromRootShare(account, recipients=[]):
"""
Retire les droits de partage sur une boite fonctionnelle
:param account: le nom de la boite (adresse mail).
:param recipients: un tableau contenant les adresses des comptes à qui supprimer le partage.
:raises TypeError: si la liste recipients est vide
:raises NameError: si l'adresse du partage à créer est invalide
"""
data = {}
# Si la liste est vide
if not (recipients):
raise TypeError
# On vérifie si le mail est valide
if not utils.checkIsMailAddress(account):
raise NameException(
"L'adresse mail {} n'est pas valide".format(account))
else:
# Préparation des attributs
data.update({"account": account, "recipients[]": recipients})
response = callMethod(services.extractDomain(account),
"/account/RemoveRecipientsFromRootShare", data)
checkResponseStatus(response)
def createResource(name,
displayName=None,
userPassword=None,
zimbraCalResType="Location",
password=None):
"""
Crée une ressource en se basant sur une instance du
modèle, ou simplement en utilisant un nom.
:param name: identifiant de la ressource
:param displayName: nom affiché
:param userPassword: empreinte du mot de passe
:param zimbraCalResType: type de la ressource
:param password: mot de passe en clair
:raises TypeError: si le paramètre n'est ni un nom ni une instance du modèle
:raises NameError: si l'adresse de la ressource à créer est invalide
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
# Les attributs issus de l'objet account
data = {}
# Les attributs obligatoires
if password is not None:
data.update({
'name': name,
'password': password,
'zimbraCalResType': zimbraCalResType,
'zimbraAccountStatus': "active",
'displayName': displayName
})
else:
if not re.search(r'^\{\S+\}', userPassword):
raise NameException(
"Le format de l'empreinte du mot de passe n'est pas correcte ; format attendu : {algo}empreinte"
)
data.update({
'name': name,
'userPassword': userPassword,
'zimbraCalResType': zimbraCalResType,
'zimbraAccountStatus': "active",
'displayName': displayName
})
if not utils.checkIsMailAddress(data['name']):
raise NameException("L'adresse mail {} n'est pas valide".format(name))
domain = services.extractDomain(data['name'])
response = callMethod(domain, 'CreateResource', data)
checkResponseStatus(response)
return getResource(name)
def modifyAccount(account):
"""
Permet de modifier un compte via l'API
:param account: un objets compte avec les attributs à changer
: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 NameException: Exception levée si le nom n'est pas une adresse mail preSupprimé
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
response = callMethod(services.extractDomain(account.name), "ModifyAccount", account.toData())
checkResponseStatus(response)
def modifyResource(resource):
"""
Modifie les informations concernant une ressource.
:param resource: l'instance du modèle contenant les nouvelles informations \
ainsi que l'adresse de la ressource à modifier
:raises NameException: l'adresse de la ressource spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
response = callMethod(services.extractDomain(resource.name),
'ModifyResource', resource.toData())
checkResponseStatus(response)
def deleteAccount(name):
"""
Permet de supprimer un compte
:param name: Nom du compte à supprimer
: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 NameException: Exception levée si le nom n'est pas une adresse mail valide
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
data = {"name": name}
response = callMethod(services.extractDomain(name), "DeleteAccount", data)
if not utils.checkResponseStatus(response["status"]):
raise ServiceException(response["status"], response["message"])
def modifyGroup(group):
"""
Modifie les informations concernant un groupe. Les membres, alias et
autorisations ne sont pas affectés.
:param group: l'instance du modèle contenant les nouvelles informations \
ainsi que l'adresse du groupe à modifier
:raises NameException: l'adresse de groupe spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
response = callMethod(services.extractDomain(group.name), 'ModifyGroup',
group.to_bss())
checkResponseStatus(response)
def renameAccount(name, newName):
"""
Permet de renommer un compte :param name: nom du compte à renommer :param newName: le nouveau nom du compte
:param name: le nom du compte à renommer
:param newName: le nouveau nom du compte
: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 NameException: Exception levée si le nom n'est pas une adresse mail preSupprimé
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not utils.checkIsMailAddress(name) or not utils.checkIsMailAddress(
newName):
raise NameException("L'adresse mail n'est pas valide")
data = {"name": name, "newname": newName}
response = callMethod(services.extractDomain(name), "RenameAccount", data)
if not utils.checkResponseStatus(response["status"]):
raise ServiceException(response["status"], response["message"])
def _group_set_op(name_or_group, entries, f_name, op_name):
"""
Fonction interne utilisée pour effectuer les ajouts ou suppressions sur les
listes de membres, d'alias et d'autorisations d'expédition d'un groupe.
:param name_or_group: le nom du groupe à modifier, ou l'instance du modèle \
correspondante
:param entries: l'entrée ou les entrées à ajouter ou supprimer
:param f_name: le nom du champ tel qu'il doit être envoyé à l'API BSS; si \
le nom finit par '[]', toutes les informations seront envoyées \
en un seul appel
:param op_name: le nom de la méthode distante à utiliser
:raises TypeError: le groupe n'est ni un nom, ni une instance de modèle
:raises NameException: l'adresse de groupe ou l'une des entrées est \
incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
if isinstance(entries, str):
entries = [entries]
else:
entries = list(entries)
if isinstance(name_or_group, Group):
name = name_or_group.name
else:
if not isinstance(name_or_group, str):
raise TypeError
name = name_or_group
for n in (name, *entries):
if not utils.checkIsMailAddress(n):
raise NameException("L'adresse mail {} n'est pas valide".format(n))
domain = services.extractDomain(name)
if '[]' in f_name:
entries = [entries]
for entry in entries:
data = {
'name': name,
f_name: entry,
}
response = callMethod(domain, op_name, data)
checkResponseStatus(response)
def removeAccountAlias(name, aliasToDelete):
"""
Méthode permettant de supprimer un alias d'un compte
:param name: le nom du compte
:param aliasToDelete: l'alias a supprimer
: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 NameException: Exception levée si le nom n'est pas une adresse mail preSupprimé
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not utils.checkIsMailAddress(name) or not utils.checkIsMailAddress(aliasToDelete):
raise NameException("L'adresse mail " + name +" ou "+aliasToDelete+" n'est pas valide")
data = {
"name": name,
"alias": aliasToDelete
}
response = callMethod(services.extractDomain(name), "RemoveAccountAlias", data)
checkResponseStatus(response)
def createGroup(name_or_group):
"""
Crée un groupe ou une liste de distribution en se basant sur une instance du
modèle, ou simplement en utilisant un nom.
Si une instance est utilisée et que des alias, des membres ou des
autorisations d'expéditions sont présents dans l'instance, ils seront
ajoutés au groupe sur Partage après sa création.
:param name_or_group: le nom du groupe à créer, ou bien une instance du \
modèle contenant les informations initiales au sujet du groupe.
:raises TypeError: si le paramètre n'est ni un nom ni une instance du modèle
:raises NameError: si l'adresse du groupe à créer est invalide, ou si \
l'une des autres informations de ce type (alias, membres, \
autorisation) est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
"""
is_group = isinstance(name_or_group, Group)
if is_group:
if name_or_group.name is None:
raise NameException("L'adresse mail n'est pas renseignée")
data = name_or_group.to_bss()
else:
if not isinstance(name_or_group, str):
raise TypeError
data = {'name': name_or_group}
if not utils.checkIsMailAddress(data['name']):
raise NameException("L'adresse mail {} n'est pas valide".format(n))
domain = services.extractDomain(data['name'])
response = callMethod(domain, 'CreateGroup', data)
checkResponseStatus(response)
if not is_group:
return
if name_or_group.has_aliases:
addGroupAliases(name_or_group.name, name_or_group.aliases)
if name_or_group.has_members:
addGroupMembers(name_or_group.name, name_or_group.members)
if name_or_group.has_senders:
addGroupSenders(name_or_group.name, name_or_group.senders)
def createResourceExt(resource: Resource):
"""
Méthode permettant de créer une ressource via l'API BSS en lui passant en
paramètre les informations concernant un compte
:param Resource resource: l'objet contenant les informations de la resource
"""
if not utils.checkIsMailAddress(resource.name):
raise NameException("L'adresse mail " + resource.name +
" n'est pas valide")
data = resource.toData()
domain = services.extractDomain(resource.name)
response = callMethod(domain, 'CreateResource', data)
checkResponseStatus(response)
return resource
def createAccount(name,userPassword, cosId = None, account = None):
"""
Méthode permettant de créer un compte via l'API BSS en lui passant en paramètre l'empreinte du mot de passe (SSHA) et le cosId
:param userPassword: l'empreine du mot de passe de l'utilisateur
:param cosId: l'identifiant du cosId à appliquer pour le compte
:param account: objet account contenant les informations à ajouter dans le compte (optionnel)
:return: Le compte créé
: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 NameException: Exception levée si le nom n'est pas une adresse mail valide
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not re.search(r'^\{\S+\}', userPassword):
raise NameException("Le format de l'empreinte du mot de passe n'est pas correcte ; format attendu : {algo}empreinte")
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
# Les attributs issus de l'objet account
data = {}
if account is not None:
data = account.toData()
# Les attributs obligatoires
data.update({
"name": name,
"password": "",
"userPassword": userPassword,
"zimbraHideInGal": "FALSE"
})
if cosId is not None:
data["zimbraCOSId"]= cosId
response = callMethod(services.extractDomain(name), "CreateAccount", data)
checkResponseStatus(response)
# if account is not None:
# modifyAccount(account)
return getAccount(name)
def getAccount(name):
"""
Méthode permettant de récupérer les informations d'un compte via l'API BSS
:return: Le compte récupéré ou None si le compte n'existe pas
: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 NameException: Exception levée si le nom n'est pas une adresse mail valide
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
data = {"name": name}
response = callMethod(services.extractDomain(name), "GetAccount", data)
if utils.checkResponseStatus(response["status"]):
account = response["account"]
return fillAccount(account)
elif re.search(".*no such account.*", response["message"]):
return None
else:
raise ServiceException(response["status"], response["message"])
def modifyPassword(name, newUserPassword):
"""
Pour modifier le mot de passe on n'accepte que l'empreinte du mot de passe.
On commence par faire un SetPassword avec une valeur factice pour forcer la déconnexion des sessions en cours
On passe ensuite via ModifyAccount l'empreinte du nouveau mot de passe
:param newUserPassword:
: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 NameException: Exception levée si le nom n'est pas une adresse mail preSupprimé
:raises DomainException: Exception levée si le domaine de l'adresse mail n'est pas un domaine valide
"""
if not re.search(r'^\{\S+\}', newUserPassword):
raise NameException(
"Le format de l'empreinte du mot de passe n'est pas correcte ; format attendu : {algo}empreinte"
)
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
setPassword(name, "valeurPourDeconnecterLesSessions")
data = {"name": name, "userPassword": newUserPassword}
response = callMethod(services.extractDomain(name), "ModifyAccount", data)
if not utils.checkResponseStatus(response["status"]):
raise ServiceException(response["status"], response["message"])
def RemoveRootDelegate(account, right=["sendAs"]):
"""
Cet appel permet de retirer aux bénéficiaires d'un partage root le droit d'envoyer des email \
"en tant que" et/ou "de la part de" de la boite de service source.
:param account: Adresse email du compte qui fournit le partage root
:param rights: Les droit retirés pour l'envoi de mail:\
sendAs="en tant que", sendOnBehalfOf="de la part de"
:raises NameError: si l'adresse du partage à créer est invalide
"""
data = {}
# On vérifie si le mail est valide
if not utils.checkIsMailAddress(account):
raise NameException(
"L'adresse mail {} n'est pas valide".format(account))
else:
# Préparation des attributs
data.update({"account": account, "right": right})
response = callMethod(services.extractDomain(account),
"/account/RemoveRootDelegate", data)
checkResponseStatus(response)
def getResource(name):
"""
Lit les informations concernant une ressource.
:param name: l'adresse mail de la resource
:raises NameException: l'adresse de groupe spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
:return: la Ressource, sous la forme d'une instance du modèle, ou bien None \
si aucune resource ne correspond au nom spécifié
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail {} n'est pas valide".format(name))
data = {'name': name}
domain = services.extractDomain(name)
response = callMethod(domain, 'GetResource', data)
try:
checkResponseStatus(response)
except NotFoundException:
return None
resource = response['resource']
return Resource.from_bss(resource)
def getSendAsGroup(name_or_group):
"""
Lit la liste des utilisateurs autorisés à expédier du mail en utilisant
l'adresse d'un groupe comme expéditeur.
:param name_or_group: l'adresse d'un groupe ou l'instance correspondant au \
groupe pour lequel on veut lire la liste des autorisations. Si une \
instance est passée, son champ 'senders' sera mis à jour
:raises NameException: l'adresse de groupe spécifiée est incorrecte
:raises ServiceException: la requête vers l'API a echoué
:raises DomainException: le domaine n'est pas valide
:return: l'ensemble des utilisateurs autorisés, ou None si le groupe n'a \
pas été trouvé
"""
if isinstance(name_or_group, Group):
name = name_or_group.name
group = name_or_group
else:
name = name_or_group
if not utils.checkIsMailAddress(name):
raise NameException(
"L'adresse mail {} n'est pas valide".format(name))
group = Group(name)
data = {'name': name}
domain = services.extractDomain(name)
response = callMethod(domain, 'GetSendAsGroup', data)
try:
checkResponseStatus(response)
except NotFoundException:
return None
return group.senders_from_bss(response)
