Hyland Connect

christophes · ‎07-25-2007

Bonjour,

J'aimerais pouvoir envoyer des mails au format HTML à partir d'un template (fichier .ftl) et via Javascript mais malheureusement, le mail n'est pas interprété. Comment indiquer au système que le mimetype est HTML ?

Pour info, j'utilise la fonction mail.parameters.template = <chemin d'accès>/fichier.ftl;

Merci d'avance,

Christophe

christophes · ‎07-30-2007

Personne n'a de réponse ou même un début de réponse ?

thomasb · ‎07-31-2007

C'est codé "en dur".

La solution serait donc de modifier le MailActionExecuter pour, par exemple, utiliser message.setText(text, true) au lieu de message.setText(text) (pour faire ça propre: créer une autre classe avec un gros copier/coller et redéfinir le <bean name="mail"> dans un extensions/*-context.xml; mais comme ça enverrai du HTML dans tous les cas, peut-être vaut-il mieux plutôt utiliser un <bean name="mailAsHtml"> et ne pas redéfinir <bean name="mail">)

En espérant avoir été clair…

christophes · ‎07-31-2007

Ok merci pour cette réponse, je vais regarder de ce côté-là.

christophes · ‎08-01-2007

Je viens de terminer de modifier/créer les fichiers comme tu me l'avais conseillé et ça fonctionne parfaitement. Encore un grand merci pour ton aide.

Pour ceux que ça intéresse :

MailHTMLActionExecuter.java

package org.alfresco.repo.action.executer;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;

import org.alfresco.model.ContentModel;
import org.alfresco.repo.action.ParameterDefinitionImpl;
import org.alfresco.repo.template.DateCompareMethod;
import org.alfresco.repo.template.HasAspectMethod;
import org.alfresco.repo.template.I18NMessageMethod;
import org.alfresco.service.ServiceRegistry;
import org.alfresco.service.cmr.action.Action;
import org.alfresco.service.cmr.action.ParameterDefinition;
import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.TemplateNode;
import org.alfresco.service.cmr.repository.TemplateService;
import org.alfresco.service.cmr.security.AuthenticationService;
import org.alfresco.service.cmr.security.AuthorityService;
import org.alfresco.service.cmr.security.AuthorityType;
import org.alfresco.service.cmr.security.PersonService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.mail.javamail.MimeMessagePreparator;

/**
 * Mail action executor implementation.
 * 
 * @author Roy Wetherall
 */
public class MailHTMLActionExecuter extends ActionExecuterAbstractBase
    implements InitializingBean
{
    private static Log logger = LogFactory.getLog(MailHTMLActionExecuter.class);
    
    /**
     * Action executor constants
     */
    public static final String NAME = "mailAsHTML"; // <– Modification de NAME
    public static final String PARAM_TO = "to";
    public static final String PARAM_TO_MANY = "to_many";
    public static final String PARAM_SUBJECT = "subject";
    public static final String PARAM_TEXT = "text";
    public static final String PARAM_FROM = "from";
    public static final String PARAM_TEMPLATE = "template";
    
    /**
     * From address
     */
    private static final String FROM_ADDRESS = "machin@bidule.be";
    
    /**
     * The java mail sender
     */
    private JavaMailSender javaMailSender;
    
    /**
     * The Template service
     */
    private TemplateService templateService;
    
    /**
     * The Person service
     */
    private PersonService personService;
    
    /**
     * The Authentication service
     */
    private AuthenticationService authService;
    
    /**
     * The Node Service
     */
    private NodeService nodeService;
    
    /**
     * The Authority Service
     */
    private AuthorityService authorityService;
    
    /**
     * The Service registry
     */
    private ServiceRegistry serviceRegistry;
    
    /**
     * Mail header encoding scheme
     */
    private String headerEncoding = null;
    
    /**
     * Default from address
     */
    private String fromAddress = null;
    
    /**
     * @param javaMailSender    the java mail sender
     */
    public void setMailService(JavaMailSender javaMailSender) 
    {
        this.javaMailSender = javaMailSender;
    }
    
    /**
     * @param templateService   the TemplateService
     */
    public void setTemplateService(TemplateService templateService)
    {
        this.templateService = templateService;
    }
    
    /**
     * @param personService     the PersonService
     */
    public void setPersonService(PersonService personService)
    {
        this.personService = personService;
    }
    
    /**
     * @param authService       the AuthenticationService
     */
    public void setAuthenticationService(AuthenticationService authService)
    {
        this.authService = authService;
    }
    
    /**
     * @param serviceRegistry   the ServiceRegistry
     */
    public void setServiceRegistry(ServiceRegistry serviceRegistry)
    {
        this.serviceRegistry = serviceRegistry;
    }
    
    /**
     * @param authorityService  the AuthorityService
     */
    public void setAuthorityService(AuthorityService authorityService)
    {
        this.authorityService = authorityService;
    }

    /**
     * @param nodeService       the NodeService to set.
     */
    public void setNodeService(NodeService nodeService)
    {
        this.nodeService = nodeService;
    }
    
    /**
     * @param headerEncoding     The mail header encoding to set.
     */
    public void setHeaderEncoding(String headerEncoding)
    {
        this.headerEncoding = headerEncoding;
    }

    /**
     * @param fromAddress   The default mail address.
     */
    public void setFromAddress(String fromAddress)
    {
        this.fromAddress = fromAddress;
    }

    /**
     * Initialise bean
     */
    public void afterPropertiesSet() throws Exception
    {
        if (fromAddress == null || fromAddress.length() == 0)
        {
            fromAddress = FROM_ADDRESS;
        }
    }
    
    /**
     * Execute the rule action
     */
    @Override
    protected void executeImpl(
            final Action ruleAction,
            final NodeRef actionedUponNodeRef) 
    {
        // Create the mime mail message
        MimeMessagePreparator mailPreparer = new MimeMessagePreparator()
        {
            public void prepare(MimeMessage mimeMessage) throws MessagingException
            {
                if (logger.isDebugEnabled())
                {
                   logger.debug(ruleAction.getParameterValues());
                }
                
                MimeMessageHelper message = new MimeMessageHelper(mimeMessage);
                
                // set header encoding if one has been supplied
                if (headerEncoding != null && headerEncoding.length() != 0)
                {
                    mimeMessage.setHeader("Content-Transfer-Encoding", headerEncoding);
                }
                
                // set recipient
                String to = (String)ruleAction.getParameterValue(PARAM_TO);
                if (to != null && to.length() != 0)
                {
                    message.setTo(to);
                }
                else
                {
                    // see if multiple recipients have been supplied - as a list of authorities
                    List<String> authorities = (List<String>)ruleAction.getParameterValue(PARAM_TO_MANY);
                    if (authorities != null && authorities.size() != 0)
                    {
                        List<String> recipients = new ArrayList<String>(authorities.size());
                        for (String authority : authorities)
                        {
                            AuthorityType authType = AuthorityType.getAuthorityType(authority);
                            if (authType.equals(AuthorityType.USER))
                            {
                                if (personService.personExists(authority) == true)
                                {
                                    NodeRef person = personService.getPerson(authority);
                                    String address = (String)nodeService.getProperty(person, ContentModel.PROP_EMAIL);
                                    if (address != null && address.length() != 0)
                                    {
                                        recipients.add(address);
                                    }
                                }
                            }
                            else if (authType.equals(AuthorityType.GROUP))
                            {
                                // else notify all members of the group
                                Set<String> users = authorityService.getContainedAuthorities(AuthorityType.USER, authority, false);
                                for (String userAuth : users)
                                {
                                    if (personService.personExists(userAuth) == true)
                                    {
                                        NodeRef person = personService.getPerson(userAuth);
                                        String address = (String)nodeService.getProperty(person, ContentModel.PROP_EMAIL);
                                        if (address != null && address.length() != 0)
                                        {
                                            recipients.add(address);
                                        }
                                    }
                                }
                            }
                        }
                        
                        message.setTo(recipients.toArray(new String[recipients.size()]));
                    }
                    else
                    {
                        // No recipiants have been specified
                        logger.error("No recipiant has been specified for the mail action");
                    }
                }
                
                // set subject line
                message.setSubject((String)ruleAction.getParameterValue(PARAM_SUBJECT));
                
                // See if an email template has been specified
                String text = null;
                NodeRef templateRef = (NodeRef)ruleAction.getParameterValue(PARAM_TEMPLATE);
                if (templateRef != null)
                {
                    // build the email template model
                    Map<String, Object> model = createEmailTemplateModel(actionedUponNodeRef);
                    
                    // process the template against the model
                    text = templateService.processTemplate("freemarker", templateRef.toString(), model);
                }
                
                // set the text body of the message
                if (text == null)
                {
                    text = (String)ruleAction.getParameterValue(PARAM_TEXT);
                }
                message.setText(text, true); // <– Ajout de true comme second argument
                
                // set the from address - use the default if not set
                String from = (String)ruleAction.getParameterValue(PARAM_FROM);
                if (from == null || from.length() == 0)
                {
                    message.setFrom(fromAddress);
                }
                else
                {
                    message.setFrom(from);
                }
            }
        };
        
        try
        {
            // Send the message
            javaMailSender.send(mailPreparer);
        }
        catch (Throwable e)
        {
            // don't stop the action but let admins know email is not getting sent
            String to = (String)ruleAction.getParameterValue(PARAM_TO);
            if (to == null)
            {
               Object obj = ruleAction.getParameterValue(PARAM_TO_MANY);
               if (obj != null)
               {
                  to = obj.toString();
               }
            }
            
            logger.error("Failed to send email to " + to, e);
        }
    }

   /**
    * @param ref    The node representing the current document ref
    * 
    * @return Model map for email templates
    */
   private Map<String, Object> createEmailTemplateModel(NodeRef ref)
   {
      Map<String, Object> model = new HashMap<String, Object>(8, 1.0f);
      
      NodeRef person = personService.getPerson(authService.getCurrentUserName());
      model.put("person", new TemplateNode(person, serviceRegistry, null));
      model.put("document", new TemplateNode(ref, serviceRegistry, null));
      NodeRef parent = serviceRegistry.getNodeService().getPrimaryParent(ref).getParentRef();
      model.put("space", new TemplateNode(parent, serviceRegistry, null));
      
      // current date/time is useful to have and isn't supplied by FreeMarker by default
      model.put("date", new Date());
      
      // add custom method objects
      model.put("hasAspect", new HasAspectMethod());
      model.put("message", new I18NMessageMethod());
      model.put("dateCompare", new DateCompareMethod());
      
      return model;
   }
    
    /**
     * Add the parameter definitions
     */
    @Override
    protected void addParameterDefinitions(List<ParameterDefinition> paramList) 
    {
        paramList.add(new ParameterDefinitionImpl(PARAM_TO, DataTypeDefinition.TEXT, false, getParamDisplayLabel(PARAM_TO)));
        paramList.add(new ParameterDefinitionImpl(PARAM_TO_MANY, DataTypeDefinition.TEXT, false, getParamDisplayLabel(PARAM_TO_MANY), true));
        paramList.add(new ParameterDefinitionImpl(PARAM_SUBJECT, DataTypeDefinition.TEXT, true, getParamDisplayLabel(PARAM_SUBJECT)));
        paramList.add(new ParameterDefinitionImpl(PARAM_TEXT, DataTypeDefinition.TEXT, true, getParamDisplayLabel(PARAM_TEXT)));
        paramList.add(new ParameterDefinitionImpl(PARAM_FROM, DataTypeDefinition.TEXT, false, getParamDisplayLabel(PARAM_FROM)));
        paramList.add(new ParameterDefinitionImpl(PARAM_TEMPLATE, DataTypeDefinition.NODE_REF, false, getParamDisplayLabel(PARAM_TEMPLATE)));
    }

}‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

*-context.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>

    <!– mailAsHTML –>
    <bean id="mailAsHTML" class="org.alfresco.repo.action.executer.MailHTMLActionExecuter" parent="action-executer">
        <property name="mailService">
            <ref bean="mailService"></ref>
        </property>
        <property name="templateService">
            <ref bean="templateService"></ref>
        </property>
        <property name="personService">
            <ref bean="personService"></ref>
        </property>
        <property name="authenticationService">
            <ref bean="authenticationService"></ref>
        </property>
        <property name="nodeService">
            <ref bean="nodeService"></ref>
        </property>
        <property name="authorityService">
            <ref bean="authorityService"></ref>
        </property>
        <property name="serviceRegistry">
            <ref bean="ServiceRegistry"></ref>
        </property>
        <property name="headerEncoding">
            <value>${mail.header}</value>
        </property>
        <property name="fromAddress">
            <value>${mail.from.default}</value>
        </property>
    </bean>‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

et enfin, la façon d'utiliser cette nouvelle classe :

var mail = actions.create("mailAsHTML");
mail.parameters.to = <adresse destinataire>;
mail.parameters.subject = <sujet>; 
mail.parameters.from = <adresse expéditeur>;
mail.parameters.template =<chemin d'accès au fichier .ftl>;
mail.parameters.text = <texte par défaut si le template n'est pas trouvé>;
mail.execute();‍‍‍‍‍‍‍

michaelh · ‎08-01-2007

Un grand merci pour le retour !

Je garde un signet pour le jour où on ouvrira la section "trucs et astuces" sur le wiki

Edit : C'est fait http://wiki.alfresco.com/fr/index.php/Envoyer_des_mails_au_format_HTML_%C3%A0_partir_d%27un_template...

fafhrd · ‎08-18-2008

Bonjour,

Je viens de suivre le modèle donné pour envoyer des mails en HTML.

Lorsque j'envois mon mail en Javascript, je reçois l'erreur suivante : La méthode 'org.alfresco.repo.jscript.ScriptAction.execute()' est introuvable (AlfrescoScript#74)

La ligne 74 correspond à mail.execute();

Le poste le code js complet :

var mail = actions.create("mailAsHTML");
      mail.parameters.to = document.properties['{http://www.alfresco.org/model/alcatel-lucent/gerard/gdoc/1.0}approbateur1'];
      mail.parameters.subject = "Un nouveau document GDOC vient d’être proposé dans Alfresco sous l’espace "+destination.name;
      mail.parameters.template = companyhome.childByNamePath("Company Home/Data Dictionary/Email Templates/appro_tech_notif_arrivee.ftl");
      mail.parameters.text = "notification";
      mail.execute();‍‍‍‍‍‍

Le bean a l'air d'être reconnu et rempli. Est-ce que vous auriez une idée sur la question ?

michel · ‎08-25-2008

Bonjour,

L'erreur vient du fait qu'il faut exécuter une action sur un document ou un espace, pour que ton template FTL puisse rependre des informations (style le nom du document).
La solution est la suivante:


mail.execute(document);
‍‍‍

Bien à Toi.

sebguillomon · ‎02-18-2009

Bonjour,

J'ai réalisé une action exactement comme décrit dans la documentation et pourtant cela semble ne pas fonctionner, j'ai fait une action récupérant les groupes de l'utilisateur :


public class UserGroupsAction extends ActionExecuterAbstractBase implements InitializingBean {

   /**
     * The Service registry
     */
    private ServiceRegistry serviceRegistry;
    
    private String userName;
    
   @Override
   protected void executeImpl(Action action, NodeRef nodeRef) {
      userName = action.getParameterValue(Constants.PARAM_USER_NAME).toString();
      System.out.println("Search groups of user : " + userName);
      
      Set<String> groups = serviceRegistry.getAuthorityService().getAuthoritiesForUser(userName);
      
      String strgroups = "";
      int i = 0;
      for ( String str : groups ){
         if ( i>0 )
            strgroups += ",";
         
         strgroups += str;
         i++;
      }
      
      action.setParameterValue(Constants.PARAM_USER_GROUPS, strgroups);
      System.out.println("Groups of user : " + strgroups);
   }

   @Override
   protected void addParameterDefinitions(List<ParameterDefinition> paramList) {
      paramList.add(new ParameterDefinitionImpl(Constants.PARAM_USER_NAME, DataTypeDefinition.TEXT, true, "user to find"));
      paramList.add(new ParameterDefinitionImpl(Constants.PARAM_USER_GROUPS, DataTypeDefinition.TEXT, false, "user groups"));
   }

   public void afterPropertiesSet() throws Exception {
      // rien
   }

    /**
     * @param serviceRegistry   the ServiceRegistry
     */
    public void setServiceRegistry(ServiceRegistry serviceRegistry)
    {
        this.serviceRegistry = serviceRegistry;
    }
}
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

Voici le code de l'appel webservice :


ActionServiceSoapBindingStub actionService = WebServiceFactory.getActionService();
Action action = new Action();
NamedValue nv = new NamedValue();
nv.setName(Constants.PARAM_USER_NAME);
nv.setValue("neil");
NamedValue nv2 = new NamedValue();
nv2.setName(Constants.PARAM_USER_GROUPS);
nv2.setValue("");
action.setActionName("userGroupsAction");
action.setParameters(new NamedValue[]{nv,nv2});
ActionExecutionResult[] results = actionService.executeActions(prd, new Action[]{action});
‍‍‍‍‍‍‍‍‍‍‍‍‍

L'action est bien exécutée sans erreur car j'ai dans ma console :


Search groups of user : neil
Groups of user : GROUP_ADMINISTRATOR_SUBGROUP,GROUP_ALFRESCO_ADMINISTRATORS,GROUP_EVERYONE,ROLE_ADMINISTRATOR
‍‍‍‍

Or dans ma variable "results" je n'ai pas de variable "Constants.PARAM_USER_GROUPS" initialisée avec la bonne valeur!!

Une idée ?
Merci bcp

riogrande · ‎06-18-2009

Vous avez une idée comme on peut récupérer en JavaScript la "Interface Language" de l'utilisateur pour envoyer un mail en fonction de sa langue (et donc crée un template pour chaque langue) ?

Hyland Connect

J'aimerais pouvoir envoyer des mails au format HTML...