Richiamo di AEM Forms tramite Remoting

Esempi ed esempi in questo documento sono solo per AEM Forms in ambiente JEE.

I processi creati in Workbench possono essere richiamati utilizzando Remoting. In altre parole, puoi richiamare un processo AEM Forms da un’applicazione client creata con Flex. Questa funzione si basa sui servizi dati.

Il seguente processo AEM Forms di breve durata, denominato MyApplication/EncryptDocument, può essere richiamato utilizzando Remoting. (Per informazioni su questo processo, ad esempio sui valori di input e output, consulta Esempio di processo a breve termine.)

Quando si richiama questo processo, vengono eseguite le azioni seguenti:

1. Ottiene il documento PDF non protetto passato come valore di input. Questa azione si basa sul SetValue funzionamento. Il nome del parametro di input è inDoc e il relativo tipo di dati è document. (2) document il tipo di dati è un tipo di dati disponibile in Workbench.)
2. Cifra il documento PDF con una password. Questa azione si basa sul PasswordEncryptPDF funzionamento. 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.
3. Salva il documento PDF crittografato con password come file PDF nel file system locale. Questa azione si basa sul WriteDocument funzionamento.

Consulta anche

Inclusione del file della libreria AEM Forms Flex

Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM)

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting

Richiamo dei servizi dei componenti personalizzati tramite Remoting

Creazione di un'applicazione client creata con Flex che richiama un processo longevo incentrato sull'uomo

Creazione di applicazioni di Flash Builder che eseguono l'autenticazione SSO utilizzando i token HTTP

Per informazioni su come visualizzare i dati del processo in un controllo grafico Flex, vedi Visualizzazione dei dati del processo AEM Forms nei grafici Flex.

Inclusione del file della libreria AEM Forms Flex

Per richiamare programmaticamente i processi AEM Forms utilizzando Remoting, aggiungi il file adobe-remoting-provider.swc al percorso di classe del progetto Flex. Questo file SWC si trova nel seguente percorso:

• <install_directory>\Adobe_Experience_Manager_forms\sdk\misc\DataServices\Client-Libraries

  dove <install_directory> è la directory in cui è installato AEM Forms.

Consulta anche

Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM)

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Gestione dei documenti con la rimozione

Uno dei tipi Java non primitivi più importanti utilizzati in AEM Forms è il com.adobe.idp.Document classe. Un documento viene 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. (Vedi Trasmissione di dati ai servizi AEM Forms tramite l’API Java.)

Un'applicazione client creata con Flex non può richiedere direttamente un documento. Ad esempio, non puoi avviare Adobe Reader per richiedere un URL che produca un file PDF. Le richieste per tipi di documenti, ad esempio documenti PDF e Microsoft Word, restituiscono un risultato che è un URL. È responsabilità del cliente mostrare il contenuto dell’URL. Il servizio Gestione documenti consente di generare l’URL e le informazioni sul tipo di contenuto. Le richieste di documenti XML restituiscono il documento XML completo nel risultato.

Passaggio di un documento come parametro di input

Un'applicazione client creata con Flex non può passare un documento direttamente a un processo AEM Forms. Al contrario, l'applicazione client utilizza un'istanza del mx.rpc.livecycle.DocumentReference Classe ActionScript per passare parametri di input a un'operazione che prevede un com.adobe.idp.Document istanza. Un'applicazione client Flex dispone di diverse opzioni per la configurazione di un DocumentReference oggetto:

• Quando il documento si trova sul server e la relativa posizione del file è nota, impostare la proprietà referenceType dell'oggetto DocumentReference su REF_TYPE_FILE. Impostare la proprietà fileRef sulla posizione del file, come illustrato nell'esempio seguente:

 ... var docRef: DocumentReference = new DocumentReference();
 docRef.referenceType = DocumentReference.REF_TYPE_FILE;
 docRef.fileRef = "C:/install/adobe/cs2/How to Uninstall.pdf"; ...

• Quando il documento si trova sul server e si conosce il relativo URL, impostare la proprietà referenceType dell'oggetto DocumentReference su REF_TYPE_URL. Imposta la proprietà url sull’URL, come illustrato nell’esempio seguente:

