Scénario : Appel des services Correspondence Management depuis un processus LiveCycle

Créez un service personnalisé basé sur une interface qui fait appel aux API Correspondence Management exposées pour effectuer la tâche personnalisée requise. Ci-dessous se trouve un exemple exposant un service pour récupérer le modèle de mise en page traité d’une correspondance et les données XML traitées, afin de les fusionner pour générer la correspondance dans un format personnalisé :

L’interface, IRenderServiceWrapper.java :

package com.adobe.livecycle.cmsa; 
import java.util.Map; 
import com.adobe.idp.Document; 
public interface IRenderServiceWrapper { 
    public abstract Map<String, Document> getProcessedTemplate(String letterName, String initialXmlData, Boolean useTestData); 
}

L’implémentation, RenderServiceWrapper.java :

package com.adobe.livecycle.cmsa; 
 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
 
import com.adobe.icc.dbforms.obj.Letter; 
import com.adobe.icc.dbforms.obj.Query; 
import com.adobe.icc.dbforms.obj.Statement; 
import com.adobe.icc.dbforms.obj.Statement.Operator; 
import com.adobe.icc.ddg.api.LetterRenderService; 
import com.adobe.icc.services.api.LetterService; 
import com.adobe.idp.Document; 
 
public class RenderServiceWrapper implements IRenderServiceWrapper { 
 
    private LetterRenderService renderService; 
    private LetterService letterService; 
 
    /** 
     * {@inheritDoc} 
     */ 
    public Map<String, Document> getProcessedTemplate(String letterName, String initialXmlData, Boolean useTestData) 
    { 
        Map<String, Document> result = new HashMap<String, Document>(); 
         
        if (letterName != null && !"".equals(letterName)) 
        {         
            Statement st = new Statement(); 
            st.setAttributeName("name"); 
            st.setOperator(Operator.EQUALS); 
            st.setAttributeValue(letterName); 
 
            Query query = new Query(); 
            query.setObjectType(Letter.class.getSimpleName()); 
            query.addStatement(st); 
            List<Letter> letters = letterService.getAllLetters(query); 
             
            if (letters.size() > 0) 
            { 
             
                Map<String, Object> processedData = renderService.processLetter(letters.get(0).getId(), initialXmlData, useTestData); 
                 
                Document xdp = new Document((byte[])processedData.get(LetterRenderService.LAYOUT_TEMPLATE_KEY)); 
                Document xml = new Document((byte[])processedData.get(LetterRenderService.XML_DATA_KEY)); 
                 
                result.put(LetterRenderService.LAYOUT_TEMPLATE_KEY, xdp); 
                result.put(LetterRenderService.XML_DATA_KEY, xml); 
            } 
            else 
                System.out.println("No Letter found with name : " + letterName); 
                 
        } 
        else 
            System.out.println("No Letter name provided."); 
         
        return result; 
    } 
     
    public LetterRenderService getRenderService() { 
        return renderService; 
    } 
 
    public void setRenderService(LetterRenderService renderService) { 
        this.renderService = renderService; 
    } 
 
    public LetterService getLetterService() { 
        return letterService; 
    } 
 
    public void setLetterService(LetterService letterService) { 
        this.letterService = letterService; 
    } 
}

Une fois que le service ci-dessus est implémenté, enregistrez-le en tant que bean Spring dans votre conteneur de service personnalisé (basé sur Spring) :

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> 
 
 
    <bean name="lc.remotingClientParent" 
        class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean" 
        abstract="true"> 
        <property name="httpInvokerRequestExecutor" ref="CRXAuthHttpInvokerRequestExecutor" /> 
    </bean> 
 
    <bean id="CRXAuthHttpInvokerRequestExecutor" 
        class="com.adobe.livecycle.spring.remoting.CRXAuthHttpInvokerRequestExecutor"> 
        <property name="appRoot" value="/content/apps/cm"/> 
    </bean> 
 
    <bean name="LetterService" parent="lc.remotingClientParent"> 
        <property name="serviceUrl" 
            value="${crx.serverUrl}/bin/remoting/lc.icc.dbservices.letterService" /> 
        <property name="serviceInterface" value="com.adobe.icc.services.api.LetterService" /> 
    </bean> 
     
    <bean name="LetterRenderService" parent="lc.remotingClientParent"> 
        <property name="serviceUrl" 
            value="${crx.serverUrl}/bin/remoting/lc.icc.renderlib.letterRenderService" /> 
        <property name="serviceInterface" value="com.adobe.icc.ddg.api.LetterRenderService" /> 
    </bean> 
 
    <bean name="RenderServiceWrapper" class="com.adobe.livecycle.cmsa.RenderServiceWrapper"> 
        <property name="renderService" ref="LetterRenderService" /> 
        <property name="letterService" ref="LetterService" /> 
    </bean> 
 
    <bean id="testProps" 
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
        <property name="locations"> 
            <list> 
                <value>classpath:cmsa.properties</value> 
                <value>file:C:/Adobe/config/cmsa.properties</value> 
            </list> 
        </property> 
    </bean> 
    
</beans>

Une fois que les services sont disponibles en tant que bean Spring, vous pouvez les exporter en tant que services LiveCycle. Définissez une implémentation com.adobe.idp.dsc.component.ServiceInstanceFactory (SpringServiceFactory.java) comme suit :

package com.adobe.livecycle.spring; 
 
import com.adobe.idp.dsc.DSCException; 
import com.adobe.idp.dsc.component.ComponentContext; 
import com.adobe.idp.dsc.component.support.AbstractServiceInstanceFactory; 
import com.adobe.idp.dsc.registry.infomodel.ServiceConfiguration; 
import org.springframework.beans.factory.BeanFactory; 
import org.springframework.context.access.ContextSingletonBeanFactoryLocator; 
 
