Vous consultez actuellement l'aide de la version:

Les classes de client requises pour générer des projets Maven utilisant des Services de document AEM sont disponibles dans le fichier JAR du SDK à l’adresse https://repo.adobe.com/nexus/content/groups/public/com/adobe/aemfd/aemfd-client-sdk/6.2.0/.

Pour plus d’informationssurla création d’un projet AEM à l’aide de Maven, voir Comment créer des projets AEM à l’aide d’Apache Maven.

Remarque :

Avant d’utiliser les API du service DocAssurance, configurez le service DocAssurance.

Service DocAssurance

Le service DocAssurance inclut les services suivants :

  • Service Signature
  • Service Encryption
  • Service Reader Extensions

Remarque :

Tous ces services utilisent l’objet Document en tant que paramètred’entréepour lequel Javadoc est disponible à l’adresse http://helpx.adobe.com/fr/experience-manager/6-2/forms/javadocs/

Ajout d’un champ de signature invisible

Les signatures numériques apparaissent dans les champs de signature qui sont des champs de formulaire contenant une représentation graphique de la signature. Les champs de signature peuvent être visibles ou invisibles. Les signataires peuvent utiliser un champ de signature existante ou l’ajout d’un champ de signature peut être programmé. Dans les deux cas, le champ de signature doit exister avant la signature du document PDF. Vous pouvez programmer l’ajout d’un champ de signature à l’aide de l’API Java du service Signature ou de l’API du service Web de signature. Vous pouvez ajouter plus d’un champ de signature à un document PDF. Toutefois, chaque nom de champ de signature doit être unique.

Syntaxe : addInvisibleSignatureField (Document inDoc, String signatureFieldName, FieldMDPOptionSpec fieldMDPOptionsSpec, PDFSeedValueOptionSpec seedValueOptionsSpec, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc Objet document contenant un PDF.
signatureFieldName
Le nom du champ de signature. Ce paramètre est obligatoire et ne peut pas avoir une valeur nulle.
fieldMDPOptionsSpec Un objet FieldMDPOptionSpec spécifiant les champs du document PDF verrouillés une fois le champ de signature signé. Ce paramètre est facultatif et peut accepter la valeur nulle.
seedValueOptionsSpec Un objet SeedValueOptions spécifiant les différentes valeurs de départ pour le champ. Ce paramètre est facultatif et peut accepter la valeur nulle.
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Ce paramètre n’est requis que pour les fichiers chiffrés.

Voici un exemple de code Java ajoutant un champ de signature invisible à un document PDF.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PositionRectangle;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * Digital signatures appear in signature fields, which are form fields that contain a graphic representation of the signature. 
 * Signature fields can be visible or invisible. Signers can use a pre existing signature field, or a signature field can be 
 * programmatically added. In either case, the signature field must exist before a PDF document can be signed.
 * You can programmatically add a signature field by using the Signature service Java API or Signature web service API. 
 * You can add more than one signature field to a PDF document; however, each signature field name must be unique.
 * 
 * The following Java code example adds an invisible signature field named SignatureField1 to a PDF document.
 */

@Component
@Service(value=AddInvisibleSignatureField.class)
public class AddInvisibleSignatureField {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to an pdf document stored at disk
	 * @param outputFile - path where the output file has to be saved 
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * @throws DocAssuranceException 
	 * 
	 */
	public void addInvisibleSignatureField(String inputFile, String outputFile) throws InvalidArgumentException, PDFOperationException, PermissionsException, DuplicateSignatureFieldException, SignaturesBaseException, DocAssuranceException {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
		
        //Specify the name of the signature field
        String fieldName = "SignatureField1";

        //Create a  PositionRectangle object that specifies
        //the signature fields location
        PositionRectangle post = new  PositionRectangle(193,47,133,12);

        //Specify the page number that will contain the signature field
        java.lang.Integer pageNum = new java.lang.Integer(1);

        //Add a signature field to the PDF document
        try {
			outDoc = docAssuranceService.addInvisibleSignatureField(
			    inDoc,
			    fieldName,
			    null,
			    null,
			    null);
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} // for an encrypted PDF input, pass unlock options
       
        //save the outDoc
        try {
			outDoc.copyToFile(outFile);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * UnlockOptions to be passed to addSignatureField() API to add a signature field in an encrypted pdf document.
	 */
	private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Ajout d’un champ de signature

Vous pouvez programmer l’ajout d’un champ de signature à l’aide de l’API Java du service Signature ou de l’API du service Web de signature. Vous pouvez ajouter plusieurs champs de signature à un document PDF. Toutefois, chaque nom de champ de signature doit être unique.

Syntaxe : public Document addSignatureField(Document inDoc,
String signatureFieldName,
Integer pageNo,
PositionRectangle positionRectangle,
FieldMDPOptionSpec fieldMDPOptionsSpec,
PDFSeedValueOptionSpec seedValueOptionsSpec, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc Objet document contenant un PDF
signatureFieldName Nom du champ de signature. Ce paramètre est obligatoire et ne peut pas accepter une valeur nulle.
pageNumber Numéro de page sur lequel le champ de signature est ajouté. Les valeurs valides vont de 1 au nombre de pages contenues dans le document. Ce paramètre est obligatoire et ne peut pas accepter une valeur nulle.
positionRectangle Un objet PositionRectangle spécifiant la position du champ de signature. Ce paramètre est obligatoire et ne peut pas accepter une valeur nulle. Si le rectangle spécifié ne se trouve pas au moins partiellement dans la zone de recadrage de la page spécifiée, une exception InvalidArgumentException est générée. En outre, la hauteur et la largeur du rectangle spécifié ne peuvent pas être égales ou inférieures à 0. Les coordonnées X inférieur gauche et Y inférieur gauche peuvent être égales ou supérieures à 0 et sont relatives par rapport à la zone de recadrage de la page.
fieldMDPOptionsSpec Un objet FieldMDPOptionSpec spécifiant les champs du document PDF verrouillés une fois le champ de signature signé. Ce paramètre est facultatif et peut être nul.
seedValueOptionsSpec Un objet SeedValueOptions spécifiant les différentes valeurs de départ pour le champ. Ce paramètre est facultatif et peut être nul.
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Ce paramètre n’est requis que pour les fichiers chiffrés.

Voici un exemple de code Java ajoutant un champ de signature à un document PDF.

/*************************************************************************
 *
-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PositionRectangle;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * Digital signatures appear in signature fields, which are form fields that contain a graphic representation of the signature. 
 * Signature fields can be visible or invisible. Signers can use a pre existing signature field, or a signature field can be 
 * programmatically added. In either case, the signature field must exist before a PDF document can be signed.
 * You can programmatically add a signature field by using the Signature service Java API or Signature web service API. 
 * You can add more than one signature field to a PDF document; however, each signature field name must be unique.
 * 
 * The following Java code example adds a signature field named SignatureField1 to a PDF document.
 */

@Component
@Service(value=AddSignatureField.class)
public class AddSignatureField {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to an pdf document stored at disk
	 * @param outputFile - path where the output file has to be saved 
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * @throws DocAssuranceException 
	 * 
	 */
	public void addSignatureField(String inputFile, String outputFile) throws InvalidArgumentException, PDFOperationException, PermissionsException, DuplicateSignatureFieldException, SignaturesBaseException, DocAssuranceException {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
		
        //Specify the name of the signature field
        String fieldName = "SignatureField1";

        //Create a  PositionRectangle object that specifies
        //the signature fields location
        PositionRectangle post = new  PositionRectangle(193,47,133,12);

        //Specify the page number that will contain the signature field
        java.lang.Integer pageNum = new java.lang.Integer(1);

        //Add a signature field to the PDF document
        try {
			outDoc = docAssuranceService.addSignatureField(
			    inDoc,
			    fieldName,
			    pageNum,
			    post,
			    null,
			    null,
			    null);
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} // for an encrypted PDF input, pass unlock options
       
        //save the outDoc
        try {
			outDoc.copyToFile(outFile);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * UnlockOptions to be passed to addSignatureField() API to add a signature field in an encrypted pdf document.
	 */
	private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Obtention de la signature

Vous pouvez récupérer les noms de tous les champs de signature d’un document PDF que vous souhaitez signer ou certifier. Si vous n’êtes pas certain(e) de connaître les noms de champ de signature d’un document PDF ou si vous souhaitez vérifier leurs noms, vous pouvez programmer leur récupération. Le service Signature renvoie le nom qualifié complet du champ de signature, tel que form1[0].grantApplication[0].page1[0].SignatureField1[0].

Syntaxe : getSignature (Document doc, signatureFieldName de chaîne, options de déverrouillage UnlockOptions)

Paramètres d’entrée

Paramètres Description
doc
Objet document contenant un PDF.
signatureFieldName Le nom du champ de signature contenant une signature. Spécifiez le nom qualifié complet du champ de signature. Lors de l’utilisation d’un document PDF basé sur un formulaire XFA, le nom partiel du champ de signature peut alors être utilisé. Par exemple, formulaire1[0].#subform[1] .SignatureField3 [3] peut être spécifié comme SignatureField3 [3].
UnlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple de code Java suivant récupère les informations de signature du champ de signature donné situé dans un document PDF.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PDFSignatureField;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.client.types.PDFSignature;

/**
 * You can retrieve the names of all signature fields that are located in a PDF document that you want to sign or certify. 
 * If you are unsure of the signature field names that are located in a PDF document or you want to verify the names, you can
 * programmatically retrieve them. The Signature service returns the fully qualified name of the signature field, such as 
 * form1[0].grantApplication[0].page1[0].SignatureField1[0].
 * 
 * The following Java code example retrieves the Signature Info for the given signature field located in a PDF document.
 */

@Component
@Service(value=GetSignature.class)
public class GetSignature {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * 
	 */
	public void GetSignature(String inputFile) throws Exception {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
	      
		//Retrieve signature data for a given signature field.
		//for encrypted document pass Unlock Options - see the method getUnlockOptions() below
        PDFSignature pdfSignature = docAssuranceService.getSignature(inDoc,"fieldName",null);
        
   }
       
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Obtention de la liste des champs de signature

Vous pouvez récupérer les noms de tous les champs de signature d’un document PDF que vous souhaitez signer ou certifier. Si vous n’êtes pas certain de connaître les noms de champ de signature d’un document PDF, vous pouvez programmer leur récupération et leur vérification. Le service Signature renvoie le nom qualifié complet du champ de signature, tel que form1[0].grantApplication[0].page1[0].SignatureField1[0].

Syntaxe : public List <PDFSignatureField> getSignatureFieldList (Document inDoc, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc Objet document contenant un PDF
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple de code Java suivant récupère les noms des champs de signature d’un document PDF.

/*************************************************************************
 *
 *
-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------
**************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PDFSignatureField;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * You can retrieve the names of all signature fields that are located in a PDF document that you want to sign or certify. 
 * If you are unsure of the signature field names that are located in a PDF document or you want to verify the names, you can
 * programmatically retrieve them. The Signature service returns the fully qualified name of the signature field, such as 
 * form1[0].grantApplication[0].page1[0].SignatureField1[0].
 * 
 * The following Java code example retrieves the names of signature fields located in a PDF document.
 */

@Component
@Service(value=GetSignatureFields.class)
public class GetSignatureFields {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * 
	 */
	public void getSignatureFields(String inputFile) throws Exception {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
	      
		//Retrieve the name of the document's signature fields
		//for encrypted document pass Unlock Options - see the method getUnlockOptions() below
        List fieldNames = docAssuranceService.getSignatureFieldList(inDoc,null);

        //Obtain the name of each signature field by iterating through the 
        //List object
        Iterator iter = fieldNames.iterator(); 
        int i = 0 ; 
        String fieldName="";
        while (iter.hasNext()) { 
            PDFSignatureField signatureField = (PDFSignatureField)iter.next(); 
            fieldName = signatureField.getName();
            System.out.println("The name of the signature field is " +fieldName); 
            i++;
        }
   }
       
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Modification des champs de signature

Vous pouvez modifier les champs de signature d’un document PDF. La modification d’un champ de signature implique de manipuler ses valeurs de dictionnaire de verrouillage des champs de signature ou ses valeurs du dictionnaire de valeur de départ.

Un dictionnaire de verrouillage de champ spécifie la liste des champs qui sont verrouillés lorsque le champ de signature est signé. Un champ verrouillé empêche les utilisateurs de modifier le champ. Un dictionnaire de valeur de départ contient des informations contraignantes utilisées au moment de l’apposition de la signature. Par exemple, vous pouvez modifier les autorisations qui contrôlent les actions pouvant se produire sans invalider la signature.

Lorsque vous modifiez un champ de signature existant, vous pouvez modifier le document PDF en fonction des besoins de votre entreprise. Par exemple, un nouveau besoin d’activité nécessite de verrouiller tous les champs du document une fois le document signé.

Syntaxe : public Document modifySignatureField(Document inDoc,String signatureFieldName,PDFSignatureFieldProperties pdfSignatureFieldProperties, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc Objet document contenant un PDF
signatureFieldName Le nom du champ de signature. Ce paramètre est obligatoire et ne peut pas accepter une valeur nulle.
pdfSignatureFieldProperties Objet spécifiant des informations sur les valeurs PDFSeedValueOptionSpec et FieldMDPOptionSpec du champ de signature.
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple de code Java suivant modifie un champ de signature en verrouillant tous les champs du formulaire lorsqu’une signature est appliquée au champ de signature.  

/*************************************************************************
 *

-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.FieldMDPAction;
import com.adobe.fd.signatures.client.types.FieldMDPOptionSpec;
import com.adobe.fd.signatures.client.types.MDPPermissions;
import com.adobe.fd.signatures.client.types.PDFSeedValueOptionSpec;
import com.adobe.fd.signatures.client.types.PDFSignatureFieldProperties;
import com.adobe.fd.signatures.client.types.PositionRectangle;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.MissingSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignatureFieldSignedException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesOtherException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * You can modify signature fields that are located in a PDF document by using the Java API and web service API. Modifying a signature field involves
 * manipulating its signature field lock dictionary values or seed value dictionary values.
 * A field lock dictionary specifies a list of fields that are locked when the signature field is signed. A locked field prevents users from making 
 * changes to the field. A seed value dictionary contains constraining information that is used at the time the signature is applied. 
 * For example, you can change permissions that control the actions that can occur without invalidating a signature.
 * By modifying an existing signature field, you can make changes to the PDF document to reflect changing business requirements. For example, 
 * a new business requirement may require locking all document fields after the document is signed.
 * This section explains how to modify a signature field by amending both field lock dictionary and seed value dictionary values. 
 * Changes made to the signature field lock dictionary result in all fields in the PDF document being locked when a signature field is signed. 
 * Changes made to the seed value dictionary prohibit specific types of changes to the document.
 * 
 * The following Java code example modifies a signature field named SignatureField1 by locking all fields in the form when a signature is applied to the signature field and ensuring that no changes are allowed. 
 * After the Signature service returns the PDF document that contains the modified signature field
 */

@Component
@Service(value=ModifySignatureField.class)
public class ModifySignatureField {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk
	 * @param outFile - path where the output file has to be saved
	 * 
	 * 
	 */
	public void modifySignatureField(String inputFile, String outFile) throws Exception {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);

		//Specify the name of the signature field
        String fieldName = "SignatureField1";
        
        //Create a PDFSignatureFieldProperties
        PDFSignatureFieldProperties fieldProperties = new PDFSignatureFieldProperties();
         
         //Create a PDFSeedValueOptionSpec object that stores 
         //seed value dictionary information.
         PDFSeedValueOptionSpec seedOptionsSpec = new PDFSeedValueOptionSpec();
         
         //Disallow changes to the PDF document. Any change to the document invalidates 
         //the signature
         seedOptionsSpec.setMdpValue(MDPPermissions.NoChanges);
         
         //Create a FieldMDPOptionSpec object that stores 
         //signature field lock dictionary information.
         FieldMDPOptionSpec fieldMDPOptionsSpec = new FieldMDPOptionSpec();    
         
         //Lock all fields in the PDF document
         fieldMDPOptionsSpec.setAction(FieldMDPAction.ALL);
         
         //Set dictionary information
         fieldProperties.setSeedValue(seedOptionsSpec);
         fieldProperties.setFieldMDP(fieldMDPOptionsSpec);
                 
         //Modify the signature field
         //for encrypted document pass Unlock Options - see the method getUnlockOptions() below
         Document modSignatureField =  docAssuranceService.modifySignatureField(inDoc,fieldName,fieldProperties,null);
       
        //save the modSignatureField
         modSignatureField.copyToFile(new File(outFile));
	}
	
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Certification de documents PDF

Vous pouvez définir un document PDF en le certifiant avec un type de signature particulier appelé signature certifiée. Une signature certifiée se différencie d’une signature numérique de plusieurs manières :

  • Elle doit être la première signature appliquée au document PDF. En d’autres termes, lorsque la signature certifiée est appliquée, les autres champs de signature du document doivent être vides. Une seule signature certifiée est autorisée dans un document PDF. Pour signer et certifier un document PDF, certifiez-le avant de le signer. Après avoir certifié un document PDF, vous pouvez signer numériquement les champs de signature supplémentaires.
  • L’auteur ou l’expéditeur du document peut indiquer que le document peut être modifié de certaines manières sans invalider la signature certifiée. Par exemple, le document peut autoriser le remplissage de formulaires ou de commentaires. Si l’auteur spécifie qu’une modification spécifique n’est pas autorisée, Acrobat limite la modification du document aux utilisateurs. Si ces modifications sont effectuées, la signature certifiée est non valide. Par ailleurs, Acrobat affiche un avertissement lorsqu’un utilisateur ouvre le document. (Avec des signatures non certifiées, les modifications ne sont pas empêchées et les opérations normales de modification n’invalident pas la signature d’origine.)
  • Au moment de la signature, les différents types de contenus du document susceptibles de rendre le document ambigu ou trompeur sont analysés. Par exemple, une annotation peut assombrir du texte sur une page qui est essentiel pour comprendre ce qui est certifié. Une explication (attestation légale) peut être fournie pour un type de contenu.
Syntaxe : secureDocument(Document inDoc, EncryptionOptions encryptionOptions,
SignatureOptions signatureOptions, ReaderExtensionOptions readerExtensionOptions, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc
Document PDF d’entrée de documents
encryptionOptions
Inclut les arguments requis pour chiffrer un document PDF
signatureOptions Inclut les options requises pour la signature ou la certification d’un document PDF
readerExtensionOptions Inclut les options requises pour doter un document PDF d’extensions Reader
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple de code suivant certifie un document PDF basé sur un fichier PDF. 

/*************************************************************************

-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.DocAssuranceServiceOperationTypes;
import com.adobe.fd.docassurance.client.api.SignatureOptions;
import com.adobe.fd.signatures.client.types.MDPPermissions;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.pdf.inputs.CredentialContext;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferences;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferencesImpl;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.PDFSignatureAppearanceType;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.TextDirection;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.pki.client.types.common.HashAlgorithm;
import com.adobe.fd.signatures.pki.client.types.common.RevocationCheckStyle;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.GeneralPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferencesImpl;

/**
 * You can secure a PDF document by certifying it with a particular type of signature called a certified signature. 
 * A certified signature is distinguished from a digital signature in these ways:
 * 
 * It must be the first signature applied to the PDF document; that is, at the time the certified signature is applied, any other signature fields in the document must be unsigned.
 * Only one certified signature is permitted in a PDF document. If you want to sign and certify a PDF document, you must certify it before signing it. 
 * After you certify a PDF document, you can digitally sign additional signature fields.
 * 
 * The author or originator of the document can specify that the document can be modified in certain ways without invalidating the certified signature. For example, 
 * the document may permit filling in forms or commenting. If the author specifies that a certain modification is not permitted, Acrobat restricts users from modifying the document 
 * in that way. If such modifications are made, such as by using another application, the certified signature is invalid and Acrobat issues a warning when a user opens the document. 
 * (With non-certified signatures, modifications are not prevented, and normal editing operations do not invalidate the original signature.)
 * 
 * At the time of signing, the document is scanned for specific types of content that could make the contents of a document ambiguous or misleading. For example, an annotation could 
 * obscure some text on a page that is important for understanding what is being certified. An explanation (legal attestation) can be provided about such content.
 * You can programmatically certify PDF documents by using the Signature service Java API or the Signature web service API. When certifying a PDF document, you must reference a security 
 * credential that exists in the Credential service.
 * 
 * Note: When certifying and signing the same PDF document, if the certify signature is not trusted, a yellow triangle appears next to the first sign signature when you open the PDF document in Acrobat or Adobe Reader. 
 * The certifying signature must be trusted to avoid this situation.
 * 
 * The following Java code example certifies a PDF document that is based on a PDF file. 
 * 
 * PreRequisites - Digital certificate for certifying the document has to be uploaded on AEM Key Store.
 *
 */

@Component
@Service(value=Certify.class)
public class Certify {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	@Reference
    private SlingRepository slingRepository;
	
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at JCR node 
	 * @param outputFile - path to the pdf document where the output needs to be stored
	 * @throws IOException
	 * @throws RepositoryException
	 * @throws InvalidArgumentException
	 * @throws DocAssuranceException
	 */
	public void certify(String inputFile, String outputFile) throws IOException, RepositoryException, InvalidArgumentException, DocAssuranceException{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
		
		Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try {
        	 
        	 /** resourceResolver to be passed to SignatureServiceAPI and Reader Extensions
        	 the resource resolver for signature options has to be corresponding to the user who has the signing certificate in his granite key store
        	 the resource resolver for signature options has to be corresponding to the user who has the credential for reader extension in his granite key store
        	 here we are using the same resource resolver
        	 */
        	 adminSession = slingRepository.loginAdministrative(null);
             resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
             
             //retrieve specifications for each of the services, you may pass null if you don't want to use that service
             //we are not extending the reader in this case, so passing null
             //for encrypted document pass Unlock Options - see the method getUnlockOptions() below
			 try {
				outDoc = docAssuranceService.secureDocument(inDoc, null, getCertificationOptions(resourceResolver), null,null);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			 
        }
        finally{
            /**
             * always close the PDFDocument object after your processing is done.
             */
            if(inDoc != null){
                inDoc.close();
            }
            if(adminSession != null && adminSession.isLive()){
                if(resourceResolver != null){
                    resourceResolver.close();
                }
                adminSession.logout();
            }
        }
        
        outDoc.copyToFile(outFile);
		
		
	}
	
	/**
	 * 
	 * @param rr resource resolver corresponding to the user with the access to signing credential for the 
	 * given alias "allcertificatesanypolicytest11ee_new" in this case
	 * @return SignatureOptions
	 */
	private SignatureOptions getCertificationOptions(ResourceResolver rr){
		
		//create an instance of SignatureOptions
		SignatureOptions signatureOptions = SignatureOptions.getInstance();
		
		//set the operation you want to perform - SIGN/CERTIFY
		signatureOptions.setOperationType(DocAssuranceServiceOperationTypes.CERTIFY);
		
		//signature field to certify, pass null if invisible signature field
		String fieldName = "Signature1" ;
		
		//alias of the private credential uploaded on the Key Store
        String alias = "allcertificatesanypolicytest11ee_new";
        
        //Hash Algo to be used to compute digest the PDF document
        HashAlgorithm algo = HashAlgorithm.SHA256;
        
        //Reason for signing/certifying
        String reason = "Reason";
        
        //location of the signer
        String location = "Location";
        
        //contact info of the signer
        String contactInfo = "Contact Info";
        
        //DocMDP Permissions associated with certification
        MDPPermissions mdpPermissions = MDPPermissions.valueOf("FormChanges");
        
        //Create a PDFSignatureAppearanceOptions object 
        //and show date information
        PDFSignatureAppearenceOptions appOptions = new PDFSignatureAppearenceOptions(
                PDFSignatureAppearanceType.NAME, null, 1.0d, null, true, true,
                true, true, false, true, true, TextDirection.AUTO);
        signatureOptions.setLockCertifyingField(true);
        signatureOptions.setSignatureFieldName(fieldName);
        signatureOptions.setAlgo(algo);
        signatureOptions.setContactInfo(contactInfo);
        signatureOptions.setLocation(location);
        signatureOptions.setSigAppearence(appOptions);
        signatureOptions.setReason(reason);
        signatureOptions.setDssPref(getDSSPreferences(rr));
        signatureOptions.setCredential(new CredentialContext(alias, rr));
        signatureOptions.setMdpPermissions(mdpPermissions);
		return signatureOptions;
	}
	
	private DSSPreferences getDSSPreferences(ResourceResolver rr){
		//sets the DSS Preferences
        DSSPreferencesImpl prefs = DSSPreferencesImpl.getInstance();
        prefs.setPKIPreferences(getPKIPreferences());
        GeneralPreferencesImpl gp = (GeneralPreferencesImpl) prefs.getPKIPreferences().getGeneralPreferences();
        gp.setDisableCache(true);
        return prefs;
    }
    
    private PKIPreferences getPKIPreferences(){
    	//sets the PKI Preferences
        PKIPreferences pkiPref = new PKIPreferencesImpl();
        pkiPref.setCRLPreferences(getCRLPreferences());
        pkiPref.setPathPreferences(getPathValidationPreferences());
        return pkiPref;
    }
    
    private CRLPreferences getCRLPreferences(){
        //specifies the CRL Preferences
        CRLPreferencesImpl crlPrefs = new CRLPreferencesImpl();
        crlPrefs.setRevocationCheck(RevocationCheckStyle.CheckIfAvailable);
        crlPrefs.setGoOnline(true);
        return crlPrefs;
    }
    
    private PathValidationPreferences getPathValidationPreferences(){
    	//sets the path validation preferences
        PathValidationPreferencesImpl pathPref = new PathValidationPreferencesImpl();
        pathPref.setDoValidation(false);
        return pathPref;
        
    }
    
    /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
    
    
}

Sécurisation de documents

secureDocument vous permet de chiffrer, signer/certifier, doter un document PDF d’extensions Reader individuellement ou dans toute combinaison dans un ordre particulier. Pour accéder à une partie de cette fonctionnalité, transmettez l’argument correspondant. Si la clé est nulle, il est supposé que le traitement particulier n’est pas requis.

Chiffrement de documents PDF avec mot de passe

Si vous chiffrez un document PDF avec un mot de passe, les utilisateurs devront indiquer ce même mot de passe pour pouvoir ouvrir le document PDF dans Adobe Reader ou Acrobat. En outre, avant qu’une autre opération de Document Services pour AEM Forms utilise le document, un document PDF chiffré par mot de passe doit être déverrouillé.

Chiffrement des documents PDF avec certificat

Le chiffrement avec certificat vous permet de chiffrer le document pour des destinataires spécifiques utilisant la technologie de clé publique.

Différents destinataires peuvent recevoir différents droits pour le document. De nombreux aspects de chiffrement sont possibles grâce à la technologie de clé publique.

Un algorithme est utilisé pour générer deux grands nombres, également appelés clés possédant les propriétés suivantes :

  • Une clé est utilisée pour chiffrer un ensemble de données. Par la suite, seule l’autre clé peut être utilisée pour déchiffrer les données.
  • Il est impossible de distinguer une clé d’une autre.
  • Une des clés fait office de clé privée d’un utilisateur. Il est important que seul l’utilisateur ait accès à cette clé.
  • L’autre clé est la clé publique de l’utilisateur, qui peut être partagée avec d’autres utilisateurs.

Un certificat de clé publique contient la clé publique d’un utilisateur et ses données d’identification. Le format X.509 est utilisé pour le stockage de certificats. Les certificats sont généralement émis et signés numériquement par une autorité de certification, qui est une entité reconnue qui garantit la validité du certificat. Les certificats comportent une date d’expiration ; au-delà de cette date, ils ne sont plus valides.

En outre, les listes de révocation des certificats (CRL) fournissent des informations sur les certificats révoqués avant leur date d’expiration. Les listes CRL sont modifiées régulièrement par des autorités de certification. Vous pouvez également récupérer l’état de révocation d’un certificat par l’intermédiaire du protocole OCSP (Online Certificate Status Protocol, protocole d’état de certificat en ligne) sur le réseau.

Remarque : Avant de chiffrer un document PDF avec un certificat, vous devez vérifier que vous ajoutez le certificat au Trust Store de AEM.

Application de droits d’utilisation aux documents PDF

Vous pouvez appliquer des droits d’utilisation aux documents PDF à l’aide de l’API cliente Java Reader Extensions et du service Web. Les droits d’utilisation appartiennent à la fonctionnalité disponible par défaut dans Acrobat mais non dans Adobe Reader, telle que la capacité à ajouter des commentaires à un formulaire ou à remplir des champs de formulaire et enregistrer ce dernier. Les documents PDF dotés de droits d’utilisation sont appelés des documents dont les droits sont activés. Un utilisateur qui ouvre un document dont les droits sont activés dans Adobe Reader peut effectuer les opérations autorisées pour ce document spécifique.

Avant de pouvoir doter un document PDF d’extensions pour Reader avec un certificat, vous devez vérifier que vous ajoutez le certificat au fichier de stockage de clés AEM.

Signature numérique de documents PDF

Les signatures numériques peuvent être appliquées aux documents PDF pour fournir un niveau de sécurité. Les signatures numériques, tout comme les signatures manuscrites, permettent aux signataires de s’identifier et d’effectuer des instructions sur le document.

La technologie utilisée pour signer numériquement des documents permet de s’assurer que le signataire et les destinataires se sont accordés sur ce qui a été signé et croient en la non-altération du document signé.

Les documents PDF sont signés au moyen de la technologie de clé publique. Le signataire a deux clés : une clé publique et une clé privée. La clé privée est stockée dans les informations d’identification d’un utilisateur. Cette clé doit être disponible au moment de la signature.

La clé publique est stockée dans le certificat de l’utilisateur, celle-ci doit être accessible aux destinataires pour valider la signature. Les informations relatives aux certificats révoqués se trouvent dans les listes de révocation des certificats et les réponses OCSP (Online Certificate Status Protocol) distribuées par les autorités de certification (CA). L’heure de la signature peut être obtenue d’une source approuvée appelée Autorité de d’horodatage.

Remarque : Avant de signer numériquement un document PDF, vous devez vérifier que vous ajoutez les informations d’identification dans le stockage de clés AEM. Les informations d’identification sont la clé privée utilisée pour la signature.

Certification de documents PDF

Vous pouvez définir un document PDF en le certifiant avec un type de signature particulier appelé signature certifiée. Une signature certifiée se différencie d’une signature numérique de plusieurs manières :

Elle doit être la première signature appliquée au document PDF ; cela veut dire que lorsque la signature certifiée est appliquée, tous les autres champs de signature du document doivent être non signés.

Une seule signature certifiée est autorisée dans un document PDF. Si vous souhaitez signer ou certifier un document PDF, vous devez le certifier avant de le signer.

Après avoir certifié un document PDF, vous pouvez signer numériquement les champs de signature supplémentaires.

L’auteur ou l’expéditeur du document peut indiquer que le document peut être modifié de certaines manières sans invalider la signature certifiée.

Par exemple, le document peut autoriser le remplissage de formulaires ou de commentaires. Si l’auteur spécifie qu’une modification spécifique est autorisée,

Acrobat limite ainsi les utilisateurs dans la modification du document. Si ces modifications sont effectuées, à l’aide d’une autre application par exemple, la signature certifiée est alors non valide et Acrobat affiche un avertissement à l’ouverture du document. (Avec des signatures non certifiées, les modifications ne sont pas empêchées et les opérations normales de modification n’invalident pas la signature d’origine.)

Au moment de la signature, les différents types de contenus du document susceptibles de rendre le document ambigu ou trompeur sont analysés.

Par exemple, une annotation peut assombrir du texte sur une page qui est essentiel pour comprendre ce qui est certifié. Une explication (attestation légale) peut être fournie pour un type de contenu.

Remarque : Avant de signer numériquement un document PDF, vous devez vérifier que vous ajoutez les informations d’identification dans le stockage de clés AEM. Les informations d’identification sont la clé privée utilisée pour la signature.

Syntaxe : secureDocument(Document inDoc,
EncryptionOptions encryptionOptions,
SignatureOptions signatureOptions,
ReaderExtensionOptions readerExtensionOptions,
UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc
Document PDF d’entrée de documents
encryptionOptions
Inclut les arguments requis pour chiffrer un document PDF
signatureOptions Inclut les options requises pour la signature ou la certification d’un document PDF
readerExtensionOptions Inclut les options requises pour doter un document PDF d’extensions Reader
unlockOptions Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

Exemple 1 : Cet exemple est utilisé pour effectuer le chiffrement avec mot de passe, certifier un champ de signature et doter le document PDF d’extensions Reader.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.DocAssuranceServiceOperationTypes;
import com.adobe.fd.docassurance.client.api.EncryptionOptions;
import com.adobe.fd.docassurance.client.api.ReaderExtensionOptions;
import com.adobe.fd.docassurance.client.api.SignatureOptions;
import com.adobe.fd.encryption.client.PasswordEncryptionCompatability;
import com.adobe.fd.encryption.client.PasswordEncryptionOption;
import com.adobe.fd.encryption.client.PasswordEncryptionOptionSpec;
import com.adobe.fd.encryption.client.PasswordEncryptionPermission;
import com.adobe.fd.readerextensions.client.ReaderExtensionsOptionSpec;
import com.adobe.fd.readerextensions.client.UsageRights;
import com.adobe.fd.signatures.client.types.MDPPermissions;
import com.adobe.fd.signatures.pdf.inputs.CredentialContext;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferences;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferencesImpl;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.PDFSignatureAppearanceType;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.TextDirection;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.pki.client.types.common.HashAlgorithm;
import com.adobe.fd.signatures.pki.client.types.common.RevocationCheckStyle;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.GeneralPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferencesImpl;

/**
 * 
 * This class provides a sample code to use {@code DocAssuranceService} to carry out
 * password encryption, certifying a signature field and reader extending the pdf document.
 * 
 * PreRequisites - Digital certificate for signing the document has to be uploaded on Granite Key Store
 * 				   Digital certificate for reader extending the document has to be uploaded on Granite Key Store
 */

@Component
@Service(value=PassEncryptCertifyExtend.class)
public class PassEncryptCertifyExtend {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	@Reference
    private SlingRepository slingRepository;
	
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk 
	 * @param outputFile - path to the pdf document where the output needs to be stored
	 * @throws Exception 
	 */
	public void SecureDocument(String inputFile, String outputFile) throws Exception{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
		
		Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try {
        	 
        	 /** resourceResolver with admin privileges to be passed to SignatureServiceAPI and Reader Extensions
        	 the resource resolver for signature options has to be corresponding to the user who has the signing certificate in his granite key store
        	 the resource resolver for signature options has to be corresponding to the user who has the credential for reader extension in his granite key store
        	 here we are using the same resource resolver
        	 */
        	 adminSession = slingRepository.loginAdministrative(null);
             resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
             
             //retrieve specifications for each of the services, you may pass null if you don't want to use that service
             //for encrypted document pass Unlock Options - see the method getUnlockOptions() below
			 outDoc = docAssuranceService.secureDocument(inDoc, getPassEncryptionOptions(), getCertificationOptions(resourceResolver), getReaderExtensionOptions(resourceResolver),null);
        }
        finally{
            /**
             * always close the PDFDocument object after your processing is done.
             */
            if(inDoc != null){
                inDoc.close();
            }
            if(adminSession != null && adminSession.isLive()){
                if(resourceResolver != null){
                    resourceResolver.close();
                }
                adminSession.logout();
            }
        }
        
        outDoc.copyToFile(outFile);
		
		
	}
	
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
	
	/**
	 * @return EncryptionOptions for password encrypting the document.
	 * 
	 */
	private EncryptionOptions getPassEncryptionOptions(){
		
		//Create an instance of EncryptionOptions
		EncryptionOptions encryptionOptions = EncryptionOptions.getInstance();
		
		//Create a PasswordEncryptionOptionSpec object that stores encryption run-time values
        PasswordEncryptionOptionSpec passSpec = new PasswordEncryptionOptionSpec();
        
        //Specify the PDF document resource to encrypt
        passSpec.setEncryptOption(PasswordEncryptionOption.ALL);
        
        //Specify the permission associated with the password
        //These permissions enable data to be extracted from a password
        //protected PDF form
        List<PasswordEncryptionPermission> encrypPermissions = new ArrayList<PasswordEncryptionPermission>(); 
        encrypPermissions.add(PasswordEncryptionPermission.PASSWORD_EDIT_ADD);
        encrypPermissions.add(PasswordEncryptionPermission.PASSWORD_EDIT_MODIFY);
        passSpec.setPermissionsRequested(encrypPermissions);
        
        //Specify the Acrobat version
        passSpec.setCompatability(PasswordEncryptionCompatability.ACRO_7);
        
        //Specify the password values
        passSpec.setDocumentOpenPassword("OpenPassword");
        passSpec.setPermissionPassword("PermissionPassword");
        
        //Set the encryption type to Password Encryption
		encryptionOptions.setEncryptionType(DocAssuranceServiceOperationTypes.ENCRYPT_WITH_PASSWORD);
        encryptionOptions.setPasswordEncryptionOptionSpec(passSpec);

    	return encryptionOptions;
	}
	
	/**
	 * 
	 * @param resourceResolver corresponding to the user with the access to Reader Extension credential 
	 * for the given alias -"production" in this case
	 * @return
	 */
	private ReaderExtensionOptions getReaderExtensionOptions(ResourceResolver resourceResolver){
		
		//Create an instance of ReaderExtensionOptions
		ReaderExtensionOptions reOptions = ReaderExtensionOptions.getInstance();
		
		//Create instance for UsageRights to be enabled in the reader
		UsageRights uRights = new UsageRights();
		//enabling comments in the PDF Reader
		uRights.setEnabledComments(true);
		//setting ReaderExtensionsOptionSpec in the reOptions
		reOptions.setReOptions(new ReaderExtensionsOptionSpec(uRights, "Enable commenting in PDF"));
		//alias of the credential to be used for extending the PDF Reader
		reOptions.setCredentialAlias("production");  
		//corresponding to the user with the access to Reader Extension credential
		reOptions.setResourceResolver(resourceResolver); 
		
		return reOptions;
	}
	
	/**
	 * 
	 * @param rr resource resolver corresponding to the user with the access to signing credential for the 
	 * given alias "allcertificatesanypolicytest11ee_new" in this case
	 * @return SignatureOptions
	 */
	private SignatureOptions getCertificationOptions(ResourceResolver rr){
		
		//create an instance of SignatureOptions
		SignatureOptions signatureOptions = SignatureOptions.getInstance();
		
		//set the operation you want to perform - SIGN/CERTIFY
		signatureOptions.setOperationType(DocAssuranceServiceOperationTypes.CERTIFY);
		
		//signature field to certify, pass null if invisible signature field
		String fieldName = "Signature1" ;
		
		//alias of the private credential uploaded on the Key Store
        String alias = "allcertificatesanypolicytest11ee_new";
        
        //Hash Algo to be used to compute digest the PDF document
        HashAlgorithm algo = HashAlgorithm.SHA384;
        
        //Reason for signing/certifying
        String reason = "Test Reason";
        
        //location of the signer
        String location = "Test Location";
        
        //contact info of the signer
        String contactInfo = "Test Contact";
        
        //DocMDP Permissions associated with certification
        MDPPermissions mdpPermissions = MDPPermissions.valueOf("FormChanges");
        
        //Create a PDFSignatureAppearanceOptions object 
        //and show date information
        PDFSignatureAppearenceOptions appOptions = new PDFSignatureAppearenceOptions(
                PDFSignatureAppearanceType.NAME, null, 1.0d, null, true, true,
                true, true, true, true, true, TextDirection.AUTO);
        
        signatureOptions.setSignatureFieldName(fieldName);
        signatureOptions.setAlgo(algo);
        signatureOptions.setContactInfo(contactInfo);
        signatureOptions.setLocation(location);
        signatureOptions.setSigAppearence(appOptions);
        signatureOptions.setReason(reason);
        signatureOptions.setDssPref(getDSSPreferences(rr));
        signatureOptions.setCredential(new CredentialContext(alias, rr));
        signatureOptions.setMdpPermissions(mdpPermissions);
		return signatureOptions;
	}
	
	private DSSPreferences getDSSPreferences(ResourceResolver rr){
		//sets the DSS Preferences
        DSSPreferencesImpl prefs = DSSPreferencesImpl.getInstance();
        prefs.setPKIPreferences(getPKIPreferences());
        GeneralPreferencesImpl gp = (GeneralPreferencesImpl) prefs.getPKIPreferences().getGeneralPreferences();
        gp.setDisableCache(true);
        return prefs;
    }
    
    private PKIPreferences getPKIPreferences(){
    	//sets the PKI Preferences
        PKIPreferences pkiPref = new PKIPreferencesImpl();
        pkiPref.setCRLPreferences(getCRLPreferences());
        pkiPref.setPathPreferences(getPathValidationPreferences());
        return pkiPref;
    }
    
    private CRLPreferences getCRLPreferences(){
        //specifies the CRL Preferences
        CRLPreferencesImpl crlPrefs = new CRLPreferencesImpl();
        crlPrefs.setRevocationCheck(RevocationCheckStyle.CheckIfAvailable);
        crlPrefs.setGoOnline(true);
        return crlPrefs;
    }
    
    private PathValidationPreferences getPathValidationPreferences(){
    	//sets the path validation preferences
        PathValidationPreferencesImpl pathPref = new PathValidationPreferencesImpl();
        pathPref.setDoValidation(false);
        return pathPref;
        
    }
    
}

Exemple 2 : Cet exemple est utilisé pour effectuer un chiffrement PKI, signer un champ de signature et doter le document PDF d’extensions Reader.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.jcr.Binary;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.DocAssuranceServiceOperationTypes;
import com.adobe.fd.docassurance.client.api.EncryptionOptions;
import com.adobe.fd.docassurance.client.api.ReaderExtensionOptions;
import com.adobe.fd.docassurance.client.api.SignatureOptions;
import com.adobe.fd.encryption.client.CertificateEncryptionCompatibility;
import com.adobe.fd.encryption.client.CertificateEncryptionIdentity;
import com.adobe.fd.encryption.client.CertificateEncryptionOption;
import com.adobe.fd.encryption.client.CertificateEncryptionOptionSpec;
import com.adobe.fd.encryption.client.CertificateEncryptionPermissions;
import com.adobe.fd.encryption.client.Recipient;
import com.adobe.fd.readerextensions.client.ReaderExtensionsOptionSpec;
import com.adobe.fd.readerextensions.client.UsageRights;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.pdf.inputs.CredentialContext;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferences;
import com.adobe.fd.signatures.pdf.inputs.DSSPreferencesImpl;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.PDFSignatureAppearanceType;
import com.adobe.fd.signatures.pdf.inputs.PDFSignatureAppearenceOptions.TextDirection;
import com.adobe.fd.signatures.pki.client.types.common.HashAlgorithm;
import com.adobe.fd.signatures.pki.client.types.common.RevocationCheckStyle;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.GeneralPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferencesImpl;

/**
 * 
 * This class provides a sample code to use {@code DocAssuranceService} to carry out
 * certificate encryption, signing a signature field and reader extending the pdf document.
 * 
 * PreRequisites - Digital certificate for encrypting the document has to be uploaded on Granite Trust Store
				   Digital certificate for signing the document has to be uploaded on Granite Key Store
 * 				   Digital certificate for reader extending the document has to be uploaded on Granite Key Store
 */

@Component
@Service(value=PassEncryptSignExtend.class)
public class PassEncryptSignExtend {
	
	@Reference
	private DocAssuranceService docAssuranceService;
	
	@Reference
    private SlingRepository slingRepository;
	
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk 
	 * @param outputFile - path to the pdf document where the output needs to be stored
	 * @throws Exception 
	 */
	public void CertEncryptSignReaderExtend(String inputFile, String outputFile) throws Exception{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
		
		Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try {
        	 
        	 /** resourceResolver with admin privileges to be passed to SignatureServiceAPI and Reader Extensions
        	 the resource resolver for signature options has to be corresponding to the user who has the signing certificate in his granite key store
        	 the resource resolver for signature options has to be corresponding to the user who has the credential for reader extension in his granite key store
        	 here we are using the same resource resolver
        	 */
        	 adminSession = slingRepository.loginAdministrative(null);
             resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
             
             //retrieve specifications for each of the services, you may pass null if you don't want to use that service
             //for encrypted document pass Unlock Options - see the method getUnlockOptions() below
			 outDoc = docAssuranceService.secureDocument(inDoc, getCertEncryptionOptions(), getSignatureOptions(resourceResolver), getReaderExtensionOptions(resourceResolver),null);
        }
        finally{
            /**
             * always close the PDFDocument object after your processing is done.
             */
            if(inDoc != null){
                inDoc.close();
            }
            if(adminSession != null && adminSession.isLive()){
                if(resourceResolver != null){
                    resourceResolver.close();
                }
                adminSession.logout();
            }
        }
        
        outDoc.copyToFile(outFile);
		
		
	}
	
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
    
	/**
	 * @return EncryptionOptions for password encrypting the document.
	 * 
	 */
	private EncryptionOptions getCertEncryptionOptions(){
		
		//Create an instance of EncryptionOptions
		EncryptionOptions encryptionOptions = EncryptionOptions.getInstance();
		
        //Set the encryption type to Certificate Encryption
		encryptionOptions.setEncryptionType(DocAssuranceServiceOperationTypes.ENCRYPT_WITH_CERTIFCATE);
		
		//Set the List that stores PKI information
		List<CertificateEncryptionIdentity> pkiIdentities = new ArrayList<CertificateEncryptionIdentity>(); 
			
		//Set the Permission List
		List<CertificateEncryptionPermissions> permList = new ArrayList<CertificateEncryptionPermissions>();
		permList.add(CertificateEncryptionPermissions.PKI_ALL_PERM) ;
			
		//Create a Recipient object to store certificate information
		Recipient recipient = new Recipient();
			
		//Specify the alias of the public certificate present in the trust store that is used to encrypt the document
		recipient.setX509Cert("alias");
		/*
		 * An alternative to add a certificate is by providing the alias
		 * of the certificate stored in AEM trust store.
		 * recipient.setAlias(alias);                             
		 */
		
		//Create an EncryptionIdentity object
		CertificateEncryptionIdentity encryptionId = new CertificateEncryptionIdentity(); 
		encryptionId.setPerms(permList);
		encryptionId.setRecipient(recipient);
			
		//Add the EncryptionIdentity to the list
		pkiIdentities.add(encryptionId);
		
		
		//Set encryption run-time options
		CertificateEncryptionOptionSpec certOptionsSpec = new CertificateEncryptionOptionSpec(); 
		certOptionsSpec.setOption(CertificateEncryptionOption.ALL);
		certOptionsSpec.setCompat(CertificateEncryptionCompatibility.ACRO_9);
		
		
		
		//Set the certificate encryption option
		encryptionOptions.setCertOptionSpec(certOptionsSpec)
		
		//Set the PKI Identities in encryption Options
        encryptionOptions.setPkiIdentities(pkiIdentities);

    	return encryptionOptions;
	}
	
	/**
	 * 
	 * @param resourceResolver corresponding to the user with the access to Reader Extension credential 
	 * for the given alias -"production" in this case
	 * @return
	 */
	private ReaderExtensionOptions getReaderExtensionOptions(ResourceResolver resourceResolver){
		
		//Create an instance of ReaderExtensionOptions
		ReaderExtensionOptions reOptions = ReaderExtensionOptions.getInstance();
		
		//Create instance for UsageRights to be enabled in the reader
		UsageRights uRights = new UsageRights();
		//enabling comments in the PDF Reader
		uRights.setEnabledComments(true);
		//setting ReaderExtensionsOptionSpec in the reOptions
		reOptions.setReOptions(new ReaderExtensionsOptionSpec(uRights, "Enable commenting in PDF"));
		//alias of the credential to be used for extending the PDF Reader
		reOptions.setCredentialAlias("production");  
		//corresponding to the user with the access to Reader Extension credential
		reOptions.setResourceResolver(resourceResolver); 
		
		return reOptions;
	}
	
	/**
	 * 
	 * @param rr resource resolver corresponding to the user with the access to signing credential for the 
	 * given alias "allcertificatesanypolicytest11ee_new" in this case
	 * @return SignatureOptions
	 */
	private SignatureOptions getSignatureOptions(ResourceResolver rr){
		
		//create an instance of SignatureOptions
		SignatureOptions signatureOptions = SignatureOptions.getInstance();
		
		//set the operation you want to perform - SIGN/CERTIFY
		signatureOptions.setOperationType(DocAssuranceServiceOperationTypes.SIGN);
		
		//field to sign
		String fieldName = "Signature1" ;
		
		//alias of the private credential uploaded on the Key Store
        String alias = "allcertificatesanypolicytest11ee_new";
        
        //Hash Algo to be used to compute digest the PDF document
        HashAlgorithm algo = HashAlgorithm.SHA384;
        
        //Reason for signing/certifying
        String reason = "Test Reason";
        
        //location of the signer
        String location = "Test Location";
        
        //contact info of the signer
        String contactInfo = "Test Contact";
        
        //Create a PDFSignatureAppearanceOptions object 
        //and show date information
        PDFSignatureAppearenceOptions appOptions = new PDFSignatureAppearenceOptions(
                PDFSignatureAppearanceType.NAME, null, 1.0d, null, true, true,
                true, true, true, true, true, TextDirection.AUTO);
        
        signatureOptions.setSignatureFieldName(fieldName);
        signatureOptions.setAlgo(algo);
        signatureOptions.setContactInfo(contactInfo);
        signatureOptions.setLocation(location);
        signatureOptions.setSigAppearence(appOptions);
        signatureOptions.setReason(reason);
        signatureOptions.setDssPref(getDSSPreferences(rr));
        signatureOptions.setCredential(new CredentialContext(alias, rr));
		return signatureOptions;
	}
	
	private DSSPreferences getDSSPreferences(ResourceResolver rr){
		//sets the DSS Preferences
        DSSPreferencesImpl prefs = DSSPreferencesImpl.getInstance();
        prefs.setPKIPreferences(getPKIPreferences());
        GeneralPreferencesImpl gp = (GeneralPreferencesImpl) prefs.getPKIPreferences().getGeneralPreferences();
        gp.setDisableCache(true);
        return prefs;
    }
    
    private PKIPreferences getPKIPreferences(){
    	//sets the PKI Preferences
        PKIPreferences pkiPref = new PKIPreferencesImpl();
        pkiPref.setCRLPreferences(getCRLPreferences());
        pkiPref.setPathPreferences(getPathValidationPreferences());
        return pkiPref;
    }
    
    private CRLPreferences getCRLPreferences(){
        //specifies the CRL Preferences
        CRLPreferencesImpl crlPrefs = new CRLPreferencesImpl();
        crlPrefs.setRevocationCheck(RevocationCheckStyle.CheckIfAvailable);
        crlPrefs.setGoOnline(true);
        return crlPrefs;
    }
    
    private PathValidationPreferences getPathValidationPreferences(){
    	//sets the path validation preferences
        PathValidationPreferencesImpl pathPref = new PathValidationPreferencesImpl();
        pathPref.setDoValidation(false);
        return pathPref;
        
    }
    
}

Obtention des droits d’utilisation d’identification

Pour récupérer les informations de droits d’utilisation des informations d’identification spécifiées par l’alias credentialAlias donné, appelez cette API depuis l’API SecureDocument.

Syntaxe : getCredentialUsageRights(String credentialAlias, ResourceResolver resourceResolver)

Paramètres d’entrée

Paramètres Description
credentialAlias
credentialAlias spécifiant les informations d’identification.
credentialPassword
Le mot de passe des informations d’identification si elles sont chiffrées, la valeur nulle est utilisée si ces informations ne sont pas chiffrées.

L’exemple suivant récupère les informations de droits d’utilisation pour les informations d’identification spécifiées.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.fd.readerextensions.samples;

import java.io.File;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.ReaderExtensionOptions;
import com.adobe.fd.readerextensions.client.GetUsageRightsResult;
import com.adobe.fd.readerextensions.client.ReaderExtensionsOptionSpec;
import com.adobe.fd.readerextensions.client.UsageRights;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 *
 */
@Component(metatype = true, immediate = true, label = "ReaderExtensionsSampleService")
@Service(value = ReaderExtensionsSampleService.class)
public class ReaderExtensionsSampleService {

	@Reference(referenceInterface=DocAssuranceService.class)
	private DocAssuranceService docAssuranceService;

	@Reference(referenceInterface=ResourceResolverFactory.class)
	private ResourceResolverFactory resourceResolverFactory;
public void getCredentialUsageRights() {
		try {

			GetUsageRightsResult usageRightsResult = docAssuranceService.getCredentialUsageRights("production", 
					resourceResolverFactory.getAdministrativeResourceResolver(null));

			System.out.println("Credential usage Rights are as follows");
			System.out.println(usageRightsResult.toString());

		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
}

Obtention des droits d’utilisation du document

Pour récupérer les informations des droits d’utilisation d’un document donné, appelez cette API depuis l’API docAssuranceService.

Syntaxe : getDocumentUsageRights(Document inDocument, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDocument
Document de récupération des informations de droits d’utilisation de

L’exemple de code suivant renvoie les informations de droits d’utilisation du document.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.fd.readerextensions.samples;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

import javax.jcr.SimpleCredentials;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.jcr.resource.JcrResourceConstants;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.ReaderExtensionOptions;
import com.adobe.fd.readerextensions.client.GetUsageRightsResult;
import com.adobe.fd.readerextensions.client.ReaderExtensionsOptionSpec;
import com.adobe.fd.readerextensions.client.UsageRights;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

@Component(metatype = true, immediate = true, label = "ReaderExtensionsSampleService")
@Service(value = ReaderExtensionsSampleService.class)
public class ReaderExtensionsSampleService {
	
	@Reference(referenceInterface=DocAssuranceService.class)
	private DocAssuranceService docAssuranceService;
	
	@Reference(referenceInterface=ResourceResolverFactory.class)
private ResourceResolverFactory resourceResolverFactory;

public void getDocumentUsageRights() {
		Document inputDocument = null;
		try {
			//Name of the input file on which usage rights is to be applied.
			String inputFileName = "C:/RETest/input/GetUsageRightsInfo/02_fromAcrobat7.0.8_Acro700_UB8_BS_signed_commenting.pdf";
			
			//Document to be input to Doc Assurance Service
			inputDocument = new Document(new File(inputFileName));
			
			//Unlock options to unlock the document if some kind of security is set on it.
			//Currently set to null because input document has no security.
			UnlockOptions unlockOptions = null;
			
			GetUsageRightsResult usageRightsResult = docAssuranceService.getDocumentUsageRights(inputDocument, unlockOptions);
			
			System.out.println("Document usage Rights are as follows");
			System.out.println(usageRightsResult.toString());
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
//			if (inputDocument != null) {
//				inputDocument.dispose(); //dispose off the document.
//			}
		}
}

/**
	 * Resource resolver of the user in whose keystore Reader Extensions Certificate is installed.
	 * @param resourceResolverFactory
	 * @return
	 * @throws LoginException
	 */
	public ResourceResolver getResourceResolver() throws LoginException{
		Map<String,Object> authInfo = new HashMap<String,Object>();
		//Username and password of the user in whose keystore Reader Extensions Certificate is installed
		SimpleCredentials credentials = new SimpleCredentials("username"/*UserName*/, "password"/*Password*/.toCharArray());
		authInfo.put(JcrResourceConstants.AUTHENTICATION_INFO_CREDENTIALS,credentials);
		return resourceResolverFactory.getResourceResolver(authInfo);
}

}

Suppression des droits d’utilisation

Vous pouvez supprimer les droits d’utilisation du document en appelant l’API removeUsageRights depuis l’API docAssuranceService.

Paramètres d’entrée

Paramètres Description
inDocument
Document de suppression des droits d’utilisation de.
unlockOptions
Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple suivant supprime les droits d’utilisation d’un document donné.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * __________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and may be covered by U.S. and Foreign Patents,
 * patents in process, and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.fd.readerextensions.samples;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

import javax.jcr.SimpleCredentials;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.jcr.resource.JcrResourceConstants;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.docassurance.client.api.ReaderExtensionOptions;
import com.adobe.fd.readerextensions.client.GetUsageRightsResult;
import com.adobe.fd.readerextensions.client.ReaderExtensionsOptionSpec;
import com.adobe.fd.readerextensions.client.UsageRights;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

@Component(metatype = true, immediate = true, label = "ReaderExtensionsSampleService")
@Service(value = ReaderExtensionsSampleService.class)
public class ReaderExtensionsSampleService {
	
	@Reference(referenceInterface=DocAssuranceService.class)
	private DocAssuranceService docAssuranceService;
	
	@Reference(referenceInterface=ResourceResolverFactory.class)
private ResourceResolverFactory resourceResolverFactory;

public void removeDocumentUsageRights() {
		Document inputDocument = null;
		Document outDocument = null;
		try {
			//Name of the input file on which usage rights is to be applied.
			String inputFileName = "C:/RETest/input/RemoveUsageRights/01_Ubiquitized_50-267_PDF1.5_UB2_Rights.pdf";
			
			//Name of the output file where result will be saved.
			String outputFileName = "C:/RETest/output/samples/removeUsageRightsOutput.pdf";
			
			//Document to be input to Doc Assurance Service
			inputDocument = new Document(new File(inputFileName));
			
			//Unlock options to unlock the document if some kind of security is set on it.
			//Currently set to null because input document has no security.
			UnlockOptions unlockOptions = null;
			
			//Specify null encryption options and signatures options. 
			//If requirement is also to encrypt and sign the document then, corresponding options can also be specified.
			outDocument = docAssuranceService.removeUsageRights(inputDocument, unlockOptions);
			
			File outputdir = new File("C:/RETest/output/samples");
			outputdir.mkdirs();
			
			outDocument.copyToFile(new File(outputFileName));
		} catch (Exception e) {
			e.printStackTrace();
		} 
}

/**
	 * Resource resolver of the user in whose keystore Reader Extensions Certificate is installed.
	 * @param resourceResolverFactory
	 * @return
	 * @throws LoginException
	 */
	public ResourceResolver getResourceResolver() throws LoginException{
		Map<String,Object> authInfo = new HashMap<String,Object>();
		//Username and password of the user in whose keystore Reader Extensions Certificate is installed
		SimpleCredentials credentials = new SimpleCredentials("username"/*UserName*/, "password"/*Password*/.toCharArray());
		authInfo.put(JcrResourceConstants.AUTHENTICATION_INFO_CREDENTIALS,credentials);
		return resourceResolverFactory.getResourceResolver(authInfo);
}

}

Vérification des signatures numériques

Les signatures numériques peuvent être vérifiées pour vous assurer qu’un document PDF signé n’a pas été modifié et que la signature numérique est valide. Lors de la vérification d’une signature numérique, vous pouvez vérifier l’état et les propriétés de la signature, comme l’identité du signataire. Avant d’approuver une signature numérique, il est recommandé de la vérifier. Lors de la vérification d’une signature numérique, référencez un document PDF contenant une signature numérique.

Syntaxe : verify( inDoc, signatureFieldName, revocationCheckStyle, verificationTime, dssPrefs, ResourceResolver resourceResolver)

Paramètres d’entrée

Paramètres Description
inDoc
Objet document contenant un PDF
signatureField
Name

Le nom du champ de signature à valider. un nom qualifié complet ou un nom partiel peut être attribué
revocationCheckStyle L’option pour diriger la vérification de révocation des certificats générés pendant la validation
verificationTime Heure à laquelle la signature doit être validée
dssPrefs Préférences pour contrôler différentes fonctionnalités de validation. Pour un document chiffré, définissez les options de verrouillage à l’aide de setUnlockOptions()
resourceResolver Résolveur de ressources au trust store Granite

Cet exemple de code utilise DocAssuranceService pour vérifier un champ de signature dans un document PDF chiffré.

/*************************************************************************
 *
-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.IdentityInformation;
import com.adobe.fd.signatures.client.types.IdentityStatus;
import com.adobe.fd.signatures.client.types.PDFSignatureType;
import com.adobe.fd.signatures.client.types.PDFSignatureVerificationInfo;
import com.adobe.fd.signatures.client.types.SignatureProperties;
import com.adobe.fd.signatures.client.types.SignatureStatus;
import com.adobe.fd.signatures.client.types.SignatureType;
import com.adobe.fd.signatures.client.types.VerificationTime;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.pdf.inputs.ValidationPreferences;
import com.adobe.fd.signatures.pdf.inputs.ValidationPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.common.RevocationCheckStyle;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.OCSPPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.TSPPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.TSPPreferencesImpl;

/**
 * 
 * This class provides a sample code to use {@code DocAssuranceService} to carry out
 * verification of a signature field in an already Encrypted PDF Document
 * 
 * Digital signatures can be verified to ensure that a signed PDF document was not modified and that the digital signature is valid. 
 * When verifying a digital signature, you can check the signature's status and the signature's properties, such as the signer's identity. 
 * Before trusting a digital signature, it is recommended that you verify it. When verifying a digital signature, reference a PDF document 
 * that contains a digital signature.
 * 
 * For unprotected document, you are not required to set UnlockOptions in ValidationPreferences
 * PreRequisites - The certificate chain upto the Root Certificate should be uploaded on CQ trust Store
 */

@Component
@Service(value=VerifyFieldEncryptedPDF.class)
public class VerifyFieldEncryptedPDF {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	@Reference
    private SlingRepository slingRepository;
	
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	
	/**
	 * 
	 * @param inputFile - path to an encrypted pdf document stored at JCR node 
	 * @throws IOException
	 * @throws RepositoryException
	 * @throws InvalidArgumentException
	 * @throws DocAssuranceException
	 */
	public void verifyFieldEncryptedPDF(String inputFile,String fieldName) throws IOException, RepositoryException, InvalidArgumentException, DocAssuranceException{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try {
        	 
        	//the resource resolver has to be corresponding to the user who has access to CQ Trust Store
        	 adminSession = slingRepository.loginAdministrative(null);
             resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
             
           //Specify the name of the signature field
             
             RevocationCheckStyle revocationCheckStyle = RevocationCheckStyle.AlwaysCheck;
             VerificationTime verificationTime = VerificationTime.CURRENT_TIME;
             ValidationPreferences dssPrefs = getValidationPreferences();
            
             //Verify the digital signature
             PDFSignatureVerificationInfo  signInfo = docAssuranceService.verify(
                 inDoc,
                 fieldName,
                 revocationCheckStyle,
                 verificationTime,
                 dssPrefs,
                 resourceResolver);

             //Get the Signature Status
             SignatureStatus sigStatus = signInfo.getStatus();
             String myStatus=""; 
             
             //Determine the status of the signature
             if (sigStatus == SignatureStatus.DynamicFormSignatureUnknown)
                 myStatus = "The signatures located in the dynamic PDF form are unknown";
             else if (sigStatus == SignatureStatus.DocumentSignatureUnknown)
                 myStatus = "The signatures located in the PDF document are unknown";
             else if (sigStatus == SignatureStatus.CertifiedDynamicFormSignatureTamper)
                 myStatus = "The signatures located in a certified PDF form are valid";
             else if (sigStatus == SignatureStatus.SignedDynamicFormSignatureTamper)
                 myStatus = "The signatures located in a signed dynamic PDF form are valid";
             else if (sigStatus == SignatureStatus.CertifiedDocumentSignatureTamper)
                 myStatus = "The signatures located in a certified PDF document are valid";
             else if (sigStatus == SignatureStatus.SignedDocumentSignatureTamper)
                 myStatus = "The signatures located in a signed PDF document are valid";
             else if (sigStatus == SignatureStatus.SignatureFormatError)
                 myStatus = "The format of a signature in a signed document is invalid";
             else if (sigStatus == SignatureStatus.DynamicFormSigNoChanges)
                 myStatus = "No changes were made to the signed dynamic PDF form";
             else if (sigStatus == SignatureStatus.DocumentSigNoChanges)
                 myStatus = "No changes were made to the signed PDF document";
             else if (sigStatus == SignatureStatus.DynamicFormCertificationSigNoChanges)
                 myStatus = "No changes were made to the certified dynamic PDF form";
             else if (sigStatus == SignatureStatus.DocumentCertificationSigNoChanges)
                 myStatus = "No changes were made to the certified PDF document";
             else if (sigStatus == SignatureStatus.DocSigWithChanges)
                 myStatus = "There were changes to a signed PDF document";
            else if (sigStatus == SignatureStatus.CertificationSigWithChanges)
                 myStatus = "There were changes made to the PDF document.";
                        
             //Get the signature type
             SignatureType sigType = signInfo.getSignatureType();
             String myType = "";
                
             if (sigType.getType() == PDFSignatureType.AUTHORSIG)
                    myType="Certification";
             else if(sigType.getType() == PDFSignatureType.RECIPIENTSIG)
                    myType="Recipient";
            
             //Get the identity of the signer
             IdentityInformation signerId = signInfo.getSigner();
             String signerMsg = "";
            
            if (signerId.getStatus() == IdentityStatus.UNKNOWN)
                signerMsg = "Identity Unknown";
            else if (signerId.getStatus() == IdentityStatus.TRUSTED)
                signerMsg = "Identity Trusted";
            else if (signerId.getStatus() == IdentityStatus.NOTTRUSTED)
                signerMsg = "Identity Not Trusted";
                     
            //Get the Signature properties returned by the Signature service
            SignatureProperties sigProps = signInfo.getSignatureProps();
            String signerName =  sigProps.getSignerName();
             
           System.out.println("The status of the signature is: "+myStatus +". The signer identity is "+signerMsg +". The signature type is "+myType +". The name of the signer is "+signerName+".");
           }
           catch (Exception ee)
           {
               ee.printStackTrace();
           }
	        finally{
	            /**
	             * always close the PDFDocument object after your processing is done.
	             */
	            if(inDoc != null){
	                inDoc.close();
	            }
	            if(adminSession != null && adminSession.isLive()){
	                if(resourceResolver != null){
	                    resourceResolver.close();
	                }
	                adminSession.logout();
	            }
	        }
        
		
	}
	
	/**
 	 * sets ValidationPreferences
 	 */
 	private static ValidationPreferences getValidationPreferences(){
        
        ValidationPreferencesImpl prefs = new ValidationPreferencesImpl();
        prefs.setPKIPreferences(getPKIPreferences());
       
        //set the unlock options for processing an encrypted pdf document, do not set if the input doc is unprotected
        prefs.setUnlockOptions(getUnlockOptions());
        return prefs;
        
    }
    
 	/**
 	 * sets PKIPreferences
 	 */
    private static PKIPreferences getPKIPreferences(){
        PKIPreferences pkiPref = new PKIPreferencesImpl();
        pkiPref.setCRLPreferences(getCRLPreferences());
        pkiPref.setPathPreferences(getPathValidationPreferences());
        pkiPref.setOCSPPreferences(getOCSPPref());
        pkiPref.setTSPPreferences(getTspPref());
        return pkiPref;
    }
    
    private static TSPPreferences getTspPref(){
    	TSPPreferencesImpl tsp = new TSPPreferencesImpl();
    	tsp.setRevocationCheck(RevocationCheckStyle.BestEffort);
    	return tsp;
    }
    private static OCSPPreferencesImpl getOCSPPref(){
    	OCSPPreferencesImpl ocsp = new OCSPPreferencesImpl();
    	ocsp.setRevocationCheck(RevocationCheckStyle.BestEffort);
    	return ocsp;
    }
    /**
     * sets CRL Preferences
     */
    private static CRLPreferences getCRLPreferences(){
    
        CRLPreferencesImpl crlPrefs = new CRLPreferencesImpl();
        crlPrefs.setRevocationCheck(RevocationCheckStyle.BestEffort);
        crlPrefs.setGoOnline(true);
        return crlPrefs;
    }
    
    

    /**
     * 
     * sets PathValidationPreferences
     */
    private static PathValidationPreferences getPathValidationPreferences(){
        PathValidationPreferencesImpl pathPref = new PathValidationPreferencesImpl();
        pathPref.setDoValidation(true);
        return pathPref;
        
    }
    
    /**
     * sets Unlock Options for encrypted PDF
     */
    private static UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
    
    
}

Vérification de plusieurs signatures numériques

AEM vous permet de vérifier les signatures numériques dans les documents PDF. Un document PDF peut contenir plusieurs signatures numériques s’il est soumis à un processus d’entreprise qui requiert des signatures de signataires multiples. Par exemple, une transaction financière nécessite des signatures du responsable des prêts et du cadre. Vous pouvez utiliser l’API du service Signature pour vérifier toutes les signatures du document PDF. Lors de la vérification de plusieurs signatures numériques, vous pouvez vérifier l’état et les propriétés de chaque signature. Avant de faire confiance à une signature numérique, Adobe vous recommande de la vérifier.

Syntaxe : verifyDocument(Document doc, RevocationCheckStyle revocationCheckStyle, VerificationTime verificationTime, ValidationPreferences prefStore, ResourceResolver resourceResolver)

Paramètres d’entrée

Paramètres Description
inDoc
Objet document contenant un PDF
revocationCheckStyle L’option pour diriger la vérification de révocation des certificats générés pendant la validation
verificationTime Heure à laquelle la signature doit être validée
dssPrefs Préférences pour contrôler différentes fonctionnalités de validation. Pour un document chiffré, définissez les options de verrouillage à l’aide de setUnlockOptions()
resourceResolver Résolveur de ressources au trust store Granite

L’exemple de code suivant utilise DocAssuranceService pour vérifier les champs de signature dans un document PDF déjà chiffré.

/*************************************************************************
 *
  *
-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file from a 
*source other than Adobe, then your use, modification, or distribution of it requires the prior 
*written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PDFDocumentVerificationInfo;
import com.adobe.fd.signatures.client.types.PDFSignatureType;
import com.adobe.fd.signatures.client.types.PDFSignatureVerificationInfo;
import com.adobe.fd.signatures.client.types.SignatureProperties;
import com.adobe.fd.signatures.client.types.SignatureStatus;
import com.adobe.fd.signatures.client.types.SignatureType;
import com.adobe.fd.signatures.client.types.VerificationTime;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.signatures.pdf.inputs.ValidationPreferences;
import com.adobe.fd.signatures.pdf.inputs.ValidationPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.common.RevocationCheckStyle;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.CRLPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PKIPreferencesImpl;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferences;
import com.adobe.fd.signatures.pki.client.types.prefs.PathValidationPreferencesImpl;

/**
 * 
 * This class provides a sample code to use {@code DocAssuranceService} to carry out
 * verification of all the signature fields in an already Encrypted PDF Document
 * 
 * Assume that a PDF document contains multiple digital signatures as a result of a business process that requires signatures from multiple 
 * signers. For example, consider a financial transaction that requires both a loan officer's and a manager's signature. You can use the 
 * Signature service Java API or web service API to verify all signatures within the PDF document. When verifying multiple digital signatures,
 * you can check the status and properties of each signature. Before you trust a digital signature, it is recommended that you verify it. It 
 * is recommended that you are familiar with verifying a single digital signature.
 * 
 * For unprotected document, you are not required to set UnlockOptions in ValidationPreferences
 * PreRequisites - The certificate chain upto the Root Certificate should be uploaded on CQ trust Store
 */

@Component
@Service(value=VerifyEncryptedPDFDoc.class)
public class VerifyEncryptedPDFDoc {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	@Reference
    private SlingRepository slingRepository;
	
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	
	/**
	 * 
	 * @param inputFile - path to an encrypted pdf document stored at JCR node 
	 * @throws IOException
	 * @throws RepositoryException
	 * @throws InvalidArgumentException
	 * @throws DocAssuranceException
	 */
	public void verifyEncryptedPDFDoc(String inputFile) throws IOException, RepositoryException, InvalidArgumentException, DocAssuranceException{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try {
        	 
        	 //the resource resolver has to be corresponding to the user who has access to CQ Trust Store
        	 adminSession = slingRepository.loginAdministrative(null);
             resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
             
             RevocationCheckStyle revocationCheckStyle = RevocationCheckStyle.CheckIfAvailable;
             VerificationTime verificationTime = VerificationTime.CURRENT_TIME;
             ValidationPreferences dssPrefs = getValidationPreferences();
            
             //Verify the digital signature
             PDFDocumentVerificationInfo  docInfo = docAssuranceService.verifyDocument(
                 inDoc,
                 revocationCheckStyle,
                 verificationTime,
                 dssPrefs,
                 resourceResolver);

             //Get a list of all signatures that are located in the PDF document
             List allSignatures = docInfo.getVerificationInfos();
             
           //Create an Iterator object and iterate through 
           //the List object
           Iterator<PDFSignatureVerificationInfo> iter = allSignatures.iterator(); 
           
           while (iter.hasNext()) { 
                  PDFSignatureVerificationInfo signInfo = (PDFSignatureVerificationInfo)iter.next(); 
                   
                  //Get the Signature Status
                     SignatureStatus sigStatus = signInfo.getStatus();
                     String myStatus=""; 
                     
                   //Determine the status of the signature
                     if (sigStatus == SignatureStatus.DynamicFormSignatureUnknown)
                         myStatus = "The signatures located in the dynamic PDF form are unknown";
                     else if (sigStatus == SignatureStatus.DocumentSignatureUnknown)
                         myStatus = "The signatures located in the PDF document are unknown";
                     else if (sigStatus == SignatureStatus.CertifiedDynamicFormSignatureTamper)
                         myStatus = "The signatures located in a certified PDF form are valid";
                     else if (sigStatus == SignatureStatus.SignedDynamicFormSignatureTamper)
                         myStatus = "The signatures located in a signed dynamic PDF form are valid";
                     else if (sigStatus == SignatureStatus.CertifiedDocumentSignatureTamper)
                         myStatus = "The signatures located in a certified PDF document are valid";
                     else if (sigStatus == SignatureStatus.SignedDocumentSignatureTamper)
                         myStatus = "The signatures located in a signed PDF document are valid";
                     else if (sigStatus == SignatureStatus.SignatureFormatError)
                         myStatus = "The format of a signature in a signed document is invalid";
                     else if (sigStatus == SignatureStatus.DynamicFormSigNoChanges)
                         myStatus = "No changes were made to the signed dynamic PDF form";
                     else if (sigStatus == SignatureStatus.DocumentSigNoChanges)
                         myStatus = "No changes were made to the signed PDF document";
                     else if (sigStatus == SignatureStatus.DynamicFormCertificationSigNoChanges)
                         myStatus = "No changes were made to the certified dynamic PDF form";
                     else if (sigStatus == SignatureStatus.DocumentCertificationSigNoChanges)
                         myStatus = "No changes were made to the certified PDF document";
                     else if (sigStatus == SignatureStatus.DocSigWithChanges)
                         myStatus = "There were changes to a signed PDF document";
                    else if (sigStatus == SignatureStatus.CertificationSigWithChanges)
                         myStatus = "There were changes made to the PDF document.";
                           
                     //Get the signature type
                    SignatureType sigType = signInfo.getSignatureType();
                    String myType = "";
                    
                    if (sigType.getType() == PDFSignatureType.AUTHORSIG)
                        myType="Certification";
                    else if(sigType.getType() == PDFSignatureType.RECIPIENTSIG)
                        myType="Recipient";
                                 
                    //Get the Signature properties returned by the Signature service
                    SignatureProperties sigProps = signInfo.getSignatureProps();
                    String signerName =  sigProps.getSignerName();
                     
                   System.out.println("The status of the signature is: "+myStatus +". The signature type is "+myType +". The name of the signer is "+signerName+".");
               }
           }
           catch (Exception ee)
           {
               ee.printStackTrace();
           }
	        finally{
	            /**
	             * always close the PDFDocument object after your processing is done.
	             */
	            if(inDoc != null){
	                inDoc.close();
	            }
	            if(adminSession != null && adminSession.isLive()){
	                if(resourceResolver != null){
	                    resourceResolver.close();
	                }
	                adminSession.logout();
	            }
	        }
        
		
	}
	
	/**
 	 * sets ValidationPreferences
 	 */
 	private static ValidationPreferences getValidationPreferences(){
        
        ValidationPreferencesImpl prefs = new ValidationPreferencesImpl();
        prefs.setPKIPreferences(getPKIPreferences());
       
        //set the unlock options for processing an encrypted pdf document, do not set if the document is unprotected
        prefs.setUnlockOptions(getUnlockOptions());
        return prefs;
        
    }
    
 	/**
 	 * sets PKIPreferences
 	 */
    private static PKIPreferences getPKIPreferences(){
        PKIPreferences pkiPref = new PKIPreferencesImpl();
        pkiPref.setCRLPreferences(getCRLPreferences());
        pkiPref.setPathPreferences(getPathValidationPreferences());
        return pkiPref;
    }
    
    /**
     * sets CRL Preferences
     */
    private static CRLPreferences getCRLPreferences(){
    
        CRLPreferencesImpl crlPrefs = new CRLPreferencesImpl();
        crlPrefs.setRevocationCheck(RevocationCheckStyle.CheckIfAvailable);
        crlPrefs.setGoOnline(true);
        return crlPrefs;
    }

    /**
     * 
     * sets PathValidationPreferences
     */
    private static PathValidationPreferences getPathValidationPreferences(){
        PathValidationPreferencesImpl pathPref = new PathValidationPreferencesImpl();
        pathPref.setDoValidation(false);
        return pathPref;
        
    }
    
    /**
     * sets Unlock Options for encrypted PDF
     */
    private static UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
    
    
}

Suppression des signatures numériques

Vous ne pouvez appliquer une nouvelle signature numérique à un champ de signature que lorsque vous supprimez la signature numérique précédente. Vous ne pouvez pas remplacer une signature numérique. Si vous tentez d’apposer une signature numérique à un champ de signature contenant déjà une signature, une exception est générée.

Syntaxe : clearSignatureField(Document inDoc, String signatureFieldName, UnlockOptions unlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc
Objet document contenant un PDF
signatureFieldName Le nom du champ de signature
unlockOptions
Comprend les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré

L’exemple de code Java suivant supprime une signature numérique d’un champ de signature.

/*************************************************************************
 *
  *
-------------------------------------------------------------
*ADOBE SYSTEMS INCORPORATED
*Copyright 2014 Adobe Systems Incorporated
*All Rights Reserved.

*NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the 
*terms of the Adobe license agreement accompanying it.  If you have received this file 
*from a source other than Adobe, then your use, modification, or distribution of it requires 
*the prior written permission of Adobe.
-------------------------------------------------------------------------------------------------

 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.io.IOException;

import javax.jcr.RepositoryException;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceException;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesOtherException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * Digital signatures must be removed from a signature field before a newer digital signature can be applied. 
 * A digital signature cannot be overwritten. 
 * If you attempt to apply a digital signature to a signature field that contains a signature, an exception occurs
 * 
 *The following Java code example removes a digital signature from a signature field named SignatureField1. 
 *The name of the PDF file that contain the signature field is LoanSigned.pdf
 */

@Component
@Service(value=ClearSignatureField.class)
public class ClearSignatureField {

	@Reference
	private DocAssuranceService docAssuranceService;
	/**
	 * 
	 * @param inputFile - path to an encrypted pdf document stored at disk
	 * @param outFile - path where the output file has to be saved 
	 * @throws Exception 
	 */
	public void clearSignatureField(String inputFile, String outFile) throws Exception{
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
        //Specify the name of the signature field
        String fieldName = "SignatureField1";

        //Clear the signature field
        //for encrypted document pass Unlock Options - see the method getUnlockOptions() below
        Document outPDF = docAssuranceService.clearSignatureField(inDoc,fieldName,null);
        
        //save the outPDF
        outPDF.copyToFile(new File(outFile));
	}
	
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Obtention du champ de signature de certification

Vous pouvez récupérer les noms de tous les champs de signature d’un document PDF que vous souhaitez signer ou certifier. Si vous n’êtes pas certain de connaître les noms de champ de signature d’un document PDF ou si vous souhaitez vérifier leurs noms, vous pouvez programmer leur récupération. Le service Signature renvoie le nom qualifié complet du champ de signature, tel que form1[0].grantApplication[0].page1[0].SignatureField1[0].

Syntaxe : getCertifyingSignatureField (inDoc du document, options de déverrouillage UnlockOptions)

Paramètres d’entrée

Paramètres Description
inDoc
Objet document contenant un PDF.
UnlockOptions UnlockOptions inclut les paramètres requis pour déverrouiller un fichier chiffré. Cette propriété n’est requise que si le fichier est chiffré.

L’exemple de code Java suivant récupère le champ de signature utilisé pour certifier le document.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PDFSignatureField;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;

/**
 * You can retrieve the names of all signature fields that are located in a PDF document that you want to sign or certify. 
 * If you are unsure of the signature field names that are located in a PDF document or you want to verify the names, you can
 * programmatically retrieve them. The Signature service returns the fully qualified name of the signature field, such as 
 * form1[0].grantApplication[0].page1[0].SignatureField1[0].
 * 
 * The following Java code example retrieves the ignature field that was used to certify the document.
 */

@Component
@Service(value=GetCertifyingSignatureField.class)
public class GetCertifyingSignatureField {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * 
	 */
	public void getCertifyingSignatureField(String inputFile) throws Exception {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
	      
		//Retrieve signature data for a given signature field.
		//for encrypted document pass Unlock Options - see the method getUnlockOptions() below
        PDFSignatureField pdfSignature = docAssuranceService.getCertifyingSignatureField(inDoc,null);
        
   }
       
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Obtention du type de chiffrement PDF

Vous pouvez récupérer les noms de tous les champs de signature d’un document PDF que vous souhaitez signer ou certifier. Si vous n’êtes pas certain de connaître les noms de champ de signature d’un document PDF ou si vous souhaitez vérifier leurs noms, vous pouvez programmer leur récupération. Le service Signature renvoie le nom qualifié complet du champ de signature, tel que form1[0].grantApplication[0].page1[0].SignatureField1[0].

Syntaxe : void getPDFEncryption(Document inDoc)

Paramètres d’entrée

Paramètres Description
inDoc
Un document fourni comme entrée. Elle peut être chiffrée ou non.

L’exemple suivant de code Java récupère les informations de signature du champ de signature donné situé dans un document PDF.

/*************************************************************************
 *
 * ADOBE CONFIDENTIAL
 * ___________________
 *
 *  Copyright 2014 Adobe Systems Incorporated
 *  All Rights Reserved.
 *
 * NOTICE:  All information contained herein is, and remains
 * the property of Adobe Systems Incorporated and its suppliers,
 * if any.  The intellectual and technical concepts contained
 * herein are proprietary to Adobe Systems Incorporated and its
 * suppliers and are protected by trade secret or copyright law.
 * Dissemination of this information or reproduction of this material
 * is strictly forbidden unless prior written permission is obtained
 * from Adobe Systems Incorporated.
 **************************************************************************/
package com.adobe.docassurance.samples;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;
import com.adobe.fd.signatures.client.types.PDFSignatureField;
import com.adobe.fd.signatures.client.types.exceptions.DuplicateSignatureFieldException;
import com.adobe.fd.signatures.client.types.exceptions.InvalidArgumentException;
import com.adobe.fd.signatures.client.types.exceptions.PDFOperationException;
import com.adobe.fd.signatures.client.types.exceptions.PermissionsException;
import com.adobe.fd.signatures.client.types.exceptions.SignaturesBaseException;
import com.adobe.fd.signatures.pdf.inputs.UnlockOptions;
import com.adobe.fd.encryption.client.EncryptionTypeResult;

/**
 * You can retrieve the names of all signature fields that are located in a PDF document that you want to sign or certify. 
 * If you are unsure of the signature field names that are located in a PDF document or you want to verify the names, you can
 * programmatically retrieve them. The Signature service returns the fully qualified name of the signature field, such as 
 * form1[0].grantApplication[0].page1[0].SignatureField1[0].
 * 
 * The following Java code example retrieves the Signature Info for the given signature field located in a PDF document.
 */

@Component
@Service(value=GetPDFEncryption.class)
public class GetPDFEncryption {

	@Reference
	private DocAssuranceService docAssuranceService;
	
	/**
	 * 
	 * @param inputFile - path to the pdf document stored at disk
	 * @throws SignaturesBaseException 
	 * @throws DuplicateSignatureFieldException 
	 * @throws PermissionsException 
	 * @throws PDFOperationException 
	 * @throws InvalidArgumentException 
	 * 
	 */
	public void getPDFEncryption(String inputFile) throws Exception {
		
		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
	      
		//Retrieve signature data for a given signature field.
		//for encrypted document pass Unlock Options - see the method getUnlockOptions() below
        EncryptionTypeResult encryptionTypeResult = docAssuranceService.getPDFEncryption(inDoc);
        
   }
       
	 /**
     * sets Unlock Options for encrypted PDF
     */
    private UnlockOptions getUnlockOptions(){
        UnlockOptions unlockOptions = new UnlockOptions();
        //sets the Open Password for password encrypted PDF
        unlockOptions.setPassword("OpenPassword");
        
        //for Certificate Encrypted Document, set the alias of the credential uploaded in the user's key store
        //and corresponding resource resolver
        
        return unlockOptions;
        
    }
}

Suppression d’un chiffrement avec mot de passe d’un PDF

Supprimez le chiffrement avec mot de passe d’un document PDF pour permettre aux utilisateurs d’ouvrir le document PDF dans Adobe Reader ou Acrobat sans préciser un mot de passe. Une fois le chiffrement avec mot de passe supprimé du document PDF, le document n’est plus sécurisé.

Syntaxe : Document removePDFPasswordSecurity (Document inDoc,String password)

Paramètres d’entrée

Paramètres Description
inDoc
Document fourni comme entrée. Elle doit être protégée par un mot de passe.
password
Document ouvert ou mot de passe d’accès aux droits à utiliser pour supprimer la protection du document.

L’exemple de code suivant supprime un chiffrement avec mot de passe d’un document PDF.

package com.adobe.docassurance.samples;

import java.io.File;
import java.io.FileNotFoundException;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.jcr.api.SlingRepository;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;

/**
 * The following Java code example removes password-based encryption from a PDF document.
 * The master password value used to remove password-based encryption is PermissionPassword
 *
 */
@Component(enabled=true,immediate=true)
@Service(value=RemovePasswordEncryption.class)
public class RemovePasswordEncryption {

	// Create reference for DocAssuranceService
	@Reference
	private DocAssuranceService docAssuranceService;
    
	@Reference
    private SlingRepository slingRepository;
    
	
	/**
	 * The below sample code demonstrates removing password encryption from a PDF using AEM EncryptionService.
	 * 
	 * @param inFilePath  path of the input PDF File
	 * 		  Path Example for Files stored at hardDisk = "C:/temp/test.pdf"	 
	 * 	
	 * @param outFilePath path where the output PDF File needs to be saved
	 * 		  Path Example for Files stored at hardDisk = "C:/temp/test_out.pdf"	 
	 * @throws Exception
	 */
	public void removePasswordEncryption(String inputFile, String outputFile) throws Exception {

		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
    	
    	try{
	
    		String password = "PermissionPassword"; //master password with which the pdf was encrypted
    												//in case if the pdf is encrypted only with user password, specify the
    												//user password
    		//Remove password-based encryption from the PDF document
    		outDoc = docAssuranceService.removePDFPasswordSecurity(inDoc,password);
	        
    	}finally{
                /**
                 * always close the PDFDocument object after your processing is done.
                 */
                if(inDoc != null){
                    inDoc.close();
                }
                
        }
            
        outDoc.copyToFile(outFile);

		
	}
	
}

Suppression d’un chiffrement de certificat

Vous pouvez supprimer le chiffrement avec certificat d’un document PDF afin que les utilisateurs puissent ouvrir le document PDF dans Adobe Reader ou Acrobat. Pour supprimer le chiffrement d’un document PDF chiffré avec certificat, référencez une clé privée. Après avoir supprimé le chiffrement d’un document PDF, celui-ci n’est plus sécurisé.

Syntaxe : removePDFCertificateSecurity(Document inDoc, String alias, ResourceResolver resourceResolver)

Paramètres d’entrée

Paramètres Description
inDoc
Un objet document correspondant au document PDF chiffré par certificat.
alias
L’alias correspondant à la clé dans le trust store Granite utilisé pour supprimer le chiffrement avec certificat du document PDF.
ResourceResolver ResourceResolver va accéder au stockage des clés de l’utilisateur spécifique pour récupérer les informations d’identification.

L’exemple de code Java suivant supprime un chiffrement avec certificat d’un document PDF.

package com.adobe.docassurance.samples;

import java.io.File;

import javax.jcr.Session;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.jcr.api.SlingRepository;
import org.apache.sling.jcr.resource.JcrResourceResolverFactory;

import com.adobe.aemfd.docmanager.Document;
import com.adobe.fd.docassurance.client.api.DocAssuranceService;

/**
 * The following Java code example removes certificate-based encryption from a PDF document
 *
 */
@Component(enabled=true,immediate=true)
@Service(value=RemovePKIEncryption.class)
public class RemovePKIEncryption {

	// Create reference for docAssuranceServiceInterface
	@Reference
	private DocAssuranceService docAssuranceService;
    
	@Reference
    private SlingRepository slingRepository;
    
	@Reference
    private JcrResourceResolverFactory jcrResourceResolverFactory ;
	
	/**
	 * The below sample code demonstrates encrypting PDF with Password using AEM docAssuranceService.
	 * 
	 * @param inFilePath  path of the input PDF File
	 * 		  Path Example for Files stored at hardDisk = "C:/temp/test.pdf"	 
	 * 	
	 * @param outFilePath path where the output PDF File needs to be saved
	 * 		  Path Example for Files stored at hardDisk = "C:/temp/test_Encrypted.pdf"	 
	 * 	 
	 * @throws Exception
	 */
	public void removePKIEncryption(String inputFile, String outputFile) throws Exception {

		File inFile = new File(inputFile);
		Document inDoc = new Document(inFile);
		
		File outFile = new File(outputFile);
		Document outDoc = null;
    	
        Session adminSession = null;
        ResourceResolver resourceResolver = null;
        try{
				adminSession = slingRepository.loginAdministrative(null);
				resourceResolver = jcrResourceResolverFactory.getResourceResolver(adminSession);
     
				//Remove certificate-based encryption from the PDF document 
				/**
				 * Here the alias("encryption") of the private credential stored in the keystore of the
				 * user has been provided with the user's resource resolver
				 */
				outDoc = docAssuranceService.removePDFCertificateSecurity(inDoc, "encryption",resourceResolver);
				
        }catch(Exception e){
        
        	// TODO Auto-generated catch block
        }finally{
            /**
             * always close the PDFDocument object after your processing is done.
             */
            if(inDoc != null){
                inDoc.close();
            }
            if(adminSession != null && adminSession.isLive()){
                if(resourceResolver != null){
                    resourceResolver.close();
                }
                adminSession.logout();
            }
        }
        
        outDoc.copyToFile(outFile);
	}


 }

Service Output

Le service Output fournit des API pour générer un fichier XDP aux formats .pdf, .pcl, .zpl, et .ps. Le service prend en charge les API suivantes :

  • generatePDFOutput : génère un document PDF en fusionnant une conception de formulaire avec des données stockées sur un emplacement réseau, un système de fichiers local, un emplacement HTTP comme des valeurs littérales.
  • generatePDFOutput : génère un document PDF en fusionnant une conception de formulaire avec les données stockées dans une application.
  • generatePDFOutputBatch : fusionne une conception de formulaire avec des données pour générer un document PDF. Vous pouvez également générer un fichier de métadonnées pour chaque enregistrement ou enregistrer la sortie pour un fichier PDF.
  • generatePrintedOutput : génère une sortie PCL, PostScript, ou ZPL à partir d’une conception de formulaire et d’un fichier de données stockés sur un emplacement réseau, un système de fichiers local ou un emplacement HTTP comme des valeurs littérales.
  • generatePrintedOutput : Génère une sortie PCL, PostScript et ZPL à partir d’une conception de formulaire et d’un fichier de données stockés dans une application.

generatePDFOutput

L’API generatePDFOutput génère un document PDF en fusionnant une conception de formulaire avec des données. Vous pouvez également générer un fichier de métadonnées pour chaque enregistrement ou enregistrer la sortie pour un fichier PDF. Utilisez l’API generatePDFOutput pour les conceptions de formulaire ou les données stockées sur un emplacement réseau, un système de fichiers local, un emplacement HTTP comme des valeurs littérales. Si la conception de formulaire et les données XML sont stockées dans une application, utilisez l’API generatePDFOutput.

Syntaxe : Document generatePDFOutput(String uriOrFileName, Document data, PDFOutputOptions options) ;

Paramètres d’entrée

Paramètres Description
uriOrFileName Spécifie le chemin et le nom du fichier d’entrée. Le fichier peut être de type PDF ou XDP. Si seul le nom de fichier est spécifié, le fichier est lu par rapport au paramètre contentRoot défini dans les options.
data Un fichier XML contenant des données fusionnées avec le document PDF.
options Indique les valeurs des variables contentRoot, locale, AcrobatVersion, linearizedPDF et taggedPDF. Le paramètre options accepte l’objet de type PDFOutputOptions.

L’exemple de code Java suivant génère un document PDF en fusionnant une conception de formulaire avec des données stockées dans un fichier XML.

@Reference private OutputService outputService;

private File generatePDFOutput(String contentRoot,File inputXML,String templateStr,String acrobatVersion,String tagged,String linearized, String locale) {

String outputFolder="C:/Output";

Document doc=null;

try {

        PDFOutputOptions option = new PDFOutputOptions();         option.setContentRoot(contentRoot);         if(acrobatVersion.equalsIgnoreCase("Acrobat_10"))

        { 

            option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_10);

        } else if(acrobatVersion.equalsIgnoreCase("Acrobat_10_1")) {

            option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_10_1);

        } else if(acrobatVersion.equalsIgnoreCase("Acrobat_11")) {             option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_11);

        }

        if (tagged.equalsIgnoreCase("true") ) {

            option.setTaggedPDF(true );

        }

        if (linearized.equalsIgnoreCase("true") ) {

            option.setTaggedPDF(true );

        }

        if(locale!=null)

        {

            option.setLocale(locale);

        }

        InputStream in = new FileInputStream(inputXML);

        doc = outputService.generatePDFOutput(templateStr,new Document(in),option);         File toSave = new File(outputFolder+"Output.pdf");

        doc.copyToFile(toSave);

        return toSave;

    } catch (OutputServiceException e) {

         e.printStackTrace();

    }catch (FileNotFoundException e) {

         e.printStackTrace();

    } catch (IOException e) {

         e.printStackTrace();

    }finally{

                doc.dispose();

    }

    return null;

}

generatePDFOutput

L’API generatePDFOutput génère un document PDF en fusionnant une conception de formulaire avec des données. Vous pouvez également créer un fichier de métadonnées pour chaque enregistrement ou enregistrer la sortie pour un fichier PDF. Utilisez l’API generatePrintedOutput pour les conceptions de formulaire ou les données stockées dans une application. Si la conception de formulaire et les données XML sont stockées sur un emplacement réseau, localement ou sur un emplacement HTTP comme des valeurs littérales, utilisez l’API generatePDFOutput.

Syntaxe : Document generatePDFOutput(Document inputdocument, Document data, PDFOutputOptions options)

Paramètre d’entrée

Paramètres Description
Inputdocument
Spécifie le chemin et le nom du fichier d’entrée. Le fichier peut être de type PDF ou XDP. Si seul le nom de fichier est spécifié, le fichier est lu par rapport au paramètre contentRoot défini dans les options.
data Un fichier XML contenant des données fusionnées avec le document PDF.
options Indique les valeurs des variables contentRoot, locale, AcrobatVersion, linearizedPDF et taggedPDF. Le paramètre options accepte l’objet de type PDFOutputOptions.

L’exemple de code Java suivant génère un document PDF en fusionnant une conception de formulaire avec des données stockées dans un fichier XML.

@Reference private OutputService outputService;

private File generatePDFOutput2(String contentRoot, File inputXML, File templateStr, String acrobatVersion, String tagged, String linearized, String locale) {

String outputFolder="C:/Output";

Document doc=null;

     try {

            PDFOutputOptions option = new PDFOutputOptions();             option.setContentRoot(contentRoot);
            if(locale!=null)

            {

                option.setLocale(locale);

            }

            if(acrobatVersion.equalsIgnoreCase("Acrobat_10"))

            {

                option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_10);

            } else if(acrobatVersion.equalsIgnoreCase("Acrobat_10_1")) {                 option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_10_1);

            } else if(acrobatVersion.equalsIgnoreCase("Acrobat_11")) {                 option.setAcrobatVersion(com.adobe.fd.output.api.AcrobatVersion.Acrobat_11);

            }

            if (tagged.equalsIgnoreCase("true") ) {

                option.setTaggedPDF(true );

            }

            if (linearized.equalsIgnoreCase("true") ) {

                option.setTaggedPDF(true );

            }

            InputStream inputXMLStream = new FileInputStream(inputXML); 

            InputStream templateStream = new FileInputStream(templateStr);;

            doc = outputService.generatePDFOutput(new Document(templateStream),new             Document(inputXMLStream),option);

                     File toSave = new File(outputFolder,"Output.pdf");

                     doc.copyToFile(toSave);

                    return toSave;

                } catch (OutputServiceException e) {

                         e.printStackTrace();

               }catch (FileNotFoundException e) {

                          e.printStackTrace();

               } catch (IOException e) {

                          e.printStackTrace();

               }finally{

                            doc.dispose();

              }

                return null;

}

generatePDFOutputBatch

Fusionne une conception de formulaire avec des données pour générer un document PDF. Vous pouvez également générer un fichier de métadonnées pour chaque enregistrement ou enregistrer la sortie pour un fichier PDF. Utilisez l’API generatePDFOutputBatch pour les conceptions de formulaire ou les données stockées sur un emplacement réseau, un système de fichiers local, un emplacement HTTP comme des valeurs littérales.

Syntaxe : BatchResult generatePDFOutputBatch(Map templates, Map data, PDFOutputOptions options, BatchOptions batchOptions);

Paramètres d’entrée

Paramètre Description
templates
Indique la carte de clés et le nom de fichier du modèle.
data Indique la carte de clés et le document de données. Si la clé n’est pas nulle, le document de données est alors rendu à l’aide du modèle correspondant à la clé spécifiée dans la carte des modèles.  
options Indique les valeurs des variables contentRoot, locale, AcrobatVersion, linearizedPDF et taggedPDF. Le paramètre options accepte l’objet de type PDFOutputOptions.
batchOptions Indique la valeur de la variable generateManyFiles. Positionnez l’indicateur generateManyFiles pour générer plusieurs fichiers. Le paramètre options accepte l’objet de type BatchOptions.

L’exemple de code Java suivant génère des documents PDF en fusionnant les conceptions de formulaire avec des données stockées dans un fichier XML.

private ArrayList generatePDFBatch(String contentRoot,String multipleFiles) {

String outputFolder="C:/Output";

    try {

        PDFOutputOptions option = new PDFOutputOptions();         option.setContentRoot(contentRoot);

        Map templates = new LinkedHashMap();

        Map data = new LinkedHashMap();

        String template1 = "PurchaseOrder.xdp"; String template2 = "CardApp.xdp";         templates.put(template1.substring(0, template1.indexOf(".xdp")),template1);         templates.put(template1.substring(0, template2.indexOf(".xdp")),template2);

        File inputXML1 = new File("c:/InputFolder/PurchaseOrder.xml");

        File inputXML2 = new File("c:/InputFolder/CardApp.xml");

        InputStream in1 = new FileInputStream(inputXML1);

        InputStream in2 = new FileInputStream(inputXML2);

        data.put(template1.substring(0, template1.indexOf(".xdp")),new         Document((in1))); data.put(template1.substring(0,         template1.indexOf(".xdp")),new Document((in2))); BatchOptions bo = new         BatchOptions(); BatchResult ret=null;         if(multipleFiles.equalsIgnoreCase("true"))

        {

            bo.setGenerateManyFiles(true);

            ret = outputService.generatePDFOutputBatch(templates, data, option, bo);

        } else {

            ret = outputService.generatePDFOutputBatch(templates, data, option, new             BatchOptions());

        }

        ArrayList outputs = new ArrayList();

        int counter=0;

        if(ret.getMetaDataDoc() !=null ){

        File toSave = new File(outputFolder+"Output.xml");

        ret.getMetaDataDoc().copyToFile(toSave);

        outputs.add(toSave);

        List<Document> list = ret.getGeneratedDocs();

        for(Document doc:list){

        File toSave = new File(outputFolder,"Output"+"_"+counter+".pdf");         doc.copyToFile(toSave);&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;         outputs.add(toSave);

        counter++;

        doc.dispose();

        }

        return outputs;

       } catch (OutputServiceException e) {

            e.printStackTrace();

       }catch (FileNotFoundException e) {

            e.printStackTrace();

       }catch (IOException e) {

            e.printStackTrace();

       }

       return null;

}

generatePrintedOutput

Génère une sortie PCL, PostScript et ZPL à partir d’une conception de formulaire et d’un fichier de données. Le fichier de données est fusionné avec la conception de formulaire et mis en forme pour l’impression. Vous pouvez envoyer la sortie directement vers une imprimante ou l’enregistrer en tant que fichier. Utilisez l’API generatePrintedOutput pour les conceptions de formulaire ou les données stockées dans une application.

Syntaxe : Document generatePrintedOutput(String uriOrFileName, Document data, PrintedOutputOptions);

Paramètres d’entrée

Paramètre Description
uriOrFileName
Spécifie le chemin et le nom du fichier d’entrée. Si seul le nom de fichier est spécifié, le fichier est lu par rapport au paramètre contentRoot défini dans les options. Le fichier peut être de type PDF ou XDP.
data Un fichier XML contenant des données fusionnées avec des documents PDF.
options Indique les valeurs des variables contentRoot, locale, AcrobatVersion, linearizedPDF et taggedPDF. Le paramètre options accepte l’objet de type PrintedOutputOptions.

L’exemple de code Java suivant génère une sortie PCL, PostScript et ZPL à partir de la conception et des données du formulaire. Le type de sortie dépend de la valeur transmise au paramètre printConfig.  

@Reference private OutputService outputService;

private File generatePrintedOutput(String contentRoot,File inputXML,String templateStr,String printConfig) {

String outputFolder="C:/Output";

Document doc=null;

    try {

            PrintedOutputOptions options = new PrintedOutputOptions();                           options.setContentRoot(contentRoot);

            if(printConfig.equalsIgnoreCase("ps"))

            {

                options.setPrintConfig(PrintConfig.PS_PLAIN);

            }else if(printConfig.equalsIgnoreCase("pcl")) {

                            options.setPrintConfig(PrintConfig.HP_PCL_5e);

                     }else if(printConfig.equalsIgnoreCase("zpl")) {                                                                       options.setPrintConfig(PrintConfig.ZPL300);

            }  

            InputStream in = new FileInputStream(inputXML);

            doc = outputService.generatePrintedOutput(templateStr,new             Document(in),options);

            in.close();

            File toSave = new File(outputFolder,"Output"+"."+printConfig);             doc.copyToFile(toSave);

            return &nbsp;toSave;

        } catch (OutputServiceException e) {

             e.printStackTrace();

        }catch (FileNotFoundException e) {

             e.printStackTrace();

        }catch (IOException e) {

             e.printStackTrace();

        }finally{

             doc.dispose();

        }

        return null;

}

generatePrintedOutput

Génère une sortie PCL, PostScript et ZPL en fonction d’une conception de formulaire et d’un fichier de données. Le fichier de données est fusionné avec la conception de formulaire et mis en forme pour l’impression. La sortie peut être envoyée directement vers une imprimante ou enregistrée en tant que fichier. Utilisez l’API generatePrintedOutput pour les conceptions de formulaire ou les données stockées dans une application.

Syntaxe : Document generatePrintedOutput(Document inputdocument, Document data, PrintedOutputOptions);

Paramètres d’entrée

Paramètre Description
Inputdocument
Spécifie le chemin et le nom du fichier d’entrée. Si seul le nom de fichier est spécifié, le fichier est lu par rapport au paramètre contentRoot défini dans les options. Le fichier peut être de type XDP.  
data Un fichier XML contenant des données fusionnées avec des documents PDF.
options Cet objet est utilisé pour définir les valeurs des paramètres contentRoot, locale, printConfig, copies et paginationOverride. Le paramètre options accepte l’objet de type PrintedOutputOptions.

L’exemple de code Java suivant génère une sortie PCL, PostScript et ZPL à partir de la conception et des données du formulaire. Le type de sortie dépend de la valeur transmise au paramètre printConfig.  

@Reference private OutputService outputService;

private File generatePrintedOutput2(File &nbsp;inputXML,File templateStr,String printConfig) {

String outputFolder="C:/Output";

Document doc=null;

       try {

            PrintedOutputOptions options = new PrintedOutputOptions();             if(printConfig.equalsIgnoreCase("ps"))

            {

                options.setPrintConfig(PrintConfig.PS_PLAIN);

            }else if(printConfig.equalsIgnoreCase("pcl")) {                                   options.setPrintConfig(PrintConfig.HP_PCL_5e);

            }else if(printConfig.equalsIgnoreCase("zpl")) {                                                                       options.setPrintConfig(PrintConfig.ZPL300);

                             }

            InputStream inputXMlStream = new FileInputStream(inputXML);

            InputStream templateStream = new FileInputStream(templateStr); doc =             outputService.generatePrintedOutput(new Document(templateStream),new             Document(inputXMlStream),options);

            File toSave = new File(outputFolder,"Output"+"."+printConfig);             doc.copyToFile(toSave);

            return toSave;

            } catch (OutputServiceException e) {

                e.printStackTrace();

            }catch (FileNotFoundException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            }finally{

                doc.dispose();

            }

            return null;

}

generatePrintedOutputBatch

Génère un document au format PS, PCL, et ZPL en fusionnant une conception de formulaire avec des données. Vous pouvez également créer un fichier de métadonnées pour chaque enregistrement ou enregistrer la sortie pour un fichier PDF. Utilisez l’API generatePrintedOutputBatch pour les conceptions de formulaire ou les données stockées sur un emplacement réseau, un système de fichiers local, un emplacement HTTP comme des valeurs littérales.

Syntaxe : BatchResult generatePrintedOutputBatch(Map templates, Map data, PrintedOutputOptions options, BatchOptions batchOptions);

Paramètres d’entrée

Paramètre Description
templates
Indique la carte de clés et le nom de fichier du modèle.
data Indique la carte de clés et le document de données. Si la clé n’est pas nulle, le document de données est alors rendu à l’aide du modèle correspondant à la clé dans la carte des modèles.
options Indique l’objet de type PrintedOutputOptions. Cet objet est utilisé pour définir les valeurs des paramètres contentRoot, locale, printConfig, copies et paginationOverride.
batchOptions Indique la valeur de la variable generateManyFiles. Positionnez l’indicateur generateManyFiles pour générer plusieurs fichiers. Le paramètre options accepte l’objet de type BatchOptions.

L’exemple de code Java suivant génère une sortie PCL, PostScript et ZPL par lot à partir de plusieurs modèles de conception de formulaire et fichiers de données. Le type de sortie dépend de la valeur transmise au paramètre printConfig.  

@Reference private OutputService outputService;

private ArrayList generatePrintedOutputBatch(String contentRoot,String multipleFiles,String printConfig) {

String outputFolder="C:/Output";

        try {

                PrintedOutputOptions option = new PrintedOutputOptions();                 option.setContentRoot(contentRoot);

                Map templates = new LinkedHashMap();

                Map data = new LinkedHashMap();

                String template1 = "PurchaseOrder.xdp";

                String template2 = "CardApp.xdp";

                templates.put(template1.substring(0,                 template1.indexOf(".xdp")),template1);                 templates.put(template1.substring(0,                 template2.indexOf(".xdp")),template2);

                File inputXML1 = new                                   File("c:/InputFolder/PurchaseOrder.xml");

                File inputXML2 = new File("c:/InputFolder/CardApp.xml");

                InputStream in1 = new FileInputStream(inputXML1);

                InputStream in2 = new FileInputStream(inputXML2);                  data.put(template1.substring(0,                     template1.indexOf(".xdp")),new Document((in1)));

                 data.put(template2.substring(0,                     template2.indexOf(".xdp")),new Document((in2)));

                 if(printConfig.equalsIgnoreCase("ps"))

                 {

                    option.setPrintConfig(PrintConfig.PS_PLAIN);

                 } else if(printConfig.equalsIgnoreCase("pcl"))

                 {

                    option.setPrintConfig(PrintConfig.HP_PCL_5e);

                 } else if(printConfig.equalsIgnoreCase("zpl")){

                                         option.setPrintConfig(PrintConfig.ZPL300);

                 }

                 option.setContentRoot(contentRoot);

                 BatchOptions bo = new BatchOptions();

                 BatchResult ret =                             outputService.generatePrintedOutputBatch(temp                                    lates, data, option, new                                                     BatchOptions());

                 ArrayList outputs = new ArrayList();

                 int counter=0;

                 if(ret.getMetaDataDoc() !=null ){

                 File toSave = new File(outputFolder,"Output"+".xml");                    ret.getMetaDataDoc().copyToFile(toSave);

                 outputs.add(toSave);

                 List<Document> list = ret.getGeneratedDocs();

                 for(Document doc:list){

                 File toSave = new                                                               File(outputFolder,"Output"+"_"+counter+".                                        "+printConfig);                                    doc.copyToFile(toSave);

                 outputs.add(toSave);

                 counter++;

                 doc.dispose();

                 }

                 return outputs;  

          }

            catch (OutputServiceException e) {

                e.printStackTrace();

          }catch (FileNotFoundException e) {

                e.printStackTrace();

          } catch (IOException e) {

                e.printStackTrace();

          }

            return null;

  }

Service Forms

Le service Forms fournit des API pour importer et exporter des données d’un formulaire PDF interactif ou vers celui-ci. Un formulaire PDF interactif est un document PDF contenant un ou plusieurs champs utilisés pour afficher et recueillir des informations des utilisateurs. Le service prend en charge les API suivantes :

  • exportData : exporte les données d’un formulaire PDF.
  • importData : importe des données dans un formulaire PDF interactif.

exportData

Exporte les données de formulaire d’un formulaire PDF interactif aux formats XML et XDP.

Syntaxe : Document exportData(Document xdpOrPdf, DataFormat dataFormat)

Paramètres d’entrée

Paramètre Description
xdpOrPdf
Indique un objet document contenant un fichier XDP ou PDF.  
dataFormat
Indique le format d’exportation des données. Il accepte la variable de type enum (XDP, XmlData, Auto).

L’exemple de code Java suivant exporte les données d’un formulaire PDF interactif aux formats XML et XDP.

Echantillon

@Reference private FormsService formsService;
private File exportData(String &nbsp;dataFormat, File &nbsp;inDoc) {

String outputFolder="C:/Output";

InputStream in; Document doc=null;

try {

        in = new FileInputStream(inDoc);

        if(dataFormat.equalsIgnoreCase("xml")) 

        {

          doc=formsService.exportData(new Document(in),                                       DataFormat.XmlData);

        }

        else if(dataFormat.equalsIgnoreCase("xdp")) {

        doc =formsService.exportData(new Document(in),                       DataFormat.XDP);

        }

        File toSave = new File(outputFolder,"Output"+"."+dataFormat);

        doc.copyToFile(toSave);

        return toSave;

    } catch (FormsServiceException e) {

       e.printStackTrace();

    }catch (FileNotFoundException e) {

       e.printStackTrace();

    } catch (IOException e) {

       e.printStackTrace();

    }finally{

        doc.dispose();

    }

    return null;

 }

importData

Importe les données de formulaire dans un formulaire PDF interactif.

Syntaxe : Document importData(Document PDF, Document data)

Paramètres d’entrée

Paramètre Description
PDF
Indique un objet document contenant des fichiers PDF.  
Données
Fichier XML contenant des données au format XML.

L’exemple de code Java suivant importe les données de formulaire dans un formulaire PDF interactif.

Echantillon

@Reference private FormsService formsService

private File importData(File inDoc, File inXML)

{

 String outputFolder="C:/Output";

 Document doc=null;

 try {

        InputStream in = new FileInputStream(inDoc);

        InputStream in2 = new FileInputStream(inXML);

        doc=formsService.importData(new Document(in), new Document(in2));

        File toSave = new File(outputFolder,"Output.pdf");

        doc.copyToFile(toSave);

    } catch (FormsServiceException e) {

         e.printStackTrace();

    }catch (FileNotFoundException e) {

         e.printStackTrace();

    } catch (IOException e) {

         e.printStackTrace();

    }finally{

        doc.dispose();

    }

    return null;

}

Service PDF Generator

Le service PDF Generator fournit des API pour convertir des formats de fichier natifs en PDF. Il convertit également des fichiers PDF en d’autres formats et optimise la taille des documents PDF.

GeneratePDFService

Le service GeneratePDFService fournit des API pour convertir de nombreux formats de fichiers, tels que .doc, .docx, .ppt, .pptx, .xls, .xlsx, .odp, .odt, .ods, (obsolète).swf, .jpg, .bmp, .tif, .png, .html et bien d’autres formats de fichier en PDF. Il fournit également des API pour exporter des PDF vers différents formats de fichiers et optimiser les fichiers PDF. Le service prend en charge les API suivantes :

  • createPDF : convertit un type de fichier pris en charge en document PDF. Il prend en charge les formats de fichier tels que Microsoft Word, Microsoft PowerPoint, Microsoft Excel et Microsoft Project. Outre les applications ci-dessus, tout type d’application générique tierce qui génère des PDF peut également être connecté à l’API.
  • exportPDF : convertit un document PDF en type de fichier pris en charge. Cette méthode accepte un PDF en entrée et exporte le contenu du PDF dans le format du type de fichier spécifié.
  • optimizePDF : optimise le document PDF et convertit également un document PDF d’un type à l’autre. Cette méthode accepte un document PDF en entrée.
  • htmlToPdf2 : convertit une page HTML en document PDF. Cette méthode accepte l’URL de la page HTML en entrée.

Remarque :

L’API HTMLtoPDF est obsolète pour le serveur AEM Forms en cours d’exécution sur le système d’exploitation AIX.

createPDF

L’API createPDF convertit un type de fichier pris en charge en document PDF. Il prend en charge plusieurs formats de fichier tels que Microsoft Word, Microsoft PowerPoint, Microsoft Excel et Microsoft Project. Outre les applications ci-dessus, tout type d’application générique tierce qui génère des PDF peut également être connecté à l’API.

Pour la conversion, seuls certains paramètres sont obligatoires. Un document d’entrée est un paramètre obligatoire. Vous pouvez appliquer les autorisations de sécurité, les paramètres de sortie PDF et les informations de métadonnées ultérieurement, dans le document PDF de sortie.

Le service createPDF renvoie un objet java.util.Map avec des résultats. Les clés de la carte sont les suivantes :  

  • ConvertedDoc : contient le document PDF que vous venez de créer.
  • LogDoc : contient le fichier journal.

Le service createPDF renvoie les exceptions suivantes :

  • ConversionException
  • InvalidParameterException
  • FileFormatNotSupportedException

Syntaxe :  la carte createPDF(document inputDoc, chaîne inputFilename, chaîne fileTypeSettings, chaîne pdfSettings, chaîne securitySettings, document settingsDoc, document xmpDoc) renvoie InvalidParameterException, ConversionException, FileFormatNotSupportedException;

Paramètres d’entrée

Paramètre Description
inputDoc
Indique un objet document. L’objet document contient le fichier d’entrée. Créez un objet com.adobe.aemfd.docmanager.Document au-dessus du document d’entrée. Ce paramètre est obligatoire.
inputFileName
Nom du fichier d’entrée avec l’extension. Ce paramètre est obligatoire.
fileTypeSettings Ce paramètre est facultatif.
pdfSettings

Sortie PDF pour le document converti. Vous pouvez appliquer uniquement les paramètres suivants :

  • High_Quality_Print
  • PDFA1b_2005_RGB
  • PDFA1b_2005_CMYK
  • PDFX1a_2001
  • PDFX3_2002
  • Press_Quality
  • Smallest_File_Size

Ce paramètre est facultatif.

securitySettings

Paramètres de sécurité du document converti. Vous pouvez appliquer les paramètres suivants :

  • Aucune protection
  • Protection par mot de passe
  • Protection par certificat
  • Serveur Adobe Policy Server

Ce paramètre est facultatif.

settingsDoc Le fichier contient les paramètres appliqués lors de la génération du document PDF (tels que l’optimisation pour l’affichage sur le Web) et des paramètres appliqués après création du document PDF (tels que l’affichage initial et la sécurité). Ce paramètre est facultatif.
xmpDoc   Le fichier contient des informations de métadonnées appliquées au document PDF généré. Ce paramètre est facultatif.

Le code Java suivant convertit un document de type de fichier pris en charge en document PDF.

@Reference GeneratePDFService generatePdfService;
File createPDF(File inputFile, String inputFilename, String fileTypeSettings, String pdfSettings, String securitySettings, File settingsFile, File xmpFile) throws Exception
{
	Transaction tx = OSGiUtils.getTransactionManager().getTransaction();
	// Begin transaction
	if (tx == null)
	OSGiUtils.getTransactionManager().begin();
	String outputFolder="C:/Output"
	Document convertedDoc = null;
	Document inDoc = null;
	Document settingsDoc = null;
	Document xmpDoc = null;
	try
	{
		inDoc = new Document(inputFile);
		if(inputFilename == null || inputFilename.trim().equals("")) {
			throw new Exception("Input file name cannot be null");
		}
		if(inputFileExtension.lastIndexOf('.') == -1) {
			throw new Exception("Input file should have an extension");
		}
		if(settingsFile != null && settingsFile.exists() && settingsFile.isFile())
		settingsDoc = new Document(settingsFile);
		if(xmpFile != null && xmpFile.exists() && xmpFile.isFile())
		xmpDoc = new Document(xmpFile);
		Map result = generatePdfService.createPDF(inDoc, inputFilename, fileTypeSettings, pdfSettings, securitySettings, settingsDoc, xmpDoc);
		convertedDoc = (Document)result.get("ConvertedDoc");
		OSGiUtils.getTransactionManager().commit();
		File outputFile = new File(outputFolder,"Output.pdf");
		doc.copyToFile(outputFile);
		return outputFile;
	}
	catch (Exception e)
	{
		if (OSGiUtils.getTransactionManager().getTransaction() != null)
		OSGiUtils.getTransactionManager().rollback();
		throw e;
	}
	finally {
		if (convertedDoc != null) {
			convertedDoc.dispose();
			convertedDoc = null;
		}
		if (inDoc != null) {
			inDoc.dispose();
			inDoc = null;
		}
		if (settingsDoc != null) {
			settingsDoc.dispose();
			settingsDoc = null;
		}
		if (xmpDoc != null) {
			xmpDoc.dispose();
			xmpDoc = null;
		}
	}
}

exportPDF

Convertit un document PDF en type de fichier pris en charge. Cette méthode accepte un PDF en entrée et exporte le contenu du PDF dans le format du type de fichier spécifié.

Le service createPDF renvoie un objet java.util.Map avec des résultats. Les clés de la carte sont les suivantes : 

  • ConvertedDoc : contient le document de sortie.

Le service createPDF renvoie les exceptions suivantes :

  • ConversionException
  • InvalidParameterException
  • FileFormatNotSupportedException

Syntaxe : Carte exportPDF(document inputDoc, chaîne inputFileName, chaîne formatType, document settingsDoc) renvoie ConversionException, InvalidParameterException, FileFormatNotSupportedException ;

Paramètres d’entrée

Paramètre Description
inputDoc
Spécifie le document à convertir.  
inputFileName
Le nom du fichier avec l’extension.
formatType Le format de fichier de sortie pour l’API exportPDF.
settingsDoc   Le fichier contient des configurations à appliquer lors de la génération du document de sortie. En règle générale, il s’agit d’un fichier XML.

L’exemple de code Java suivant convertit un document PDF en type de fichier spécifié.

(tx == null)
OSGiUtils.getTransactionManager().begin();
String outputFolder="C:/Output"
Document convertedDoc = null;
Document inDoc = null;
Document settingsDoc = null;
try
{
	inDoc = new Document(inputFile);
	if(inputFileName == null || inputFileName.trim().equals("")) {
		throw new Exception("Input file name cannot be null");
	}
	if(inputFileExtension.lastIndexOf('.') == -1) {
		throw new Exception("Input file should have an extension");
	}
	if(settingsFile != null && settingsFile.exists() && settingsFile.isFile())
	settingsDoc = new Document(settingsFile);
	Map result = generatePdfService.exportPDF(inDoc, inputFileName, formatType, settingsDoc);
	convertedDoc = (Document)result.get("ConvertedDoc");
	OSGiUtils.getTransactionManager().commit();
	File outputFile = new File(outputFolder,"OutputFile");
	doc.copyToFile(outputFile);
	return outputFile;
}
catch (Exception e)
{
	if (OSGiUtils.getTransactionManager().getTransaction() != null)
	OSGiUtils.getTransactionManager().rollback();
	throw e;
}
finally {
	if (convertedDoc != null) {
		convertedDoc.dispose();
		convertedDoc = null;
	}
	if (inDoc != null) {
		inDoc.dispose();
		inDoc = null;
	}
	if (settingsDoc != null) {
		settingsDoc.dispose();
		settingsDoc = null;
	}
}
}

optimizePDF

L’API OptimizePDF optimise les fichiers PDF en réduisant leur taille. Le résultat de cette conversion est un fichier PDF moins volumineux que sa version d’origine. Cette opération permet également de convertir des documents PDF vers la version PDF spécifiée dans les paramètres d’optimisation. Il renvoie l’objet OptimizePDFResult contenant le fichier PDF optimisé.

Le service createPDF renvoie les exceptions suivantes :

  • ConversionException
  • InvalidParameterException
  • FileFormatNotSupportedException

Syntaxe : OptimizePDFResult optimizePDF(document inputDoc, chaîne fileTypeSettings, document settingsDoc) renvoie ConversionException, InvalidParameterException, FileFormatNotSupportedException;

Paramètres d’entrée

Paramètre Description
inputDoc
Indique le document d’entrée. Ce paramètre est obligatoire.
fileTypeSettings
Ce paramètre est facultatif.
settingsDoc   Le fichier contient les paramètres appliqués lors de la génération du document PDF (tels que l’optimisation pour l’affichage sur le Web) et des paramètres appliqués après création du document PDF (tels que l’affichage initial et la sécurité). Ce paramètre est facultatif.

L’exemple de code Java suivant optimise le fichier PDF d’entrée en réduisant sa taille.

@Reference GeneratePDFService generatePdfService;
File optimizePDF(File inputFile, String fileTypeSettings, File settingsFile) throws Exception
{
	Transaction tx = OSGiUtils.getTransactionManager().getTransaction();
	// Begin transaction
	if (tx == null)
	OSGiUtils.getTransactionManager().begin();
	String outputFolder="C:/Output"
	Document convertedDoc = null;
	Document inDoc = null;
	Document settingsDoc = null;
	try
	{
		inDoc = new Document(inputFile);
		if(settingsFile != null && settingsFile.exists() && settingsFile.isFile())
		settingsDoc = new Document(settingsFile);
		OptimizePDFResult result = generatePdfService.optimizePDF(inDoc, fileTypeSettings, settingsDoc);
		convertedDoc = result.getConvertedDocument();
		OSGiUtils.getTransactionManager().commit();
		File outputFile = new File(outputFolder,"Output.pdf");
		doc.copyToFile(outputFile);
		return outputFile;
	}
	catch (Exception e)
	{
		if (OSGiUtils.getTransactionManager().getTransaction() != null)
		OSGiUtils.getTransactionManager().rollback();
		throw e;
	}
	finally {
		if (convertedDoc != null) {
			convertedDoc.dispose();
			convertedDoc = null;
		}
		if (inDoc != null) {
			inDoc.dispose();
			inDoc = null;
		}
		if (settingsDoc != null) {
			settingsDoc.dispose();
			settingsDoc = null;
		}
	}
}

htmlToPdf2

Convertit une page HTML en document PDF. Cette méthode accepte l’URL de la page HTML en entrée.

Le service htmlToPdf2 renvoie un objet HtmlToPdfResult. Vous pouvez obtenir le fichier PDF converti via result.getConvertedDocument().

Le service htmlToPdf2 renvoie les exceptions suivantes :

  • ConversionException
  • InvalidParameterException
  • FileFormatNotSupportedException

Syntaxe :  HtmlToPdfResult htmlToPdf2(chaîne inputUrl, chaîne fileTypeSettingsName, chaîne securitySettingsName, document settingsDoc, document xmpDoc) renvoie ConversionException, InvalidParameterException, FileFormatNotSupportedException ;

Paramètres d’entrée

Paramètre Description
inputDoc
Indique le document d’entrée. Ce paramètre est obligatoire.
fileTypeSettings
Ce paramètre est facultatif.
settingsDoc   Le fichier contient les paramètres appliqués lors de la génération du document PDF (tels que l’optimisation pour l’affichage sur le Web) et des paramètres appliqués après création du document PDF (tels que l’affichage initial et la sécurité). Ce paramètre est facultatif.

L’exemple de code Java suivant convertit une page HTML en document PDF.

Reference GeneratePDFService generatePdfService;
File htmlToPdf(String inputUrl, String fileTypeSettingsName, String securitySettingsName, File settingsFile, File xmpFile) throws Exception
{
	Transaction tx = OSGiUtils.getTransactionManager().getTransaction();
	// Begin transaction
	if (tx == null)
	OSGiUtils.getTransactionManager().begin();
	String outputFolder="C:/Output"
	Document convertedDoc = null;
	Document settingsDoc = null;
	Document xmpDoc = null;
	try
	{
		if(settingsFile != null && settingsFile.exists() && settingsFile.isFile())
		settingsDoc = new Document(settingsFile);
		if(xmpFile != null && xmpFile.exists() && xmpFile.isFile())
		xmpDoc = new Document(xmpFile);
		HtmlToPdfResult result = generatePdfService.htmlToPdf2(inputURL, fileTypeSettingsName, securitySettingsName, settingsDoc, xmpDoc);;
		convertedDoc = result.getConvertedDocument();
		OSGiUtils.getTransactionManager().commit();
		File outputFile = new File(outputFolder,"Output.pdf");
		doc.copyToFile(outputFile);
		return outputFile;
	}
	catch (Exception e)
	{
		if (OSGiUtils.getTransactionManager().getTransaction() != null)
		OSGiUtils.getTransactionManager().rollback();
		throw e;
	}
	finally {
		if (convertedDoc != null) {
			convertedDoc.dispose();
			convertedDoc = null;
		}
		if (xmpDoc != null) {
			xmpDoc.dispose();
			xmpDoc = null;
		}
		if (settingsDoc != null) {
			settingsDoc.dispose();
			settingsDoc = null;
		}
	}
}

DistillerService

Le service Distiller convertit les fichiers PostScript, Encapsulated PostScript (EPS) et PRN en fichiers PDF. Ce service est généralement utilisé pour convertir en documents électroniques d’importants volumes de documents papier, tels que des factures et des déclarations. La conversion de documents en PDF permet également aux entreprises d’envoyer à leurs clients un document à la fois dans sa version papier et dans sa version électronique. Les formats de fichiers pris en charge sont .ps, .eps et .prn. Le service prend en charge les API suivantes :

Le service createPDF renvoie un objet java.util.Map avec des résultats. Les clés de la carte sont les suivantes :  

  • ConvertedDoc : contient le document PDF que vous venez de créer.
  • LogDoc : contient le fichier journal.

Le service createPDF renvoie les exceptions suivantes :

  • ConversionException
  • InvalidParameterException
  • FileFormatNotSupportedException

createPDF

Convertit les formats pris en charge en documents PDF. Cette méthode accepte les fichiers au format .ps, .eps et .prn en entrée. Vous pouvez appliquer des autorisations de sécurité spécifiques, des paramètres de sortie et des informations de métadonnées dans le document PDF de sortie.

Syntaxe :  Carte createPDF (document inputDoc, chaîne inputFileName, chaîne pdfSettings, chaîne securitySettings, document settingsDoc, document xmpDoc) renvoie ConversionException, InvalidParameterException, FileFormatNotSupportedException ;

Paramètres d’entrée

Paramètre Description
inputDoc
Indique le document d’entrée. Ce paramètre est obligatoire.
inputFileName Spécifie le nom complet du fichier d’entrée avec l’extension du fichier. Ce paramètre est obligatoire.
pdfSettings

Paramètres de sortie PDF pour le document converti. Vous pouvez appliquer uniquement les paramètres suivants :

  • High_Quality_Print
  • PDFA1b_2005_RGB
  • PDFA1b_2005_CMYK
  • PDFX1a_2001
  • PDFX3_2002
  • Press_Quality
  • Smallest_File_Size

Ce paramètre est facultatif.

securitySettings

Paramètres de sécurité du document converti. Vous pouvez appliquer les paramètres suivants :

  • Aucune protection
  • Protection par mot de passe
  • Protection par certificat
  • Serveur Adobe Policy Server

Ce paramètre est facultatif.

settingsDoc   Le fichier contient les paramètres appliqués lors de la génération du document PDF (tels que l’optimisation pour l’affichage sur le Web) et des paramètres appliqués après création du document PDF (tels que l’affichage initial et la sécurité). Ce paramètre est facultatif.
xmpDoc   Le fichier contient des informations de métadonnées pour le document PDF généré. Ce paramètre est facultatif.

L’exemple de code Java suivant convertit les fichiers d’entrée de type PostScript (PS), Encapsulated PostScript (EPS) et PRN en fichiers PDF.

@Reference DistillerService distillerService;
File createPDF(File inputFile, String inputFilename, String pdfSettings, String securitySettings, File settingsFile, File xmpFile) throws Exception
{
	Transaction tx = OSGiUtils.getTransactionManager().getTransaction();
	// Begin transaction
	if (tx == null)
	OSGiUtils.getTransactionManager().begin();
	String outputFolder="C:/Output"
	Document convertedDoc = null;
	Document inDoc = null;
	Document settingsDoc = null;
	Document xmpDoc = null;
	try
	{
		inDoc = new Document(inputFile);
		if(inputFilename == null || inputFilename.trim().equals("")) {
			throw new Exception("Input file name cannot be null");
		}
		if(inputFileExtension.lastIndexOf('.') == -1) {
			throw new Exception("Input file should have an extension");
		}
		if(settingsFile != null && settingsFile.exists() && settingsFile.isFile())
		settingsDoc = new Document(settingsFile);
		if(xmpFile != null && xmpFile.exists() && xmpFile.isFile())
		xmpDoc = new Document(xmpFile);
		Map result = distillerService.createPDF(inDoc, inputFilename, pdfSettings, securitySettings, settingsDoc, xmpDoc);
		convertedDoc = (Document)result.get("ConvertedDoc");
		OSGiUtils.getTransactionManager().commit();
		File outputFile = new File(outputFolder,"Output.pdf");
		doc.copyToFile(outputFile);
		return outputFile;
	}
	catch (Exception e)
	{
		if (OSGiUtils.getTransactionManager().getTransaction() != null)
		OSGiUtils.getTransactionManager().rollback();
		throw e;
	}
	finally {
		if (convertedDoc != null) {
			convertedDoc.dispose();
			convertedDoc = null;
		}
		if (inDoc != null) {
			inDoc.dispose();
			inDoc = null;
		}
		if (settingsDoc != null) {
			settingsDoc.dispose();
			settingsDoc = null;
		}
		if (xmpDoc != null) {
			xmpDoc.dispose();
			xmpDoc = null;
		}
	}
}

Ce produit est distribué sous licence Creative Commons Attribution - Pas d’utilisation commerciale - Partage à l’identique 3.0 non transposé  Les publications Twitter™ et Facebook ne sont pas couvertes par les dispositions Creative Commons.

Mentions légales   |   Politique de confidentialité en ligne