Scénario : création d’un portfolio à l’aide de l’API

L’objet document peut être créé à l’aide du constructeur de PortfolioDocument, comme indiqué ci-dessous :

public PortfolioDocument(String id, String name, String desc, String comment, int state, DocumentSource docSource, byte[] docContent, String docReference, Category ucat, Category lcat, int version, Date activeStartDate, Date activeEndDate, String lastChangeBy, String mimeType)

Une autre solution consiste à utiliser les méthodes Set de PortfolioDocument pour définir les différentes propriétés de l’objet. Un document portfolio peut être un document provenant d’un fichier ou de la lettre de correspondance créée dans le système Correspondence Management. Certains paramètres de la classe PortfolioDocument permettent de créer ces deux documents. Le tableau ci-dessous répertorie les paramètres qui indiquent le type d’objet document créé :

• DocumentSource : indique si l’objet document est créé à partir d’un fichier ou d’une lettre. Par conséquent, il peut prendre la valeur DocumentSource.FILE ou DocumentSource.LETTER

• DocumentReference : défini sur NULL si la source DocumentSource est un fichier. Dans le cas contraire, ce paramètre fait référence à l’ID de lettre du nouvel objet document.

• DocumentContent : défini sur NULL si la source DocumentSource est une lettre. Si la source DocumentSource est un fichier, alors elle fait référence au tableau d’octets du fichier PDF.

L’extrait de code ci-dessous illustre la création du document portfolioDocument :

PortfolioDocument doc = new PortfolioDocument(); 
doc.setActiveEndDate(getDate()); 
doc.setActiveStartDate(getDate()); 
doc.setComment("Sample document"); 
doc.setDesc("Sample document"); 
doc.setDocContent(getdocumentContent()); 
doc.setDocReference(null); 
doc.setDocSource(DocumentSource.FILE); 
doc.setLcat(subCategoryObject); 
doc.setUcat(categoryObject); 
doc.setName(documentName); 
doc.setState(iState); 
doc.setVersion(0);

Pendant la création du portfolio, vous pouvez organiser les documents dans une structure de dossiers en créant l’objet PortfolioFolder. De manière semblable à l’objet portfolioDocument vous pouvez utiliser le constructeur ou une autre méthode Set.

public PortfolioFolder(String id, String name, String desc, List<PortfolioFolder> subFolders, List<PortfolioDocument> documents) 

Enfin, l’objet portfolio est créé à l’aide des objets dossier et document et référence également les autres actifs gérés de CM.

public Portfolio(String id, String name, String desc, String comment, int state, Category ucat, Category lcat, int version, Date activeStartDate, Date activeEndDate, String lastChangeBy, PortfolioDocument navigator, PortfolioDocument cover, PortfolioFolder rootFolder) 

Certains documents spéciaux sont mentionnées ci-dessus dans le constructeur de portfolio.

• Navigator : l’objet document est créé à l’aide du format de fichier Adobe spécial (.nav) pour la navigation dans le portfolio.

• Cover Page : l’objet document défini en tant que page de couverture du portfolio.

Création des objets document nécessaires pour le portfolio.

/* Creating a document object for the Navigator */ 
PortfolioDocument navDoc = new PortfolioDocument(); 
navDoc.setActiveEndDate(getDate()); 
navDoc.setActiveStartDate(getDate()); 
navDoc.setComment("Navigator document"); 
navDoc.setDesc("Navigator document"); 
navDoc.setDocContent(getdocumentContent()); 
navDoc.setDocReference(null); 
navDoc.setDocSource(DocumentSource.FILE); 
navDoc.setLcat(getCategoryObject("SubCategory",1)); 
navDoc.setUcat(getCategoryObject("MainCategory",0)); 
navDoc.setName("SampleNavigator"); 
navDoc.setState(0); 
navDoc.setVersion(0);

Où :

De même, créez l’objet document de page de couverture coverDoc.

