Richiamo di AEM Forms tramite i servizi web invoking-aem-forms-using-web-services

La maggior parte dei servizi AEM Forms nel contenitore di servizi è configurata per esporre un servizio Web, con il supporto completo per la generazione del linguaggio 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 disponibili utilizzando l’API Java. L’utilizzo dei servizi web per richiamare i servizi AEM Forms offre il vantaggio di creare un’applicazione client in un ambiente di sviluppo che supporta SOAP. Un'applicazione client non è associata a un ambiente di sviluppo o a un linguaggio di programmazione specifici. 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 tra piattaforme. Per informazioni, consulta https://www.ws-i.org/.

AEM Forms supporta i seguenti standard di servizio Web:

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

È possibile recuperare un servizio WDSL specificando la seguente definizione 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 WSDL del servizio (partendo dal presupposto che AEM Forms sia distribuito sull’host locale e che il post sia 8080).

Definizioni WSDL del processo AEM Forms

Per accedere a una WSDL appartenente a un processo creato in Workbench, è necessario specificare il nome dell’applicazione e il nome del processo all’interno della definizione WSDL. Supponiamo che il nome dell'applicazione sia MyApplication e il nome del processo è EncryptDocument. In questa situazione, specifica 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à dei servizi AEM Forms tramite i servizi web. Ad esempio, in AEM Forms viene introdotta la possibilità di codificare gli allegati utilizzando MTOM. (Vedi Richiamo di AEM Forms tramite MTOM.)

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

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

Tipo di dati BLOB del servizio Web

Le WSDL del servizio AEM Forms definiscono molti tipi di dati. Uno dei tipi di dati più importanti esposti in un servizio Web è un BLOB digitare. Questo tipo di dati è associato al com.adobe.idp.Document Classe quando si lavora con le API Java di AEM Forms. (Vedi Trasmissione di dati ai servizi AEM Forms tramite l’API Java.)

A BLOB l'oggetto invia e recupera dati binari (ad esempio file PDF, dati XML e così via) da e verso AEM Forms Services. La BLOB Il tipo è definito in una 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>

La MTOM e swaRef i campi sono supportati solo in AEM Forms. Puoi utilizzare questi nuovi campi solo se specifichi un URL che include lc_version proprietà.

Fornitura di oggetti BLOB nelle richieste di servizi

Se un’operazione del servizio AEM Forms richiede un BLOB digita come valore di input, crea un'istanza del BLOB digita nella logica dell’applicazione. (Molti degli avvii rapidi del servizio Web si trovano in Programmazione con moduli AEM mostra come utilizzare un tipo di dati BLOB.)

Assegna valori ai campi che appartengono al gruppo BLOB come segue:

Accesso ai dati negli oggetti BLOB restituiti dai servizi

Protocollo di trasmissione per la restituzione BLOB Gli oggetti dipendono da diversi fattori, considerati nell’ordine seguente, che si arrestano quando la condizione principale è soddisfatta:

Come descritto nella prima condizione, è possibile 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 codificati base64

Oltre al BLOB il protocollo MTOM supporta qualsiasi parametro della matrice di byte o campo della matrice di byte di un tipo complesso. Ciò significa che i framework SOAP client che supportano MTOM possono inviare qualsiasi xsd:base64Binary come allegato MTOM (anziché come testo codificato base64). Gli endpoint SOAP di AEM Forms possono leggere questo tipo di codifica byte-array. Tuttavia, il servizio AEM Forms restituisce sempre un tipo di matrice byte come testo codificato base64. I parametri della matrice dei 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 di matrice dei 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

La tabella seguente elenca i tipi di dati Java e mostra il tipo di dati del servizio Web corrispondente.

Creazione di classi proxy Java utilizzando 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 compilazione che genera classi proxy Java facendo riferimento a una WSDL del servizio AEM Forms. È possibile generare file proxy JAX-WS eseguendo i seguenti passaggi:

Consulta anche

Creazione di classi proxy Java utilizzando Apache Axis

Richiamo di AEM Forms con codifica Base64

Richiamo di dati AEM Forms tramite BLOB su HTTP

Richiamo di AEM Forms tramite SwaRef

Creazione di classi proxy Java utilizzando Apache Axis 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, puoi generare file di libreria Axis da una WSDL di servizio. Puoi scaricare Apache Axis all'URL https://ws.apache.org/axis/.

Puoi generare file libreria Java Axis eseguendo le seguenti operazioni:

Consulta anche

