- Subscribe to RSS Feed
- Mark as New
- Mark as Read
- Bookmark
- Subscribe
- Printer Friendly Page
- Report Inappropriate Content
Obsolete Pages{{Obsolete}}
The official documentation is at: http://docs.alfresco.com
Table of Contents
- 1 Content Management Interoperability Services (CMIS)
- 2 Core CMIS concepts
- 3 Alfresco CMIS implementation
- 4 Alfresco server
- 4.1 RESTful AtomPub binding
- 4.2 Services binding
- 4.3 Browser binding
- 4.4 Web Services binding
- 4.5 CMIS To Alfresco mapping
- 4.5.1 Repository Capabilities
- 4.5.2 Model Mapping
- 4.5.3 Object properties
- 4.5.4 Document (inc. Object) Properties
- 4.5.5 Folder (inc. Object) properties
- 4.5.6 Relationship (inc. Object) properties
- 4.5.7 Meta Model Mapping
- 4.5.8 Base Object Types
- 4.5.9 Object Type Definition
- 4.5.10 Property Type Definition
- 4.5.11 Property Type Mapping
- 4.5.12 Permissions
- 4.5.13 Document
- 4.5.14 Folder
- 4.5.15 Relationship
- 4.6 RESTful AtomPub binding test harness
- 5 CMIS Query Language
- 6 Alfresco client
- 7 Integrating CMIS clients with Alfresco
- 8 Building CMIS applications with Alfresco SURF
- 9 Frequently Asked Questions
- 10 Glossary
- 11 References
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)
- Alfresco Draft CMIS Implementation
- Hosted Alfresco Draft CMIS Implementation (username/password=demo/demo) Alfresco CMIS Demo Site
- EMC Documentum
- IBM FileNet P8 Content Manager 4.0
- sensenet
- Day Software (hosted)
CMIS toolkits (Client APIs, protocol bindings, SPI, test repositories)
- Apache Chemistry
- CMIS FileShare by Florian Mueller
- NCMIS (.NET)
- PHP CMIS Client API Module
- Flex CMIS Client API
- CMIS Spaces ActionScript (Flex+Browser, Flex+AIR) Client APIs for both CMIS Atom REST and CMIS Web S...
CMIS clients (user interfaces, tools)
- CMIS Federated Search from AIIM iECM Demo
- Drupal CMIS Alfresco Module
- Joomla Integration
- Shane Johnson's Flex/AIR CMIS Browser Source code Google Group
- Steve Reiner's CMIS Spaces Flex+AIR and Flex+Browser Clients Source code Google Group
- Sten Andersons JavaFX Client
- Jan Pfitzner's Ext GWT Client
- Integrating External Document Repositories with SharePoint Server 2007
- sensenet CMIS Client sensenet CMIS Aggregation
Events
PlugFests (Compatibility Testing Events)
- Redmond Aug 08
- Basel Apr 09 Report Day 1 live Day 2 live and results Day 1 report Day 2 report Interop Videos
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:
- Support for the CMIS REST API Binding
- Support for the CMIS Web Services API Binding
- Support for the CMIS Query Language providing SQL-like querying of the repository including location, properties, and full-text
- Apache Abdera (Atom Syndication/Publishing Library) CMIS Extension
- A CMIS REST API Binding Test Harness
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.
- CMIS Web Scripts Reference
- Alfresco Repository CMIS Service Document: http://<host>:<port>/alfresco/service/api/cmis
Services binding
Browser binding
Web Services binding
The Alfresco Content Repository provides the CMIS Web Services v0.61 binding.
- Alfresco repository CMIS WSDL: http://localhost:8080/alfresco/cmis
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, dath, 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.
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.
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:
- OASIS CMIS: TC charter
- CMIS specification: v0.61
- CMIS News: press blog posts twitter Cover Pages
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:
- CMIS sample dashlets
- CMIS video that walks developers through the code
- CMIS trial of the draft CMIS implementation
- Alfresco Labs 3 Final download
Alfresco CMIS materials:
- Alfresco Press Release
- Read what our CTO, John Newton has to say about CMIS
- Alfresco CMIS Implementation Blog
- Alfresco CMIS Implementation Forum
- CMIS Top Ten Questions
- CMIS webinar recording on-demand
- One-minute CMIS Survey
EMC, IBM & Microsoft: