Richiamare AEM Forms tramite servizi Web invoking-aem-forms-using-web-services

Gli esempi e gli esempi contenuti in questo documento sono solo per AEM Forms in ambiente JEE.

La maggior parte dei servizi AEM Forms nel contenitore di servizi è configurata per esporre un servizio Web, con supporto completo per la generazione WSDL (Web Service Definition Language). In altre parole, puoi creare oggetti proxy che utilizzano lo stack SOAP nativo di un servizio AEM Forms. Di conseguenza, i servizi AEM Forms possono scambiare ed elaborare i seguenti messaggi SOAP:

Utilizzando i servizi web, puoi eseguire le stesse operazioni dei servizi AEM Forms possibili utilizzando l’API Java. Un vantaggio dell’utilizzo dei servizi web per richiamare i servizi AEM Forms è la possibilità di creare un’applicazione client in un ambiente di sviluppo che supporta l’SOAP. Un'applicazione client non è associata a un ambiente di sviluppo o a un linguaggio di programmazione specifico. È ad esempio possibile creare un'applicazione client utilizzando Microsoft Visual Studio .NET e C# come linguaggio di programmazione.

I servizi AEM Forms sono esposti tramite il protocollo SOAP e sono conformi al profilo di base WSI 1.1. Web Services Interoperability (WSI) è un'organizzazione di standard aperti che promuove l'interoperabilità dei servizi web su più piattaforme. Per informazioni, vedere https://www.ws-i.org/.

AEM Forms supporta i seguenti standard di servizi web:

Per richiamare i servizi AEM Forms utilizzando un servizio Web, in genere si crea una libreria proxy che utilizza il servizio WSDL. La sezione Richiamo di AEM Forms tramite Web Services utilizza JAX-WS per creare classi proxy Java per richiamare i servizi. (Vedi Creazione di classi proxy Java tramite JAX-WS.)

È possibile recuperare un servizio WDSL specificando la seguente definizione di URL (gli elementi tra parentesi sono facoltativi):

 https://<your_serverhost>:<your_port>/soap/services/<service_name>?wsdl[&version=<version>][&async=true|false][lc_version=<lc_version>]

Dove:

