Beispiel: Portfolio mithilfe der API erstellen

Das Dokumentobjekt kann mithilfe des Konstruktors des PortfolioDocument erstellt werden:

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)

Alternativ können mithilfe der Setter-Methoden des PortfolioDocument die verschiedenen Eigenschaften des Objekts festgelegt werden. Ein Portfoliodokument kann entweder ein Dokument aus einer Datei oder aus dem im Correspondence Management-System erstellten Brief sein. Mithilfe einiger Parameter in der Klasse „PortfolioDocument“ können Dokumente auf beide Weisen erstellt werden. Die folgenden Parameter legen fest, welcher Dokumentobjekttyp erstellt wird:

• DocumentSource: Legt fest, ob das Dokumentobjekt aus einer Datei oder einem Brief erstellt wird. Folglich kann es entweder den Wert „DocumentSource.FILE“ oder „DocumentSource.LETTER“ annehmen.

• DocumentReference: Hat Wert NULL, wenn DocumentSource eine Datei ist. Andernfalls wird auf die Brief-ID des neuen Dokumentenobjekts verwiesen.

• DocumentContent: Hat Wert NULL, wenn DocumentSource ein Brief ist. Wenn die DocumentSource eine Datei ist, verweist Sie auf das Byte-Array der PDF-Datei.

Im folgenden Codeausschnitt wird veranschaulicht, wie das portfolioDocument erstellt werden kann:

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

Beim Erstellen des Portfolios können Sie die Dokumente in einer Ordnerstruktur organisieren, indem Sie das PortfolioFolder-Objekt erstellen. Analog zum portfolioDocument können Sie entweder den Konstruktor oder eine andere Setter-Methode anwenden.

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

Zuletzt wird das Portfolioobjekt mithilfe der Ordner- und Dokumentobjekte erstellt. Auch dieses verweist auf die verwalteten CM-Elemente.

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) 

Im oben aufgeführten Portfolio-Konstruktor sind einige spezielle Dokumente angegeben.

• Navigator: Das Dokumentobjekt wird im speziellen Dateiformat von Adobe (.nav) für die Navigation im Portfolio erstellt.

• Deckblatt: Das Dokumentobjekt, das als Deckblatt des Portfolios festgelegt ist.

Erforderliche Dokumentobjekte für das Portfolio erstellen

/* 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);

Dabei gilt Folgendes:

Erstellen Sie auf ähnliche Weise das Deckblatt-Dokumentobjekt „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);

Die Dokumentobjekte navDoc, coverDoc und ltrDoc werden erstellt, aber noch nicht gespeichert. Verwenden Sie dazu die Correspondence Management-API „createDocument()“.

public PortfolioDocument createDocument(PortfolioDocument document)

Bei dieser Methode wird ein Dokumentobjekt erfasst und gespeichert. Dabei wird ein PortfolioDocument-Objekt mit der ID zurückgegeben, mit der im Inhaltsbereich auf dieses verwiesen wird.

Erstellte Dokumentobjekte speichern:

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

Diese Elemente können dann mithilfe der folgenden activateDocument-API aktiviert werden.

public PortfolioDocument activateDocument(String documentID, boolean updateDependencies)

Erstellen Sie das Portfolioobjekt, das die verschiedenen erstellten Dokumentobjekte verknüpft.

/* 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);

Nachdem das Portfolioobjekt mit allen festgelegten Eigenschaften erstellt wurde, speichern Sie das Objekt mithilfe der createPortfolio-API.

public Portfolio createPortfolio(Portfolio portfolio)

Speichern Sie das Portfolioobjekt.

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

Aktivieren Sie wie auch beim PortfolioDocument das Portfolioelement mithilfe der acitivatePortfolio()-API.

public Portfolio activatePortfolio(String portfolioID)

Nachdem alle erforderlichen Elemente des Portfolios und der Portfolioobjekte erstellt wurden, können Sie das Portfolio rendern. Correspondence Management stellt folgende API zur Verfügung:

public PDFResponseType renderPortfolio(Portfolio portfolio, String dataXML)

Bei dieser Methode werden das Portfolioobjekt und die Daten-XML erfasst und ein PDFResponseType-Objekt zurückgegeben, aus dem das Portfolio extrahiert und gespeichert werden kann.

Die Daten-XML wird verwendet, wenn ein Dokument aus einem Brief erstellt wird, der wiederum auf einige Datenwörterbuchelemente verweist. Wenn das Portfolio gerendert wird, wird das Briefdokument mit allen Verweisen auf die Datenwörterbuchelemente gerendert, die mit den XML-Daten aufgelöst wurden.

Dieses Codefragment zeigt, wie das endgültige Portfolioobjekt gerendert und die Portfoliodatei, die auf der lokalen Festplatte gespeichert werden kann, extrahiert wird.

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