... var docRef: DocumentReference = new DocumentReference();
docRef.referenceType = DocumentReference.REF_TYPE_URL;
docRef.url = "https://companyserver:8080/DocumentManager/116/7855"; ...

• Per creare un oggetto DocumentReference da una stringa di testo nell'applicazione client, impostare la proprietà referenceType dell'oggetto DocumentReference su REF_TYPE_INLINE. Impostare la proprietà text sul testo da includere nell'oggetto, come illustrato nell'esempio seguente:

... 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 il documento non è sul server, utilizza il servlet di caricamento Remoting per caricare un documento in AEM Forms. La novità di AEM Forms è la possibilità di caricare documenti protetti. Quando si carica un documento protetto, è necessario utilizzare un utente che ha Utente applicazione di caricamento documenti ruolo. Senza questo ruolo, l'utente non può caricare un documento protetto. È consigliabile utilizzare il single sign on per caricare un documento protetto. (Vedi Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting.)

Utilizza le funzionalità di caricamento di Flash standard per l’URL di caricamento designato: https://SERVER:PORT/remoting/lcfileupload. È quindi possibile utilizzare la DocumentReference ovunque 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;  }Per passare un file PDF al servizio di caricamento Remoting, è necessario utilizzare il servlet di caricamento Remoting MyApplication/EncryptDocumentprocesso. (Vedi 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;
}

Per passare un file PDF al servizio di caricamento Remoting, è necessario utilizzare il servlet di caricamento Remoting MyApplication/EncryptDocumentprocesso. (Vedi Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)

Restituzione di un documento a un'applicazione client

Un'applicazione client riceve un oggetto di tipo mx.rpc.livecycle.DocumentReference per un'operazione di servizio che restituisce un com.adobe.idp.Document istanza 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. Invece, il server genera un URL per il documento e lo trasmette nuovamente al client. La DocumentReference dell’oggetto referenceType specifica se il contenuto si trova nel DocumentReference o deve essere recuperato da un URL nel DocumentReference.url proprietà. La DocumentReference.contentType specifica il tipo di documento.

Consulta anche

Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Inclusione del file della libreria AEM Forms Flex

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting

Richiamare un processo di breve durata passando un documento non sicuro utilizzando Remoting

Per richiamare un processo AEM Forms da un'applicazione creata con Flex, esegui le seguenti attività:

1. Crea un mx:RemoteObject istanza.
2. Crea un ChannelSet istanza.
3. Passa i valori di input richiesti.
4. Gestisci i valori restituiti.

Creazione di un'istanza mx:RemoteObject

Crea un mx:RemoteObject istanza per richiamare un processo AEM Forms creato in Workbench. Per creare una mx:RemoteObject , specifica i seguenti valori:

• id: Nome della mx:RemoteObject istanza che rappresenta il processo da richiamare.
• destinazione: Nome del processo AEM Forms da richiamare. Ad esempio, per richiamare MyApplication/EncryptDocument processo, specificare MyApplication/EncryptDocument.
• risultato: Nome del metodo Flex che gestisce il risultato.

All'interno di mx:RemoteObject , specifica un <mx:method> che specifica il nome del metodo di chiamata del processo. In genere, il nome di un metodo di chiamata Forms è invoke.

Nell'esempio di codice seguente viene creato un mx:RemoteObject istanza che richiama il 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 su AEM Forms

Un’applicazione client può richiamare AEM Forms specificando un canale in MXML o ActionScript, come illustrato nell’esempio di ActionScript seguente. Il canale deve essere un AMFChannel, SecureAMFChannel, HTTPChanneloppure 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 ChannelSet l'istanza mx:RemoteObject dell’istanza channelSet (come mostrato nell’esempio di codice precedente). In genere, si importa la classe di canale in un'istruzione di importazione anziché specificare il nome completo quando si richiama il ChannelSet.addChannel metodo .

Trasferimento dei valori di ingresso

Un processo creato in Workbench può richiedere 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 a 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). (Vedi Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting.)

Nell’esempio di codice seguente 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 un DocumentReference, vedi Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM).

Richiamo di 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);

La 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 attiva dell'intestazione.

Gestione dei valori restituiti

