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 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 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 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 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 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 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 fillAccount(accountResponse):
"""
Permet de remplir un objet compte depuis une réponse de l'API BSS
:param accountResponse: l'objet account renvoyé par l'API
:return: l'objet account 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
"""
if not utils.checkIsMailAddress(accountResponse["name"]):
raise NameException("L'adresse mail " + accountResponse["name"] + " n'est pas valide")
retAccount = models.Account(accountResponse["name"])
accountKeys = accountResponse.keys()
for attr in accountKeys:
if accountResponse[attr] is not None:
if isinstance(accountResponse[attr], str):
if accountResponse[attr] == "TRUE" or accountResponse[attr] == "FALSE":
retAccount.__setattr__("_" + attr, utils.changeStringToBoolean(accountResponse[attr]))
else:
retAccount.__setattr__("_" + attr, accountResponse[attr])
elif isinstance(accountResponse[attr], OrderedDict):
if "type" in accountResponse[attr].keys():
if accountResponse[attr]["type"] == "integer":
retAccount.__setattr__("_" + attr, int(accountResponse[attr]["content"]))
elif accountResponse[attr]["type"] == "array":
if attr == "zimbraZimletAvailableZimlets":
retAccount.__setattr__("_" + attr, accountResponse[attr]["zimbraZimletAvailableZimlet"])
elif attr == "zimbraMailAlias":
retAccount.__setattr__("_" + attr, accountResponse[attr]["zimbraMailAlias"])
return retAccount
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 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 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 modifyAccountAliases(name, listOfAliases):
"""
Méthode permettant de changer l'ensemble des alias d'un compte par ceux passés en paramètre
:param name: le nom du compte
:param listOfAliases: la liste des alias pour le 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
:raises TypeError: Exception levée si le parametre listOfAliases n'est pas une liste
"""
if not utils.checkIsMailAddress(name):
raise NameException("L'adresse mail " + name + " n'est pas valide")
if not isinstance(listOfAliases, list):
raise TypeError
account = getAccount(name)
#On vérifie que les adresses mail passées en paramètres sont des adresses valide
for alias in listOfAliases:
if not utils.checkIsMailAddress(alias):
raise NameException("L'adresse mail " + alias +
" n'est pas valide")
#On parcour la liste passé en paramètre
for alias in listOfAliases:
if isinstance(account.zimbraMailAlias, list) or isinstance(
account.zimbraMailAlias, str):
#si la l'adresse mail n'est pas présente dans partage on la rajoute
if alias not in account.zimbraMailAlias:
addAccountAlias(name, alias)
#si la liste partage est vide on rajoute l'adresse
elif account.zimbraMailAlias is None:
addAccountAlias(name, alias)
if isinstance(account.zimbraMailAlias, list):
#On parcours la liste des adresses partages
for alias in account.zimbraMailAlias:
#Si l'adresse n'est pas présente dans la liste passé en parametre on supprime l'adresse de partage
if alias not in listOfAliases:
removeAccountAlias(name, alias)
#Si le compte n'a qu'un alias on test si il est présent ou pas dans la liste passé en paramètre
elif isinstance(account.zimbraMailAlias, str):
if account.zimbraMailAlias not in listOfAliases:
removeAccountAlias(name, account.zimbraMailAlias)
def extractDomain(mailAddress):
"""
Méthode permettant d'extraire le domaine d'une adresse mail
:param mailAddress: adresse mail pour extraire le domaine
:return: le nom de domaine
:raises NameException: Exception levée si l'adresse mail n'est pas valide
"""
if utils.checkIsMailAddress(mailAddress):
return mailAddress.split("@")[1]
else:
raise NameException("L'adresse mail " + mailAddress + " n'est pas valide")
def restorePreDeleteAccount(name):
"""
Permet d'annuler la préSuppression d'un compte
:param name: le nom du compte preSupprimé à restaurer
: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.checkIsPreDeleteAccount(name):
raise NameException("L'adresse mail " + name + " n'est pas une adresse mail preSupprimé")
activateAccount(name)
renameAccount(name, name.split("_")[2])
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 activateAccount(name):
"""
Méthode permettant de passer l'état d'un compte à activer
:param name: le nom du compte à (ré)activer
: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):
raise NameException("L'adresse mail " + name + " n'est pas valide")
account = models.Account(name)
account.zimbraAccountStatus = "active"
modifyAccount(account)
def add_mail_suffix_( self , original , suffix ):
"""
Ajoute un suffixe à la partie "utilisateur" d'une adresse mail.
:param original: l'adresse mail originale
:param suffix: le suffixe à ajouter
:return: l'adresse modifiée
"""
from lib_Partage_BSS.exceptions import NameException
spl_name = original.split( '@' )
if len( spl_name ) != 2:
raise NameException( 'Adresse {} invalide'.format( original ) )
name = '{}-{}@{}'.format( spl_name[ 0 ] , suffix , spl_name[ 1 ] )
return name
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 _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 preDeleteAccount(name):
"""
Permet de mettre un compte dans un état de préSuppression
Cette méthode désactive le compte puis le renomme (ajout d'un préfixe 'deleted_timestampactuel_name')
:param name: nom du compte à pré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")
closeAccount(name)
newname = "readytodelete_" + utils.changeTimestampToDate(round(
time())) + "_" + name
renameAccount(name, newname)
return newname
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 closeAccount(name):
"""
Cette méthode déconnecte toutes les instances du compte et empêche la connexion à celui-ci.
Le compte ne sera plus visible dans la GAL et les mails entrants seront rejetés
:param name: le nom du compte à Désactiver
: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):
raise NameException("L'adresse mail n'est pas valide")
setPassword(name, "valeurPourDeconnecterLesSessions")
account = models.Account(name)
account.zimbraAccountStatus = "closed"
account.zimbraHideInGal = True
modifyAccount(account)
def lockAccount(name):
"""
Méthode permettant de passer l'état d'un compte à lock
Cette état déconnecte toutes les instances du compte et empêche la connexion à celui-ci.
Le compte sera toujours visible dans la GAL et les mails seront toujours acheminés vers cette boîte
:param name: le nom du compte à verrouiller
: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):
raise NameException("L'adresse mail " + name + " n'est pas valide")
setPassword(name, "valeurPourDeconnecterLesSessions")
account = models.Account(name)
account.zimbraAccountStatus = "locked"
modifyAccount(account)
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 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 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 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 preDeleteAccount(name):
"""
Permet de mettre un compte dans un état de préSuppression
Cette méthode désactive le compte puis le renomme (ajout d'un préfixe 'deleted_timestampactuel_name')
:param name: nom du compte à pré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")
closeAccount(name)
newname = "readytodelete_"+utils.changeTimestampToDate(round(time()))+"_"+name
renameAccount(name, newname)
# On altère l'EPPN (champ carLicense) pour éviter un conflit en cas de création d'un compte avec même EPPN
account = getAccount(newname)
account2 = models.Account(newname)
account2.carLicense = "DISABLED_" + account.carLicense
modifyAccount(account2)
return newname
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)
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)