Draft CMIS

Document created by resplin Employee on Jun 6, 2015Last modified by alfresco-archivist on Aug 31, 2016
Version 6Show Document
  • View in full screen mode

Obsolete Pages{{Obsolete}}

The official documentation is at: http://docs.alfresco.com



Draft





none|250px|CMIS Logo




Table of Contents


Content Management Interoperability Services (CMIS)


What is CMIS?


IMPORTANT NOTE: This page is a work in progress. Please refer to the main Alfresco CMIS page for information
http://wiki.alfresco.com/wiki/CMIS

Content Management Interoperability Services (CMIS) is a specification that defines how Enterprise Content Management (ECM) systems exchange content. ECM implementations today have proprietary APIs and query interfaces. Typically, those APIs are language-dependent, which makes it difficult to work across multiple ECM applications or to make them interoperate. The CMIS specification aims to bridge the gap between multiple ECM solutions within organizations by allowing application developers to access the repositories using an application and platform independent method.

The stated CMIS objective is to:


'define a domain model and set of bindings, such as Web Service and RESTful AtomPub that can be used by applications to work with one or more Content Management repositories/systems'.

By delivering platform independence, CMIS promises to be as important for the ECM industry as SQL in the database industry.


Background


On September 10, 2008, Enterprise Content Management vendors EMC Corporation, IBM Corporation, and Microsoft Corporation announced the publication of Content Management Interoperability Services (CMIS), distributed as a ZIP archive with four prose documents and a collection of schemas, WSDLs, and XML instances.

On the same day, Alfresco announced the availability of the first implementation of the draft CMIS Specification.

On October 06, 2008, OASIS issued a public call for participation in a new technical committee chartered to define specifications for use of Web services and Web 2.0 interfaces to enable information sharing across content management repositories from different vendors. The OASIS CMIS TC works 'to standardize a Web services interface specification that will enable greater interoperability of Enterprise Content Management (ECM) systems. CMIS uses Web services and Web 2.0 interfaces to enable rich information to be shared across Internet protocols in vendor-neutral formats, among document systems, publishers and repositories, within one enterprise and between companies.'

Alfresco is a CMIS Technical Committee participant. Alfresco has provided its draft CMIS implementation to foster discussion, to provide a learning tool to gain hands-on experience, and to ensure a robust, implemented specification.


Going forward


As a contributing member of the draft technical specification, Alfresco is committed to growing the CMIS Community and being the leading Open Source CMIS member, driving development, discussion, and adoption of both CMIS and CMIS best practices.


Known CMIS implementations


Although the CMIS specification is still in a draft state, several initiatives are underway to implement both CMIS providers and clients.

Discussion of interoperability problems between CMIS clients or servers


CMIS providers (vendor repositories)


CMIS toolkits (Client APIs, protocol bindings, SPI, test repositories)


CMIS clients (user interfaces, tools)


Events


PlugFests (Compatibility Testing Events)


Core CMIS concepts


Domain model


CMIS defines a common domain model for content management repositories. It covers common types and allows for extending those types with additional properties and creating relationships between the types.


Data model


The Data model allows for the discovery of defined custom content types. Note that CMIS does not specify how to define content - that is repository-specific.


Services model


CMIS addresses a common set of content services. CMIS doesn't define all the
common services vendors might possibly implement, but it looks at broadly accepted services most
content applications require and most content repositories provide, such as check-in/check-out,
versioning, and others. Importantly, CMIS also provides a capability to discover which services a
particular repository supports.


Protocol bindings


CMIS defines a set of protocol bindings to interact with the model. This allows
application developers to connect to the model and invoke some of the services. Initial protocol
bindings detailed in the specification are the AtomPub binding for REST-style (HTTP and URL interaction) and the SOAP binding for Web Services.


Query language


CMIS has a standardized query language based on SQL and adding its own extensions for content management including:


  • Full text search
  • Multi-valued properties
  • Folder hierarchy queries

This query language is very powerful because it offers a standard way of finding and querying information
which will allow application vendors to run against any CMIS-compliant repository without having to
make any changes to their code.


Alfresco CMIS implementation


Alfresco's draft CMIS implementation is available as part of Alfresco Community. This allows developers to gain hands-on experience with the specification as a CMIS provider or client.


  • For up-to-date news on the Draft Implementation, see the CMIS Blog
  • To discuss the Draft Implementation or CMIS in general, visit the CMIS Forum

Architectural overview