/* Creating a document object from a Letter */ 
PortfolioDocument ltrDoc = new PortfolioDocument(); 
ltrDoc.setActiveEndDate(getDate()); 
ltrDoc.setActiveStartDate(getDate()); 
ltrDoc.setComment("Sample document"); 
ltrDoc.setDesc("Sample document"); 
ltrDoc.setDocContent(null); 
ltrDoc.setDocReference(getLetterID("SampleLetter",0)); 
ltrDoc.setDocSource(DocumentSource.LETTER); 
ltrDoc.setLcat(getCategoryObject("SubCategory",1)); 
ltrDoc.setUcat(getCategoryObject("MainCategory",0)); 
ltrDoc.setName("SampleDocFromLetter"); 
ltrDoc.setState(0); 
ltrDoc.setVersion(0);

Les objets navDoc, coverDoc et ltrDoc du document sont créés, mais ne sont pas encore conservés. Pour ce faire, utilisez l’API createDocument() de Correspondence Management.

public PortfolioDocument createDocument(PortfolioDocument document)

Cette méthode accepte un objet document et le conserve. Elle renvoie un objet PortfolioDocument avec l’ID avec lequel il est référencé dans l’espace de contenu.

Conservez les objets document créés :

/* Persisting the document objects */ 
navDoc = documentService.createDocument(navDoc); 
coverDoc = documentService.createDocument(coverDoc); 
ltrDoc = documentService.createDocument(ltrDoc);

Ces actifs peuvent ensuite être activés à l’aide de l’API activateDocument suivante.

public PortfolioDocument activateDocument(String documentID, boolean updateDependencies)

Créez l’objet portfolio en associant les différents objets document créés.

/* Creating the portfolio object */ 
Portfolio pf = new Portfolio(); 
pf.setName("SamplePortfolio"); 
pf.setActiveEndDate(getDate()); 
pf.setActiveStartDate(getDate()); 
pf.setComment("Sample portfolio"); 
pf.setDesc("Sample portfolio "); 
pf.setLcat(getCategoryObject("SubCategory",1)); 
pf.setUcat(getCategoryObject("MainCategory",0)); 
pf.setState(0); 
pf.setVersion(0); 
pf.setNavigator(navDoc); 
pf.setCover(coverDoc); 
/* Create the folders and associate the documents with it */ 
PortfolioFolder folder = new PortfolioFolder(); 
List<PortfolioDocument> docList = new ArrayList<PortfolioDocument>(); 
docList.add(ltrDoc); 
folder.setName("root"); 
folder.setSubFolders(null); 
folder.setDesc("root folder"); 
folder.setDocuments(docList); 
pf.setRootFolder(folder);

Maintenant que l’objet portfolio est créé avec toutes ses propriétés définies, conservez l’objet à l’aide de l’API createPortfolio.

public Portfolio createPortfolio(Portfolio portfolio)

Conservez l’objet portfolio.

/* Persisting the portfolio object */ 
pf = portfolioService.createPortfolio(pf);

De manière semblable à l’objet PortfolioDocument, activez l’actif de portfolio en utilisant l’API activatePortfolio().

public Portfolio activatePortfolio(String portfolioID)

Maintenant, tous les actifs nécessaires du portfolio et l’objet portfolio lui-même ont été créés pour effectuer le rendu du portfolio. Correspondence Management fournit l’API suivante :

public PDFResponseType renderPortfolio(Portfolio portfolio, String dataXML)

Cette méthode prend l’objet portfolio et le fichier dataXML et renvoie un objet PDFResponseType à partir duquel le portfolio peut être extrait et enregistré.

Les données XML sont utilisées lorsqu’un document a été créé à partir d’une lettre, qui à son tour référence des éléments d’un dictionnaire de données. Lorsque le portfolio est rendu, le document de lettre est rendu avec toutes les références aux éléments de dictionnaire de données résolus avec les données XML.

Cet extrait de code montre comment effectuer le rendu de l’objet portfolio final et extraire le fichier de portfolio pouvant être enregistré sur le disque local.

byte[] pdfDoc = null; 
PDFResponseType resp = portfolioRenderService.renderPortfolio(pf, xmlData); 
pdfDoc = resp.getFile().getDocument();