Richiamo dei processi a lunga durata incentrati sull'uomo invoking-human-centric-long-lived-processes
È possibile richiamare programmaticamente i processi a lunga vita incentrati sulle persone creati in Workbench utilizzando le seguenti applicazioni client:
- Applicazione client basata su Web Java che utilizza l'API di vocazione. (Vedi Richiamo di AEM Forms tramite l’API Java(https://experienceleague.adobe.com/docs/experience-manager-64/forms/developer-reference/programming-aem-forms-jee/invoking-aem-forms-jee-apis/invoking-aem-forms-using-java.html?lang=it#invoking-aem-forms-using-the-java-api).
- Applicazione ASP.NET che utilizza servizi Web. (Vedi Richiamo di AEM Forms tramite servizi web.)
- Applicazione client integrata con Flex che utilizza Remoting. (Vedi Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)
Il processo a lungo termine richiamato viene denominato FirstAppSolution/PreLoanProcess. Puoi creare questo processo seguendo l’esercitazione specificata in Creazione della prima applicazione AEM Forms.
Un processo incentrato sulle persone comporta un’attività a cui un utente può rispondere utilizzando Workspace. Ad esempio, utilizzando Workbench, è possibile creare un processo che consenta a un responsabile bancario di approvare o negare un'applicazione di prestito. La figura seguente illustra il processo FirstAppSolution/PreLoanProcess.
Il processo* FirstAppSolution/PreLoanProcess* accetta un parametro di input denominato* formData* il cui tipo di dati è XML. I dati XML vengono uniti con una struttura del modulo denominata PreLoanForm.xdp. Nell'illustrazione seguente viene illustrato un modulo che rappresenta un'attività assegnata a un utente per approvare o negare una richiesta di prestito. L’utente approva o nega l’applicazione utilizzando Workspace. L’utente di Workspace può approvare la richiesta di prestito facendo clic sul pulsante Approva mostrato nella figura seguente. Allo stesso modo, l'utente può negare la richiesta di prestito facendo clic sul pulsante nega.
Un processo longevo viene richiamato in modo asincrono e non può essere richiamato in modo sincrono a causa dei seguenti fattori:
- Un processo può avere un periodo di tempo significativo.
- Un processo può superare i limiti organizzativi.
- Per completare un processo, è necessario un input esterno. Ad esempio, si consideri una situazione in cui un modulo viene inviato a un responsabile che non è in ufficio. In questa situazione, il processo non viene completato finché il responsabile non restituisce e compila il modulo.
Quando si richiama un processo di lunga durata, AEM Forms crea un valore di identificatore di chiamata come parte della creazione di un record. Il record tiene traccia dello stato del processo di lunga durata e viene memorizzato nel database AEM Forms. Utilizzando il valore dell'identificatore di chiamata, puoi tenere traccia dello stato del processo di lunga durata. Inoltre, è possibile utilizzare il valore dell'identificatore di chiamata del processo per eseguire operazioni di Process Manager, ad esempio la terminazione di un'istanza di processo in esecuzione.
La FirstAppSolution/PreLoanProcess
Il processo viene richiamato quando un richiedente invia una domanda, rappresentata come dati XML. Il nome della variabile del processo di input è formData
e il relativo tipo di dati è XML. Ai fini della presente discussione, si presuppone che i seguenti dati XML siano utilizzati come input per la FirstAppSolution/PreLoanProcess
processo.
<?xml version="1.0" encoding="UTF-8"?>
<LoanApp>
<Name>Sam White</Name>
<LoanAmount>250000</LoanAmount>
<PhoneOrEmail>(555)555-5555</PhoneOrEmail>
<ApprovalStatus>PENDING APPROVAL</ApprovalStatus>
</LoanApp>
I dati XML trasmessi a un processo devono corrispondere ai campi presenti nel modulo utilizzato nel processo. In caso contrario, i dati non vengono visualizzati all’interno del modulo. Tutte le applicazioni che richiamano il FirstAppSolution/PreLoanProcess
Il processo deve passare questa origine dati XML. Le applicazioni create in Richiamo dei processi a lunga durata incentrati sull'uomo creare dinamicamente l'origine dati XML dai valori immessi da un utente in un client web.
Utilizzando un'applicazione client, puoi inviare *FirstAppSolution/PreLoanProcess elabora i dati XML richiesti. Un processo di lunga durata restituisce come valore restituito un valore di identificatore di chiamata. La figura seguente mostra le applicazioni client che richiamano PrimoAppSolution/PreLoanProcess *processo a lungo termine. Le applicazioni client inviano dati XML e restituiscono un valore stringa che rappresenta il valore dell'identificatore di chiamata.
Consulta anche
Creazione di un'applicazione web Java che richiama un processo longevo incentrato sull'uomo
Creazione di un'applicazione web Java che richiama un processo longevo incentrato sull'uomo creating-a-java-web-application-that-invokes-a-human-centric-long-lived-process
Puoi creare un'applicazione basata sul Web che utilizza un servlet Java per richiamare l' FirstAppSolution/PreLoanProcess
processo. Per richiamare questo processo da un servlet Java, utilizza l’API di chiamata all’interno del servlet Java. (Vedi Richiamo di AEM Forms tramite l’API Java.)
L'illustrazione seguente mostra un'applicazione client basata su Web che pubblica nome, telefono (o e-mail) e valori di importo. Questi valori vengono inviati al servlet Java quando l’utente fa clic sul pulsante Invia applicazione.
Il servlet Java esegue le seguenti attività:
- Recupera i valori inviati dalla pagina HTML al servlet Java.
- Crea in modo dinamico un'origine dati XML da passare al processo* FirstAppSolution/PreLoanProcess *. Il nome, il telefono (o l'e-mail) e i valori di quantità sono specificati nell'origine dati XML.
- Richiama il FirstAppSolution/PreLoanProcess mediante l’API di esortazione di AEM Forms.
- Restituisce il valore dell'identificatore di chiamata al browser Web client.
Riepilogo dei passaggi summary-of-steps
Per creare un'applicazione Java basata sul Web che richiama il FirstAppSolution/PreLoanProcess
esegui le seguenti operazioni:
Creare un progetto web create-a-web-project
Il primo passo per creare un'applicazione web è quello di creare un progetto web. L'IDE Java su cui si basa questo documento è Eclipse 3.3. Utilizzando l'IDE Eclipse, crea un progetto web e aggiungi i file JAR richiesti al progetto. Aggiungi al tuo progetto una pagina HTML denominata *index.html *e un servlet Java.
L’elenco seguente specifica i file JAR da includere nel progetto Web:
- adobe-livecycle-client.jar
- adobe-usermanager-client.jar
- J2EE.jar
Per la posizione di questi file JAR, vedi Inclusione dei file libreria Java di AEM Forms.
Creare un progetto web
- Avvia Eclipse e fai clic su File > Nuovo progetto.
- In Nuovo progetto finestra di dialogo, seleziona Web > Progetto web dinamico.
- Tipo
InvokePreLoanProcess
per il nome del progetto, quindi fai clic su Fine.
Aggiungi i file JAR richiesti al progetto
- Nella finestra Esplora progetti fare clic con il pulsante destro del mouse sul pulsante
InvokePreLoanProcess
progetto e seleziona Proprietà. - Fai clic su Percorso build Java quindi fai clic sul pulsante Librerie scheda .
- Fai clic sul pulsante Aggiungi JAR esterni e naviga ai file JAR da includere.
Aggiungere un servlet Java al progetto
- Nella finestra Esplora progetti fare clic con il pulsante destro del mouse sul pulsante
InvokePreLoanProcess
progetto e seleziona Nuovo > Altro. - Espandi la Web cartella, seleziona Servlet, quindi fai clic su Successivo.
- Nella finestra di dialogo Crea servlet digitare
SubmitXML
per il nome del servlet, quindi fai clic su Fine.
Aggiungere una pagina HTML al progetto
- Nella finestra Esplora progetti fare clic con il pulsante destro del mouse sul pulsante
InvokePreLoanProcess
progetto e seleziona Nuovo > Altro. - Espandi la Web cartella, seleziona HTML e fai clic su Successivo.
- Nella finestra di dialogo Nuovo HTML, digitare
index.html
per il nome del file, quindi fai clic su Fine.
Creare una logica di applicazione Java per il servlet create-java-application-logic-for-the-servlet
Creare una logica di applicazione Java che richiama l’ FirstAppSolution/PreLoanProcess
dall’interno del servlet Java. Il codice seguente mostra la sintassi della SubmitXML
Servlet Java:
public class SubmitXML extends HttpServlet implements Servlet {
public void doGet(HttpServletRequest req, HttpServletResponse resp
throws ServletException, IOException {
doPost(req,resp);
}
public void doPost(HttpServletRequest req, HttpServletResponse resp
throws ServletException, IOException {
//Add code here to invoke the FirstAppSolution/PreLoanProcess process
}
Normalmente, non inserisci il codice client all'interno di un servlet Java doGet
o doPost
metodo . Una migliore pratica di programmazione consiste nel collocare questo codice all'interno di una classe separata. Quindi crea un'istanza della classe all'interno della doPost
metodo (o doGet
e chiamare i metodi appropriati. Tuttavia, per la brevità del codice, gli esempi di codice sono limitati al minimo e vengono inseriti nel doPost
metodo .
Per richiamare FirstAppSolution/PreLoanProcess
Procedi utilizzando l'API di vocazione ed esegui le seguenti attività:
-
Includi file JAR client, come adobe-livecycle-client.jar, nel percorso di classe del progetto Java. Per informazioni sulla posizione di questi file, vedi Inclusione dei file libreria Java di AEM Forms.
-
Recupera il nome, il telefono e i valori di quantità inviati dalla pagina HTML. Utilizzare questi valori per creare in modo dinamico un'origine dati XML inviata al
FirstAppSolution/PreLoanProcess
processo. È possibile utilizzareorg.w3c.dom
classi per creare l'origine dati XML (questa logica di applicazione viene mostrata nell'esempio di codice seguente). -
Crea un
ServiceClientFactory
oggetto contenente le proprietà di connessione. (Vedi Impostazione delle proprietà di connessione.) -
Crea un
ServiceClient
utilizzando il relativo costruttore e passandoServiceClientFactory
oggetto. AServiceClient
consente di richiamare un'operazione del servizio. Gestisce attività quali l'individuazione, l'invio e l'indirizzamento delle richieste di chiamata. -
Crea un
java.util.HashMap
utilizzando il relativo costruttore. -
Richiama il
java.util.HashMap
dell’oggettoput
metodo per ogni parametro di input da passare al processo longevo. Assicurati di specificare il nome dei parametri di input del processo. PerchéFirstAppSolution/PreLoanProcess
il processo richiede un parametro di input di tipoXML
(denominatoformData
), è sufficiente richiamareput
metodo una volta.code language-as3 //Get the XML to pass to the FirstAppSolution/PreLoanProcess process org.w3c.dom.Document inXML = GetDataSource(name,phone,amount); //Create a Map object to store the parameter value Map params = new HashMap(); params.put("formData", inXML);
-
Crea un
InvocationRequest
richiamando l'oggettoServiceClientFactory
dell’oggettocreateInvocationRequest
e passando i seguenti valori:- Valore stringa che specifica il nome del processo a lunga durata da richiamare. Per richiamare
FirstAppSolution/PreLoanProcess
processo, specificareFirstAppSolution/PreLoanProcess
. - Valore stringa che rappresenta il nome dell'operazione di processo. Il nome dell'operazione di processo a lungo termine è
invoke
. - La
java.util.HashMap
oggetto contenente i valori dei parametri richiesti dall'operazione del servizio. - Un valore booleano che specifica
false
, che crea una richiesta asincrona (questo valore è applicabile per richiamare un processo longevo).
note note NOTE Un processo di breve durata può essere invocato passando il valore true come quarto parametro del metodo createInvocationRequest. Passando il valore true si crea una richiesta sincrona. - Valore stringa che specifica il nome del processo a lunga durata da richiamare. Per richiamare
-
Invia la richiesta di chiamata ad AEM Forms richiamando il
ServiceClient
dell’oggettoinvoke
e passareInvocationRequest
oggetto. Lainvoke
restituisce unInvocationReponse
oggetto. -
Un processo longevo restituisce un valore stringa che rappresenta un valore di identificazione di chiamata. Recupera questo valore richiamando il
InvocationReponse
dell’oggettogetInvocationId
metodo .code language-as3 //Send the invocation request to the long-lived process and //get back an invocation response object InvocationResponse lcResponse = myServiceClient.invoke(lcRequest); String invocationId = lcResponse.getInvocationId();
-
Scrivi il valore di identificazione della chiamata al browser Web del client. Puoi utilizzare un
java.io.PrintWriter
istanza per scrivere questo valore nel browser Web client.
Avvio rapido: Richiamare un processo di lunga durata utilizzando l’API di richiamo quick-start-invoking-a-long-lived-process-using-the-invocation-api
Il seguente esempio di codice Java rappresenta il servlet Java che richiama il FirstAppSolution/PreLoanProcess
processo.
/*
* This Java Quick Start uses the following JAR files
* 1. adobe-livecycle-client.jar
* 2. adobe-usermanager-client.jar
*
* (Because this quick start is implemented as a Java servlet, it is
* not necessary to include J2EE specific JAR files - the Java project
* that contains this quick start is exported as a WAR file which
* is deployed to the J2EE application server)
*
* These JAR files are located in the following path:
* <install directory>/sdk/client-libs/common
*
* For complete details about the location of these JAR files,
* see "Including AEM Forms library files" in Programming with AEM forms
* */
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import com.adobe.idp.dsc.clientsdk.ServiceClientFactory;
import com.adobe.idp.dsc.clientsdk.ServiceClientFactoryProperties;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import com.adobe.idp.dsc.InvocationRequest;
import com.adobe.idp.dsc.InvocationResponse;
import com.adobe.idp.dsc.clientsdk.ServiceClient;
import org.w3c.dom.Element;
public class SubmitXML extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
static final long serialVersionUID = 1L;
public SubmitXML() {
super();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doPost(request,response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try{
//Set connection properties required to invoke AEM Forms
Properties connectionProps = new Properties();
connectionProps.setProperty(ServiceClientFactoryProperties.DSC_DEFAULT_EJB_ENDPOINT, "jnp://localhost:1099");
connectionProps.setProperty(ServiceClientFactoryProperties.DSC_TRANSPORT_PROTOCOL,ServiceClientFactoryProperties.DSC_EJB_PROTOCOL);
connectionProps.setProperty(ServiceClientFactoryProperties.DSC_SERVER_TYPE, "JBoss");
connectionProps.setProperty(ServiceClientFactoryProperties.DSC_CREDENTIAL_USERNAME, "administrator");
connectionProps.setProperty(ServiceClientFactoryProperties.DSC_CREDENTIAL_PASSWORD, "password");
//Create a ServiceClientFactory object
ServiceClientFactory myFactory = ServiceClientFactory.createInstance(connectionProps);
//Create a ServiceClient object
ServiceClient myServiceClient = myFactory.getServiceClient();
//Get the values that are passed from the Loan HTML page
String name = (String)request.getParameter("name");
String phone = (String)request.getParameter("phone");
String amount = (String)request.getParameter("amount");
//Create XML to pass to the FirstAppSolution/PreLoanProcess process
org.w3c.dom.Document inXML = GetDataSource(name,phone,amount);
//Create a Map object to store the XML input parameter value
Map params = new HashMap();
params.put("formData", inXML);
//Create an InvocationRequest object
InvocationRequest lcRequest = myFactory.createInvocationRequest(
"FirstAppSolution/PreLoanProcess", //Specify the long-lived process name
"invoke", //Specify the operation name
params, //Specify input values
false); //Create an asynchronous request
//Send the invocation request to the long-lived process and
//get back an invocation response object
InvocationResponse lcResponse = myServiceClient.invoke(lcRequest);
String invocationId = lcResponse.getInvocationId();
//Create a PrintWriter instance
PrintWriter pp = response.getWriter();
//Write the invocation identifier value back to the client web browser
pp.println("The job status identifier value is: " +invocationId);
}catch (Exception e) {
System.out.println("The following exception occurred: "+e.getMessage());
}
}
//Create XML data to pass to the long-lived process
private static org.w3c.dom.Document GetDataSource(String name, String phone, String amount)
{
org.w3c.dom.Document document = null;
try
{
//Create DocumentBuilderFactory and DocumentBuilder objects
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
//Create a new Document object
document = builder.newDocument();
//Create MortgageApp - the root element in the XML
Element root = (Element)document.createElement("LoanApp");
document.appendChild(root);
//Create an XML element for Name
Element nameElement = (Element)document.createElement("Name");
nameElement.appendChild(document.createTextNode(name));
root.appendChild(nameElement);
//Create an XML element for Phone
Element phoneElement = (Element)document.createElement("PhoneOrEmail");
phoneElement.appendChild(document.createTextNode(phone));
root.appendChild(phoneElement);
//Create an XML element for amount
Element loanElement = (Element)document.createElement("LoanAmount");
loanElement.appendChild(document.createTextNode(amount));
root.appendChild(loanElement);
//Create an XML element for ApprovalStatus
Element approveElement = (Element)document.createElement("ApprovalStatus");
approveElement.appendChild(document.createTextNode("PENDING APPROVAL"));
root.appendChild(approveElement);
}
catch (Exception e) {
System.out.println("The following exception occurred: "+e.getMessage());
}
return document;
}
}
Creare la pagina Web per l'applicazione Web create-the-web-page-for-the-web-application
La pagina web* index.html *fornisce un punto di ingresso al servlet Java che richiama il FirstAppSolution/PreLoanProcess
processo. Questa pagina web è un modulo HTML di base contenente un modulo HTML e un pulsante di invio. Quando l’utente fa clic sul pulsante di invio, i dati del modulo vengono inviati al SubmitXML
Servlet Java.
Il servlet Java acquisisce i dati inviati dalla pagina HTML utilizzando il seguente codice Java:
//Get the values that are passed from the Loan HTML page
String name = request.getParameter("name");
String phone = request.getParameter("phone");
String amount = request.getParameter("amount");
Il seguente codice HTML rappresenta il file index.html creato durante l'installazione dell'ambiente di sviluppo. (Vedi Creare un progetto web.)
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<table>
<TBODY>
<TR>
<td><img src="financeCorpLogo.jpg" width="172" height="62"></TD>
<td><FONT size="+2"><strong>Java Loan Application Page</strong></FONT></TD>
<td> </TD>
<td> </TD>
</TR>
</TBODY>
</TABLE>
<FORM action="https://hiro-xp:8080/PreLoanProcess/SubmitXML" method="post">
<table>
<TBODY>
<TR>
<td><LABEL for="name">Name: </LABEL></TD>
<td><INPUT type="text" name="name"></TD>
<td><input type="submit" value="Submit Application"></TD>
</TR>
<TR>
<td> <LABEL for="phone">Phone/Email: </LABEL></TD>
<td><INPUT type="text" name="phone"></TD>
<td></TD>
</TR>
<TR>
<td><LABEL for="amount">Amount: </LABEL></TD>
<td><INPUT type="text" name="amount"></TD>
<td></TD>
</TR>
</TBODY>
</TABLE>
</FORM>
</body>
</html>
Creare un pacchetto dell'applicazione Web in un file WAR package-the-web-application-to-a-war-file
Per distribuire il servlet Java che richiama il FirstAppSolution/PreLoanProcess
elaborare, creare un pacchetto dell'applicazione Web in un file WAR. Assicurati che nel file WAR siano inclusi anche i file JAR esterni da cui dipende la logica di business del componente, come adobe-livecycle-client.jar e adobe-usermanager-client.jar.
L’illustrazione seguente mostra il contenuto del progetto Eclipse, che viene assemblato in un file WAR.
Creare un pacchetto di un'applicazione web in un file WAR:
- Da Esplora progetti fare clic con il pulsante destro del mouse sulla finestra
InvokePreLoanProcess
progetto e seleziona Esporta > File WAR. - In Modulo web casella di testo, tipo
InvokePreLoanProcess
nome del progetto Java. - In Destinazione casella di testo, tipo
PreLoanProcess.war
per nome file, specificare il percorso del file WAR, quindi fare clic su Fine.
Distribuire il file WAR al server applicazioni J2EE che ospita AEM Forms deploy-the-war-file-to-the-j2ee-application-server-hosting-aem-forms
Distribuisci il file WAR al server dell'applicazione J2EE in cui viene distribuito AEM Forms. Per distribuire il file WAR al server applicazioni J2EE, copia il file WAR dal percorso di esportazione in [Installazione AEM Forms]\Adobe\Adobe Experience Manager Forms\jboss\server\lc_turnkey\deploy.
Test dell'applicazione web test-your-web-application
Dopo aver distribuito l'applicazione web, puoi testarla utilizzando un browser web. Supponendo di utilizzare lo stesso computer che ospita AEM Forms, puoi specificare il seguente URL:
-
http://localhost:8080/PreLoanProcess/index.html
Immettere i valori nei campi del modulo HTML e fare clic sul pulsante Invia applicazione. Se si verificano dei problemi, vedere il file di registro dell'application server J2EE.
note note NOTE Per confermare che l'applicazione Java ha richiamato il processo, avviare Workspace e accettare il prestito.
Creazione di un'applicazione Web ASP.NET che richiama un processo di lunga durata incentrato sull'uomo creating-an-asp-net-web-application-that-invokes-a-human-centric-long-lived-process
È possibile creare un'applicazione ASP.NET che richiama FirstAppSolution/PreLoanProcess
processo. Per richiamare questo processo da un'applicazione ASP.NET, utilizzare i servizi Web. (Vedi Richiamo di AEM Forms tramite i servizi web.)
Nell'illustrazione seguente viene illustrato un'applicazione client ASP.NET che ottiene dati da un utente finale. I dati vengono inseriti in un’origine dati XML e inviati al FirstAppSolution/PreLoanProcess
quando l'utente fa clic sul pulsante Invia applicazione.
Dopo aver richiamato il processo, viene visualizzato un valore di identificatore di chiamata . Il valore di un identificatore di chiamata viene creato come parte di un record che tiene traccia dello stato del processo di lunga durata.
L'applicazione ASP.NET esegue le seguenti attività:
- Recupera i valori immessi dall’utente nella pagina web.
- Crea in modo dinamico un'origine dati XML passata al processo* FirstAppSolution/PreLoanProcess *. I tre valori sono specificati nell'origine dati XML.
- Richiama il processo* FirstAppSolution/PreLoanProcess *utilizzando i servizi web.
- Restituisce il valore dell'identificatore di chiamata e lo stato dell'operazione a lungo termine al browser Web del client.
Riepilogo dei passaggi summary_of_steps-1
Per creare un'applicazione ASP.NET in grado di richiamare il processo FirstAppSolution/PreLoanProcess, eseguire le operazioni seguenti:
Creare un'applicazione Web ASP.NET create-an-asp-net-web-application
Creare un'applicazione Web Microsoft .NET C# ASP.NET. Nell'illustrazione seguente viene illustrato il contenuto del progetto ASP.NET denominato InvokePreLoanProcess.
In Riferimenti al servizio sono presenti due elementi. Il primo elemento è denominato* JobManager*. Questo riferimento consente all'applicazione ASP.NET di richiamare il servizio Job Manager. Questo servizio restituisce informazioni sullo stato di un processo di lunga durata. Ad esempio, se il processo è in esecuzione, questo servizio restituisce un valore numerico che specifica il processo attualmente in esecuzione. Il secondo riferimento è denominato PreLoanProcess. Questo riferimento al servizio rappresenta il riferimento al processo* FirstAppSolution/PreLoanProcess *. Dopo aver creato un riferimento a un servizio, i tipi di dati associati al servizio AEM Forms sono disponibili per l'utilizzo all'interno del progetto .NET.
Creare un progetto ASP.NET:
- Avviare Microsoft Visual Studio 2008.
- Da File menu, seleziona Nuovo, Sito Web.
- In Modelli elenco, selezionare Sito Web ASP.NET.
- In Posizione seleziona una posizione per il progetto. Assegnare un nome al progetto InvokePreLoanProcess.
- In Lingua selezionare Visual C#
- Fai clic su OK.
Aggiungi riferimenti al servizio:
-
Nel menu Progetto, seleziona Aggiungi riferimento al servizio.
-
In Indirizzo specificare il WSDL nel servizio Job Manager.
code language-as3 https://hiro-xp:8080/soap/services/JobManager?WSDL&lc_version=9.0.1
-
Nel campo Namespace, digita
JobManager
. -
Fai clic su Vai quindi fai clic su OK.
-
In Progetto menu, seleziona Aggiungi riferimento al servizio.
-
In Indirizzo specificare il processo WSDL al processo FirstAppSolution/PreLoanProcess.
code language-as3 https://hiro-xp:8080/soap/services/FirstAppSolution/PreLoanProcess?WSDL&lc_version=9.0.1
-
Nel campo Namespace, digita
PreLoanProcess
. -
Fai clic su Vai quindi fai clic su OK.
hiro-xp
con l’indirizzo IP del server dell’applicazione J2EE che ospita AEM Forms. La lc_version
assicura la disponibilità della funzionalità AEM Forms, ad esempio MTOM. Senza specificare la lc_version
non è possibile richiamare AEM Forms utilizzando MTOM. (Vedi Richiamo di AEM Forms tramite MTOM.)Creare una pagina ASP che richiama FirstAppSolution/PreLoanProcess create-an-asp-page-that-invokes-firstappsolution-preloanprocess
All'interno del progetto ASP.NET, aggiungere un modulo Web (un file ASPX) responsabile della visualizzazione di una pagina HTML al richiedente del prestito. Il modulo web si basa su una classe derivata da System.Web.UI.Page
. Logica dell'applicazione C# che richiama FirstAppSolution/PreLoanProcess
si trova in Button1_Click
(questo pulsante rappresenta il pulsante Invia applicazione).
Nell'illustrazione seguente viene mostrata l'applicazione ASP.NET
Nella tabella seguente sono elencati i controlli che fanno parte di questa applicazione ASP.NET.
La logica dell'applicazione che fa parte dell'applicazione ASP.NET deve creare in modo dinamico un'origine dati XML da passare al FirstAppSolution/PreLoanProcess
processo. I valori immessi dal richiedente nella pagina HTML devono essere specificati all'interno dell'origine dati XML. Questi valori dati vengono uniti nel modulo quando il modulo viene visualizzato in Workspace. Le classi situate nel System.Xml
Lo spazio dei nomi viene utilizzato per creare l'origine dati XML.
Quando si richiama un processo che richiede dati XML da un'applicazione ASP.NET, è disponibile un tipo di dati XML da utilizzare. Cioè, non puoi passare un System.Xml.XmlDocument
istanza al processo. Il nome completo di questa istanza XML da passare al processo è InvokePreLoanProcess.PreLoanProcess.XML
. Converti System.Xml.XmlDocument
istanza a InvokePreLoanProcess.PreLoanProcess.XML
. È possibile eseguire questa attività utilizzando il seguente codice.
//Create the XML to pass to the FirstAppSolution/PreLoanProcess process
XmlDocument myXML = CreateXML(userName, phone, amount);
//Convert the XML to a InvokePreLoanProcess.PreLoanProcess.XML instance
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
myXML.WriteTo(xw);
InvokePreLoanProcess.PreLoanProcess.XML inXML = new XML();
inXML.document = sw.ToString();
Per creare una pagina ASP che richiama il FirstAppSolution/PreLoanProcess
eseguire le seguenti operazioni nel Button1_Click
metodo:
-
Crea un
FirstAppSolution_PreLoanProcessClient
utilizzando il relativo costruttore predefinito. -
Crea un
FirstAppSolution_PreLoanProcessClient.Endpoint.Address
utilizzandoSystem.ServiceModel.EndpointAddress
costruttore. Passa un valore stringa che specifica il WSDL al servizio AEM Forms e il tipo di codifica:code language-as3 https://hiro-xp:8080/soap/services/FirstAppSolution/PreLoanProcess?blob=mtom
Non è necessario utilizzare il
lc_version
attributo. Questo attributo viene utilizzato quando si crea un riferimento a un servizio. Tuttavia, assicurati di specificare?blob=mtom
.note note NOTE Sostituisci hiro-xp
* con l'indirizzo IP del server applicativo J2EE che ospita AEM Forms. * -
Crea un
System.ServiceModel.BasicHttpBinding
ottenendo il valore delFirstAppSolution_PreLoanProcessClient.Endpoint.Binding
membro dati. Imposta il valore restituito suBasicHttpBinding
. -
Imposta la
System.ServiceModel.BasicHttpBinding
dell’oggettoMessageEncoding
membro dei datiWSMessageEncoding.Mtom
. Questo valore assicura che venga utilizzato MTOM. -
Abilita l’autenticazione HTTP di base eseguendo le seguenti attività:
- Assegnare il nome utente del modulo di AEM al membro dati
FirstAppSolution_PreLoanProcessClient.ClientCredentials.UserName.UserName
. - Assegna il valore della password corrispondente al membro dati
FirstAppSolution_PreLoanProcessClient.ClientCredentials.UserName.Password
. - Assegna il valore costante
HttpClientCredentialType.Basic
al membro interessatoBasicHttpBindingSecurity.Transport.ClientCredentialType
. - Assegna il valore costante
BasicHttpSecurityMode.TransportCredentialOnly
al membro interessatoBasicHttpBindingSecurity.Security.Mode
.
L'esempio di codice seguente mostra queste attività.
code language-as3 //Enable BASIC HTTP authentication BasicHttpBinding b = (BasicHttpBinding)mortgageClient.Endpoint.Binding; b.MessageEncoding = WSMessageEncoding.Mtom; mortgageClient.ClientCredentials.UserName.UserName = "administrator"; mortgageClient.ClientCredentials.UserName.Password = "password"; b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic; b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly; b.MaxReceivedMessageSize = 2000000; b.MaxBufferSize = 2000000; b.ReaderQuotas.MaxArrayLength = 2000000;
- Assegnare il nome utente del modulo di AEM al membro dati
-
Recupera il nome, il telefono e i valori di quantità immessi dall’utente nella pagina web. Utilizzare questi valori per creare in modo dinamico un'origine dati XML inviata al
FirstAppSolution/PreLoanProcess
processo. Crea unSystem.Xml.XmlDocument
che rappresenta l'origine dati XML da passare al processo (questa logica di applicazione è mostrata nell'esempio di codice seguente). -
Converti
System.Xml.XmlDocument
istanza aInvokePreLoanProcess.PreLoanProcess.XML
(questa logica di applicazione viene mostrata nell'esempio di codice seguente). -
Richiama il
FirstAppSolution/PreLoanProcess
richiamando ilFirstAppSolution_PreLoanProcessClient
dell’oggettoinvoke_Async
metodo . Questo metodo restituisce un valore di stringa che rappresenta il valore dell'identificatore di chiamata del processo longevo. -
Crea un
JobManagerClient
utilizzando il costruttore . Assicurati di aver impostato un riferimento al servizio nel servizio Job Manager. -
Ripetere i passaggi da 1 a 5. Specifica il seguente URL per il passaggio 2:
https://hiro-xp:8080/soap/services/JobManager?blob=mtom
. -
Crea un
JobId
utilizzando il relativo costruttore. -
Imposta la
JobId
dell'oggettoid
membro con il valore restituito delFirstAppSolution_PreLoanProcessClient
dell’oggettoinvoke_Async
metodo . -
Assegna
value
trueJobId
dell'oggettopersistent
membro dati. -
Crea un
JobStatus
richiamando l'oggettoJobManagerService
dell'oggettogetStatus
e passareJobId
oggetto. -
Ottieni il valore di stato recuperando il valore del
JobStatus
dell'oggettostatusCode
membro dati. -
Assegna il valore dell'identificatore di chiamata al
LabelJobID.Text
campo . -
Assegna il valore di stato al
LabelStatus.Text
campo .
Avvio rapido: Richiamare un processo di lunga durata utilizzando l’API del servizio Web quick-start-invoking-a-long-lived-process-using-the-web-service-api
Il seguente esempio di codice C# richiama il FirstAppSolution/PreLoanProcess
processo.
???/**
* Ensure that you create a .NET project that uses
* MS Visual Studio 2008 and version 3.5 of the .NET
* framework. This is required to invoke a
* AEM Forms service using MTOM.
using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.ServiceModel;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Xml;
using System.IO;
//A reference to FirstAppSolution/PreLoanProcess
using InvokePreLoanProcess.PreLoanProcess;
//A reference to JobManager service
using InvokePreLoanProcess.JobManager;
namespace InvokePreLoanProcess
{
public partial class _Default : System.Web.UI.Page
{
//This method is called when the Submit Application button is
//Clicked
protected void Button1_Click(object sender, EventArgs e)
{
//Create a FirstAppSolution_PreLoanProcessClient object
FirstAppSolution_PreLoanProcessClient mortgageClient = new FirstAppSolution_PreLoanProcessClient();
mortgageClient.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/FirstAppSolution/PreLoanProcess?blob=mtom");
//Enable BASIC HTTP authentication
BasicHttpBinding b = (BasicHttpBinding)mortgageClient.Endpoint.Binding;
b.MessageEncoding = WSMessageEncoding.Mtom;
mortgageClient.ClientCredentials.UserName.UserName = "administrator";
mortgageClient.ClientCredentials.UserName.Password = "password";
b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
b.MaxReceivedMessageSize = 2000000;
b.MaxBufferSize = 2000000;
b.ReaderQuotas.MaxArrayLength = 2000000;
//Retrieve values that user entered into the web page
String userName = TextBoxName.Text;
String phone = TextBoxPhone.Text;
String amount = TextBoxAmount.Text;
//Create the XML to pass to the FirstAppSolution/PreLoanProcess process
XmlDocument myXML = CreateXML(userName, phone, amount);
StringWriter sw = new StringWriter();
XmlTextWriter xw = new XmlTextWriter(sw);
myXML.WriteTo(xw);
InvokePreLoanProcess.PreLoanProcess.XML inXML = new XML();
inXML.document = sw.ToString();
//INvoke the FirstAppSolution/PreLoanProcess process
String invocationID = mortgageClient.invoke_Async(inXML);
//Create a JobManagerClient object to obtain the status of the long-lived operation
JobManagerClient jobManager = new JobManagerClient();
jobManager.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/JobManager?blob=mtom");
//Enable BASIC HTTP authentication
BasicHttpBinding b1 = (BasicHttpBinding)jobManager.Endpoint.Binding;
b1.MessageEncoding = WSMessageEncoding.Mtom;
jobManager.ClientCredentials.UserName.UserName = "administrator";
jobManager.ClientCredentials.UserName.Password = "password";
b1.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
b1.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
b1.MaxReceivedMessageSize = 2000000;
b1.MaxBufferSize = 2000000;
b1.ReaderQuotas.MaxArrayLength = 2000000;
//Create a JobID object that represents the status of the
//long-lived operation
JobId jobId = new JobId();
jobId.id = invocationID;
jobId.persistent = true;
JobStatus jobStatus = jobManager.getStatus(jobId);
System.Int16 val2 = jobStatus.statusCode;
LabelJobID.Text = "The job status identifier value is " + invocationID;
LabelStatus.Text = "The status of the long-lived operation is " + getJobDescription(val2);
}
private static XmlDocument CreateXML(String name, String phone, String amount)
{
//This method dynamically creates a DDX document
//to pass to the FirstAppSolution/PreLoanProcess process
XmlDocument xmlDoc = new XmlDocument();
//Create the root element and append it to the XML DOM
System.Xml.XmlElement root = xmlDoc.CreateElement("LoanApp");
xmlDoc.AppendChild(root);
//Create the Name element
XmlElement nameElement = xmlDoc.CreateElement("Name");
nameElement.AppendChild(xmlDoc.CreateTextNode(name));
root.AppendChild(nameElement);
//Create the LoanAmount element
XmlElement LoanAmount = xmlDoc.CreateElement("LoanAmount");
LoanAmount.AppendChild(xmlDoc.CreateTextNode(amount));
root.AppendChild(LoanAmount);
//Create the PhoneOrEmail element
XmlElement PhoneOrEmail = xmlDoc.CreateElement("PhoneOrEmail");
PhoneOrEmail.AppendChild(xmlDoc.CreateTextNode(phone));
root.AppendChild(PhoneOrEmail);
//Create the ApprovalStatus element
XmlElement ApprovalStatus = xmlDoc.CreateElement("ApprovalStatus");
ApprovalStatus.AppendChild(xmlDoc.CreateTextNode("PENDING APPROVAL"));
root.AppendChild(ApprovalStatus);
//Return the XmlElement instance
return xmlDoc;
}
//Returns the String value of the Job Manager status code
private String getJobDescription(int val)
{
switch(val)
{
case 0:
return "JOB_STATUS_UNKNOWN";
case 1:
return "JOB_STATUS_QUEUED";
case 2:
return "JOB_STATUS_RUNNING";
case 3:
return "JOB_STATUS_COMPLETED";
case 4:
return "JOB_STATUS_FAILED";
case 5:
return "JOB_STATUS_COMPLETED";
case 6:
return "JOB_STATUS_SUSPENDED";
case 7:
return "JOB_STATUS_COMPLETE_REQUESTED";
case 8:
return "JOB_STATUS_TERMINATE_REQUESTED";
case 9:
return "JOB_STATUS_SUSPEND_REQUESTED";
case 10:
return "JOB_STATUS_RESUME_REQUESTED";
}
return "";
}
}
}
Eseguire l'applicazione ASP.NET run-the-asp-net-application
Dopo aver compilato e distribuito l'applicazione ASP.NET, è possibile eseguirla utilizzando un browser Web. Presupponendo che il nome del progetto ASP.NET sia InvokePreLoanProcess, specifica l’URL seguente all’interno di un browser web:
*http://localhost:1629/InvokePreLoanProcess/*Default.aspx
dove localhost è il nome del server web che ospita il progetto ASP.NET e 1629 è il numero di porta. Quando si compila e si crea l'applicazione ASP.NET, Microsoft Visual Studio la distribuisce automaticamente.
Creazione di un'applicazione client creata con Flex che richiama un processo longevo incentrato sull'uomo creating-a-client-application-built-with-flex-that-invokes-a-human-centric-long-lived-process
Puoi creare un’applicazione client creata con Flex per richiamare l’ FirstAppSolution/PreLoanProcess processo. Questa applicazione utilizza Remoting per richiamare FirstAppSolution/PreLoanProcess processo. (Vedi Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)
L'illustrazione seguente mostra un'applicazione client creata con Flex che raccoglie dati da un utente finale. I dati vengono inseriti in un’origine dati XML e inviati al processo.
Dopo aver richiamato il processo, viene visualizzato un valore di identificatore di chiamata . Il valore di un identificatore di chiamata viene creato come parte di un record che tiene traccia dello stato del processo di lunga durata.
L’applicazione client creata con Flex esegue le seguenti attività:
- Recupera i valori immessi dall’utente nella pagina web.
- Crea in modo dinamico un'origine dati XML passata a FirstAppSolution/PreLoanProcess processo. I tre valori sono specificati nell'origine dati XML.
- Richiama il FirstAppSolution/PreLoanProcess utilizzando Remoting.
- Restituisce il valore dell'identificatore di chiamata del processo longevo.
Riepilogo dei passaggi summary_of_steps-2
Per creare un'applicazione client creata con Flex in grado di richiamare il processo FirstAppSolution/PreLoanProcess, esegui i seguenti passaggi:
-
Avvia un nuovo progetto Flex.
-
Includi il file adobe-remoting-provider.swc nel percorso di classe del progetto. (Vedi Inclusione del file della libreria AEM Forms Flex.)
-
Crea un
mx:RemoteObject
tramite ActionScript o MXML. (Vedi Creazione di un'istanza mx:RemoteObject) -
Imposta un
ChannelSet
istanza per comunicare con AEM Forms e associarla almx:RemoteObject
istanza. (Vedi Creare un canale su AEM Forms.) -
Chiamare il
login
metodo o del serviziosetCredentials
per specificare il valore dell'identificatore utente e la password. (Vedi Utilizzo del single sign-on.) -
Crea l'origine dati XML da passare al
FirstAppSolution/PreLoanProcess
mediante la creazione di un'istanza XML. (Questa logica di applicazione viene mostrata nell'esempio di codice seguente.) -
Creare un oggetto di tipo Object utilizzando il relativo costruttore. Assegna il codice XML all’oggetto specificando il nome del parametro di input del processo, come illustrato nel codice seguente:
code language-as3 //Get the XML data to pass to the AEM Forms process var xml:XML = createXML(); var params:Object = new Object(); params["formData"]=xml;
-
Richiama il
FirstAppSolution/PreLoanProcess
chiamando ilmx:RemoteObject
dell’istanzainvoke_Async
metodo . Passa laObject
che contiene il parametro di input. (Vedi Trasferimento dei valori di ingresso.) -
Recupera il valore di identificazione della chiamata restituito da un processo longevo, come mostrato nel codice seguente:
code language-as3 // Handles async call that invokes the long-lived process private function resultHandler(event:ResultEvent):void { ji = event.result as JobId; jobStatusDisplay.text = "Job Status ID: " + ji.jobId as String; }
Richiamo di un processo di lunga durata tramite Remoting invoking-a-long-lived-process-using-remoting
Il seguente esempio di codice Flex richiama il FirstAppSolution/PreLoanProcess
processo.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns="*" backgroundColor="#FFFFFF"
creationComplete="initializeChannelSet();">
<mx:Script>
<![CDATA[
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import flash.net.navigateToURL;
import mx.messaging.ChannelSet;
import mx.messaging.channels.AMFChannel;
import mx.collections.ArrayCollection;
import mx.rpc.livecycle.JobId;
import mx.rpc.livecycle.JobStatus;
import mx.rpc.livecycle.DocumentReference;
import mx.formatters.NumberFormatter;
// Holds the job ID returned by LC.JobManager
private var ji:JobId;
private function initializeChannelSet():void
{
var cs:ChannelSet= new ChannelSet();
cs.addChannel(new AMFChannel("remoting-amf", "https://hiro-xp:8080/remoting/messagebroker/amf"));
LC_MortgageApp.setCredentials("tblue", "password");
LC_MortgageApp.channelSet = cs;
}
private function submitApplication():void
{
//Get the XML data to pass to the AEM Forms process
var xml:XML = createXML();
var params:Object = new Object();
params["formData"]=xml;
LC_MortgageApp.invoke_Async(params);
}
// Handles async call that invokes the long-lived process
private function resultHandler(event:ResultEvent):void
{
ji = event.result as JobId;
jobStatusDisplay.text = "Job Status ID: " + ji.jobId as String;
}
private function createXML():XML
{
//Calculate the Mortgage value to place in the XML data
var propertyPrice:String = txtAmount.text ;
var name:String = txtName.text ;
var phone:String = txtPhone.text ;;
var model:XML =
<LoanApp>
<Name>{name}</Name>
<LoanAmount>{propertyPrice}</LoanAmount>
<PhoneOrEmail>{phone}</PhoneOrEmail>
<ApprovalStatus>PENDING APPROVAL</ApprovalStatus>
</LoanApp>
return model;
}
]]>
</mx:Script>
<!-- Declare the RemoteObject and set its destination to the mortgage-app remoting endpoint defined in AEM Forms. -->
<mx:RemoteObject id="LC_MortgageApp" destination="FirstAppSolution/PreLoanProcess" result="resultHandler(event);">
<mx:method name="invoke_Async" result="resultHandler(event)"/>
</mx:RemoteObject>
<mx:Grid x="229" y="186">
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Image>
<mx:source>file:///D|/LiveCycle_9/FirstApp/financeCorpLogo.jpg</mx:source>
</mx:Image>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:Label text="Flex Loan Application Page" fontSize="20"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
</mx:GridRow>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Label text="Name:" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput id="txtName"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:Button label="Submit Application" click="submitApplication()"/>
</mx:GridItem>
</mx:GridRow>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Label text="Phone/Email:" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput id="txtPhone"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
</mx:GridRow>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Label text="Amount:" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput id="txtAmount"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
</mx:GridRow>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:Label text="Label" id="jobStatusDisplay" enabled="true" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
</mx:GridRow>
</mx:Grid>
</mx:Application>