Plume

Rédiger vos emails depuis Flower

    Plume est un plugin ARender permettant de rédiger des emails depuis votre navigateur WEB.

    Ce plugin est accessible à travers une nouvelle icône dans la barre de menu ARender.


    Parmis ses principales fonctionnalités, Plume vous permet de :

    • Rédiger un email
    • Répondre à un email
    • Transférer des documents visualisés
    • Sélectionner un modèle parmis la bibliothèque
    • Définir une signature adaptée à chaque utilisateur

Deux types de packaging sont fournis :

  • WAR (à déployer dans le même serveur d’application que la GUI)
  • JAR exécutable

WAR

Lorsque Plume est déployée en tant qu’application WEB dans un conteneur de servlet, il est nécessaire d’ajouter une propriété plume.config.dir, au niveau de la JVM. Cette propriété doit référencé le répertoire dans lequel est stocké le fichier de configuration plume.properties.

Le nom du fichier de configuration peut être changé en ajoutant la propriété spring.config.name avec comme valeur le nom du fichier (sans extension).

JAR exécutable

La configuration de l’application est basée sur les mécanismes Spring Boot. Les propriétés permettant de configurer Plume et ses connecteurs peuvent être fournies de différentes manières :

  • Par une propriété de la JVM :

    java -D<name>=<value> -jar plume-<version>.jar
    
  • Par un fichier de propriété. Le nom de ce fichier (sans extension) doit être fourni comme propriété de la JVM spring.config.name. A l’exécution, ce fichier sera cherché par Spring dans les répertoires suivants :

    • Le sous-répertoire /config du répertoire courant (/ d’exécution)
    • Le répertoire courant


Cette documentation décrit les différents connecteurs disponibles pour Plume. Il faut à minima en définir un dans le fichier plume.properties présent dans le dossier plume.config.dir renseigné dans la partie précédente.

L’expéditeur du mail est renseigné par la propriété email.from avec pour valeur par défaut plume@arondor.com.

Connecteurs

Flower

Le connecteur Flower permet de stocker les emails rédigés à l’aide de Plume dans Flower. Pour l’activer, il est nécessaire d’ajouter la propriété flower.enabled=true.

De plus, il est nécessaire de renseigner la propriété flower.url avec l’URL des web services Flower.

flower.enabled=true
flower.url=http://<host>:<port>/<Core path>/services

SMTP

Le connecteur SMTP permet l’envoie d’un email rédigé dans Plume en utilisant le protocole SMTP. Pour activer ce connecteur, il est nécessaire de rajouter la propriété smtp.enabled=true

smtp.enabled=true
smtp.host=SSL0.OVH.NET
smtp.username=no-reply@flowerdocs.com
smtp.password=***
smtp.parameters.socketFactory.port=465
smtp.parameters.socketFactory.class=javax.net.ssl.SSLSocketFactory
smtp.parameters.starttls.enable=true

Il est possible de rajouter des paramètres au connecteur SMTP en ajoutant des propriétés smtp.parameters.<name>=<value>.

Activation dans l’IHM

