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.javapackage 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();