public class SpringServiceFactory extends AbstractServiceInstanceFactory { 
    public void activateInstance(ServiceConfiguration serviceConfiguration, 
            Object o) { 
    } 
 
    public Object createInstance(ServiceConfiguration serviceConfiguration) 
            throws DSCException { 
        return getBeanFactory(serviceConfiguration).getBean( 
                serviceConfiguration.getServiceId()); 
    } 
 
    public void destroyInstance(ServiceConfiguration serviceConfiguration, 
            Object o) throws DSCException { 
    } 
 
    public void passivateInstance(ServiceConfiguration serviceConfiguration, 
            Object o) { 
    } 
 
    public boolean validateInstance(ServiceConfiguration serviceConfiguration, 
            Object o) { 
        return true; 
    } 
 
    private BeanFactory getBeanFactory(ServiceConfiguration serviceConfiguration) { 
        String componentId = serviceConfiguration.getComponentId(); 
        ComponentContext ctx = getComponentContext(); 
        ClassLoader cl = Thread.currentThread().getContextClassLoader(); 
        try { 
            Thread.currentThread().setContextClassLoader(ctx.getClassLoader()); 
            return ContextSingletonBeanFactoryLocator.getInstance( 
                    "classpath:/spring/beanRefContext.xml").useBeanFactory( 
                    componentId).getFactory(); 
        } finally { 
            Thread.currentThread().setContextClassLoader(cl); 
        } 
    } 
}

La fabrique de l’exemple ci-dessus nécessite un fichier de configuration Spring nommé beanRefContext.xml sous classpath:/spring, qui charge la configuration ou les beans Spring du client. Par exemple :

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" 
    xmlns:context="http://www.springframework.org/schema/context"> 
 
 
    <!-- 
     Note: The beanId must be same as the componentId 
    --> 
    <bean name="com.adobe.livecycle.cmsa.RenderWrapper" class="org.springframework.context.support.ClassPathXmlApplicationContext"> 
        <property name="configLocations"> 
            <value> 
                classpath:cmsa-spring-config.xml 
            </value> 
            </property> 
    </bean> 
 
</beans>

Suivez ces conventions pour simplifier les définitions de service ou de composant et exposer les beans en tant que service LiveCycle :

• L’ID ou le nom de bean dans beanRefContext.xml est le même que l’ID du composant, comme défini dans le fichier component.xml du conteneur de service.

• Le bean de service personnalisé a le même nom que l’ID de service LiveCycle, comme défini dans le fichier component.xml du conteneur de service.

Ensuite, définissez les détails du composant de conteneur de service dans son fichier component.xml comme suit :

<component xmlns="http://adobe.com/idp/dsc/component/document"> 
    <component-id>com.adobe.livecycle.cmsa.RenderWrapper</component-id> 
    <version>1.0</version> 
    <services> 
        <!-- Service name must be same as the name of the corresponding Spring 
            bean --> 
        <service name="RenderServiceWrapper" orchestrateable="true"> 
            <implementation-class>com.adobe.livecycle.cmsa.IRenderServiceWrapper 
            </implementation-class> 
            <auto-deploy service-id="RenderServiceWrapper" 
                minor-version="0" major-version="1" category-id="Correspondence Management" /> 
            <operations> 
                <operation name="getProcessedTemplate"> 
                    <input-parameter name="letterName" title="Letter Name" 
                        type="java.lang.String" /> 
                    <input-parameter name="initialXmlData" title="Initial XML Data (for DDI)" 
                        type="java.lang.String" /> 
                    <input-parameter name="useTestData" title="Use Letter Test Data?" 
                        type="java.lang.Boolean" /> 
                    <output-parameter name="result" 
                        title="Result Map with Layout and Data" type="java.util.Map" /> 
                </operation> 
            </operations> 
        </service> 
 
                  <!-- Mandatory service to capture CRX credentials --> 
        <service name="CRXUserCredentialService"> 
            <implementation-class>com.adobe.livecycle.crx.CRXUserCredentialService 
            </implementation-class> 
            <factory-method>getInstance</factory-method> 
            <supported-connectors></supported-connectors> 
            <auto-deploy major-version="1" service-id="CRXUserCredentialService" 
                category-id="Correspondence Management" /> 
            <config-parameter name="username" type="java.lang.String" 
                title="Username"> 
                <description>User name with which to connect to CM</description> 
                <default-value>admin</default-value> 
            </config-parameter> 
            <config-parameter name="password" type="java.lang.String" 
                title="Password"> 
                <description>Password for the above user</description> 
                <default-value>admin</default-value> 
                <property-editor editor-id="com.adobe.idp.dsc.propertyeditor.system.PasswordPropertyEditorComponent" /> 
            </config-parameter> 
            <operation-config> 
                <operation-name>*</operation-name> 
                <transaction-type>None</transaction-type> 
            </operation-config> 
        </service> 
    </services> 
    <supports-export>false</supports-export> 
    <class-path>lib/dom4j-1.6.1.jar lib/lc-content-api.jar lib/adobe-acm-client.jar lib/adobe-dct-client.jar lib/com.springsource.org.aopalliance-1.0.0.jar lib/spring-aop-3.0.2.RELEASE.jar lib/spring-asm-3.0.2.RELEASE.jar lib/spring-beans-3.0.2.RELEASE.jar lib/spring-context-3.0.2.RELEASE.jar lib/spring-core-3.0.2.RELEASE.jar lib/spring-expression-3.0.2.RELEASE.jar lib/spring-web-3.0.2.RELEASE.jar lib/spring-security-core-3.0.2.RELEASE.jar</class-path> 
 
    <service-factory-class>com.adobe.livecycle.spring.SpringServiceFactory 
    </service-factory-class> 
</component>