The draft CMIS implementation provides:


The following architectural diagram represents the CMIS implementation with Alfresco:

none|450px|Alfresco Draft CMIS Implementation

When installed and started, the Alfresco Repository URI http://<host>:<port>/alfresco/service/api/cmis.html provides access to the Alfresco Draft CMIS Implementation, including reference documentation for the RESTful AtomPub binding, test harnesses and Web Service WSDL.


Specification compliance


Alfresco Labs (HEAD svn) currently supports the CMIS v0.61 specification.


Alfresco server


RESTful AtomPub binding


The Alfresco Content Repository provides the CMIS RESTful AtomPub v0.61 binding, an extension of the Atom Publishing Protocol. All CMIS RESTful AtomPub services are implemented as Alfresco Web Scripts and support all Web Script capabilities such as authentication, content negotiation, and tunneling.





Services binding


Browser binding


Web Services binding


The Alfresco Content Repository provides the CMIS Web Services v0.61 binding.


CMIS To Alfresco mapping


The Alfresco content repository is mapped to the CMIS technical specification as follows:


Repository Capabilities


  • Multi-filing -> TRUE
  • Unfiling -> FALSE
  • Version-specific-filing -> FALSE
  • PWC-Searchable -> TRUE
  • PWC-Updatable -> TRUE
  • Query-non-latest-versions -> FALSE 
  • Inner-join -> FALSE
  • Outer-join -> FALSE
  • Full-text-query -> Full-text + Properties

Model Mapping


  • Note: Node Refs are serialized ${sys:store_protocol}://${sys:store_id}/${sys:node-uuid}
  • Note: (*) - Not supported

Object properties


  • ObjectId -> sys:referencable node ref (as a String) + '/{versionLabel}' if versioned
  • Uri (*)
  • ObjectTypeId -> M2TypeDefinition.name (Note: refer to Meta Model mapping) as a String
  • CreatedBy -> cm:creator
  • CreationDate  -> cm:created
  • LastModifiedBy -> cm:modifier
  • LastModificationDate -> cm:modified
  • ChangeToken ->

Document (inc. Object) Properties


  • Name  -> cm:name
  • IsImmutable -> TRUE if cm:lockable.lockType == readonly || cm:versionable.auto-version == false
  • IsLatestVersion -> TRUE  (FALSE if PWC)
  • IsMajorVersion -> VersionService().getCurrentVersion().getVersionType() == VersionType.MAJOR   (FALSE if PWC)
  • IsLatestMajorVersion -> IS_MAJOR_VERSION
  • VersionLabel -> cm:versionLabel
  • VersionSeriesId -> sys:referencable node ref (as a String)
  • IsVersionSeriesCheckedOut -> TRUE if COCI.getWorkingCopy is not null
  • VersionSeriesCheckedOutBy -> if COCI.getWorkingCopy is not null cm:lockable.lockOwner
  • VERSION_SERIES_CHECKED_OUT_ID  -> if COCI.getWorkingCopy is not null then COCI.getWorkingCopy noderef (as a String)
  • CheckinComment -> VersionService().getCurrentVersion().getDescription()
  • ContentStreamAllowed -> ContentStreamAllowed.ALLOWED.toString()
  • ContentStreamLength -> cm:content.size
  • ContentStreamMimeType -> cm:content.mimetype
  • ContentStreamFilename-> cm:name
  • ContentStreamUri

Folder (inc. Object) properties


  • Name -> cm:name
  • ParentId -> primary parent node ref
  • AllowedChildObjecTypeIds -> M2ChildAssociationDefinition.targetClassName

Relationship (inc. Object) properties


  • ObjecTypeId -> M2AssociationDefinition.name (Note: refer to Meta Model mapping)
  • CreatedBy (*)
  • CreationDate (*)
  • LastModifiedBy (*)
  • LastModificationDate (*)
  • SourceId -> AssociationRef.sourceRef node ref
  • TargetId -> AssociationRef.targetRef node ref

Meta Model Mapping


Base Object Types


  • DOCUMENT_OBJECT_TYPE  -> cm:content type
  • FOLDER_OBJECT_TYPE  -> cm:folder type
  • RELATIONSHIP_OBJECT_TYPE  -> simulate (no natural mapping)

Note: This means any type outside the cm:content and cm:folder hierarchy is not exposed via the CMIS interface.