Nella tabella seguente sono elencate le definizioni del servizio WSDL (supponendo che AEM Forms sia distribuito sull'host locale e che il post sia 8080).

Definizioni WSDL processo AEM Forms

Specificare il nome dell'applicazione e il nome del processo all'interno della definizione WSDL per accedere a un WSDL appartenente a un processo creato in Workbench. Si supponga che il nome dell'applicazione sia MyApplication e che il nome del processo sia EncryptDocument. In questa situazione, specificare la seguente definizione WSDL:

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?wsdl

 http://localhost:8080/soap/services/MyApplication/[<folderA>/.../<folderZ>/]EncryptDocument?wsdl

Accesso a nuove funzionalità tramite i servizi Web

È possibile accedere alle nuove funzionalità del servizio AEM Forms tramite i servizi web. In AEM Forms, ad esempio, è stata introdotta la possibilità di codificare gli allegati utilizzando MTOM. (Vedi Chiamata di AEM Forms tramite MTOM.)

Per accedere alle nuove funzionalità introdotte in AEM Forms, specifica l'attributo lc_version nella definizione WSDL. Ad esempio, per accedere a nuove funzionalità di servizio (incluso il supporto MTOM), specificare la seguente definizione WSDL:

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?wsdl&lc_version=9.0.1

Tipo di dati BLOB servizio Web

I WSDL dei servizi AEM Forms definiscono molti tipi di dati. Uno dei tipi di dati più importanti esposti in un servizio Web è BLOB. Questo tipo di dati viene mappato alla classe com.adobe.idp.Document quando si utilizzano le API Java di AEM Forms. (Vedi Trasmissione di dati ai servizi AEM Forms tramite l'API Java.)

Un oggetto BLOB invia e recupera dati binari (ad esempio, file PDF, dati XML e così via) da e verso i servizi AEM Forms. Il tipo BLOB è definito in un WSDL di servizio come segue:

 <complexType name="BLOB">
     <sequence>
         <element maxOccurs="1" minOccurs="0" name="contentType"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="binaryData"
             type="xsd:base64Binary"/>
         <element maxOccurs="1" minOccurs="0" name="attachmentID"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="remoteURL"
             type="xsd:string"/>
         <element maxOccurs="1" minOccurs="0" name="MTOM"
             type="xsd:base64Binary"
             xmime:expectedContentTypes="*/*"
             xmlns:xmime="https://www.w3.org/2005/05/xmlmime"/>
         <element maxOccurs="1" minOccurs="0" name="swaRef"
             type="tns1:swaRef"/>
         <element maxOccurs="1" minOccurs="0" name="attributes"
             type="impl:MyMapOf_xsd_string_To_xsd_anyType"/>
     </sequence>
 </complexType>

I campi MTOM e swaRef sono supportati solo in AEM Forms. È possibile utilizzare questi nuovi campi solo se si specifica un URL che include la proprietà lc_version.

Fornitura di oggetti BLOB nelle richieste di servizio

Se un'operazione del servizio AEM Forms richiede un tipo BLOB come valore di input, creare un'istanza del tipo BLOB nella logica dell'applicazione. Molti degli avvii rapidi del servizio Web in Programmazione con moduli AEM mostrano come utilizzare un tipo di dati BLOB.

Assegnare i valori ai campi che appartengono all'istanza BLOB nel modo seguente:

Accesso ai dati negli oggetti BLOB restituiti dai servizi

Il protocollo di trasmissione per gli oggetti BLOB restituiti dipende da diversi fattori, considerati nell'ordine seguente, che vengono interrotti quando viene soddisfatta la condizione principale:

Come descritto nella prima condizione, puoi garantire il tipo di trasmissione per tutti i documenti restituiti estendendo l’URL dell’endpoint SOAP con un suffisso come segue:

     https://<your_serverhost>:<your_port>/soap/services/<service
     name>?blob=base64|dime|mime|http|mtom|swaref

Ecco la correlazione tra i tipi di trasmissione e il campo da cui si ottengono i dati:

Trasmissione MTOM di array di byte con codifica base64

Oltre all'oggetto BLOB, il protocollo MTOM supporta qualsiasi parametro di matrice di byte o campo di matrice di byte di tipo complesso. Ciò significa che i framework SOAP client che supportano MTOM possono inviare qualsiasi elemento xsd:base64Binary come allegato MTOM (invece di un testo con codifica base64). Gli endpoint SOAP di AEM Forms possono leggere questo tipo di codifica di matrice di byte. Tuttavia, il servizio AEM Forms restituisce sempre un tipo di matrice di byte come testo con codifica base64. I parametri dell'array di byte di output non supportano MTOM.

I servizi AEM Forms che restituiscono una grande quantità di dati binari utilizzano il tipo Document/BLOB anziché il tipo a matrice di byte. Il tipo di documento è molto più efficiente per la trasmissione di grandi quantità di dati.

Tipi di dati del servizio Web web-service-data-types

Nella tabella seguente sono elencati i tipi di dati Java e viene visualizzato il tipo di dati del servizio Web corrispondente.

Creazione di classi proxy Java tramite JAX-WS creating-java-proxy-classes-using-jax-ws

È possibile utilizzare JAX-WS per convertire un servizio Forms WSDL in classi proxy Java. Queste classi consentono di richiamare le operazioni dei servizi AEM Forms. Apache Ant consente di creare uno script di build che genera classi proxy Java facendo riferimento a un WSDL del servizio AEM Forms. Per generare i file proxy JAX-WS, effettuare le seguenti operazioni:

Consulta anche

Creazione di classi proxy Java tramite l’asse Apache

Richiamare AEM Forms utilizzando la codifica Base64

Richiamare AEM Forms utilizzando i dati BLOB su HTTP

Richiamare AEM Forms con SwaRef

Creazione di classi proxy Java tramite l’asse Apache creating-java-proxy-classes-using-apache-axis

È possibile utilizzare lo strumento Apache Axis WSDL2Java per convertire un servizio Forms in classi proxy Java. Queste classi consentono di richiamare le operazioni del servizio Forms. Utilizzando Apache Ant, potete generare i file della libreria Axis da un WSDL di servizio. Puoi scaricare Apache Axis all'URL https://ws.apache.org/axis/.

Per generare i file della libreria Java Axis, effettuare le seguenti operazioni:

Consulta anche

Creazione di classi proxy Java tramite JAX-WS

Richiamare AEM Forms utilizzando la codifica Base64

Richiamare AEM Forms utilizzando i dati BLOB su HTTP

Richiamare AEM Forms utilizzando la codifica Base64 invoking-aem-forms-using-base64-encoding

È possibile richiamare un servizio AEM Forms utilizzando la codifica Base64. La codifica Base64 codifica gli allegati inviati con una richiesta di chiamata del servizio Web. In altre parole, i dati di BLOB sono codificati in Base64, non l'intero messaggio SOAP.

"Richiamare AEM Forms utilizzando la codifica Base64" viene descritto come richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument utilizzando la codifica Base64.

Quando viene richiamato, il processo esegue le azioni seguenti:

Creazione di un assembly client .NET che utilizza la codifica Base64 creating-a-net-client-assembly-that-uses-base64-encoding

È possibile creare un assembly client .NET per richiamare un servizio Forms da un progetto Microsoft Visual Studio .NET. Per creare un assembly client .NET che utilizza la codifica base64, effettuare le seguenti operazioni:

Creazione di una classe proxy

È possibile creare una classe proxy utilizzata per creare l'assembly client .NET utilizzando uno strumento che accompagna Microsoft Visual Studio. Il nome dello strumento è wsdl.exe e si trova nella cartella di installazione di Microsoft Visual Studio. Per creare una classe proxy, aprire il prompt dei comandi e passare alla cartella contenente il file wsdl.exe. Per ulteriori informazioni sullo strumento wsdl.exe, vedere la Guida MSDN.

Immetti il seguente comando al prompt dei comandi:

 wsdl https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1

Per impostazione predefinita, questo strumento crea un file CS nella stessa cartella in base al nome del file WSDL. In questa situazione, viene creato un file CS denominato EncryptDocumentService.cs. Questo file CS consente di creare un oggetto proxy che consente di richiamare il servizio specificato nell'URL di chiamata.

Modificare l'URL nella classe proxy per includere ?blob=base64 in modo che l'oggetto BLOB restituisca dati binari. Nella classe proxy, individua la seguente riga di codice:

 "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument";

e cambiarlo in:

 "https://hiro-xp:8080/soap/services/MyApplication/EncryptDocument?blob=base64";

La sezione Richiamo di AEM Forms utilizzando la codifica Base64 utilizza MyApplication/EncryptDocument come esempio. Se si sta creando un assembly client .NET per un altro servizio Forms, assicurarsi di sostituire MyApplication/EncryptDocument con il nome del servizio.

Sviluppo dell'assembly client .NET

Creare un progetto Libreria di classi di Visual Studio che produce un assembly client .NET. Il file CS creato con wsdl.exe può essere importato in questo progetto. Questo progetto genera un file DLL (l'assembly client .NET) che è possibile utilizzare in altri progetti Visual Studio .NET per richiamare un servizio.

Riferimento all'assembly client .NET

Inserire l'assembly client .NET appena creato nel computer in cui si sta sviluppando l'applicazione client. Dopo aver inserito l'assembly client .NET in una directory, è possibile fare riferimento a esso da un progetto. Fai riferimento anche alla libreria System.Web.Services dal progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.

Richiamo di un servizio tramite un assembly client .NET che utilizza la codifica Base64

È possibile richiamare il servizio MyApplication/EncryptDocument (creato in Workbench) utilizzando un assembly client .NET che utilizza la codifica Base64. Per richiamare il servizio MyApplication/EncryptDocument, effettuare le seguenti operazioni:

Richiamare un servizio utilizzando le classi proxy Java e la codifica Base64 invoking-a-service-using-java-proxy-classes-and-base64-encoding

È possibile richiamare un servizio AEM Forms utilizzando le classi proxy Java e Base64. Per richiamare il servizio MyApplication/EncryptDocument utilizzando le classi proxy Java, effettuare le seguenti operazioni:

Consulta anche

Guida introduttiva: Richiamare un servizio utilizzando i file proxy Java e la codifica Base64

Creazione di un assembly client .NET che utilizza la codifica Base64

Richiamare AEM Forms tramite MTOM invoking-aem-forms-using-mtom

È possibile richiamare i servizi AEM Forms utilizzando il servizio Web standard MTOM. Questo standard definisce il modo in cui i dati binari, ad esempio un documento PDF, vengono trasmessi tramite Internet o Intranet. Una caratteristica di MTOM è l'utilizzo dell'elemento XOP:Include. Questo elemento è definito nella specifica XOP (Binary Optimized Packaging) XML per fare riferimento agli allegati binari di un messaggio SOAP.

La discussione qui riguarda l'utilizzo di MTOM per richiamare il seguente processo di breve durata di AEM Forms denominato MyApplication/EncryptDocument.

Quando viene richiamato, il processo esegue le azioni seguenti:

La discussione qui riguarda l'utilizzo di MTOM all'interno di un progetto Microsoft .NET per richiamare i servizi AEM Forms. .NET Framework utilizzato è 3.5 e l'ambiente di sviluppo è Visual Studio 2008. Se nel computer di sviluppo sono installati i miglioramenti dei servizi Web (WSE), rimuoverli. .NET 3.5 supporta un framework SOAP denominato Windows Communication Foundation (WCF). Quando si richiama AEM Forms utilizzando MTOM, è supportato solo WCF (non WSE).

Creazione di un progetto .NET che richiama un servizio tramite MTOM creating-a-net-project-that-invokes-a-service-using-mtom

È possibile creare un progetto Microsoft .NET che possa richiamare un servizio AEM Forms utilizzando i servizi Web. Creare innanzitutto un progetto Microsoft .NET utilizzando Visual Studio 2008. Per richiamare un servizio AEM Forms, crea un riferimento al servizio AEM Forms che desideri richiamare all’interno del progetto. Quando crei un Riferimento servizio, specifica un URL per il servizio AEM Forms:

 http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL&lc_version=9.0.1

Sostituire localhost con l'indirizzo IP del server applicazioni J2EE che ospita AEM Forms. Sostituire MyApplication/EncryptDocument con il nome del servizio AEM Forms da richiamare. Per richiamare ad esempio un'operazione di Rights Management, specificare:

http://localhost:8080/soap/services/RightsManagementService?WSDL&lc_version=9.0.1

L'opzione lc_version garantisce la disponibilità delle funzionalità di AEM Forms, ad esempio MTOM. Senza specificare l'opzione lc_version, non è possibile richiamare AEM Forms utilizzando MTOM.

Dopo aver creato un riferimento al servizio, i tipi di dati associati al servizio AEM Forms sono disponibili per l'utilizzo all'interno del progetto .NET. Per creare un progetto .NET che richiami un servizio AEM Forms, effettuare le seguenti operazioni:

Richiamare un servizio utilizzando MTOM in un progetto .NET invoking-a-service-using-mtom-in-a-net-project

Considerare il processo MyApplication/EncryptDocument che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il processo MyApplication/EncryptDocument (creato in Workbench) utilizzando MTOM, effettuare le seguenti operazioni:

Consulta anche

Guida introduttiva: richiamare un servizio utilizzando MTOM in un progetto .NET

Accesso a più servizi tramite servizi web

Creazione di un'applicazione Web ASP.NET che richiama un processo di lunga durata incentrato sull'uomo

Richiamare AEM Forms con SwaRef invoking-aem-forms-using-swaref

È possibile richiamare i servizi di AEM Forms utilizzando SwaRef. Il contenuto dell'elemento XML wsi:swaRef viene inviato come allegato all'interno di un corpo SOAP che memorizza il riferimento all'allegato. Quando si richiama un servizio Forms utilizzando SwaRef, creare classi proxy Java utilizzando l'API Java per servizi Web XML (JAX-WS). (Vedi API Java per i servizi Web XML.)

Si tratta di richiamare il seguente processo di breve durata di Forms denominato MyApplication/EncryptDocument utilizzando SwaRef.

Quando viene richiamato, il processo esegue le azioni seguenti:

Di seguito viene illustrato come richiamare i servizi Forms utilizzando SwaRef all’interno di un’applicazione client Java. L'applicazione Java utilizza le classi proxy create mediante JAX-WS.

Richiama un servizio utilizzando i file di libreria JAX-WS che utilizzano SwaRef invoke-a-service-using-jax-ws-library-files-that-use-swaref

Per richiamare il processo MyApplication/EncryptDocument utilizzando i file proxy Java creati con JAX-WS e SwaRef, effettuare le seguenti operazioni:

Consulta anche

Guida introduttiva: Richiamare un servizio utilizzando SwaRef in un progetto Java

Richiamare AEM Forms utilizzando i dati BLOB su HTTP invoking-aem-forms-using-blob-data-over-http

È possibile richiamare i servizi AEM Forms utilizzando i servizi web e passando i dati BLOB su HTTP. Il passaggio di dati BLOB su HTTP è una tecnica alternativa all’utilizzo della codifica base64, DIME o MIME. È possibile, ad esempio, passare dati tramite HTTP in un progetto Microsoft .NET che utilizza Web Service Enhancement 3.0, che non supporta DIME o MIME. Quando si utilizzano dati BLOB su HTTP, i dati di input vengono caricati prima che venga richiamato il servizio AEM Forms.

"Richiamare AEM Forms utilizzando i dati BLOB su HTTP" illustra come richiamare il seguente processo di breve durata di AEM Forms denominato MyApplication/EncryptDocument passando i dati BLOB su HTTP.

Quando viene richiamato, il processo esegue le azioni seguenti:

Creazione di un assembly client .NET che utilizza dati tramite HTTP creating-a-net-client-assembly-that-uses-data-over-http

Per creare un assembly client che utilizza dati tramite HTTP, seguire la procedura specificata in Richiamare AEM Forms utilizzando la codifica Base64. Tuttavia, modificare l'URL nella classe proxy in modo da includere ?blob=http anziché ?blob=base64. Questa azione assicura che i dati vengano trasmessi tramite HTTP. Nella classe proxy, individua la seguente riga di codice:

 "http://localhost:8080/soap/services/MyApplication/EncryptDocument";

e cambiarlo in:

 "http://localhost:8080/soap/services/MyApplication/EncryptDocument?blob=http";

Riferimento all'assembly .NET clienMyApplication/EncryptDocumentt

Inserire il nuovo assembly client .NET nel computer in cui si sta sviluppando l'applicazione client. Dopo aver inserito l'assembly client .NET in una directory, è possibile fare riferimento a esso da un progetto. Fai riferimento alla libreria System.Web.Services dal progetto. Se non si fa riferimento a questa libreria, non è possibile utilizzare l'assembly client .NET per richiamare un servizio.

Richiamo di un servizio tramite un assembly client .NET che utilizza dati BLOB tramite HTTP

È possibile richiamare il servizio MyApplication/EncryptDocument (creato in Workbench) utilizzando un assembly client .NET che utilizza dati tramite HTTP. Per richiamare il servizio MyApplication/EncryptDocument, effettuare le seguenti operazioni:

Richiamare un servizio utilizzando le classi proxy Java e i dati BLOB su HTTP invoking-a-service-using-java-proxy-classes-and-blob-data-over-http

Puoi richiamare un servizio AEM Forms utilizzando le classi proxy Java e i dati BLOB su HTTP. Per richiamare il servizio MyApplication/EncryptDocument utilizzando le classi proxy Java, effettuare le seguenti operazioni:

Richiamare AEM Forms utilizzando DIME invoking-aem-forms-using-dime

È possibile richiamare i servizi AEM Forms utilizzando l’SOAP con allegati. AEM Forms supporta sia gli standard di servizio web MIME che DIME. DIME consente di inviare allegati binari, ad esempio documenti PDF, insieme a richieste di chiamata anziché codificare l’allegato. Nella sezione Richiamare AEM Forms utilizzando DIME viene illustrato come richiamare il seguente processo di breve durata di AEM Forms denominato MyApplication/EncryptDocument utilizzando DIME.

Quando viene richiamato, il processo esegue le azioni seguenti:

Questo processo non è basato su un processo AEM Forms esistente. Per seguire gli esempi di codice, creare un processo denominato MyApplication/EncryptDocument utilizzando Workbench. (Vedi Utilizzo di Workbench.)

Creazione di un progetto .NET che utilizza DIME creating-a-net-project-that-uses-dime

Per creare un progetto .NET che possa richiamare un servizio Forms utilizzando DIME, eseguire le operazioni seguenti:

Installazione dei miglioramenti dei servizi Web 2.0

Installare Web Services Enhancements 2.0 nel computer di sviluppo e integrarlo con Microsoft Visual Studio .NET. È possibile scaricare i miglioramenti ai servizi Web 2.0 dall'Area download Microsoft.

Da questa pagina Web cercare Miglioramenti servizi Web 2.0 e scaricarlo sul computer di sviluppo. Questo download inserisce nel computer un file denominato Microsoft WSE 2.0 SPI.msi. Eseguire il programma di installazione e seguire le istruzioni in linea.

Creazione di un riferimento Web a un servizio AEM Forms

Dopo aver installato i miglioramenti dei servizi Web 2.0 nel computer di sviluppo e aver creato un progetto Microsoft .NET, creare un riferimento Web al servizio Forms. Ad esempio, per creare un riferimento Web al processo MyApplication/EncryptDocument e presupporre che Forms sia installato nel computer locale, specificare il seguente URL:

     http://localhost:8080/soap/services/MyApplication/EncryptDocument?WSDL

Dopo aver creato un riferimento Web, sono disponibili i due tipi di dati proxy seguenti da utilizzare nel progetto .NET: EncryptDocumentService e EncryptDocumentServiceWse. Per richiamare il processo MyApplication/EncryptDocument utilizzando DIME, utilizzare il tipo EncryptDocumentServiceWse.

Riferimento alla libreria WSE

Creare un riferimento Web a un servizio Forms

Richiamo di un servizio tramite DIME in un progetto .NET

È possibile richiamare un servizio Forms utilizzando DIME. Considerare il processo MyApplication/EncryptDocument che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare il processo MyApplication/EncryptDocument utilizzando DIME, effettuare le seguenti operazioni:

Creazione di classi proxy Java Apache Axis che utilizzano DIME creating-apache-axis-java-proxy-classes-that-use-dime

È possibile utilizzare lo strumento Apache Axis WSDL2Java per convertire un servizio WSDL in classi proxy Java in modo da poter richiamare le operazioni del servizio. Utilizzando Apache Ant, è possibile generare i file della libreria Axis da un WSDL del servizio AEM Forms che consente di richiamare il servizio. (Vedi Creazione di classi proxy Java tramite l'asse Apache.)

Lo strumento Apache Axis WSDL2Java genera file JAVA che contengono metodi utilizzati per inviare richieste SOAP a un servizio. Le richieste SOAP ricevute da un servizio vengono decodificate dalle librerie generate dall'asse e restituite ai metodi e agli argomenti.

Per richiamare il servizio MyApplication/EncryptDocument (creato in Workbench) utilizzando i file di libreria generati da Axis e DIME, effettuare le seguenti operazioni:

Consulta anche

Guida introduttiva: Richiamare un servizio utilizzando DIME in un progetto Java

Utilizzo dell’autenticazione basata su SAML using-saml-based-authentication

AEM Forms supporta varie modalità di autenticazione dei servizi web quando si richiamano i servizi. Una modalità di autenticazione specifica sia un nome utente che un valore di password utilizzando un’intestazione di autorizzazione di base nella chiamata del servizio web. AEM Forms supporta anche l’autenticazione basata su asserzione SAML. Quando un’applicazione client richiama un servizio AEM Forms utilizzando un servizio web, può fornire le informazioni di autenticazione in uno dei seguenti modi:

AEM Forms non supporta l’autenticazione standard basata su certificati, ma supporta invece l’autenticazione basata su certificati in una forma diversa.

L’identità degli utenti dei moduli AEM può essere rappresentata tramite un’asserzione SAML firmata utilizzando una chiave segreta. Il codice XML seguente mostra un esempio di asserzione SAML.

 <Assertion xmlns="urn:oasis:names:tc:SAML:1.0:assertion"
     xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion"
     xmlns:samlp="urn:oasis:names:tc:SAML:1.0:protocol"
     AssertionID="fd4bd0c87302780e0d9bbfa8726d5bc0" IssueInstant="2008-04-17T13:47:00.720Z" Issuer="LiveCycle"
     MajorVersion="1" MinorVersion="1">
     <Conditions NotBefore="2008-04-17T13:47:00.720Z" NotOnOrAfter="2008-04-17T15:47:00.720Z">
     </Conditions>
     <AuthenticationStatement
         AuthenticationInstant="2008-04-17T13:47:00.720Z"
         AuthenticationMethod="urn:oasis:names:tc:SAML:1.0:am:unspecified">
         <Subject>
             <NameIdentifier NameQualifier="DefaultDom">administrator</NameIdentifier>
             <SubjectConfirmation>
                 <ConfirmationMethod>urn:oasis:names:tc:SAML:1.0:cm:sender-vouches</ConfirmationMethod>
             </SubjectConfirmation>
         </Subject>
     </AuthenticationStatement>
     <ds:Signature >
         <ds:SignedInfo>
             <ds:CanonicalizationMethod Algorithm="https://www.w3.org/2001/10/xml-exc-c14n#"></ds:CanonicalizationMethod>
             <ds:SignatureMethod    Algorithm="https://www.w3.org/2000/09/xmldsig#hmac-sha1"></ds:SignatureMethod>
             <ds:Reference URI="#fd4bd0c87302780e0d9bbfa8726d5bc0">
                 <ds:Transforms>
                     <ds:Transform Algorithm="https://www.w3.org/2000/09/xmldsig#enveloped-signature"></ds:Transform>
                     <ds:Transform Algorithm="https://www.w3.org/2001/10/xml-exc-c14n#">
                         <ec:InclusiveNamespaces
                             PrefixList="code ds kind rw saml samlp typens #default">
                         </ec:InclusiveNamespaces>
                     </ds:Transform>
                 </ds:Transforms>
                 <ds:DigestMethod Algorithm="https://www.w3.org/2000/09/xmldsig#sha1"></ds:DigestMethod>
                 <ds:DigestValue>hVrtqjWr+VzaVUIpQx0YI9lIjaY=</ds:DigestValue>
             </ds:Reference>
         </ds:SignedInfo>
         <ds:SignatureValue>UMbBb+cUcPtcWDCIhXes4n4FxfU=</ds:SignatureValue>
     </ds:Signature>
 </Assertion>

Questa asserzione di esempio viene rilasciata per un utente amministratore. Questa asserzione contiene i seguenti elementi rilevanti:

Un'applicazione client può recuperare l'asserzione da qualsiasi API AEM Forms AuthenticationManager che restituisce un oggetto AuthResult. È possibile ottenere un'istanza AuthResult eseguendo uno dei due metodi seguenti:

Un utente AEM forms può essere autenticato utilizzando un token SAML ottenuto. Questa asserzione SAML (frammento xml) può essere inviata come parte dell'intestazione WS-Security con la chiamata al servizio Web per l'autenticazione utente. In genere, un'applicazione client ha autenticato un utente ma non ha memorizzato le credenziali utente. (Oppure l'utente ha effettuato l'accesso al client tramite un meccanismo diverso dall'utilizzo di un nome utente e di una password.) In questa situazione, l’applicazione client deve richiamare AEM Forms e rappresentare un utente specifico che è autorizzato a richiamare AEM Forms.

Per rappresentare un utente specifico, richiamare il metodo AuthenticationManager.getAuthResultOnBehalfOfUser utilizzando un servizio Web. Questo metodo restituisce un'istanza AuthResult che contiene l'asserzione SAML per l'utente.

Quindi, utilizza tale asserzione SAML per richiamare qualsiasi servizio che richiede l’autenticazione. Questa azione comporta l’invio dell’asserzione come parte dell’intestazione dell’SOAP. Quando viene effettuata una chiamata al servizio web con questa asserzione, AEM Forms identifica l’utente come quello rappresentato da tale asserzione. In altre parole, l’utente specificato nell’asserzione è l’utente che sta richiamando il servizio.

Utilizzo delle classi dell’asse Apache e dell’autenticazione basata su SAML using-apache-axis-classes-and-saml-based-authentication

È possibile richiamare un servizio AEM Forms da classi proxy Java create utilizzando la libreria Axis. (Vedi Creazione di classi proxy Java tramite l'asse Apache.)

Quando si utilizza AXIS che utilizza l’autenticazione basata su SAML, registrare il gestore di richieste e risposte con Axis. Apache Axis richiama il gestore prima di inviare una richiesta di chiamata ad AEM Forms. Per registrare un gestore, creare una classe Java che estenda org.apache.axis.handlers.BasicHandler.

Creare un AssertionHandler con l'asse

La seguente classe Java, denominata AssertionHandler.java, mostra un esempio di classe Java che estende org.apache.axis.handlers.BasicHandler.

 public class AssertionHandler extends BasicHandler {
        public void invoke(MessageContext ctx) throws AxisFault {
            String assertion = (String) ctx.getProperty(LC_ASSERTION);

            //no assertion hence nothing to insert
            if(assertion == null) return;

            try {
                MessageElement samlElement = new MessageElement(convertToXML(assertion));
                SOAPHeader header = (SOAPHeader) ctx.getRequestMessage().getSOAPHeader();
                //Create the wsse:Security element which would contain the SAML element
                SOAPElement wsseHeader = header.addChildElement("Security", "wsse", WSSE_NS);
                wsseHeader.appendChild(samlElement);
                //remove the actor attribute as in LC we do not specify any actor. This would not remove the actor attribute though
                //it would only remove it from the soapenv namespace
                wsseHeader.getAttributes().removeNamedItem("actor");
            } catch (SOAPException e) {
                throw new AxisFault("Error occured while adding the assertion to the SOAP Header",e);
            }
        }
 }

Registra il gestore

Per registrare un gestore con Axis, creare un file client-config.wsdd. Per impostazione predefinita, Axis cerca un file con questo nome. Il codice XML seguente è un esempio di file client-config.wsdd. Per ulteriori informazioni, consultate la documentazione sugli assi.

 <deployment xmlns="https://xml.apache.org/axis/wsdd/" xmlns:java="https://xml.apache.org/axis/wsdd/providers/java">
     <transport name="http" pivot="java:org.apache.axis.transport.http.HTTPSender"/>
      <globalConfiguration >
       <requestFlow >
        <handler type="java:com.adobe.idp.um.example.AssertionHandler" />
       </requestFlow >
      </globalConfiguration >
 </deployment>

Richiama un servizio AEM Forms

Esempio Nell'esempio di codice riportato di seguito viene richiamato un servizio AEM Forms utilizzando l'autenticazione basata su SAML.

 public class ImpersonationExample {
        . . .
        public void  authenticateOnBehalf(String superUsername,String password,
                String canonicalName,String domainName) throws UMException, RemoteException{
            ((org.apache.axis.client.Stub) authenticationManager).setUsername(superUsername);
            ((org.apache.axis.client.Stub) authenticationManager).setPassword(password);

            //Step 1 - Invoke the Auth manager api to get an assertion for the user to be impersonated
            AuthResult ar = authenticationManager.getAuthResultOnBehalfOfUser(canonicalName, domainName, null);
            String assertion = ar.getAssertion();
            //Step 2 - Setting the assertion here to be picked later by the AssertionHandler. Note that stubs are not threadSafe
            //hence should not be reused. For this simple example we have made them instance variable but care should be taken
            //regarding the thread safety
            ((javax.xml.rpc.Stub) authorizationManager)._setProperty(AssertionHandler.LC_ASSERTION, assertion);
        }

        public Role findRole(String roleId) throws UMException, RemoteException{
            //This api would be invoked under bob's user rights
            return authorizationManager.findRole(roleId);
        }

        public static void main(String[] args) throws Exception {
            ImpersonationExample ie = new ImpersonationExample("http://localhost:5555");
            //Get the SAML assertion for the user to impersonate and store it in stub
            ie.authenticateOnBehalf(
                    "administrator", //The Super user which has the required impersonation permission
                    "password", // Password of the super user as referred above
                    "bob", //Cannonical name of the user to impersonate
                    "testdomain" //Domain of the user to impersonate
                    );

            Role r = ie.findRole("BASIC_ROLE_ADMINISTRATOR");
            System.out.println("Role "+r.getName());
        }
 }

Utilizzo di un assembly client .NET e dell'autenticazione basata su SAML using-a-net-client-assembly-and-saml-based-authentication

È possibile richiamare un servizio Forms utilizzando un assembly client .NET e l'autenticazione basata su SAML. Per eseguire questa operazione, è necessario utilizzare il Web Service Enhancements 3.0 (WSE). Per informazioni sulla creazione di un assembly client .NET che utilizza WSE, vedere Creazione di un progetto .NET che utilizza DIME.

L’architettura WSE utilizza i tipi di dati Policy, Assertions e SecurityToken. Per una chiamata al servizio web, specifica brevemente un criterio. Un criterio può avere più asserzioni. Ogni asserzione può contenere filtri. Un filtro viene richiamato in determinate fasi di una chiamata al servizio web e, in quel momento, può modificare la richiesta SOAP. Per informazioni dettagliate, consulta la documentazione sui miglioramenti dei servizi Web 3.0.

Crea asserzione e filtro

Nell'esempio di codice C# seguente vengono create classi di filtro e di asserzione. In questo esempio di codice viene creato SamlAssertionOutputFilter. Questo filtro viene richiamato dal framework WSE prima che la richiesta SOAP venga inviata ad AEM Forms.

 class LCSamlPolicyAssertion : Microsoft.Web.ServicES4.Design.PolicyAssertion
 {
        public override Microsoft.Web.ServicES4.SoapFilter CreateClientOutputFilter(FilterCreationContext context)
        {
           return new SamlAssertionOutputFilter();
        }
        . . .
 }


 class SamlAssertionOutputFilter : SendSecurityFilter
 {
        public override void SecureMessage(SoapEnvelope envelope, Security security)
        {
           // Get the SamlToken from the SessionState
           SamlToken samlToken = envelope.Context.Credentials.UltimateReceiver.GetClientToken<SamlToken>();
           security.Tokens.Add(samlToken);
        }
 }

Crea token SAML

Creare una classe per rappresentare l'asserzione SAML. L'attività principale eseguita da questa classe consiste nel convertire i valori dei dati da stringa a xml e nel mantenere uno spazio vuoto. Questo xml di asserzione viene successivamente importato nella richiesta SOAP.

 class SamlToken : SecurityToken
 {
        public const string SAMLAssertion = "https://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1";
        private XmlElement _assertionElement;

        public SamlToken(string assertion)
             : base(SAMLAssertion)
        {
           XmlDocument xmlDoc = new XmlDocument();
           //The white space has to be preserved else the digital signature would get broken
           xmlDoc.PreserveWhitespace = true;
           xmlDoc.LoadXml(assertion);
           _assertionElement = xmlDoc.DocumentElement;
         }

         public override XmlElement GetXml(XmlDocument document)
         {
            return (XmlElement)document.ImportNode(_assertionElement, true);
         }
        . . .
 }

Richiama un servizio AEM Forms

Esempio Nell'esempio di codice C# riportato di seguito viene richiamato un servizio Forms utilizzando l'autenticazione basata su SAML.

 public class ImpersonationExample
 {
        . . .
        public void AuthenticateOnBehalf(string superUsername, string password, string canonicalName, string domainName)
        {
            //Create a policy for UsernamePassword Token
            Policy usernamePasswordPolicy = new Policy();
            usernamePasswordPolicy.Assertions.Add(new UsernameOverTransportAssertion());

            UsernameToken token = new UsernameToken(superUsername, password, PasswordOption.SendPlainText);
            authenticationManager.SetClientCredential(token);
            authenticationManager.SetPolicy(usernamePasswordPolicy);

            //Get the SAML assertion for impersonated user
            AuthClient.AuthenticationManagerService.AuthResult ar
                = authenticationManager.getAuthResultOnBehalfOfUser(canonicalName, domainName, null);
            System.Console.WriteLine("Received assertion " + ar.assertion);

            //Create a policy for inserting SAML assertion
            Policy samlPolicy = new Policy();
            samlPolicy.Assertions.Add(new LCSamlPolicyAssertion());
            authorizationManager.SetPolicy(samlPolicy);
            //Set the SAML assertion obtained previously as the token
            authorizationManager.SetClientCredential(new SamlToken(ar.assertion));
        }

        public Role findRole(string roleId)
        {
            return authorizationManager.findRole(roleId);
        }

        static void Main(string[] args)
        {
            ImpersonationExample ie = new ImpersonationExample("http://localhost:5555");
            ie.AuthenticateOnBehalf(
                 "administrator", //The Super user which has the required impersonation permission
                 "password", // Password of the super user as referred above
                 "bob", //Cannonical name of the user to impersonate
                 "testdomain" //Domain of the user to impersonate
                 );

         Role r = ie.findRole("BASIC_ROLE_ADMINISTRATOR");
            System.Console.WriteLine("Role "+r.name);
     }
 }

Considerazioni correlate quando si utilizzano i servizi web related-considerations-when-using-web-services

Talvolta si verificano problemi quando si richiamano determinate operazioni dei servizi AEM Forms utilizzando i servizi web. L'obiettivo di questa discussione è quello di identificare tali problemi e fornire una soluzione, se disponibile.

Richiamare le operazioni del servizio in modo asincrono invoking-service-operations-asynchronously

Se si tenta di richiamare in modo asincrono un'operazione del servizio AEM Forms, ad esempio l'operazione Genera PDF htmlToPDF, si verifica un errore SoapFaultException. Per risolvere il problema, creare un file XML di associazione personalizzata che associa l'elemento ExportPDF_Result e altri elementi in classi diverse. Il codice XML seguente rappresenta un file di associazione personalizzato.

 <bindings
        xmlns:xsd="https://www.w3.org/2001/XMLSchema"
        xmlns:jxb="https://java.sun.com/xml/ns/jaxb" jxb:version="1.0"
        xmlns:wsdl="https://schemas.xmlsoap.org/wsdl/"
      wsdlLocation="http://localhost:8080/soap/services/GeneratePDFService?wsdl&async=true&lc_version=9.0.0"
        xmlns="https://java.sun.com/xml/ns/jaxws">
        <enableAsyncMapping>false</enableAsyncMapping>
        <package name="external_customize.client"/>
        <enableWrapperStyle>true</enableWrapperStyle>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='ExportPDF_Result']">
            <jxb:class name="ExportPDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='CreatePDF_Result']">
            <jxb:class name="CreatePDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='HtmlToPDF_Result']">
            <jxb:class name="HtmlToPDFAsyncResult">
            </jxb:class>
        </bindings>
        <bindings node="/wsdl:definitions/wsdl:types/xsd:schema[@targetNamespace='https://adobe.com/idp/services']/xsd:element[@name='OptimizePDF_Result']">
            <jxb:class name="OptimizePDFAsyncResult">
            </jxb:class>
        </bindings>
        <!--bindings node="//wsdl:portType[@name='GeneratePDFService']/wsdl:operation[@name='HtmlToPDF_Result']">
            <jxb:class name="HtmlToPDFAsyncResult"/>
        </bindings-->
 </bindings>

Utilizzare questo file XML quando si creano file proxy Java utilizzando JAX-WS. (Vedi Creazione di classi proxy Java tramite JAX-WS.)

Fare riferimento a questo file XML durante l'esecuzione dello strumento JAX-WS (wsimport.exe) utilizzando l'opzione della riga di comando - b. Aggiornare l'elemento wsdlLocation nel file XML di binding per specificare l'URL di AEM Forms.

Per garantire il funzionamento della chiamata asincrona, modificare il valore dell'URL del punto finale e specificare async=true. Ad esempio, per i file proxy Java creati con JAX-WS, specificare quanto segue per BindingProvider.ENDPOINT_ADDRESS_PROPERTY.

https://server:port/soap/services/ServiceName?wsdl&async=true&lc_version=9.0.0

Nell'elenco seguente vengono specificati altri servizi che richiedono un file di associazione personalizzato quando viene richiamato in modo asincrono:

Differenze nei server applicazioni J2EE differences-in-j2ee-application-servers

A volte una libreria proxy creata utilizzando un server applicazioni J2EE specifico non richiama correttamente AEM Forms ospitato su un server applicazioni J2EE diverso. Considera una libreria proxy generata utilizzando AEM Forms distribuita su WebSphere. Questa libreria proxy non può richiamare correttamente i servizi AEM Forms distribuiti sul server applicazioni JBoss.

Alcuni tipi di dati complessi di AEM Forms, ad esempio PrincipalReference, vengono definiti in modo diverso quando AEM Forms viene distribuito su WebSphere rispetto all'Application Server JBoss. Le differenze tra i JDK utilizzati dai diversi servizi applicativi J2EE sono il motivo per cui esistono differenze nelle definizioni WSDL. Di conseguenza, utilizzare le librerie proxy generate dallo stesso server applicazioni J2EE.

Accesso a più servizi tramite servizi web accessing-multiple-services-using-web-services

A causa di conflitti di spazio dei nomi, gli oggetti dati non possono essere condivisi tra più WSDL di servizio. Diversi servizi possono condividere tipi di dati e, pertanto, i servizi condividono la definizione di questi tipi nei WSDL. Ad esempio, non è possibile aggiungere due assembly client .NET contenenti un tipo di dati BLOB allo stesso progetto client .NET. Se si tenta di eseguire questa operazione, si verifica un errore di compilazione.

L'elenco seguente specifica i tipi di dati che non possono essere condivisi tra più WSDL di servizio:

Per evitare questo problema, si consiglia di qualificare completamente i tipi di dati. Si consideri ad esempio un'applicazione .NET che fa riferimento sia al servizio Forms che al servizio Signature utilizzando un riferimento al servizio. Entrambi i riferimenti al servizio conterranno una classe BLOB. Per utilizzare un'istanza BLOB, qualificare completamente l'oggetto BLOB quando viene dichiarato. Questo approccio è illustrato nell’esempio di codice seguente. Per informazioni su questo esempio di codice, vedere Forms interattivo con firma digitale.

Nell'esempio di codice C# riportato di seguito viene firmato un modulo interattivo di cui è stato eseguito il rendering dal servizio Forms. L'applicazione client dispone di due riferimenti di servizio. L'istanza BLOB associata al servizio Forms appartiene allo spazio dei nomi SignInteractiveForm.ServiceReference2. Analogamente, l'istanza BLOB associata al servizio di firma appartiene allo spazio dei nomi SignInteractiveForm.ServiceReference1. Il modulo interattivo firmato viene salvato come file PDF denominato LoanXFASigned.pdf.

 ???/**
     * Ensure that you create a .NET project that uses
     * MS Visual Studio 2008 and version 3.5 of the .NET
     * framework. This is required to invoke a
     * AEM Forms service using MTOM.
     *
     * For information, see "Invoking AEM Forms using MTOM" in Programming with AEM forms
     */
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.ServiceModel;
 using System.IO;

 //A reference to the Signature service
 using SignInteractiveForm.ServiceReference1;

 //A reference to the Forms service
 using SignInteractiveForm.ServiceReference2;

 namespace SignInteractiveForm
 {
        class Program
        {
            static void Main(string[] args)
            {
                try
                {
                    //Because BLOB objects are used in both service references
                    //it is necessary to fully qualify the BLOB objects

                    //Retrieve the form -- invoke the Forms service
                    SignInteractiveForm.ServiceReference2.BLOB formData = GetForm();

                    //Create a BLOB object associated with the Signature service
                    SignInteractiveForm.ServiceReference1.BLOB sigData = new SignInteractiveForm.ServiceReference1.BLOB();

                    //Transfer the byte stream from one Forms BLOB object to the
                    //Signature BLOB object
                    sigData.MTOM = formData.MTOM;

                    //Sign the Form -- invoke the Signature service
                    SignForm(sigData);
                }
                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
            }

            //Creates an interactive PDF form based on a XFA form - invoke the Forms service
            private static SignInteractiveForm.ServiceReference2.BLOB GetForm()
            {

                try
                {
                    //Create a FormsServiceClient object
                    FormsServiceClient formsClient = new FormsServiceClient();
                    formsClient.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/FormsService?blob=mtom");

                    //Enable BASIC HTTP authentication
                    BasicHttpBinding b = (BasicHttpBinding)formsClient.Endpoint.Binding;
                    b.MessageEncoding = WSMessageEncoding.Mtom;
                    formsClient.ClientCredentials.UserName.UserName = "administrator";
                    formsClient.ClientCredentials.UserName.Password = "password";
                    b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                    b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
                    b.MaxReceivedMessageSize = 2000000;
                    b.MaxBufferSize = 2000000;
                    b.ReaderQuotas.MaxArrayLength = 2000000;

                    //Create a BLOB to store form data
                    SignInteractiveForm.ServiceReference2.BLOB formData = new SignInteractiveForm.ServiceReference2.BLOB();
                    SignInteractiveForm.ServiceReference2.BLOB pdfForm = new SignInteractiveForm.ServiceReference2.BLOB();

                    //Specify an XML form data
                    string path = "C:\\Adobe\Loan.xml";
                    FileStream fs = new FileStream(path, FileMode.Open);

                    //Get the length of the file stream
                    int len = (int)fs.Length;
                    byte[] ByteArray = new byte[len];

                    fs.Read(ByteArray, 0, len);
                    formData.MTOM = ByteArray;

                    //Specify an XML form data
                    string path2 = "C:\\Adobe\LoanSigXFA.pdf";
                    FileStream fs2 = new FileStream(path2, FileMode.Open);

                    //Get the length of the file stream
                    int len2 = (int)fs2.Length;
                    byte[] ByteArray2 = new byte[len2];

                    fs2.Read(ByteArray2, 0, len2);
                    pdfForm.MTOM = ByteArray2;

                    PDFFormRenderSpec renderSpec = new PDFFormRenderSpec();
                    renderSpec.generateServerAppearance = true;

                    //Set out parameter values
                    long pageCount = 1;
                    String localValue = "en_US";
                    FormsResult result = new FormsResult();

                    //Render an interactive PDF form
                    formsClient.renderPDFForm2(
                        pdfForm,
                        formData,
                        renderSpec,
                        null,
                        null,
                        out pageCount,
                        out localValue,
                        out result);

                    //Write the data stream to the BLOB object
                    SignInteractiveForm.ServiceReference2.BLOB outForm = result.outputContent;
                    return outForm;
                }
                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
                return null;
            }

            //Sign the form -- invoke the Signature service
            private static void SignForm(SignInteractiveForm.ServiceReference1.BLOB inDoc)
            {

                try
                {
                    //Create a SignatureServiceClient object
                    SignatureServiceClient signatureClient = new SignatureServiceClient();
                    signatureClient.Endpoint.Address = new System.ServiceModel.EndpointAddress("https://hiro-xp:8080/soap/services/SignatureService?blob=mtom");

                    //Enable BASIC HTTP authentication
                    BasicHttpBinding b = (BasicHttpBinding)signatureClient.Endpoint.Binding;
                    b.MessageEncoding = WSMessageEncoding.Mtom;
                    signatureClient.ClientCredentials.UserName.UserName = "administrator";
                    signatureClient.ClientCredentials.UserName.Password = "password";
                    b.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                    b.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
                    b.MaxReceivedMessageSize = 2000000;
                    b.MaxBufferSize = 2000000;
                    b.ReaderQuotas.MaxArrayLength = 2000000;

                    //Specify the name of the signature field
                    string fieldName = "form1[0].grantApplication[0].page1[0].SignatureField1[0]";

                    //Create a Credential object
                    Credential myCred = new Credential();
                    myCred.alias = "secure";

                    //Specify the reason to sign the document
                    string reason = "The document was reviewed";

                    //Specify the location of the signer
                    string location = "New York HQ";

                    //Specify contact information
                    string contactInfo = "Tony Blue";

                    //Create a PDFSignatureAppearanceOptions object
                    //and show date information
                    PDFSignatureAppearanceOptionSpec appear = new PDFSignatureAppearanceOptionSpec();
                    appear.showDate = true;

                    //Sign the PDF document
                    SignInteractiveForm.ServiceReference1.BLOB signedDoc = signatureClient.sign(
                        inDoc,
                        fieldName,
                        myCred,
                        HashAlgorithm.SHA1,
                        reason,
                        location,
                        contactInfo,
                        appear,
                        true,
                        null,
                        null,
                        null);

                    //Populate a byte array with BLOB data that represents the signed form
                    byte[] outByteArray = signedDoc.MTOM;

                    //Save the signed PDF document
                    string fileName = "C:\\Adobe\LoanXFASigned.pdf";
                    FileStream fs2 = new FileStream(fileName, FileMode.OpenOrCreate);

                    //Create a BinaryWriter object
                    BinaryWriter w = new BinaryWriter(fs2);
                    w.Write(outByteArray);
                    w.Close();
                    fs2.Close();
                }

                catch (Exception ee)
                {
                    Console.WriteLine(ee.Message);
                }
            }
        }
 }

Servizi che iniziano con la lettera I produce file proxy non validi services-starting-with-the-letter-i-produce-invalid-proxy-files

Il nome di alcune classi proxy generate da AEM Forms non è corretto quando si utilizzano Microsoft .Net 3.5 e WCF. Questo problema si verifica quando vengono create classi proxy per IBMFilenetContentRepositoryConnector, IDPSchedulerService o qualsiasi altro servizio il cui nome inizia con la lettera I. Ad esempio, il nome del client generato se è presente IBMFileNetContentRepositoryConnector è BMFileNetContentRepositoryConnectorClient. Lettera I mancante nella classe proxy generata.