Afin d’activer Plume dans ARender, il faut :

  • Ajouter la propriété plume.enabled dans le profil fourni à ARender

    	gui.client.arender.profile=arender&plume.enabled=true
    
  • Configurer Plume comme un plugin de la GUI :

    	plugins.routes.plume.path=/plume/**
    	plugins.routes.plume.url=http://localhost:8080/plume
    

Pour plus d’informations, concernant l’utilisation de plugin de la GUI, la documentation est disponible ici.

Ces modèles sont déterminés à partir d’une recherche de document de classe Template (cette classe peut être modifiée par la propriété flower.template.class). Les modèles doivent donc être accessibles aux utilisateurs utilisant Plume.

Filtres

Les modèles disponnibles pour un utilisateur peuvent être filtrés en fonction de différents filtres.

Le premier concerne la source de modèle. Dans cette documentation, seuls les modèles issus de Flower sont documentés, c’est pourquoi les différents exemples de filtres ont la propriété source valorisée à flower.


Il est également possible de définir des filtres sur des tags portés par les modèles. Par exemple, si la classe Template possède un tag TemplateType, il est posssible de définir un ensemble de filtres tel que :

var filters = { "source": [ "flower" ], "TemplateType": ["Custom"] };

Types de modèle

En fonction du type de modèles, différentes fonctions doivent être appelées pour initialiser le plugin Plume.

Corps de l’email

Le premier type de modèle concerne le corps de l’email à rédiger.

context.getTemplatesComponent().initTemplates(filters);

Signature

Le second type de modèle concerne la signature de l’utilisateur rédigeant l’email.

context.initSignature(filters);

Variables

La notion de variable peut être utilisée au sein des modèles afin de les pré-remplir et ainsi faciliter la rédaction d’un email.


Par défaut, plusieurs variables sont valorisées par défaut comme :

  • les tags : l’ensemble des tags du composant ouvert sont ajoutés comme variable
  • l’URL de la GUI : flowerURL
  • le nom de l’utilisateur connecté : userDisplayName
  • l’adresse email de l’utilisateur connecté : userMail
  • le scope courant : scope


Il est également posssible de rajouter des variables personnalisées :

$wnd.getARenderJS().preparePluginEvent("<name>", "<value>", "plume");


Une fois définies, ces variables peuvent être utilisés dans les modèles tel que {variableName}.

Indexation du courrier sortant

Les emails rédigés depuis Plume peuvent être stockés dans Flower. Pour cela, il peut être nécessaire de les indexer pour être capable de les retrouver.

L’indexation de ces courriers sortants se fait à l’aide d’un PreProcessor. Cet objet permet de manipuler l’email, côté client, avant qu’il ne soit envoyé côté serveur pour traitement.


Dans l’exemple ci-dessous, on indexe l’email rédigé à partir du composant ouvert :

context.setPreProcessor(function(email){ 
	var component = JSAPI.get().getLastComponentFormAPI().getComponent();
	email.properties={};
	email.properties.classid="CourrierSortant";
	email.properties.name=email.subject;
	email.properties.CanalEntree=component.getTagValue("CanalEntree");
	email.properties.RefClient=component.getTagValue("RefClient");
});

Clustering


Cette section adresse la situation où un cluster Plume doit être déployé si l’affinité de session n’est pas préservée. Dans ce cas plusieurs aspects doivent être pris en compte.

Pour centraliser les différentes données stockées au niveau d’une instance du cluster, il est nécessaire d’installer la base de données clé-valeur Redis et de configurer son accès depuis Plume. Pour cela, il est nécessaire de définir les propriétés suivantes :

spring.redis.host=<redis host>
spring.redis.port=6379


Pour plus d’information, consulter la documentation Spring Data Redis

Sessions

Plume s’appuie sur la session utilisateur pour sauvegarder les emails en cours de rédaction. Il est donc nécessaire de stocker les sessions dans Redis. Pour utiliser Redis comme backend de stockage des sessions HTTP, ajouter la propriété :

spring.session.store-type=redis

Caches

Différentes données sont stockées en cache pour des questions de performances. Ces caches doivent donc être répliqués sur chacune des instances du cluster. Pour cela, ajouter la propriété suivante :

spring.cache.type=redis

Fichiers temporaires

Le dernier aspect à prendre en compte est la gestion des fichiers temporaires utilisés pour stocker les pièces jointes d’un email. Celles-ci sont stockées, de manière temporaire, dans un répertoire (par défaut: ${java.io.tmpdir}/plume/attachments ). Ce répertoire doit être partagé entre les différentes instances du cluster. Pour cela, il est possible de modifier l’emplacement du répertoire utilisé avec la propriété plume.tmp.dir.

Logs

La gestion des logs est basée sur Spring et son intégration de Logback. Pour configurer les logs générés par l’application, il suffit donc d’ajouter les propriétés voulues dans le fichier de propriété.

Le niveau de log défini par défaut est INFO.

Quelques exemples de configuration :

  • Pour modifier le niveau de logs de l’application :

    logging.level.root=trace
    
  • Pour modifier le niveau de logs de l’application :

    logging.level.com.arondor=ERROR
    
  • Pour définir le fichier de log utilisé :

    logging.file=plume.log  
    


Pour plus d’information, consulter la documentation Spring Boot Logging

Session

La durée de la session peuvent être configurée avec les paramètres suivants :

server.servlet.session.timeout=30
server.servlet.session.cookie.max-age=30