I parametri di output del processo AEM Forms vengono deserializzati in oggetti ActionScript da cui 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;
     ...

Richiamo del processo MyApplication/EncryptDocument

È possibile richiamare MyApplication/EncryptDocument esegui le seguenti operazioni:

1. Crea un mx:RemoteObject tramite ActionScript o MXML. Consulta Creazione di un'istanza mx:RemoteObject .
2. Imposta un ChannelSet istanza per comunicare con AEM Forms e associarla al mx:RemoteObject istanza. Consulta Creare un canale su AEM Forms .
3. Chiamare il login metodo o del servizio setCredentials per specificare il valore dell'identificatore utente e la password. (Vedi Utilizzo del single sign-on.)
4. Popolare un mx.rpc.livecycle.DocumentReference istanza con un documento PDF non protetto da passare a MyApplication/EncryptDocument processo. (Vedi Passaggio di un documento come parametro di input.)
5. Cifrare il documento PDF chiamando il mx:RemoteObject dell’istanza invoke metodo . Passa la Object che contiene il parametro di input (che è il documento PDF non protetto). Vedere Trasmissione dei valori di input.
6. Recupera il documento PDF crittografato con password restituito dal processo. Consulta Gestione dei valori restituiti.

Avvio rapido: Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Sono disponibili diversi modi per AEM Forms User Manager per l’autenticazione di una richiesta Remoting da un’applicazione Flex, tra cui il single sign-on AEM Forms tramite il servizio di accesso centrale, l’autenticazione di base e l’autenticazione personalizzata. Se non è abilitato né l'accesso single sign-on né l'accesso anonimo, una richiesta Remoting restituisce l'autenticazione di base (impostazione predefinita) o l'autenticazione personalizzata.

L’autenticazione di base si basa sull’autenticazione di base J2EE standard dal contenitore dell’applicazione web. Per l’autenticazione di base, un errore HTTP 401 causa una sfida 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 l'autenticazione è necessaria.

Utilizzo dell’autenticazione personalizzata

Per abilitare l’autenticazione personalizzata nella console di amministrazione, cambia il metodo di autenticazione da Base a Personalizzato sull’endpoint remoto. Se utilizzi l’autenticazione personalizzata, l’applicazione client chiama il ChannelSet.login metodo di accesso e ChannelSet.logout metodo di disconnessione.

Poiché più destinazioni possono utilizzare gli stessi canali e l'oggetto ChannelSet corrispondente, l'accesso a una destinazione consente all'utente di accedere a qualsiasi altra destinazione che utilizzi lo stesso canale o gli stessi 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, la chiamata al logout registra tutti i componenti fuori dalle destinazioni.

Nell'esempio seguente viene utilizzato il ChannelSet.login e ChannelSet.logout metodi con un controllo RemoteObject. Questa applicazione esegue le azioni seguenti:

• Crea un ChannelSet nell'oggetto creationComplete che rappresenta i canali utilizzati dal RemoteObject component
• Trasmette le credenziali al server chiamando il ROLogin in risposta a un evento clic pulsante
• Utilizza il componente RemoteObject per inviare una stringa al server in risposta a un evento di clic Button. Il server restituisce lo stesso valore String al componente RemoteObject
• Utilizza l'evento risultato del componente RemoteObject per visualizzare la stringa in un controllo TextArea
• Si disconnette dal server chiamando il ROLogout in risposta a un evento clic pulsante

 <?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>

La login e logout restituiscono un oggetto AsyncToken. Assegna i gestori eventi all'oggetto AsyncToken affinché l'evento risultato possa gestire una chiamata riuscita e che l'evento di errore possa gestire un errore.

Utilizzo del single sign-on

AEM gli utenti dei moduli possono connettersi a più applicazioni Web AEM Forms per eseguire un’attività. Poiché gli utenti passano da un'applicazione Web all'altra, non è efficiente richiedere loro di accedere separatamente a ogni applicazione web. Il meccanismo di single sign-on AEM Forms consente agli utenti di accedere una volta e quindi di accedere a qualsiasi applicazione web AEM Forms. Poiché gli sviluppatori 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 assemblata nel proprio file WAR (Web Archive), che viene quindi compilato come parte di un file Enterprise Archive (EAR). Poiché un server applicazioni non consente la condivisione di dati di sessione tra diverse applicazioni web, AEM Forms utilizza 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 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 AEM moduli) 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.