Creazione di classi proxy Java utilizzando JAX-WS

Richiamo di AEM Forms con codifica Base64

Richiamo di dati AEM Forms tramite BLOB su HTTP

Richiamo di AEM Forms con 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. Cioè, BLOB i dati sono codificati in Base64 e non nell’intero messaggio SOAP.

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

Quando si richiama questo processo, vengono eseguite 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 .NET di Microsoft Visual Studio. Per creare un assembly client .NET che utilizza la codifica base64, eseguire le operazioni seguenti:

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 Guida a MSDN.

Immettere il comando seguente 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 della WSDL. In questa situazione, crea un file CS denominato EncryptDocumentService.cs. Utilizza questo file CS per creare un oggetto proxy che ti consente di richiamare il servizio specificato nell'URL di chiamata.

Modifica l'URL nella classe proxy per includere ?blob=base64 assicurare che BLOB restituisce 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 Richiamo di AEM Forms tramite codifica Base64 utilizzi della sezione MyApplication/EncryptDocument come esempio. Se si crea 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 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 produce un file DLL (l'assembly client .NET) che è possibile utilizzare in altri progetti .NET di Visual Studio per richiamare un servizio.

Riferimento all'assembly client .NET

Posizionare l'assembly client .NET appena creato sul computer in cui si sta sviluppando l'applicazione client. Dopo aver posizionato l'assembly client .NET in una directory, è possibile fare riferimento a tale assembly da un progetto. Fai riferimento anche al 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 utilizzando un assembly client .NET che utilizza la codifica Base64

È possibile richiamare MyApplication/EncryptDocument servizio (generato in Workbench) utilizzando un assembly client .NET che utilizza la codifica Base64. Per richiamare MyApplication/EncryptDocument , esegui i seguenti passaggi:

Richiamo di 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 MyApplication/EncryptDocument utilizzando le classi proxy Java, esegui i seguenti passaggi:

Consulta anche

Avvio rapido: Richiamo di un servizio tramite file proxy Java e codifica Base64

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

Richiamo di AEM Forms tramite MTOM invoking-aem-forms-using-mtom

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

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

Quando si richiama questo processo, vengono eseguite 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 è installato WSE (Web Service Enhancements), rimuoverlo. Il framework .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 utilizzando MTOM creating-a-net-project-that-invokes-a-service-using-mtom

È possibile creare un progetto Microsoft .NET in grado di richiamare un servizio AEM Forms utilizzando i servizi Web. Per prima cosa, creare 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 a un servizio, specifica un URL per il servizio AEM Forms:

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

Sostituisci localhost con l’indirizzo IP del server dell’applicazione J2EE che ospita AEM Forms. Sostituisci MyApplication/EncryptDocument con il nome del servizio AEM Forms da richiamare. Ad esempio, per richiamare un’operazione di Rights Management, specificare:

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

La lc_version assicura la disponibilità della funzionalità AEM Forms, ad esempio MTOM. Senza specificare la lc_version non è possibile richiamare AEM Forms utilizzando MTOM.

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

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

Considera la MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare MyApplication/EncryptDocument Il processo (generato in Workbench) utilizzando MTOM, esegue i seguenti passaggi:

Consulta anche

Avvio rapido: Richiamo di un servizio utilizzando MTOM in un progetto .NET

Accesso a più servizi tramite i servizi web

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

Richiamo di AEM Forms tramite SwaRef invoking-aem-forms-using-swaref

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

La discussione qui riguarda l'invocazione del seguente processo Forms di breve durata denominato MyApplication/EncryptDocument utilizzando SwaRef.

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

La discussione seguente è su come invocare i servizi Forms utilizzando SwaRef all'interno di un'applicazione client Java. L'applicazione Java utilizza le classi proxy create utilizzando JAX-WS.

Richiamare 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 MyApplication/EncryptDocument utilizzando i file proxy Java creati con JAX-WS e SwaRef, esegui i seguenti passaggi:

Consulta anche

Avvio rapido: Richiamo di un servizio utilizzando SwaRef in un progetto Java

Richiamo di dati AEM Forms tramite BLOB su HTTP invoking-aem-forms-using-blob-data-over-http

Puoi richiamare i servizi AEM Forms utilizzando i servizi web e passando dati BLOB su HTTP. Il passaggio dei dati BLOB su HTTP è una tecnica alternativa anziché utilizzare la codifica base64, DIME o MIME. Ad esempio, è possibile trasmettere 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 il servizio AEM Forms venga richiamato.

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

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

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

