06-1_Anlage 1H _ Anlage 2 - VIS_6.3_CMIS_Schnittstelle.pdf

[Seite 1]

Schnittstelle CMIS

Konfiguration

Version: 6.3 Stand: 15. Dezember 2021

[Seite 2]

© Copyright by PDV GmbH Haarbergstraße 73 99097 Erfurt

Alle Rechte vorbehalten. Sämtliche Angaben vorbehaltlich technischer Änderungen. Trotz sorgfältiger Prüfung wird für den Inhalt keine Haftung übernommen. Alle aufgeführten Warennamen sind eingetragen und als solche zu behandeln.

Im Interesse der besseren Lesbarkeit des Textes wird auf geschlechterspezifische Formulierungen verzichtet. Die männliche Form wird als generisches Maskulinum und damit ausdrücklich als Sammelbezeichnung für beide Geschlechter verwendet.

Nachdruck und Vervielfältigung – auch auszugsweise – nur mit Genehmigung der PDV GmbH, Erfurt

[Seite 3]

Inhaltsverzeichnis

Inhaltsverzeichnis

Inhaltsverzeichnis ............................................................................................................ 3 1 Einleitung ................................................................................................................ 4 1.1 Begleitende Dokumente ........................................................................................ 4 2 CMIS im Überblick .................................................................................................. 5 2.1 Entwicklung von CMIS und aktueller Stand ........................................................... 5 2.2 Vorteile von CMIS ................................................................................................. 5 2.3 Anbindungen ......................................................................................................... 5 3 Voraussetzungen .................................................................................................... 7 3.1 Authentifizierung mittels Basic-Authentifizierung ................................................... 7 3.2 Authentifizierung mittels Kerberos ......................................................................... 8 4 CMIS-Funktionen in VIS ......................................................................................... 9 4.1 Verbindung zu einem VIS-Mandanten herstellen................................................... 9 4.1.1 Repository-Funktionen ........................................................................................ 11 4.1.2 Objekt-Funktionen ............................................................................................... 13 4.1.3 Navigations-Funktionen....................................................................................... 20 5 Beispiel .................................................................................................................. 22 6 Anhang .................................................................................................................. 25 6.1 Standard-Objekttypen und ihre IDs ..................................................................... 25 6.2 Abkürzungsverzeichnis ....................................................................................... 28

3

[Seite 4]

Einleitung

Begleitende Dokumente

1 Einleitung

In der öffentlichen Verwaltung kommen verschiedene und teils mehrere Dokumentenmanagement- und Vorgangssysteme sowie diverse Fachanwendungen zum Einsatz. CMIS (Content Management Interoperability Services) ist ein offener und herstellerunabhängiger Standard, dessen Ziel es ist, die Interoperabilität proprietärer Systeme herstellerübergreifend zu ermöglichen.

Mit der implementierten CMIS-Schnittstelle stehen nun für Fachanwendungen Funktionen zum Erstellen und Verwalten von Schriftgutobjekten und Geschäftsgängen in der VIS-Suite zur Verfügung. Basierend auf Webtechnologien werden die Systeme miteinander gekoppelt. Ebenso werden für die Kommunikation Webdienste genutzt. Eine effizientere Zusammenarbeit der Anwender der Systeme wird erreicht.

Dieses Dokument gibt einen Überblick über die Entwicklung des CMIS Standards, beschreibt die Voraussetzungen für den Einsatz von CMIS und den Funktionsumfang von CMIS in der VIS-Suite und erklärt anhand von Beispielen den Einsatz der Schnittstelle.

1.1 Begleitende Dokumente

Tabelle 1: Begleitende Dokumente

4

[Seite 5]

CMIS im Überblick

Entwicklung von CMIS und aktueller Stand

2 CMIS im Überblick

In diesem Kapitel wird erläutert, wie sich der CMIS-Standard entwickelt hat, welches Ziel hinter der Entwicklung steht und welche Vorteile der CMIS-Standard insbesondere für die öffentliche Verwaltung bietet.

G 2 ut

.1 Entwicklung von CMIS und aktueller Stand