È possibile bypassare il meccanismo di single sign-on di AEM Forms scrivendo un'applicazione client che esegue l'accesso e la disconnessione da sola. Se si bypassa il meccanismo di single sign-on, è possibile utilizzare l'autenticazione di base o personalizzata con l'applicazione.

Poiché questo meccanismo non utilizza il meccanismo di single sign-on di AEM Forms, nessun cookie di autenticazione viene scritto sul client. Le credenziali di accesso sono memorizzate in ChannelSet oggetto per il canale remoto. Di conseguenza, RemoteObject effettua le stesse chiamate ChannelSet nel contesto di tali credenziali.

Configurazione del single sign-on in AEM Forms

Per utilizzare il single sign-on in AEM Forms, installa il componente del flusso di lavoro dei moduli, che include il servizio di accesso centralizzato. Dopo che un utente ha eseguito correttamente l'accesso, il servizio di accesso centralizzato restituisce un cookie di autenticazione all'utente. 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.

Scrittura di un'applicazione client che utilizza il single sign-on

Quando si utilizza il meccanismo di accesso singolo, gli utenti dovranno effettuare l'accesso 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 di single sign-on di AEM Forms, configura l'endpoint Remoting per l'utilizzo dell'autenticazione personalizzata, non di base. In caso contrario, quando si utilizza l'autenticazione di base, un errore di autenticazione causa una sfida del browser, che non si desidera che l'utente veda. Al contrario, l'applicazione rileva l'errore di autenticazione e visualizza un messaggio che indica all'utente di effettuare l'accesso 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 a 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. Successivamente, 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.

Nella richiesta successiva 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 uscire 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 è quello di consentire a un utente di effettuare l'accesso una volta, non si desidera che un'applicazione client elimini il cookie. Questa azione disconnette efficacemente l’utente.

Pertanto, la RemoteObject.logout in un'applicazione client genera un messaggio di errore sul client specificando che la sessione non è disconnessa. Al contrario, 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. Come parte del processo di logout, il cookie di autenticazione viene eliminato. Se una richiesta remota viene effettuata senza un cookie o con un cookie non valido, la sessione utente viene invalidata. Questa azione è in effetti un logout. Al successivo tentativo di connessione dell’applicazione client a un servizio AEM Forms, l’utente viene invitato ad effettuare l’accesso.

Consulta anche

Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM)

Inclusione del file della libreria AEM Forms Flex

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting

Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting

È possibile passare documenti protetti ad AEM Forms quando si richiama un processo che richiede uno o più documenti. Approvando un documento sicuro, proteggi le informazioni commerciali e i documenti confidenziali. In questa situazione, un documento può fare riferimento a un documento PDF, a un documento XML, a un documento Word e così via. Quando AEM Forms è configurato per consentire documenti sicuri, è necessario passare un documento protetto ad AEM Forms da un’applicazione client scritta in Flex. (Vedi Configurazione di AEM Forms per accettare documenti sicuri e non protetti.)

Quando si passa un documento protetto, utilizzare il single sign-on e specificare un utente AEM forms con il tag Utente applicazione di caricamento documenti ruolo. Senza questo ruolo, l'utente non può caricare un documento protetto. Puoi assegnare un ruolo a un utente a livello di programmazione. (Vedi Gestione di ruoli e autorizzazioni.)

AEM Forms supporta un’operazione denominata getFileUploadToken che restituisce un token passato al servlet di caricamento. La DocumentReference.constructRequestForUpload richiede un URL ad AEM Forms insieme al token restituito da LC.FileUploadAuthenticator.getFileUploadToken metodo . Questo metodo restituisce un URLRequest oggetto utilizzato nella chiamata al servlet di caricamento. Il codice seguente illustra questa logica di 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;
         }
         ...

)

Configurazione di AEM Forms per accettare documenti sicuri e non protetti

È 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. Puoi configurare AEM Forms per accettare documenti protetti eseguendo le operazioni seguenti:

1. Accedi alla console di amministrazione.
2. Fai clic su Impostazioni.
3. Fai clic su Impostazioni di sistema di base.
4. Fai clic su Configurazioni.
5. Assicurati che l'opzione Consenti caricamento di documenti non protetti da applicazioni Flex sia deselezionata.

Avvio rapido: Richiamare un processo di breve durata passando un documento sicuro utilizzando Remoting

L'esempio di codice seguente richiama il MyApplication/EncryptDocument.Un utente deve effettuare l’accesso per fare clic sul pulsante Seleziona file utilizzato per caricare un file PDF e richiamare il processo. In altre parole, una volta che l’utente è autenticato, il pulsante Seleziona file è attivato. L'illustrazione seguente mostra l'applicazione client Flex dopo l'autenticazione di un utente. Tenere presente che la casella di controllo Autenticata è abilitata.

se AEM Forms è configurato per consentire solo il caricamento di documenti sicuri e l'utente non ha Utente applicazione di caricamento documenti allora viene lanciata un'eccezione. Se l’utente ha 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

Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM)

Inclusione del file della libreria AEM Forms Flex

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Richiamo dei servizi dei componenti personalizzati tramite Remoting

È possibile richiamare servizi situati in un componente personalizzato utilizzando Remoting. Ad esempio, considera il componente Banca che contiene il servizio clienti. Puoi richiamare le operazioni che appartengono al servizio clienti utilizzando un'applicazione client scritta in Flex. Prima di eseguire l’avvio rapido associato a questa sezione, è necessario creare il componente personalizzato Banca.

Il servizio clienti espone un'operazione denominata createCustomer. Questa discussione descrive come creare un'applicazione client Flex che richiama il servizio clienti e crea un cliente. Questa operazione richiede un oggetto complesso di tipo com.adobe.livecycle.sample.customer.Customer che rappresenta il nuovo cliente. L'illustrazione seguente mostra l'applicazione client che richiama il servizio clienti e crea un nuovo cliente. La createCustomer restituisce un valore di identificatore 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.

Mappatura di tipi di dati complessi AEM Forms

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 si richiama un servizio AEM Forms, creare oggetti ActionScript da associare ai tipi complessi AEM Forms richiesti. Per ogni tipo di dati complesso richiesto da un'operazione, creare un oggetto ActionScript separato.

Nella classe ActionScript, utilizza il RemoteClass tag metadati da mappare al tipo complesso di AEM Forms. Ad esempio, quando si richiama il servizio del cliente createCustomer creare una classe ActionScript mappata su com.adobe.livecycle.sample.customer.Customer tipo di dati.

La seguente classe ActionScript denominata Customer illustra 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 di AEM Forms viene assegnato al tag alias.

I campi della classe ActionScript corrispondono ai campi che appartengono al tipo complesso di AEM Forms. I sei campi situati nella classe Customer ActionScript corrispondono ai campi che appartengono a com.adobe.livecycle.sample.customer.Customer.

La classe Customer ActionScript appartiene a un pacchetto denominato cliente. È consigliabile inserire nel proprio pacchetto tutte le classi ActionScript associate a tipi di dati AEM Forms complessi. Crea una cartella nella cartella src del progetto Flex e inserisci il file ActionScript nella cartella , come illustrato di seguito.

Avvio rapido: Richiamo del servizio personalizzato Cliente tramite Remoting

Nell'esempio di codice seguente viene richiamato il servizio clienti e viene creato un nuovo cliente. Quando esegui questo esempio di codice, assicurati di compilare tutte le caselle di testo. Inoltre, assicurati di creare il file Customer.as associato a com.adobe.livecycle.sample.customer.Customer.

 <?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>

Foglio di stile

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

Richiamo di AEM Forms utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Gestione dei documenti tramite AEM Forms Remoting (obsoleto per i moduli AEM)

Inclusione del file della libreria AEM Forms Flex

Richiamare un processo di breve durata passando un documento non sicuro utilizzando (obsoleto per i moduli AEM) AEM Forms Remoting

Autenticazione di applicazioni client integrate con Flex

Trasferimento di documenti protetti per richiamare i processi utilizzando Remoting

Risorse Business.Adobe.com

Auto Form Fill Asset Collections Embedded Charts Version History Headless Cms Content Management System