Per creare un assembly client che utilizza i dati tramite HTTP, seguire il processo specificato in Richiamo di AEM Forms con codifica Base64. Tuttavia, modifica l’URL nella classe proxy in modo da includere ?blob=http anziché ?blob=base64. Questa azione assicura che i dati vengano trasmessi via 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/EncryptDocument

Posizionare il nuovo assembly client .NET nel computer in cui si sta sviluppando l'applicazione client. Dopo aver posizionato l'assembly client .NET in una directory, è possibile fare riferimento a tale assembly da un progetto. Fai riferimento al 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 utilizzando un assembly client .NET che utilizza dati BLOB su HTTP

È possibile richiamare MyApplication/EncryptDocument servizio (generato in Workbench) tramite un assembly client .NET che utilizza i dati tramite HTTP. Per richiamare MyApplication/EncryptDocument , esegui i seguenti passaggi:

Richiamo di 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 MyApplication/EncryptDocument utilizzando le classi proxy Java, esegui i seguenti passaggi:

Richiamo di AEM Forms tramite DIME invoking-aem-forms-using-dime

È possibile richiamare i servizi AEM Forms utilizzando SOAP con allegati. AEM Forms supporta sia gli standard del servizio Web MIME che DIME. DIME consente di inviare allegati binari, ad esempio documenti PDF, insieme a richieste di chiamata invece di codificare l'allegato. La Richiamo di AEM Forms tramite DIME in questa sezione viene illustrato come richiamare il seguente processo AEM Forms di breve durata denominato MyApplication/EncryptDocument utilizzando DIME.

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

Questo processo non è basato su un processo AEM Forms esistente. Per seguire gli esempi di codice, crea 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 in grado di richiamare un servizio Forms utilizzando DIME, eseguire le operazioni seguenti:

Installazione dei miglioramenti dei servizi Web 2.0

Installare i miglioramenti dei servizi Web 2.0 nel computer di sviluppo e integrarli con Microsoft Visual Studio .NET. È possibile scaricare i miglioramenti di Web Services 2.0 dal Centro download Microsoft.

Da questa pagina web, cerca i miglioramenti dei servizi Web 2.0 e scaricalo sul computer di sviluppo. Questo download inserisce un file denominato Microsoft WSE 2.0 SPI.msi sul computer. Eseguire il programma di installazione e seguire le indicazioni online.

Creazione di un riferimento web a un servizio AEM Forms

Dopo aver installato Miglioramenti di Web Services 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 MyApplication/EncryptDocument e, partendo dal presupposto che Forms sia installato nel computer locale, specificare l'URL seguente:

     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 all'interno del progetto .NET: EncryptDocumentService e EncryptDocumentServiceWse. Per richiamare MyApplication/EncryptDocument utilizzando DIME, utilizza EncryptDocumentServiceWse digitare.

Fai 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. Considera la MyApplication/EncryptDocument processo che accetta un documento PDF non protetto e restituisce un documento PDF crittografato con password. Per richiamare MyApplication/EncryptDocument elabora utilizzando DIME, esegui 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 operazioni del servizio. Utilizzando Apache Ant, puoi generare file di libreria Axis da una WSDL di servizio AEM Forms che ti consente di richiamare il servizio. (Vedi Creazione di classi proxy Java utilizzando Apache Axis.)

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

Per richiamare MyApplication/EncryptDocument il servizio (generato in Workbench) utilizzando i file di libreria generati da Axis e DIME, esegue i seguenti passaggi:

Consulta anche

Avvio rapido: Richiamo di un servizio tramite DIME in un progetto Java

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

AEM Forms supporta diverse 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 al servizio Web. AEM Forms supporta anche l’autenticazione basata sull’asserzione SAML. Quando un'applicazione client richiama un servizio AEM Forms utilizzando un servizio Web, l'applicazione client può fornire informazioni di autenticazione in uno dei seguenti modi:

AEM Forms non supporta l’autenticazione basata su certificato standard, ma supporta l’autenticazione basata su certificato in un modulo diverso.

L’identità degli utenti dei moduli AEM può essere rappresentata tramite un’asserzione SAML firmata utilizzando una chiave segreta. Il seguente codice XML 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 affermazione di esempio viene rilasciata per un utente amministratore. Questa asserzione contiene i seguenti elementi notevoli:

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

un utente di moduli AEM 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 del servizio Web per l'autenticazione dell'utente. In genere, un'applicazione client ha autenticato un utente ma non ha memorizzato le credenziali utente. Oppure l’utente ha effettuato l’accesso a tale 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 può richiamare AEM Forms.

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

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

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

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

Quando utilizzi AXIS che utilizza l’autenticazione basata su SAML, registra 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, crea una classe Java che si estende org.apache.axis.handlers.BasicHandler.

Creare un gestore di asserzione con Axis

La seguente classe Java, denominata AssertionHandler.java, mostra un esempio di classe Java che si 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, crea un file client-config.wsdd. Per impostazione predefinita, Asse cerca un file con questo nome. Il seguente codice XML è un esempio di file client-config.wsdd. Per ulteriori informazioni, consulta la documentazione sull’asse .

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

Richiamare un servizio AEM Forms

L'esempio di codice seguente richiama 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 di un'autenticazione basata su SAML using-a-net-client-assembly-and-saml-based-authentication

È possibile richiamare un servizio Forms utilizzando un assembly client .NET e un'autenticazione basata su SAML. A questo scopo, è necessario utilizzare il servizio Web 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 tipi di dati Criteri, Asserzioni e SecurityToken. In breve, per una chiamata a un servizio Web, specifica un criterio. Un criterio può avere più asserzioni. Ogni asserzione può contenere filtri. Un filtro viene richiamato in determinate fasi di una chiamata a un servizio Web e, in quel momento, può modificare la richiesta SOAP. Per informazioni dettagliate, consulta la documentazione sul servizio Web Enhancements 3.0 .

Creare l’asserzione e il filtro

Nell'esempio di codice C# seguente vengono create classi di filtro e asserzione. Questo esempio di codice crea un 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);
        }
 }

Creare il token SAML

Crea una classe per rappresentare l’asserzione SAML. L'attività principale eseguita da questa classe è convertire i valori dei dati da stringa a xml e mantenere lo 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);
         }
        . . .
 }

Richiamare un servizio AEM Forms

L'esempio di codice C# seguente richiama 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 durante l’utilizzo dei servizi web related-considerations-when-using-web-services

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

Richiamo asincrono delle operazioni del servizio invoking-service-operations-asynchronously

Se tenti di richiamare in modo asincrono un’operazione del servizio AEM Forms, ad esempio la funzione Genera PDF htmlToPDF funzionamento, SoapFaultException si verifica. Per risolvere il problema, creare un file XML con binding personalizzato che associa il ExportPDF_Result e altri elementi in classi diverse. Il seguente XML rappresenta un file di binding 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 durante la creazione di file proxy Java utilizzando JAX-WS. (Vedi Creazione di classi proxy Java utilizzando JAX-WS.)

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

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

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

L’elenco seguente specifica altri servizi che richiedono un file di binding 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 applicativo J2EE specifico non richiama correttamente AEM Forms ospitata su un server applicativo 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, sono definiti in modo diverso quando AEM Forms viene distribuito su WebSphere rispetto al server applicazioni JBoss. Le differenze tra i JDK utilizzati dai diversi servizi applicativi J2EE sono il motivo per cui esistono differenze nelle definizioni WSDL. Di conseguenza, utilizza le librerie proxy generate dallo stesso server applicativo J2EE.

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

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

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

Per evitare questo problema, ti consigliamo di qualificare completamente i tipi di dati. Ad esempio, considerare un'applicazione .NET che fa riferimento sia al servizio Forms che al servizio Signature utilizzando un riferimento al servizio. Entrambi i riferimenti di servizio contengono un BLOB classe. Per utilizzare un BLOB istanza, qualificare completamente il BLOB quando viene dichiarato. Questo approccio è mostrato nell'esempio di codice seguente. Per informazioni su questo esempio di codice, vedi Firma digitale di Forms interattivo.

Nell'esempio di codice C# seguente viene firmato un modulo interattivo di cui il servizio Forms esegue il rendering. L'applicazione client ha due riferimenti al servizio. La BLOB L'istanza associata al servizio Forms appartiene al SignInteractiveForm.ServiceReference2 spazio dei nomi. Allo stesso modo, il BLOB l’istanza associata al servizio Signature appartiene al SignInteractiveForm.ServiceReference1 spazio dei nomi. 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 a 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 a 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);
                }
            }
        }
 }

I servizi che iniziano con la lettera producono 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 nel caso di IBMFileNetContentRepositoryConnector è BMFileNetContentRepositoryConnectorClient. Lettera mancante nella classe proxy generata.