Object Type Definition


  • ObjectTypeId -> M2TypeDefinition.name - serialized as D|F|R|P/{prefix}_localName
  • ObjectTypeQueryName -> M2TypeDefinition.name - serialized as prefix_localName (Note: For above base types, use name as defined in CMIS spec)
  • ObjectTypeDisplayName  -> M2TypeDefinition.title
  • ParentTypeId  -> M2TypeDefinition.parentName - serialized as D|F|R|P/{prefix}_localName
  • RootTypeQueryName  -> as defined in CMIS spec
  • Description  -> M2TypeDefinition.description
  • Creatable  -> true for files and folders and false otherwise
  • Fileable  -> true for files and folders and false otherwise
  • Queryable -> true for files and folders and false otherwise
  • Controllable -> false
  • Versionable  -> true
  • ContentStreamAllowed  -> type == cm:content ? allowed : notallowed
  • AllowedSourceTypes -> Assocs - DD source definition if a valid CMIS type
  • AllowedTargetTypes -> Assocs - DD target definition if a valid CMIS type

Property Type Definition


  • PropertyName -> M2PropertyDefinition.name - serialized as prefix_localName
  • PropertyId -> M2PropertyDefinition.name - serialized as {uri}localName or just the CMIS propertyname
  • DisplayName -> M2PropertyDefinition.title
  • Description -> M2PropertyDefinition.description
  • IsInherited -> true if the type definition is inherited from a super type (or a mandatory aspect inherits from another aspect)
  • PropertyType -> M2PropertyDefinition.dataType (Note: refer to Property Type mapping)
  • Cardinality -> M2PropertyDefinition.isMultiValued
  • MaximumLength -> Set if there is an appropriate constraint
  • SchemaURI -> null
  • Encoding -> null
  • Choices  -> M2PropertyDefinition.constraints['list of values'], if any
  • OpenChoice  -> false
  • Required  -> M2PropertyDefinition.isMandatoryEnforced
  • DefaultValue  -> M2PropertyDefinition.defaultValue
  • Updatability  -> M2PropertyDefinition.isProtected
  • Queryable - if indexed
  • Orderable - if indexed and tokenisation supports ordering

Property Type Mapping


  • String -> d:text, d:mltext (server locale only?), d:category?
  • Decimal -> d:float, d:double
  • Integer -> d:int, d:long
  • Boolean -> d:boolean
  • DateTime  -> d:date, d:datetime
  • Uri
  • Id -> d:text
  • Xml
  • Html

Note:


  • ID Mapping - In the CMIS model a data type of d:qname, d:noderef is mapped to a CMIS ID in type and property definitions.  They are converted to text in the property mapping.
  • Alfresco data types not mapped - d:any, d:content, d:childassocref, d:assocref, d:path, d:locale, d:version
  • Any Alfresco property whose data type is not mapped to CMIS MUST be excluded from CMIS type definitions.

Permissions


Document


  • DeleteObject -> DeleteNode
  • UpdateProperties  -> WriteProperties
  • CheckOut  -> CheckOut
  • CancelCheckout  -> CancelCheckOut
  • CheckIn  -> CheckIn (on PWC)
  • DeleteAllVersions  -> TRUE
  • AddDocumentToFolder  -> LinkChildren
  • RemoveDocumentFromFolder
  • SetContentStream  -> WriteContent
  • DeleteContentStream  -> WriteProperties
  • GetAllVersions  -> TRUE
  • GetDocumentParents  -> TRUE
  • GetRelationships  -> TRUE
  • GetProperties  -> ReadProperties
  • GetContentStream  -> ReadContent
  • MoveObject  -> DeleteNode?

Folder


  • DeleteObject  -> DeleteNode
  • DeleteTree  -> DeleteNode
  • UpdateProperties  -> WriteProperties
  • GetChildren  -> ReadChildren
  • GetDescendants  -> ReadChildren
  • GetFolderParent  -> TRUE
  • GetProperties  -> ReadProperties
  • GetRelationships  -> TRUE
  • MoveObject  -> DeleteNode?

Relationship


  • DeleteObject  -> TRUE
  • UpdateProperties  -> N/A
  • GetProperties  -> N/A
  • GetRelationships

RESTful AtomPub binding test harness


The Alfresco test harness exercises the CMIS RESTful AtomPub binding. It's available in the following flavors:


  • JUnit test
  • Test Harness Web Page: http://<host>:<port>/alfresco/service/api/cmis.html

