Gli esempi e gli esempi contenuti in questo documento sono solo per l’ambiente AEM Forms su JEE.
I processi creati in Workbench possono essere richiamati utilizzando la funzione di comunicazione remota. In altre parole, è possibile richiamare un processo AEM Forms da un’applicazione client creata con Flex. Questa funzione si basa su Data Services.
Quando si utilizza la comunicazione remota, è consigliabile richiamare i processi creati in Workbench anziché i servizi di AEM Forms. Tuttavia, è possibile invocare direttamente i servizi di AEM Forms. Consulta Crittografia dei documenti di PDF tramite la comunicazione remota disponibile in AEM Forms Developer Center.
Se un servizio AEM Forms non è configurato per consentire l’accesso anonimo, le richieste provenienti da un client Flex generano un problema con il browser web. L'utente deve immettere il nome utente e la password.
Il seguente processo di breve durata di AEM Forms, denominato MyApplication/EncryptDocument
, può essere richiamato utilizzando la funzione di comunicazione remota. Per informazioni sul processo, ad esempio i valori di input e output, vedere Esempio di processo di breve durata.)
Per richiamare un processo AEM Forms utilizzando un’applicazione Flex, accertati che sia abilitato un endpoint remoto. Per impostazione predefinita, quando si distribuisce un processo viene abilitato un endpoint remoto.
Quando viene richiamato, il processo esegue le azioni seguenti:
SetValue
operazione. Il nome del parametro di input è inDoc
e il suo tipo di dati è document
. (Il document
il tipo di dati è un tipo di dati disponibile all’interno di Workbench.)PasswordEncryptPDF
operazione. Il nome del valore di output per questo processo è outDoc
e rappresenta il documento PDF crittografato con password. Il tipo di dati di outDoc è document
.WriteDocument
operazione.Il MyApplication/EncryptDocument
processo non basato su un processo AEM Forms esistente. Per seguire insieme agli esempi di codice, creare un processo denominato MyApplication/EncryptDocument
utilizzando Workbench.
Per informazioni sull'utilizzo della comunicazione remota per richiamare un processo di lunga durata, vedere Richiamare processi a lunga durata incentrati sull'uomo.
Consulta anche
Inclusione del file della libreria Flex di AEM Forms
Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting
Autenticazione delle applicazioni client create con Flex
Passaggio di documenti protetti per richiamare i processi tramite la comunicazione remota
Richiamare servizi di componenti personalizzati tramite la comunicazione remota
Creazione di applicazioni di Flash Builder che eseguono l'autenticazione SSO tramite token HTTP
Assicurati di posizionare il file crossdomain.xml nella posizione corretta. Ad esempio, supponendo che AEM Forms sia stato distribuito su JBoss, inserisci il file nella seguente posizione: <install_directory>\Adobe_Experience_Manager_forms\jboss\server\lc_turnkey\deploy\jboss-web.deployer\ROOT.war.
Per richiamare in modo programmatico i processi di AEM Forms utilizzando la funzione di comunicazione remota, aggiungi il file adobe-remoting-provider.swc al percorso della classe del progetto Flex. Il file SWC si trova nella posizione seguente:
<install_directory>\Adobe_Experience_Manager_forms\sdk\misc\DataServices\Client-Libraries
dove <directory_di_installazione> è la directory in cui è installato AEM Forms.
Consulta anche
Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting
Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting
Autenticazione delle applicazioni client create con Flex
Uno dei più importanti tipi Java™ non primitivi utilizzati in AEM Forms è com.adobe.idp.Document
classe. Un documento è comunemente richiesto per richiamare un’operazione AEM Forms. Si tratta principalmente di un documento PDF, ma può contenere altri tipi di documenti, ad esempio SWF, HTML, XML o un file DOC. (vedere Passaggio dei dati ai servizi AEM Forms tramite API Java.)
Un'applicazione client creata con Flex non può richiedere direttamente un documento. Ad esempio, non è possibile avviare Adobe Reader per richiedere un URL che generi un file PDF. Le richieste di tipi di documenti, ad esempio documenti PDF e Microsoft® Word, restituiscono un risultato che corrisponde a un URL. È responsabilità del cliente visualizzare il contenuto dell’URL. Il servizio Document Management consente di generare informazioni sull’URL e sul tipo di contenuto. Le richieste di documenti XML restituiscono il documento XML completo nel risultato.
Un’applicazione client creata con Flex non può trasmettere un documento direttamente a un processo AEM Forms. L’applicazione client utilizza invece un’istanza di mx.rpc.livecycle.DocumentReference
Classe ActionScript per passare i parametri di input a un'operazione che richiede un com.adobe.idp.Document
dell'istanza. Un'applicazione client Flex dispone di diverse opzioni per la configurazione di un DocumentReference
oggetto:
... var docRef: DocumentReference = new DocumentReference();
docRef.referenceType = DocumentReference.REF_TYPE_FILE;
docRef.fileRef = "C:/install/adobe/cs2/How to Uninstall.pdf"; ...
... var docRef: DocumentReference = new DocumentReference();
docRef.referenceType = DocumentReference.REF_TYPE_URL;
docRef.url = "https://companyserver:8080/DocumentManager/116/7855"; ...
... var docRef: DocumentReference = new DocumentReference();
docRef.referenceType = DocumentReference.REF_TYPE_INLINE;
docRef.text = "Text for my document"; // Optionally, you can override the server's default character set // if necessary: // docRef.charsetName=CharacterSetName ...
se AEM Forms è configurato per consentire il caricamento di documenti non sicuri, puoi utilizzare un utente che non dispone del ruolo di utente dell’applicazione di caricamento documento per caricare un documento. Un utente può anche disporre dell’autorizzazione Caricamento documento. Tuttavia, se AEM Forms è configurato per consentire solo documenti protetti, accertati che l’utente disponga del ruolo di utente dell’applicazione di caricamento del documento o dell’autorizzazione di caricamento del documento. (vedere Configurazione di AEM Forms per accettare documenti protetti e non protetti.
Utilizzi le funzionalità di caricamento standard del Flash per l’URL di caricamento designato: https://SERVER:PORT/remoting/lcfileupload
. È quindi possibile utilizzare DocumentReference
oggetto in cui un parametro di input di tipo Document
è previsto
private function startUpload():void { fileRef.addEventListener(Event.SELECT, selectHandler); fileRef.addEventListener("uploadCompleteData", completeHandler); try { var success:Boolean = fileRef.browse(); } catch (error:Error) { trace("Unable to browse for files."); } } private function selectHandler(event:Event):void { var request:URLRequest = new URLRequest("https://SERVER:PORT/remoting/lcfileupload") try { fileRef.upload(request); } catch (error:Error) { trace("Unable to upload file."); } } private function completeHandler(event:DataEvent):void { var params:Object = new Object(); var docRef:DocumentReference = new DocumentReference(); docRef.url = event.data as String; docRef.referenceType = DocumentReference.REF_TYPE_URL; }
La Guida rapida alla comunicazione remota utilizza il servlet di caricamento della comunicazione remota per trasmettere un file PDF al MyApplication/EncryptDocument
processo. (vedere Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)
private
function startUpload(): void {
fileRef.addEventListener(Event.SELECT, selectHandler);
fileRef.addEventListener("uploadCompleteData", completeHandler);
try {
var success: Boolean = fileRef.browse();
}
catch (error: Error) {
trace("Unable to browse for files.");
}
}
private
function selectHandler(event: Event): void {
var request: URLRequest = new URLRequest("https://SERVER:PORT/remoting/lcfileupload") try {
fileRef.upload(request);
}
catch (error: Error) {
trace("Unable to upload file.");
}
}
private
function completeHandler(event: DataEvent): void {
var params: Object = new Object();
var docRef: DocumentReference = new DocumentReference();
docRef.url = event.data as String;
docRef.referenceType = DocumentReference.REF_TYPE_URL;
}
La Guida rapida alla comunicazione remota utilizza il servlet di caricamento della comunicazione remota per trasmettere un file PDF al MyApplication/EncryptDocument
processo. (vedere Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)
Un'applicazione client riceve un oggetto di tipo mx.rpc.livecycle.DocumentReference
per un'operazione di servizio che restituisce un com.adobe.idp.Document
come parametro di output. Poiché un’applicazione client si occupa di oggetti ActionScript e non di Java, non è possibile restituire un oggetto Document basato su Java a un client Flex. Il server genera invece un URL per il documento e lo restituisce al client. Il DocumentReference
dell'oggetto referenceType
specifica se il contenuto si trova nel DocumentReference
o deve essere recuperato da un URL in DocumentReference.url
proprietà. Il DocumentReference.contentType
specifica il tipo di documento.
Consulta anche
Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting
Inclusione del file della libreria Flex di AEM Forms
Autenticazione delle applicazioni client create con Flex
Passaggio di documenti protetti per richiamare i processi tramite la comunicazione remota
Per richiamare un processo AEM Forms da un’applicazione creata con Flex, esegui le seguenti attività:
mx:RemoteObject
dell'istanza.ChannelSet
dell'istanza.Questa sezione illustra come richiamare un processo AEM Forms e caricare un documento quando AEM Forms è configurato per caricare documenti non sicuri. Per informazioni su come richiamare i processi di AEM Forms e caricare documenti protetti e su come configurare AEM Forms per l’accettazione di documenti protetti e non protetti, consulta Passaggio di documenti protetti per richiamare i processi tramite la comunicazione remota.
Creazione di un'istanza mx:RemoteObject
Si crea un mx:RemoteObject
per richiamare un processo AEM Forms creato in Workbench. Per creare un mx:RemoteObject
specifica i seguenti valori:
mx:RemoteObject
istanza che rappresenta il processo da richiamare.MyApplication/EncryptDocument
processo, specificare MyApplication/EncryptDocument
.All'interno del mx:RemoteObject
, specifica un <mx:method>
tag che specifica il nome del metodo di chiamata del processo. In genere, il nome di un metodo di chiamata Forms è invoke
.
Esempio Nell'esempio di codice riportato di seguito viene creata una mx:RemoteObject
istanza che richiama MyApplication/EncryptDocument
processo.
<mx:RemoteObject id="EncryptDocument" destination="MyApplication/EncryptDocument" result="resultHandler(event);">
<mx:method name="invoke" result="handleExecuteInvoke(event)"/>
</mx:RemoteObject>
Creare un canale per AEM Forms
Un’applicazione client può richiamare AEM Forms specificando un canale in MXML o ActionScript, come mostra l’ActionScript seguente. Il canale deve essere un AMFChannel
, SecureAMFChannel
, HTTPChannel
, o SecureHTTPChannel
.
...
private function refresh():void{
var cs:ChannelSet= new ChannelSet();
cs.addChannel(new AMFChannel("my-amf",
"https://yourlcserver:8080/remoting/messagebroker/amf"));
EncryptDocument.setCredentials("administrator", "password");
EncryptDocument.channelSet = cs;
}
...
Assegna la ChannelSet
istanza al mx:RemoteObject
dell'istanza channelSet
come nell’esempio di codice precedente. In genere, si importa la classe channel in un'istruzione import anziché specificare il nome completo quando si richiama ChannelSet.addChannel
metodo.
Trasmissione dei valori di input
Un processo creato in Workbench può accettare zero o più parametri di input e restituire un valore di output. Un'applicazione client trasmette i parametri di input all'interno di un ActionScript
oggetto con campi corrispondenti ai parametri appartenenti al processo AEM Forms. Il processo di breve durata, denominato MyApplication/EncryptDocument
, richiede un parametro di input denominato inDoc
. Il nome dell’operazione esposta dal processo è invoke
(nome predefinito per un processo di breve durata). (vedere Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting.)
Esempio Nell'esempio di codice riportato di seguito viene passato un documento PDF al MyApplication/EncryptDocument
processo:
...
var params:Object = new Object();
//Document is an instance of DocumentReference
//that store an unsecured PDF document
params["inDoc"] = pdfDocument;
// Invoke an operation synchronously:
EncryptDocument.invoke(params);
...
In questo esempio di codice, pdfDocument
è un DocumentReference
istanza che contiene un documento PDF non protetto. Per informazioni su DocumentReference
, vedi Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting.
Richiamare una versione specifica di un servizio
È possibile richiamare una versione specifica di un servizio Forms utilizzando un _version
nella mappa dei parametri della chiamata. Ad esempio, per richiamare la versione 1.2 del MyApplication/EncryptDocument
servizio:
var params:Object = new Object();
params["inDoc"] = pdfDocument;
params["_version"] = "1.2"
var token:AsyncToken = echoService.echoString(params);
Il version
Il parametro deve essere una stringa contenente un singolo punto. I valori a sinistra, versione principale e a destra, versione secondaria, del periodo devono essere numeri interi. Se questo parametro non viene specificato, viene richiamata la versione head attiva.
Gestione dei valori restituiti
I parametri di output dei processi di AEM Forms vengono deserializzati in oggetti ActionScript dai quali l'applicazione client estrae parametri specifici per nome, come illustrato nell'esempio seguente. (Il valore di output del MyApplication/EncryptDocument
processo denominato outDoc
.)
...
var res:Object = event.result;
var docRef:DocumentReference = res["outDoc"] as DocumentReference;
...
Richiamare il processo MyApplication/EncryptDocument
È possibile richiamare MyApplication/EncryptDocument
eseguire i seguenti passaggi:
mx:RemoteObject
tramite ActionScript o MXML. Vedere Creazione di un'istanza mx:RemoteObject.ChannelSet
per comunicare con AEM Forms e associarla al mx:RemoteObject
dell'istanza. Consulta Creazione di un canale per AEM Forms.login
metodo o del servizio setCredentials
per specificare il valore e la password dell'identificatore utente. (vedere Utilizzo del Single Sign-On.)mx.rpc.livecycle.DocumentReference
istanza con un documento PDF non protetto da passare al MyApplication/EncryptDocument
processo. (vedere Trasmissione di un documento come parametro di input.)mx:RemoteObject
dell'istanza invoke
metodo. Passa il Object
che contiene il parametro di input (che è il documento di PDF non protetto). Consulta Trasmissione dei valori di input.Sono disponibili diversi modi in cui AEM Forms User Manager può autenticare una richiesta remota da un’applicazione Flex, tra cui AEM Forms single sign-on tramite il servizio di accesso centrale, l’autenticazione di base e l’autenticazione personalizzata. Se non è abilitato né il Single Sign-On né l'accesso anonimo, una richiesta di comunicazione remota determina l'autenticazione di base (impostazione predefinita) o personalizzata.
L’autenticazione di base si basa sull’autenticazione di base standard J2EE dal contenitore dell’applicazione web. Per l’autenticazione di base, un errore HTTP 401 causa un problema del browser. Ciò significa che quando si tenta di connettersi a un'applicazione Forms utilizzando RemoteObject e non si è ancora effettuato l'accesso dall'applicazione Flex, il browser richiede un nome utente e una password.
Per l'autenticazione personalizzata, il server invia un errore al client per indicare che è necessaria l'autenticazione.
Per informazioni sull’esecuzione dell’autenticazione tramite token HTTP, consulta Creazione di applicazioni di Flash Builder che eseguono l'autenticazione SSO tramite token HTTP.
Per abilitare l’autenticazione personalizzata nella console di amministrazione, devi modificare il metodo di autenticazione da Basic a Custom sull’endpoint remoto. Se utilizzi l’autenticazione personalizzata, l’applicazione client chiama ChannelSet.login
metodo di accesso e ChannelSet.logout
metodo per disconnettersi.
Nella versione precedente di AEM Forms, hai inviato credenziali a una destinazione chiamando il RemoteObject.setCredentials
metodo. Il setCredentials
il metodo non ha effettivamente passato le credenziali al server fino al primo tentativo del componente di connettersi al server. Pertanto, se il componente ha generato un evento di errore, non è possibile stabilire con certezza se l'errore è stato causato da un errore di autenticazione o da un altro motivo. Il ChannelSet.login
Il metodo si connette al server quando viene chiamato in modo da poter gestire immediatamente un problema di autenticazione. Anche se è possibile continuare a utilizzare setCredentials
si consiglia di utilizzare il metodo ChannelSet.login
metodo.
Poiché più destinazioni possono utilizzare gli stessi canali e l'oggetto ChannelSet corrispondente, l'accesso a una destinazione comporta l'accesso dell'utente a qualsiasi altra destinazione che utilizza lo stesso canale o canali. Se due componenti applicano credenziali diverse allo stesso oggetto ChannelSet, vengono utilizzate le ultime credenziali applicate. Se più componenti utilizzano lo stesso oggetto ChannelSet autenticato, chiamare logout
Il metodo disconnette tutti i componenti dalle destinazioni.
Nell'esempio seguente viene utilizzato ChannelSet.login
e ChannelSet.logout
metodi con un controllo RemoteObject. Questa applicazione esegue le azioni seguenti:
ChannelSet
oggetto in creationComplete
gestore che rappresenta i canali utilizzati da RemoteObject
componenteROLogin
funzione in risposta a un evento Button clickROLogout
funzione in risposta a un evento Button click <?xml version="1.0"?>
<!-- security/SecurityConstraintCustom.mxml -->
<mx:Application xmlns:mx="https://www.adobe.com/2006/mxml" width="100%"
height="100%" creationComplete="creationCompleteHandler();">
<mx:Script>
<![CDATA[
import mx.controls.Alert;
import mx.messaging.config.ServerConfig;
import mx.rpc.AsyncToken;
import mx.rpc.AsyncResponder;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import mx.messaging.ChannelSet;
// Define a ChannelSet object.
public var cs:ChannelSet;
// Define an AsyncToken object.
public var token:AsyncToken;
// Initialize ChannelSet object based on the
// destination of the RemoteObject component.
private function creationCompleteHandler():void {
if (cs == null)
cs = ServerConfig.getChannelSet(remoteObject.destination);
}
// Login and handle authentication success or failure.
private function ROLogin():void {
// Make sure that the user is not already logged in.
if (cs.authenticated == false) {
token = cs.login("sampleuser", "samplepassword");
// Add result and fault handlers.
token.addResponder(new AsyncResponder(LoginResultEvent,
LoginFaultEvent));
}
}
// Handle successful login.
private function LoginResultEvent(event:ResultEvent,
token:Object=null):void {
switch(event.result) {
case "success":
authenticatedCB.selected = true;
break;
default:
}
}
// Handle login failure.
private function LoginFaultEvent(event:FaultEvent,
token:Object=null):void {
switch(event.fault.faultCode) {
case "Client.Authentication":
default:
authenticatedCB.selected = false;
Alert.show("Login failure: " + event.fault.faultString);
}
}
// Logout and handle success or failure.
private function ROLogout():void {
// Add result and fault handlers.
token = cs.logout();
token.addResponder(new
AsyncResponder(LogoutResultEvent,LogoutFaultEvent));
}
// Handle successful logout.
private function LogoutResultEvent(event:ResultEvent,
token:Object=null):void {
switch (event.result) {
case "success":
authenticatedCB.selected = false;
break;
default:
}
}
// Handle logout failure.
private function LogoutFaultEvent(event:FaultEvent,
token:Object=null):void {
Alert.show("Logout failure: " + event.fault.faultString);
}
// Handle message recevied by RemoteObject component.
private function resultHandler(event:ResultEvent):void {
ta.text += "Server responded: "+ event.result + "\n";
}
// Handle fault from RemoteObject component.
private function faultHandler(event:FaultEvent):void {
ta.text += "Received fault: " + event.fault + "\n";
}
]]>
</mx:Script>
<mx:HBox>
<mx:Label text="Enter a text for the server to echo"/>
<mx:TextInput id="ti" text="Hello World!"/>
<mx:Button label="Login"
click="ROLogin();"/>
<mx:Button label="Echo"
enabled="{authenticatedCB.selected}"
click="remoteObject.echo(ti.text);"/>
<mx:Button label="Logout"
click="ROLogout();"/>
<mx:CheckBox id="authenticatedCB"
label="Authenticated?"
enabled="false"/>
</mx:HBox>
<mx:TextArea id="ta" width="100%" height="100%"/>
<mx:RemoteObject id="remoteObject"
destination="myDest"
result="resultHandler(event);"
fault="faultHandler(event);"/>
</mx:Application>
Il login
e logout
I metodi restituiscono un oggetto AsyncToken. Assegnare gestori eventi all'oggetto AsyncToken affinché l'evento risultante gestisca una chiamata riuscita e l'evento di errore gestisca un errore.
Gli utenti di moduli AEM possono connettersi a più applicazioni web AEM Forms per eseguire un’attività. Quando gli utenti passano da un’applicazione web a un’altra, non è efficiente richiedere loro di accedere separatamente a ogni applicazione web. Il meccanismo single sign-on di AEM Forms consente agli utenti di accedere una sola volta e quindi a qualsiasi applicazione web AEM Forms. Poiché gli sviluppatori di AEM Forms possono creare applicazioni client da utilizzare con AEM Forms, devono anche poter sfruttare il meccanismo di single sign-on.
Ogni applicazione web AEM Forms viene inserita in un proprio file di archivio web (WAR), che viene quindi inserito in un pacchetto come parte di un file di archivio aziendale (EAR). Poiché un server applicazioni non consente la condivisione dei dati di sessione tra diverse applicazioni web, AEM Forms utilizza i cookie HTTP per memorizzare le informazioni di autenticazione. I cookie di autenticazione consentono a un utente di accedere a un’applicazione Forms e quindi di connettersi ad altre applicazioni web AEM Forms. Questa tecnica è nota come single sign-on.
Gli sviluppatori di AEM Forms scrivono applicazioni client per estendere le funzionalità delle guide dei moduli (obsolete) e personalizzare Workspace. Ad esempio, un’applicazione Workspace può avviare un processo. L'applicazione client utilizza quindi un endpoint remoto per recuperare i dati dal servizio Forms.
Quando un servizio AEM Forms viene richiamato utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting, l’applicazione client trasmette il cookie di autenticazione come parte della richiesta. Poiché l’utente ha già eseguito l’autenticazione, non è necessario alcun accesso aggiuntivo per effettuare una connessione dall’applicazione client al servizio AEM Forms.
Se un cookie non è valido o è mancante, non esiste alcun reindirizzamento implicito a una pagina di accesso. Pertanto, è ancora possibile chiamare un servizio anonimo.
È possibile evitare il meccanismo Single Sign-On di AEM Forms scrivendo un'applicazione client che esegue l'accesso e la disconnessione autonomamente. Se si ignora il meccanismo Single Sign-On, è possibile utilizzare l'autenticazione di base o personalizzata con l'applicazione.
Poiché questo meccanismo non utilizza il meccanismo Single Sign-On di AEM Forms, nel client non viene scritto alcun cookie di autenticazione. Le credenziali di accesso sono memorizzate in ChannelSet
oggetto per il canale remoto. Pertanto, qualsiasi RemoteObject
chiamate effettuate più volte ChannelSet
sono effettuate nell’ambito di tali credenziali.
Per utilizzare il single sign-on in AEM Forms, installa il componente del flusso di lavoro moduli, che include il servizio di accesso centralizzato. Dopo che un utente ha effettuato l’accesso, il servizio di accesso centralizzato restituisce all’utente un cookie di autenticazione. Ogni richiesta successiva a un’applicazione web Forms contiene il cookie. Se il cookie è valido, l’utente viene considerato autenticato e non deve effettuare di nuovo l’accesso.
Quando si utilizza il meccanismo di accesso singolo, è possibile che gli utenti accedano utilizzando il servizio di accesso centralizzato prima di avviare un'applicazione client. In altre parole, un’applicazione client non effettua l’accesso tramite il browser o chiamando il ChannelSet.login
metodo.
Se utilizzi il meccanismo Single Sign-On di AEM Forms, configura l’endpoint remoto in modo che utilizzi l’autenticazione personalizzata, non di base. In caso contrario, quando si utilizza l’autenticazione di base, un errore di autenticazione causa un problema del browser che non deve essere visualizzato dall’utente. Al contrario, l’applicazione rileva l’errore di autenticazione e quindi visualizza un messaggio per istruire l’utente ad accedere utilizzando il servizio di accesso centralizzato.
Un’applicazione client accede ad AEM Forms tramite un endpoint remoto utilizzando RemoteObject
come illustrato nell'esempio seguente.
<?xml version="1.0"?>
<mx:Application
backgroundColor="#FFFFFF">
<mx:Script>
<![CDATA[
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
// Prompt user to login on a fault.
private function faultHandler(event:FaultEvent):void
{
if(event.fault.faultCode=="Client.Authentication")
{
Alert.show(
event.fault.faultString + "\n" +
event.fault.faultCode + "\n" +
"Please login to continue.");
}
}
]]>
</mx:Script>
<mx:RemoteObject id="srv"
destination="product"
fault="faultHandler(event);"/>
<mx:DataGrid
width="100%" height="100%"
dataProvider="{srv.getProducts.lastResult}"/>
<mx:Button label="Get Data"
click="srv.getProducts();"/>
</mx:Application>
Accesso come nuovo utente mentre l'applicazione Flex è ancora in esecuzione
Un’applicazione creata con Flex include il cookie di autenticazione con ogni richiesta a un servizio AEM Forms. Per motivi di prestazioni, AEM Forms non convalida il cookie su ogni richiesta. Tuttavia, AEM Forms rileva quando un cookie di autenticazione viene sostituito da un altro cookie di autenticazione.
Ad esempio, si avvia un'applicazione client e mentre l'applicazione è attiva, si utilizza il servizio di accesso centralizzato per disconnettersi. Quindi, puoi accedere come un altro utente. L’accesso come utente diverso sostituisce il cookie di autenticazione esistente con un cookie di autenticazione per il nuovo utente.
Alla successiva richiesta dell’applicazione client, AEM Forms rileva che il cookie è stato modificato e disconnette l’utente. Pertanto, la prima richiesta dopo una modifica del cookie non riesce. Tutte le richieste successive vengono effettuate nel contesto del nuovo cookie e hanno esito positivo.
Disconnessione
Per disconnettersi da AEM Forms e annullare la validità di una sessione, il cookie di autenticazione deve essere eliminato dal computer del client. Poiché lo scopo del Single Sign-On è consentire a un utente di effettuare l'accesso una sola volta, non si desidera che un'applicazione client elimini il cookie. Questa azione comporta la disconnessione dell’utente.
Di conseguenza, chiamando RemoteObject.logout
in un'applicazione client genera un messaggio di errore sul client che specifica che la sessione non è disconnessa. L’utente può utilizzare il servizio di accesso centralizzato per disconnettersi ed eliminare il cookie di autenticazione.
Disconnessione mentre l'applicazione Flex è ancora in esecuzione
Puoi avviare un’applicazione client creata con Flex e utilizzare il servizio di accesso centralizzato per disconnettersi. Durante il processo di disconnessione, il cookie di autenticazione viene eliminato. Se viene effettuata una richiesta remota senza un cookie o con un cookie non valido, la sessione utente viene invalidata. Questa azione corrisponde a una disconnessione. Alla successiva connessione dell’applicazione client a un servizio AEM Forms, viene richiesto all’utente di effettuare l’accesso.
Consulta anche
Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting
Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting
Inclusione del file della libreria Flex di AEM Forms
Passaggio di documenti protetti per richiamare i processi tramite la comunicazione remota
È possibile passare documenti protetti ad AEM Forms quando si richiama un processo che richiede uno o più documenti. Trasmettendo un documento sicuro si proteggono le informazioni commerciali e i documenti riservati. In questa situazione, un documento può fare riferimento a un documento PDF, a un documento XML, a un documento Word e così via. Il passaggio di un documento protetto ad AEM Forms da un’applicazione client scritta in Flex è necessario quando AEM Forms è configurato per consentire l’utilizzo di documenti protetti. (vedere Configurazione di AEM Forms per accettare documenti protetti e non protetti.)
Quando trasmetti un documento protetto, utilizza il Single Sign-On e specifica un utente di AEM Forms con Carica documento utente applicazione ruolo. Senza questo ruolo, l’utente non può caricare un documento protetto. È possibile assegnare un ruolo a un utente a livello di programmazione. (vedere Gestione di ruoli e autorizzazioni.)
Quando crei un nuovo ruolo e desideri che i membri di tale ruolo caricino documenti protetti, accertati di specificare l’autorizzazione Caricamento documento.
AEM Forms supporta un’operazione denominata getFileUploadToken
che restituisce un token passato al servlet di caricamento. Il DocumentReference.constructRequestForUpload
Il metodo richiede un URL ad AEM Forms insieme al token restituito dal LC.FileUploadAuthenticator.getFileUploadToken
metodo. Questo metodo restituisce un URLRequest
oggetto utilizzato nella chiamata al servlet di caricamento. Il codice seguente illustra questa logica dell'applicazione.
...
private function startUpload():void
{
fileRef.addEventListener(Event.SELECT, selectHandler);
fileRef.addEventListener("uploadCompleteData", completeHandler);
try
{
var success:Boolean = fileRef.browse();
}
catch (error:Error)
{
trace("Unable to browse for files.");
}
}
private function selectHandler(event:Event):void
{
var authTokenService:RemoteObject = new RemoteObject("LC.FileUploadAuthenticator");
authTokenService.addEventListener("result", authTokenReceived);
authTokenService.channelSet = cs;
authTokenService.getFileUploadToken();
}
private function authTokenReceived(event:ResultEvent):void
{
var token:String = event.result as String;
var request:URLRequest = DocumentReference.constructRequestForUpload("http://localhost:8080", token);
try
{
fileRef.upload(request);
}
catch (error:Error)
{
trace("Unable to upload file.");
}
}
private function completeHandler(event:DataEvent):void
{
var params:Object = new Object();
var docRef:DocumentReference = new DocumentReference();
docRef.url = event.data as String;
docRef.referenceType = DocumentReference.REF_TYPE_URL;
}
...
)
È possibile utilizzare la console di amministrazione per specificare se i documenti sono protetti quando si passa un documento da un'applicazione client Flex a un processo AEM Forms. Per impostazione predefinita, AEM Forms è configurato per accettare documenti protetti. Per configurare AEM Forms per l’accettazione di documenti protetti, effettua le seguenti operazioni:
Per configurare AEM Forms per l’accettazione di documenti non protetti, seleziona l’opzione Consenti caricamento di documenti non protetti dalle applicazioni Flex. Riavviare quindi un'applicazione o un servizio per assicurarsi che l'impostazione abbia effetto.
Esempio Nell'esempio di codice riportato di seguito viene richiamato MyApplication/EncryptDocument.
Per richiamare la procedura e caricare un file PDF, l’utente deve effettuare l’accesso facendo clic sul pulsante Seleziona file. In altre parole, una volta che l’utente è autenticato, il pulsante Seleziona file è abilitato. La figura seguente mostra l’applicazione client Flex dopo l’autenticazione di un utente. La casella di controllo Autenticato è attivata.
se AEM Forms è configurato per consentire solo il caricamento di documenti protetti e l’utente non dispone di Carica documento utente applicazione , viene generata un'eccezione. Se l’utente dispone di questo ruolo, il file viene caricato e il processo viene richiamato.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns="*"
creationComplete="initializeChannelSet();">
<mx:Script>
<![CDATA[
import mx.rpc.livecycle.DocumentReference;
import flash.net.FileReference;
import flash.net.URLRequest;
import flash.events.Event;
import flash.events.DataEvent;
import mx.messaging.ChannelSet;
import mx.messaging.channels.AMFChannel;
import mx.rpc.events.ResultEvent;
import mx.collections.ArrayCollection;
import mx.rpc.AsyncToken;
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
import mx.rpc.AsyncResponder;
// Classes used in file retrieval
private var fileRef:FileReference = new FileReference();
private var docRef:DocumentReference = new DocumentReference();
private var parentResourcePath:String = "/";
private var now1:Date;
private var serverPort:String = "hiro-xp:8080";
// Define a ChannelSet object.
public var cs:ChannelSet;
// Define an AsyncToken object.
public var token:AsyncToken;
// Holds information returned from AEM Forms
[Bindable]
public var progressList:ArrayCollection = new ArrayCollection();
// Handles a successful login
private function LoginResultEvent(event:ResultEvent,
token:Object=null):void {
switch(event.result) {
case "success":
authenticatedCB.selected = true;
btnFile.enabled = true;
btnLogout.enabled = true;
btnLogin.enabled = false;
break;
default:
}
}
// Handle login failure.
private function LoginFaultEvent(event:FaultEvent,
token:Object=null):void {
switch(event.fault.faultCode) {
case "Client.Authentication":
default:
authenticatedCB.selected = false;
Alert.show("Login failure: " + event.fault.faultString);
}
}
// Set up channel set to invoke AEM Forms
private function initializeChannelSet():void {
cs = new ChannelSet();
cs.addChannel(new AMFChannel("remoting-amf", "https://" + serverPort + "/remoting/messagebroker/amf"));
EncryptDocument2.channelSet = cs;
}
// Call this method to upload the file.
// This creates a file picker and lets the user select a PDF file to pass to the EncryptDocument process.
private function uploadFile():void {
fileRef.addEventListener(Event.SELECT, selectHandler);
fileRef.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA,completeHandler);
fileRef.browse();
}
// Gets called for selected file. Does the actual upload via the file upload servlet.
private function selectHandler(event:Event):void {
var authTokenService:RemoteObject = new RemoteObject("LC.FileUploadAuthenticator");
authTokenService.addEventListener("result", authTokenReceived);
authTokenService.channelSet = cs;
authTokenService.getFileUploadToken();
}
private function authTokenReceived(event:ResultEvent):void
{
var token:String = event.result as String;
var request:URLRequest = DocumentReference.constructRequestForUpload("https://hiro-xp:8080", token);
try
{
fileRef.upload(request);
}
catch (error:Error)
{
trace("Unable to upload file.");
}
}
// Called once the file is completely uploaded.
private function completeHandler(event:DataEvent):void {
// Set the docRef's url and referenceType parameters
docRef.url = event.data as String;
docRef.referenceType=DocumentReference.REF_TYPE_URL;
executeInvokeProcess();
}
//This method invokes the EncryptDocument process
public function executeInvokeProcess():void {
//Create an Object to store the input value for the EncryptDocument process
now1 = new Date();
var params:Object = new Object();
params["inDoc"]=docRef;
// Invoke the EncryptDocument process
var token:AsyncToken;
token = EncryptDocument2.invoke(params);
token.name = name;
}
// AEM Forms login method
private function ROLogin():void {
// Make sure that the user is not already logged in.
//Get the User and Password
var userName:String = txtUser.text;
var pass:String = txtPassword.text;
if (cs.authenticated == false) {
token = cs.login(userName, pass);
// Add result and fault handlers.
token.addResponder(new AsyncResponder(LoginResultEvent, LoginFaultEvent));
}
}
// This method handles a successful process invocation
public function handleResult(event:ResultEvent):void
{
//Retrieve information returned from the service invocation
var token:AsyncToken = event.token;
var res:Object = event.result;
var dr:DocumentReference = res["outDoc"] as DocumentReference;
var now2:Date = new Date();
// These fields map to columns in the DataGrid
var progObject:Object = new Object();
progObject.filename = token.name;
progObject.timing = (now2.time - now1.time).toString();
progObject.state = "Success";
progObject.link = "<a href='" + dr.url + "'> open </a>";
progressList.addItem(progObject);
}
// Prompt user to login on a fault.
private function faultHandler(event:FaultEvent):void
{
if(event.fault.faultCode=="Client.Authentication")
{
Alert.show(
event.fault.faultString + "\n" +
event.fault.faultCode + "\n" +
"Please login to continue.");
}
}
// AEM Forms logout method
private function ROLogout():void {
// Add result and fault handlers.
token = cs.logout();
token.addResponder(new AsyncResponder(LogoutResultEvent,LogoutFaultEvent));
}
// Handle successful logout.
private function LogoutResultEvent(event:ResultEvent,
token:Object=null):void {
switch (event.result) {
case "success":
authenticatedCB.selected = false;
btnFile.enabled = false;
btnLogout.enabled = false;
btnLogin.enabled = true;
break;
default:
}
}
// Handle logout failure.
private function LogoutFaultEvent(event:FaultEvent,
token:Object=null):void {
Alert.show("Logout failure: " + event.fault.faultString);
}
private function resultHandler(event:ResultEvent):void {
// Do anything else here.
}
]]>
</mx:Script>
<mx:RemoteObject id="EncryptDocument" destination="MyApplication/EncryptDocument" result="resultHandler(event);">
<mx:method name="invoke" result="handleResult(event)"/>
</mx:RemoteObject>
<!--//This consists of what is displayed on the webpage-->
<mx:Panel id="lcPanel" title="EncryptDocument (Deprecated for AEM forms) AEM Forms Remoting Example"
height="25%" width="25%" paddingTop="10" paddingLeft="10" paddingRight="10"
paddingBottom="10">
<mx:Label width="100%" color="blue"
text="Select a PDF file to pass to the EncryptDocument process"/>
<mx:DataGrid x="10" y="0" width="500" id="idProgress" editable="false"
dataProvider="{progressList}" height="231" selectable="false" >
<mx:columns>
<mx:DataGridColumn headerText="Filename" width="200" dataField="filename" editable="false"/>
<mx:DataGridColumn headerText="State" width="75" dataField="state" editable="false"/>
<mx:DataGridColumn headerText="Timing" width="75" dataField="timing" editable="false"/>
<mx:DataGridColumn headerText="Click to Open" dataField="link" editable="false" >
<mx:itemRenderer>
<mx:Component>
<mx:Text x="0" y="0" width="100%" htmlText="{data.link}"/>
</mx:Component>
</mx:itemRenderer>
</mx:DataGridColumn>
</mx:columns>
</mx:DataGrid>
<mx:Button label="Select File" click="uploadFile()" id="btnFile" enabled="false"/>
<mx:Button label="Login" click="ROLogin();" id="btnLogin"/>
<mx:Button label="LogOut" click="ROLogout();" enabled="false" id="btnLogout"/>
<mx:HBox>
<mx:Label text="User:"/>
<mx:TextInput id="txtUser" text=""/>
<mx:Label text="Password:"/>
<mx:TextInput id="txtPassword" text="" displayAsPassword="true"/>
<mx:CheckBox id="authenticatedCB"
label="Authenticated?"
enabled="false"/>
</mx:HBox>
</mx:Panel>
</mx:Application>
Consulta anche
Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting
Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting
Inclusione del file della libreria Flex di AEM Forms
Autenticazione delle applicazioni client create con Flex
È possibile richiamare i servizi che si trovano in un componente personalizzato utilizzando la funzione di comunicazione remota. Si consideri, ad esempio, il componente Banca che contiene il servizio clienti. È possibile richiamare le operazioni che appartengono al servizio clienti utilizzando un'applicazione client scritta in Flex. Prima di poter eseguire l’avvio rapido associato a questa sezione, è necessario creare il componente personalizzato Banca.
Il servizio clienti espone un’operazione denominata createCustomer
. In questa discussione viene descritto come creare un'applicazione client Flex che richiami il servizio clienti e crei un cliente. Questa operazione richiede un oggetto complesso di tipo com.adobe.livecycle.sample.customer.Customer
che rappresenta il nuovo cliente. Nell'illustrazione seguente viene illustrata l'applicazione client che richiama l'assistenza clienti e crea un nuovo cliente. Il createCustomer
L'operazione restituisce un valore di identificativo del cliente. Il valore dell'identificatore viene visualizzato nella casella di testo Identificatore cliente.
Nella tabella seguente sono elencati i controlli che fanno parte di questa applicazione client.
Nome controllo |
Descrizione |
---|---|
txtFirst |
Specifica il nome del cliente. |
txtLast |
Specifica il cognome del cliente. |
txtPhone |
Specifica il numero di telefono del cliente. |
txtStreet |
Specifica il nome della via del cliente. |
txtState |
Specifica lo stato del cliente. |
txtZIP |
Specifica il codice postale del cliente. |
txtCity |
Specifica la città del cliente. |
txtCustId |
Specifica il valore dell'identificatore cliente a cui appartiene il nuovo account. Questa casella di testo viene compilata dal valore restituito del |
Alcune operazioni di AEM Forms richiedono tipi di dati complessi come valori di input. Questi tipi di dati complessi definiscono i valori di runtime utilizzati dall'operazione. Ad esempio, il createCustomer
l'operazione richiede un Customer
istanza che contiene i valori di runtime richiesti dal servizio. Senza il tipo complesso, il servizio clienti genera un’eccezione e non esegue l’operazione.
Quando richiami un servizio AEM Forms, crea oggetti ActionScript mappati sui tipi complessi AEM Forms richiesti. Per ogni tipo di dati complesso richiesto da un'operazione, creare un oggetto ActionScript separato.
Nella classe ActionScript, utilizza RemoteClass
tag di metadati da mappare al tipo complesso AEM Forms. Ad esempio, quando si richiama il createCustomer
, creare una classe ActionScript che esegua il mapping a com.adobe.livecycle.sample.customer.Customer
tipo di dati.
La seguente classe ActionScript denominata Cliente mostra come eseguire il mapping al tipo di dati AEM Forms com.adobe.livecycle.sample.customer.Customer
.
package customer
{
[RemoteClass(alias="com.adobe.livecycle.sample.customer.Customer")]
public class Customer
{
public var name:String;
public var street:String;
public var city:String;
public var state:String;
public var phone:String;
public var zip:int;
}
}
Il tipo di dati completo del tipo complesso AEM Forms viene assegnato al tag alias.
I campi della classe ActionScript corrispondono ai campi che appartengono al tipo complesso AEM Forms. I sei campi presenti nella classe ActionScript del cliente corrispondono ai campi appartenenti a com.adobe.livecycle.sample.customer.Customer
.
Un buon modo per determinare i nomi di campo che appartengono a un tipo complesso di Forms consiste nel visualizzare il WSDL di un servizio in un browser web. Un WSDL specifica i tipi complessi di un servizio e i membri dati corrispondenti. Il seguente WSDL viene utilizzato per il servizio clienti: https://[yourServer]:[yourPort]/soap/services/CustomerService?wsdl.
La classe ActionScript cliente appartiene a un pacchetto denominato cliente. È consigliabile inserire nel proprio pacchetto tutte le classi ActionScript mappate a tipi di dati AEM Forms complessi. Creare una cartella nella cartella src del progetto Flex e inserire il file ActionScript nella cartella, come illustrato nella figura seguente.
Esempio Nell'esempio di codice riportato di seguito viene richiamato il Servizio clienti e viene creato un cliente. Quando si esegue questo esempio di codice, assicurarsi di compilare tutte le caselle di testo. Inoltre, assicurati di creare il file Customer.as associato a com.adobe.livecycle.sample.customer.Customer
.
Prima di poter eseguire questo avvio rapido, è necessario creare e distribuire il componente personalizzato Banca.
<?xml version="1.0" encoding="utf-8"?>
<mx:Application layout="absolute" backgroundColor="#B1ABAB">
<mx:Script>
<![CDATA[
import flash.net.FileReference;
import flash.net.URLRequest;
import flash.events.Event;
import flash.events.DataEvent;
import mx.messaging.ChannelSet;
import mx.messaging.channels.AMFChannel;
import mx.rpc.events.ResultEvent;
import mx.collections.ArrayCollection;
import mx.rpc.AsyncToken;
import mx.managers.CursorManager;
import mx.rpc.remoting.mxml.RemoteObject;
// Custom class that corresponds to an input to the
// AEM Forms encryption method
import customer.Customer;
// Classes used in file retrieval
private var fileRef:FileReference = new FileReference();
private var parentResourcePath:String = "/";
private var serverPort:String = "hiro-xp:8080";
private var now1:Date;
private var fileName:String;
// Prepares parameters for encryptPDFUsingPassword method call
public function executeCreateCustomer():void
{
var cs:ChannelSet= new ChannelSet();
cs.addChannel(new AMFChannel("remoting-amf", "https://" + serverPort + "/remoting/messagebroker/amf"));
customerService.setCredentials("administrator", "password");
customerService.channelSet = cs;
//Create a Customer object required to invoke the Customer service's
//createCustomer operation
var myCust:Customer = new Customer();
//Get values from the user of the Flex application
var fullName:String = txtFirst.text +" "+txtLast.text ;
var Phone:String = txtPhone.text;
var Street:String = txtStreet.text;
var State:String = txtState.text;
var Zip:int = parseInt(txtZIP.text);
var City:String = txtCity.text;
//Populate Customer fields
myCust.name = fullName;
myCust.phone = Phone;
myCust.street= Street;
myCust.state= State;
myCust.zip = Zip;
myCust.city = City;
//Invoke the Customer service's createCustomer operation
var params:Object = new Object();
params["inCustomer"]=myCust;
var token:AsyncToken;
token = customerService.createCustomer(params);
token.name = name;
}
private function handleResult(event:ResultEvent):void
{
// Retrieve the information returned from the service invocation
var token:AsyncToken = event.token;
var res:Object = event.result;
var custId:String = res["CustomerId"] as String;
//Assign to the custId to the text box
txtCustId.text = custId;
}
private function resultHandler(event:ResultEvent):void
{
}
]]>
</mx:Script>
<mx:RemoteObject id="customerService" destination="CustomerService" result="resultHandler(event);">
<mx:method name="createCustomer" result="handleResult(event)"/>
</mx:RemoteObject>
<mx:Style source="../bank.css"/>
<mx:Grid>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Label text="New Customer" fontSize="16" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</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="First Name:" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtFirst"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:Button label="Create Customer" id="btnCreateCustomer" click="executeCreateCustomer()"/>
</mx:GridItem>
</mx:GridRow>
<mx:GridRow width="100%" height="100%">
<mx:GridItem width="100%" height="100%">
<mx:Label text="Last Name" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtLast"/>
</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="Phone" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" 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="Street" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtStreet"/>
</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="State" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtState"/>
</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="ZIP" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtZIP"/>
</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="City" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtCity"/>
</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="Customer Identifier" fontSize="12" fontWeight="bold"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
<mx:TextInput styleName="textField" id="txtCustId" editable="false"/>
</mx:GridItem>
<mx:GridItem width="100%" height="100%">
</mx:GridItem>
</mx:GridRow>
</mx:Grid>
</mx:Application>
Stile foglio
Questo avvio rapido contiene un foglio di stile denominato bank.css. Il codice seguente rappresenta il foglio di stile utilizzato.
/* CSS file */
global
{
backgroundGradientAlphas: 1.0, 1.0;
backgroundGradientColors: #525152,#525152;
borderColor: #424444;
verticalAlign: middle;
color: #FFFFFF;
font-size:12;
font-weight:normal;
}
ApplicationControlBar
{
fillAlphas: 1.0, 1.0;
fillColors: #393839, #393839;
}
.textField
{
backgroundColor: #393839;
background-disabled-color: #636563;
}
.button
{
fillColors: #636563, #424242;
}
.dropdownMenu
{
backgroundColor: #DDDDDD;
fillColors: #636563, #393839;
alternatingItemColors: #888888, #999999;
}
.questionLabel
{
}
ToolTip
{
backgroundColor: black;
backgroundAlpha: 1.0;
cornerRadius: 0;
color: white;
}
DateChooser
{
cornerRadius: 0; /* pixels */
headerColors: black, black;
borderColor: black;
themeColor: black;
todayColor: red;
todayStyleName: myTodayStyleName;
headerStyleName: myHeaderStyleName;
weekDayStyleName: myWeekDayStyleName;
dropShadowEnabled: true;
}
.myTodayStyleName
{
color: white;
}
.myWeekDayStyleName
{
fontWeight: normal;
}
.myHeaderStyleName
{
color: red;
fontSize: 16;
fontWeight: bold;
}
Consulta anche
Richiamare AEM Forms tramite (obsoleto per i moduli AEM) AEM Forms Remoting
Gestione dei documenti con (obsoleto per i moduli AEM) AEM Forms Remoting
Inclusione del file della libreria Flex di AEM Forms
Autenticazione delle applicazioni client create con Flex
Passaggio di documenti protetti per richiamare i processi tramite la comunicazione remota