CMIS (Content Management Interoperability Services) ist ein offener und herstellerunabhängiger Standard für eine Verbindung zu Content- und Dokumentenmanagementsystemen durch die Nutzung von Webprotokollen. Es werden standardisierte Dienste für den Zugriff auf Dokumente im ECM-System und deren Bearbeitung bereitgestellt. Diese Dienste ermöglichen es, Verwaltungstätigkeiten wie das Erstellen, Anzeigen, Aktualisieren, Löschen, Versionieren und die Rechtvergabe von Content jeglicher Art einheitlich über den Standard durchzuführen, ohne direkt mit dem jeweiligen ECM-System arbeiten zu müssen.

AIIM, ein internationaler Branchenverband für Informationsmanagement mit Mitgliedern aus Herstellern und Anwendern von ECM-Systemen, begann bereits im Jahre 2005 an der Arbeit an einem Standard für ECM. Später wurde die Entwicklung unter dem Dach von OASIS, ein Konsortium für Webstandards bestehend aus namhaften Unternehmen vorangetrieben. Im Mai 2010 wurde schließlich die Version 1.0 offiziell veröffentlicht. Aktuell liegt die Version 1.1 als OASIS Standard vom 23. Mai 2013 vor.

2.2 Vorteile von CMIS

CMIS ermöglicht Zugriffe auf ECM-Systeme zu vereinheitlichen und die Interoperabilität zwischen proprietären Softwaresystemen. Es ist nicht notwendig, die jeweiligen Besonderheiten des ECM-Systems zu kennen.

So lassen sich ECM-Systeme deutlich einfacher in eine bestehende Fachverfahrenslandschaft integrieren und eine realistische Einhaltung der E-Government- Vorgaben ist möglich.

Da die CMIS-Dienste auf Standards basieren, müssen nicht erst noch projektspezifische bzw. herstellerspezifische Schnittstellen entwickelt werden. Finanzielle Risiken bei der Einführung eines neuen ECM-Systems reduzieren sich und die Verwaltung der Softwaresysteme wird vereinfacht.

2.3 Anbindungen

Standardmäßig werden über CMIS drei Möglichkeiten der Anbindung angeboten: • AtomPub-Anbindung • SOAP Webservice-Anbindung • Browser-Anbindung (JSON)

5

[Seite 6]

CMIS im Überblick

Anbindungen

Die Anbindung an das VIS-System erfolgt über AtomPub, die auf dem REST-konformen Atom Publishing Protocol basiert. Der CMIS-Standard erweitert das Protokoll um Funktionen, wie beispielsweise Zugriffskontrollen, Versionierung und die Hierarchie von Objekten.

Die Daten werden konform nach dem Atom Syndication Format übertragen. Dieses Format ist ein XML-Format und ermöglicht so einen plattformunabhängigen Datenaustausch. Für die Kommunikation werden die HTTP-Methoden GET, POST, PUT und DELETE genutzt.

Tabelle 2: HTTP-Methoden des AtomPub-Protokolls

Abbildung 1: Anbindungen an VIS über die AtomPub-Bindung

6

[Seite 7]

Voraussetzungen

Authentifizierung mittels Basic-Authentifizierung

3 Voraussetzungen

Es wird empfohlen, einen speziellen VIS-Nutzer anzulegen, der nur für die Verwendung der CMIS-Schnittstelle genutzt wird. Die Rechte dieses VIS-Nutzers werden beim Ausführen von Aktionen über VIS genutzt. Eine Anleitung zum Einrichten eines VIS-Nutzers finden Sie im »Handbuch Fachadministration«.

Die CMIS-Spezifikation sieht für die Authentifizierung ein Verfahren auf der http- Transportebene vor.

3.1 Authentifizierung mittels Basic-Authentifizierung

Der VIS-Nutzer für die CMIS-Schnittstelle muss für die Basic-Authentifizierung freigeschaltet sein.

Zusätzlich ergänzen Sie die folgenden Codezeilen, die hier als eigenständige Klasse realisiert sind. Die Klasse erweitert den »StandardAuthenticationProvider« dahingehend, dass ein HTTP-Header mitgeschickt wird, der den Server informiert, dass der Request-Client eine Service-Komponente ist, die mit Basic-Authentification arbeiten möchte.

// Java-Klasse: VISAuthProvider.java package [PACKAGE-PATH];

import java.util.Collections; import java.util.List; import java.util.Map; import org.apache.chemistry.opencmis.client.bindings.spi. StandardAuthenticationProvider;

public class VISAuthProvider extends StandardAuthenticationProvider{ @Override public Map<String, List> getHTTPHeaders(String url) { Map<String, List> headers = super.getHTTPHeaders(url); // To change body of generated methods, // choose Tools | Templates. headers.put("X-vis-apply-basic-auth", Collections.singletonList("true")); return headers; } }

7

[Seite 8]

Voraussetzungen

Authentifizierung mittels Kerberos

3.2 Authentifizierung mittels Kerberos

Soll die CMIS-Schnittstelle nur innerhalb des Unternehmensnetzes verfügbar sein, so besteht theoretisch1 auch die Möglichkeit, mit dem Kerberos-Verfahren zu authentisieren.

1 PDV ist derzeit kein CMIS-Client-Framework bekannt, welches Kerberos unterstützt.

8

[Seite 9]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

4 CMIS-Funktionen in VIS

In diesem Kapitel werden alle CMIS-Funktionen vorgestellt, die von der aktuellen VIS-Suite bereitgestellt werden. Die Funktionalitäten werden anhand von kleinen Beispielen in Java veranschaulicht.

Tabelle 3: Übersicht über CMIS-Funktionen in VIS

4.1 Verbindung zu einem VIS-Mandanten herstellen

In diesem Kapitel wird erläutert, wie Sie eine Verbindung über CMIS zu einem VIS- Mandanten herstellen, um im Anschluss Daten über die Schnittstelle abzurufen oder zu bearbeiten.

9

[Seite 10]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

Für eine Verbindung sind die folgenden Parameter notwendig: • Deklaration der Parameter

// Deklaration SessionFactory sessionFactory = SessionFactoryImpl.newInstance(); Map<String, String> parameter = new HashMap<>(); Repository repository; Session session;

• Verbindungsparameter Die Endpoint/URL für die Schnittstelle an VIS setzt sich folgendermaßen zusammen:

// Endpoint/URL // http://[Servername].[Domain]:[Port]/vis/[Mandantenkennung]/cmis String endpoint = "http://visserver.pdv.lan:8080/12345A67-B890-123C- 45D6-7E8901F234G8/cmis";

Verbindungstyp ist AtomPub:

// AtomPub als Verbindungstyp festlegen parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value()); parameter.put(SessionParameter.ATOMPUB_URL, endpoint);

• Authentifizierung gegenüber VIS Zur Authentifizierung gegenüber dem VIS-Server ist ein spezieller Nutzer notwendig (3 Voraussetzungen).

// Benutzerdaten übergeben parameter.put(SessionParameter.USER, "username"); parameter.put(SessionParameter.PASSWORD, "password");

• Verbindungsaufbau

// Erstes Element der Liste der Repositories wird zurückgegeben // Bei VIS: 1 Repository = 1 Mandanten repository = sessionFactory.getRepositories(parameter).get(0); session = repository.createSession();

10

[Seite 11]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

4.1.1 Repository-Funktionen

Die Repository-Funktionen liefern Informationen zu den Repositories des VIS-Mandanten zurück. Bei VIS entspricht ein Repository einem Mandanten, d. h. bei einer Verbindung ist immer nur ein Repository verfügbar. Neben allgemeinen Informationen wie der Name oder die ID der Datenbank können auch Details zu den Objekttypen und abgeleiteten Objekttypen in der Datenbank abgefragt werden.

• getRepositories

Die Funktion liefert eine Liste der zur Verfügung stehenden Repositories zurück, die über die angegebene Schnittstelle erreichbar sind. Bei VIS enthält die Liste immer nur ein Element, da ein Repository gleich einem Mandanten ist.

Repository repository = session.getRepositories(parameter).get(0);

• getRepositoryInfo Über diese Funktion erhalten Sie Informationen zum angefragten Datendepot, wie z. B. den Namen, die ID des Hauptknotens (Rootfolder-ID), die unterstützte CMIS- Version.

RepositoryInfo repInfo = session.getRepositoryInfo(); // Ausgabe des Namens des Repositories (= Name des Mandanten) System.out.printf("Name: %s\n", repInfo.getName()); // ID des Wurzelknotens System.out.printf("RootFolderID: %s\n", repInfo.getRootFolderID());

• getTypeChildren Es wird eine Liste mit den von einem angegebenen Objekttypen abgeleiteten Objekttypen zurückgegeben.

// Abfrage der Basisobjekttypen, die das Repository unterstützt ItemIterable typeChildren = session.getTypeChildren(null, false); for (Iterator it = typeChildren.iterator(); it.hasNext();) { ObjectType objType = it.next(); System.out.printf("Name: %s, ID: %s\n", objType.getDisplayName(), objType.getID()); }

11

[Seite 12]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

Das Beispiel liefert als Ergebnis die Basisobjekttypen cmis:document, cmis:folder und cmis:item. Ersetzen Sie den ersten Parameter in der Funktion durch den Objekttyp cmis:item, liefert die Funktion die abgeleiteten Objekttypen des Basisobjekttyps zurück. Das folgende Beispiel veranschaulicht, wie alle verpflichtenden Attribute des Objekttyps cmis:item ausgegeben werden können:

// Abfrage der Objekttypen von "cmis:item" inkl. aller Attribute ItemIterable typeChildren = session.getTypeChildren("cmis:item", true); for (Iterator it = typeChildren.iterator(); it.hasNext();) { ObjectType oType =it.next(); Map<String, PropertyDefinition<?>> propDef = oType.getPropertyDefinitions(); System.out.printf("Bezeichnung: %s, ID: %s – Anzahl der Attribute: %d\n", oType.getDisplayName(), oType.getId(), propDef.size();

for (Map.Entry e : propDef.entrySet()) { if (((PropertyDefinition)e.getValue()).isRequired()) System.out.printf("ID: %s, Bezeichnung: %s\n", e.getKey(), propDef.get(e.getKey()).getDescription()); } } // ********************* // Ausgabe // ********************* Bezeichnung: VIS Item, ID: vis:item - Anzahl der Attribute: 13 ID: cmis:name, Bezeichnung: Name ID: cmis:objectTypeId, Bezeichnung: Object Type Id

12

[Seite 13]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

• getTypeDescendants Die Funktion liefert für die Datenbank definierte Objektdefinitionen in hierarchischer Form zurück.

// Abfrage der Objekttypdefinition der Akte (ID 1) und Anzeige der // Bezeichnung und ID List<Tree>tree = session.getTypeDescendants("1",1,false); tree.forEach(t -> System.out.printf( "Bezeichnung: %s, ID: %s\n", t.getItem().getDisplayName(), t.getItem().getID()));

• getTypeDefinition Die Funktion gibt die Definition für den angegebenen Objekttypen zurück.

// Abfrage der Definition einer Aktennotiz (ID -70) ObjectType objType = session.getTypeDefinition("-70", true); System.out.printf("DisplayName: %s, QueryName: %s, Erzeugbar: %s", objType.getDisplayName(), objType.getQueryName(), objType.isCreatable());

Zusätzlich werden noch die Definitionen aller Attribute ausgegeben.

Map<String, PropertyDefinition<?>> propDef = objType.getPropertyDefinitions(); System.out.printf("Bezeichnung: %s(ID: %s) – Anzahl der Attribute: %d\n\n", objType.getDisplayName(), objType.getId(), propDef.size()); for (Map.Entry e : propDef.entrySet()) System.out.printf("Attribut: %s, Definition: %s\n", e.getKey(), e.getValue());

4.1.2 Objekt-Funktionen

• createDocument Die Funktion erstellt ein Dokument des angegebenen Objekttyps. Der Objekttyp wird über die Eigenschaft »cmis:objectTypeId« zugewiesen. Ein Dokument (»vis:document«) in CMIS entspricht einer Datei in VIS.

13

[Seite 14]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

Im nachfolgenden Beispiel wird eine PDF-Datei dem Dokument »Bescheid« hinzugefügt. Der Pfad des Bescheids wird als bekannt vorausgesetzt. Die PDF-Datei befindet sich im Hauptverzeichnis C:\ und hat den Namen Bescheid.pdf.

Folder bescheid = (Folder)session.getObjectByPath("[FOLDER_PATH]"); String fileName = "abc.pdf"; String filePath = "C:/abc.pdf"; Path path = Paths.get(filePath); InputStream stream = new FileInputStream(filePath);

Map<String, String> docProps = new HashMap<>(); docProps.put(PropertyIds.NAME, fileName); docProps.put(PropertyIds.OBJECT_TYPE_ID, "vis:document"); ContentStream contentStream = session.getObjectFactory().createContentStream (fileName, Files.size(path), "application/pdf", stream);

bescheid.createDocument(docProps, contentStream, VersioningState.NONE);

• createFolder Diese Funktion erstellt einen Ordner des angegebenen Objekttyps an dem zugewiesenen Objekt. Ein Ordner in CMIS entspricht einem Schriftgutobjekt (z. B. Akte, Vorgang, Dokument) in VIS.

Um ein neues Geschäftsobjekt in VIS anzulegen, wird die Objekttyp-ID benötigt. Eine Übersicht der Standardgeschäftsobjekte und ihrer ID finden Sie in Kapitel 6.1 Standard-Objekttypen und ihre IDs.

14

[Seite 15]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

Im nachfolgenden Beispiel wird eine »Klage« (ID 70) (Untertyp eines »Vorgangs«) innerhalb einer bestehenden Akte angelegt. Der Pfad der Akte wird als bekannt vorausgesetzt.

Folder akte = (Folder)session.getObjectByPath("[FOLDER_PATH]"); String objTypeName = session.getTypeDefinition("70").getDisplayName(); // Ausgabe des Typs des Geschäftsobjektes, das erzeugt werden soll, // sowie des Namens und des Typs des Geschäftsobjektes, in dem das // neue Objekt erzeugt wird System.out.printf ("Geschäftsobjekt '%s' wird in Akte '%s' des Typs '%s' erzeugt\n", objTypeName, vorgang.getName(), vorgang.getType().getDisplayName());

// Definition einiger Eigenschaften für das neue Geschäftsobjekt Map<String, Object> props = new HashMap<>(); props.put("vis:kurzbez", "Klage"); props.put(PropertyIds.OBJECT_TYPE_ID, "70"); props.put("vis:betreff", "Betreff: Klage gegen A");

Folder vorgang = akte.createFolder(props); System.out.printf("ObjektID des neuen Vorgangs: %s\n", vorgang.getId());

// ************** // Ausgabe // ************** Geschäftsobjekt 'Klage' wird in Akte 'ABC' des Typs 'Fachakte' erzeugt ObjektID des neuen Vorgangs: 2345987

15

[Seite 16]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

• createItem Die Funktion erstellt ein Item des angegebenen Typs. GGV (Geschäftsgangverfügung) und WV (Wiedervorlage) sind Objekte des Basistyps »cmis:item«. Zum Erstellen einer neuen GGV übergeben Sie als Typ »vis:ggv« und für eine WV den Typ »vis:wv«. GGV und WV können nur Objekte des Basistyps »cmis:folder« erstellt werden. Ablagen (Typ »vis:ablage«) sind davon jedoch ausgeschlossen.

// Neue GGV für einen Vorgang anlegen Folder vorgang = (Folder)session.getObject("[OBJECT-ID]"); String ggvname = "Neue Aufgabe per CMIS"; Map<String, Object> itemProps = new HashMap<>(); itemProps.put(PropertyIds.NAME, ggvname); itemProps.put(PropertyIds.OBJECT_TYPE_ID, "vis:ggv"); itemProps.put("vis:kategorie", "141"); // Aufgabenbeschreibung itemProps.put("vis:aufgabe", ggvname); // Termin im Format Jahr, Monat, Tag itemProps.put("vis:termin", new GregorianCalendar(2021,1,14)); itemProps.put("vis:erlassen_fuer_id", "177"); itemProps.put("vis:erledigung", "Vermerk"); itemProps.put("vis:stufe",10);

Item item = vorgang.createItem(itemProps);

16

[Seite 17]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

// Neue WV für einen Vorgang anlegen

Folder vorgang = (Folder)session.getObject("[OBJECT_ID]"); String wvname = "Neue Aufgabe per CMIS"; Map<String, Object> itemProps = new HashMap<>(); itemProps.put(PropertyIds.NAME, wvname); itemProps.put(PropertyIds.OBJECT_TYPE_ID, "vis:wv"); itemProps.put("vis:aufgabe", wvname); //Termin im Format Jahr, Monat, Tag itemProps.put("vis:termin", new GregorianCalendar(2021,1,14)); itemProps.put("vis:erlassen_fuer_id", "177"); itemProps.put("vis:erledigung", "Vermerk"); // Angabe des Zyklus in Textform itemProps.put("vis:zyklus","jeder 01. des Monats");

Item item = a1.createItem(itemProps);

• getObject Es werden die angegebenen Informationen für das entsprechende Objekt zurückgegeben. Bei dem Objekt kann es sich dabei um ein Objekt des Typs »cmis:document« oder »cmis:folder« handeln.

// in Bezug auf das vorangegangene Beispiel wird die ID des erzeugten Vorgangs verwendet CmisObject cmisObj = session.getObject("[OBJECT-ID]"); // Ausgabe des Basisobjekttyps System.out.printf("Basistyp: %s", cmisObj.getBaseTypeId()); // ************** // Ausgabe // ************** Basistyp: CMIS_FOLDER

17

[Seite 18]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

• getContentStream Es wird entweder der Inhalt des angegebenen Dokumentes zurückgegeben oder die eines Dokumentes oder Ordners in Form eines »RenditionStreams«.

// Auslesen und Anzeige des Inhalts einer Textdatei Document doc = (Document)session.getObject("[ID Textdatei]"); ContentStream cs = doc.getContentStream(); if (cs != null) { String text = IOUtils.toString(cs.getStream(), "UTF-8"); System.out.printf("Inhalt der Datei:\n%s\n", text); } else System.out.printf("Datei ist leer.");

• setContentStream Der Inhalt des angegebenen Dokuments wird gesetzt.

// Leere Datei (schon angelegt) wird mit Text gefüllt Document emptyDoc = (Document)session.getObject("[OBJECT-ID]"); String docText = "Das ist mein Text."; byte[] content = docText.getBytes(); boolean overwrite = true, refresh = true; InputStream iStream = new ByteArrayInputStream(content); ContentStream contentStream = session.getObjectFactory().createContentStream ("Leer", Long.valueOf(content.length),"text/plain", iStream); emptyDoc.setContentStream(contentStream, overwrite, refresh);

18

[Seite 19]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

• deleteContentStream Es wird der Inhalt des Dokumentes gelöscht.

// Löschen des Inhalts einer Datei und Ausgabe der Dateigröße vor und // nach dem Löschen Document doc = (Document)session.getObject("[OBJECT-ID]"); System.out.printf("Dateigröße vor dem Löschen: %s Bytes\n", doc.getProperty("cmis:contentStreamLength").getValueAsString()); boolean refresh = true; doc.deleteContentStream(refresh); System.out.printf("Dateigröße nach dem Löschen: %s Bytes\n", doc.getProperty("cmis:contentStreamLength").getValueAsString());

• deleteObject Das angegebene Objekt wird gelöscht.

// Löschen einer Datei, Objekt-ID der Datei wird als bekannt // vorausgesetzt CmisObject cmisObj = session.getObject("[OBJECT-ID]"); cmisObj.delete();

19

[Seite 20]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

4.1.3 Navigations-Funktionen

• getChildren Diese Funktion liefert die in einem Verzeichnis abgelegten Objekte zurück. Unterstützt das Repository versionsabhängiges Ablegen von Dokumenten, muss die entsprechende Version des Dokumentes zurückgegeben werden, ansonsten die letzte Version oder Hauptversion des Dokumentes.

// Anzeige der Objekte eines Verzeichnis Folder folder = (Folder)session.getObject("[OBJECT-ID]"); ItemIterable children = folder.getChildren();

System.out.printf("Objekte in '%s' des Typs '%s':\n", folder.getName(), folder.getType().getDisplayName()); children.forEach(t -> System.out.printf("Bezeichnung: %s\n", t.getProperty("cmis:name").getValueAsString()));

• getDescendants Es werden alle in dem Verzeichnis abgelegten Objekte inklusive der in Unterordnern abgelegten Objekte zurückgegeben.

Unterstützt das Repository versionsabhängiges Ablegen von Dokumenten, muss die entsprechende Version des Dokumentes zurückgeben werden, ansonsten die letzte Version oder Hauptversion des Dokumentes.

Unterstützt das Repository das Ablegen von ein und demselben Dokument in mehreren Ordnern, muss das Dokument für jeden Ordner zurückgegeben werden.

// Anzeige der Objekte eines Verzeichnis sowie sämtlicher Unterobjekte Folder folder = (Folder)session.getObject("[OBJECT-ID]"); System.out.printf("Objekte und Unterobjekte in '%s':\n", folder.getName()); List<Tree> desc = folder.getDescendants(-1);

// Parameter -1 = alle Ebenen werden ausgelesen, ansonsten Anzahl der // Ebenen angeben for (Tree t : folder.getDescendants(-1)) printTree(t, "");

20

[Seite 21]

CMIS-Funktionen in VIS

Verbindung zu einem VIS-Mandanten herstellen

Funktion zur Ausgabe des Baumes:

private static void printTree(Tree tree, String tab) { System.out.printf("%s Objekt: %s vom Typ: %s\n", tab, tree.getItem().getName(), tree.getItem().getType().getDisplayName()); for (Tree t : tree.getChildren()) printTree(t, " "); }

• getFolderTree Diese Funktion liefert alle Unterordner eines angegebenen Ordners zurück. Im Gegensatz zur Funktion »getDescendants«, bei der alle Kind- und Kinderobjekte zurückgeliefert werden, gib die Funktion »getFolderTree« nur Objekte vom Typ »cmis:folder« zurück.

• getFolderParent Diese Funktion gibt den übergeordneten Ordner des angegebenen Ordners an. Diese Funktion ist nur auf Schriftgutobjekte (»cmis:folder«) und nicht auf Dateien anwendbar.

Folder folder = (Folder)session.getObject("[OBJECT-ID]"); Folder parent = folder.getFolderParent(); System.out.printf("Das Schriftgut '%s' befindet sich im Verzeichnis '%s' vom Typ '%s'", folder.getName(), parent.getName(), parent.getType().getDisplayName());

• getObjectParents Der oder die übergeordneten Ordner eines in einem Verzeichnis ablegbaren Objektes werden mittels dieser Funktion angegeben. Diese Funktion ist nur auf Dateien (»cmis:document«) anwendbar.

Document doc = (Document)session.getObject("[OBJECT-ID"); Folder folder = doc.getParents().get(0); System.out.printf("Elternobjekt des Dokuments '%s' ist '%s'\n", doc.getName(), folder.getName());

21

[Seite 22]

Beispiel

5 Beispiel

Im nachfolgenden Beispiel wird in zu einer bestehenden Akte mit der Kurzbezeichnung »cmis« ein neues internes Dokument hinzugefügt. Das interne Dokument hat den Objekttyp »Aktennotiz«. Anschließend wird in das erzeugte Dokument eine PDF-Datei aus der Dateiablage nach VIS kopiert. Das Beispiel deckt die Geschäftsfälle »Neues Schriftgutobjekt erstellen« sowie »Importieren/ Hochladen einer Datei« ab. Die Angaben in den eckigen Klammern [] müssen jeweils durch Ihre spezifischen Daten ersetzt werden.

// Aufbau einer Verbindung zur Datenbank SessionFactory sessionFactory = SessionFactoryImpl.newInstance(); Map<String, String> parameter = new HashMap<>();

// Übergabe der Parameter für die Verbindung: // - Anbindung per ATOMPUB // - URL des CMIS-Servers in der Form // "http://[Servername].[Domain].lan:[Port]/vis/ // [Mandanten-GUID]/cmis" ('cmis' = Name des Servlets)

// Festlegung des Typs der Anbindung per ATOMPUB parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());

// Übergabe der URL über die Atompub-Anbindung parameter.put(SessionParameter.ATOMPUB_URL, "http://srv-app1vis5dev.pd.lan:8084/vis/ F00C197F-EFD5-7362-7532-3AC09270D25C/cmis");

// Übergabe der Daten für die Nutzerauthentifizierung parameter.put(SessionParameter.USER, "[Nutzername]"); parameter.put(SessionParameter.PASSWORD,"[Passwort]");

// Sitzung herstellen Session session; Repository repo;

try { repo = sessionFactory.getRepositories(parameter).get(0); session = repo.createSession(); } catch (CmisConnectionException | CmisRuntimeException e) { // Fehlerbehandlung }

// Die Objekt-ID (941) wird hier übergeben.

22

[Seite 23]

Beispiel

Folder akte = (Folder)session.getObject(new ObjectIdImpl("941")); String objTypeName = session.getTypeDefinition ("-70").getDisplayName();

Map<String, Object> props = new HashMap<>();

// Setzen von einigen Metadaten

props.put("vis:kurzbez", args[0]); props.put(PropertyIds.NAME, args[0]);

// Objekttyp -70 entspricht der Aktennotiz

props.put(PropertyIds.OBJECT_TYPE_ID, "-70"); props.put("vis:betreff", args[1]);

Folder visDoc = akte.createFolder(props); String filePathStr = args[2]; Path filePath = Paths.get(filePathStr); String fileName = filePath.getFileName().toString();

if (Files.exists(filePath)) { Map<String, String> docProps = new HashMap<>(); docProps.put(PropertyIds.NAME, fileName); docProps.put(PropertyIds.OBJECT_TYPE_ID, "vis:document"); ContentStream contentStream = session.getObjectFactory().createContentStream(fileName, Files.size(filePath), "text/plain", Files.newInputStream(filePath));

visDoc.createDocument(docProps, contentStream, VersioningState.NONE); } else { System.out.printf("File '%s' does not exist.\n"); }

System.out.printf("Content of Akte '%s' with id %s:\n", akte.getName(), akte.getId());

ItemIterable fchds = akte.getChildren(); for (Iterator iterator = fchds.iterator(); iterator.hasNext();) { CmisObject next = iterator.next(); System.out.println(next.getName()); }

23

[Seite 24]

Beispiel

24

[Seite 25]

Anhang

Standard-Objekttypen und ihre IDs

6 Anhang

6.1 Standard-Objekttypen und ihre IDs

Tabelle 4: Übersicht über die Standardobjekttypen und ihre ID

Tabelle 5: Übersicht über die Standarduntertypen der Akte und ihre ID

25

[Seite 26]

Anhang

Standard-Objekttypen und ihre IDs

Tabelle 6: Übersicht über die Untertypen des Dokuments und ihre ID

26

[Seite 27]

Anhang

Standard-Objekttypen und ihre IDs

Tabelle 7: Übersicht über die Untertypen des Vorgangs und ihre ID

Tabelle 8: Übersicht über die Untertypen der Korrespondenz und ihre ID

Tabelle 9: Übersicht über die Untertypen der Mappe und ihre ID

27

[Seite 28]

Anhang

Abkürzungsverzeichnis

6.2 Abkürzungsverzeichnis

Tabelle 10: Verzeichnis der verwendeten Abkürzungen

28

[Seite 29]

Anhang

Abkürzungsverzeichnis

29