By default, the test executes against the Alfresco Draft CMIS Implementation. However, you can test any CMIS RESTful AtomPub binding provider by adjusting one or more of the following settings:


  • Service URI
  • Username/Password (BASIC HTTP Authentication, for now)
  • Validate Responses (against CMIS specification XSDs)
  • Trace Request/Responses
  • Argument Style (URL or Headers)

The test harness also doubles as a set of Java CMIS client samples:


Example of test harness as a web page:
none|550px|Alfresco CMIS Unit Tests


CMIS Query Language


The first part of the CMIS specification provides a definition of a standard query language for
CMIS. The query language is a form of SQL, which means the specification provides a mapping
between the domain model and the relational view of the model. This allows the CMIS repository to
be exposed as a relational database. Each object that can be queried is mapped as a relational type
or a virtual table.


Syntax


The CMIS Query Language is a subset of SQL-92, with some extensions specific to the content
management world. These extensions include:


  • ANY - ability to query multi-valued properties common in properties such as keywords;
  • IN_FOLDER() and IN_TREE() - ability to find documents and recursively descend a folder hierarchy; and,
  • CONTAINS() and SCORE() $ - to search text inside the content and relevance ranking of results.

These can be combined with traditional attribute search.

All capabilities of CMIS SQL are supported (except join between Types). The Alfresco FTS language may be embedded in the CMIS SQL contains() predicate.

Alfresco Aspects may also be queried as if they were tables and joined to Types by ObjectId.

SELECT D.*, O.* FROM DOCUMENT AS D JOIN CM_OWNABLE AS O ON (D.ObjectId = O.ObjectId)

Search by document name


Search by document author


Search by exact text


This query finds documents containing the text string 'Caribbean Central America Cruise Tour' picking out any DepartureDates (multi-value property) after January 1st 2010. It also sorts based on relevance of the search.


SELECT ObjectId, SCORE() AS Relevance, Destination, DepartureDates
FROM TravelBrochure
WHERE CONTAINS( FCARIBBEAN CENTRAL AMERICA CRUISE TOUR5 )
AND F2010-1-15

The content stream is not part of the SQL specification and cannot be returned through
querying as other services handle retrieving the content. Additionally, there are some optional
repository specific capabilities which can be discovered, such as the level of search support, and inner
and left outer joins support, among others.




Alfresco client


Talking to the Alfresco server


Soap binding client APIs


AtomPub binding client APIs


Talking to web services


Viewing documents


Connecting to the Alfresco server


Integrating CMIS clients with Alfresco


Apache Abdera


Apache Abdera is an implementation of the Atom Syndication Format (RFC 4287) and Atom Publishing Protocol (RFC 5023) specifications. The CMIS REST API binding is an extension of the Atom Publishing Protocol. Therefore, Apache Abdera may be used as a client library to any CMIS REST provider.

To support the custom CMIS schema, the Alfresco Draft Implementation provides a CMIS extension to Apache Abdera.


Alfresco and Joomla


The CMIS Joomla-Alfresco Integration project provides a mechanism to achieve the benefits of Alfresco and Joomla working together through a standards-compliant interface.

The following is an example of a Joomla! Site with an Alfresco module.

Joomla-Alfresco.png



Test the CMIS Joomla-Alfresco Demo yourself. Guest Login is demo/demo.


Alfresco and Drupal


The CMIS Drupal-Alfresco Integration project provides a mechanism to achieve the benefits of Alfresco and Drupal working together through a standards-compliant interface.

The following is an example of how Drupal can act as a CMIS client to Alfresco.

Drupal-Alfresco.png



Test the CMIS Drupal-Alfresco Integration Module yourself. Guest Login is demo/demo.


Building CMIS applications with Alfresco SURF


Frequently Asked Questions


  1. What is CMIS?
  2. What problem does CMIS address?
  3. What functionality does CMIS address?
  4. How does CMIS relate to other standards?
  5. Which vendors are involved in CMIS and how long have they been working on the Draft Specification?
  6. What will be the impact of CMIS on the ECM market?
  7. Why CMIS?
  8. How do I get access to the Draft Specification and what is the OASIS process?
  9. How can I start developing against the CMIS API today to prepare for tomorrow?
10. How can I participate and comment on the Specification?

Glossary


References


CMIS specification:


Alfresco CMIS Developer Toolbox:
To encourage developers to learn, explore and prototype CMIS, we've assembled the following collection of resources in the Content Community:


Alfresco CMIS materials:


EMC, IBM & Microsoft:


Outcomes