CMIS UG TMP

Document created by resplin Employee on Jun 6, 2015
Version 1Show Document
  • View in full screen mode

Obsolete Pages{{Obsolete}}

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




Table of Contents





  • 1.2 Alfresco CMIS API

  • 1.3 How is CMIS Mapped to Alfresco?

  • 1.4 How do I get Started?

  • 1.5 Use Cases / Scenarios




  • Updates to CMIS User Guide


    Introduction


    What is it


    We can pull this from existing content


    Concepts


    Objects


    Object represent the entities that are in the repository.  Each object has a type.  There are 4 base types defined by CMIS, Documents, Folders, Relationships and Policies.  Every object in the repository will be derived from one of these types.  An object will be identified by an Object ID and will have a set of properties associated with it.  The properties that an object has is defined by its Object Type. The CMIS specification does specify how new object types are created.

    In addition to the metadata properties that define object types, there are some additional attributes that govern some of the behavior of objects within the repository they are listed below


    • Versionable:  Can be versioned (only document objects are fileable)
    • Fileable: Can be filed in a folder (folder object must be fileable, relationship objects are not fileable).
    • Queryable: Can be queried (is mapped to a virtual table). Only folder and document objects can be queryable.
    • Controllable-Policy: Can have a policy applied to it. Policies are not controllable.
    • Controllable-ACL: Can have an ACL applied to it. Policies are not controllable.

    Properties


    Properties are named values that are associated with each object type.  Properties are of a specific type (date, integer, text etc...).  Properties can be single valued or multi valued, required or optional. Some properties may be read only or only updatable at certain times. One point to note is that properties can have different names associated with them their display name, ID and query name may all be different.


    Document Objects


    Document objects represent the enties that we really come to the repository for, the content. Document objects (and only document objects) may have Content Streams (the actual file associated with the document).  In some cases it makes sense to have document objects without content streams. Content streams exist only as part of a containing document object.  The content stream will have a mimetype associated with it. In addition to a content stream, a document object may contain one or more renditions (alternate views of the content).

    Documents objects are also the only objects that are versionable, or for which versions can be exposed via CMIS. Each version of a document object will have their own object ID.  All versions of a document make up a Version Series and will share a Version Series ID.


    Folder Objects


    Folder objects are containers used to organize the document objects within the repository.  With the obvious exception of the root folder, folder objects must have one and only one parent folder.  A folder has a folder path that is automatically generated representing its place in the repository's hierarchy. A folder object may be defined in a way the limits what object types can it can contain (for example, an accounting related folder could be defined to only contain document objects of type invoice). A folder object may have renditions (for example a folder may have a thumbnail as a rendition representing what is in the folder).


    Relationship Objects


    Relationship objects define a non-invasive two way relationships between two objects (source and target) in the repository. Manipulating the relationships should not effect any changes to either the source or target objects.  Relationship objects are optional for CMIS compliant repositories.


    Policy Objects


    Policy objects are optional repository specific objects that can be applied to controllable objects. The behavior of policies are not modeled by the CMIS specification.  A single policy object may be applied to multiple controllable objects and a single controllable object may have multiple policies applied to it.  In order to preserve referential integrity, a policy object can not be deleted if it is applied to one or more controllable objects.


    Renditions


    Renditions are alternate views of the content stream such as previews, PDF renditions and thumbnails. It is also possible to have a thumbnail rendition object without content streams (i.e. folders). Renditions attributes must include a Stream ID and a mimetype. Additional common attributes for rendition are length, title and kind.  The only kind of rendition that the CMIS specification defines is a thumbnail.  Thumbnail renditions should only include height and width as attributes.  The repository may define its own rendition types in addition to thumbnails.

    Renditions cannot be queried unless they have a Rendition Document ID, that allows them to be exposed as documents.


    Access Control


    Access control is used to specify who can do what with an object in the repository.  If the repository supports access control then access control lists are applied to each object within the repository.  Access control lists specify what types of access or permissions (read, write etc..) to an object are given to groups or users (known collectively as principles).  CMIS defines three permissions cmis:read, cmis:write and cmis:all.  When setting an ACL cmis:user can be used to represent the current authemticated user.


    Change Log


    The repository may have an optional change log that contains an entry for each change made to content in the repository.  Each entry has a Change Log Token.  The repository must expose the latest change log token if it support change logs. Change log entries include the object ID and the change type (created, updated, deleted or security). Armed with a change log token, a client could retrieve the list of objects that have been changed since the change was made.

    A change log need not contain every change for the life of the repository, but it must contain every change made since the earliest change in the log.


    What you can do with it


    Below is a list of all of the methods available to the client.  There is a brief summary of what functionality each method provides.  Keep in mind that some of these methods may not be supported in all repositories as they may provide optional functionality.

    Does it make sense to use the descriptions from the book for each of the services (page 72 and 73)


    Browsing The Repository


    Repository Services

    • Get Repositories: Get a list of repositories that can be accessed from this service endpoint.
    • Get Repository Info: Get information about the specified repository
    • Get Type Children, Get Type Descendants: Various ways to discover the object types in a repository
    • Get Type Definition: Get the definition (list of properties) of the specified type.
    Navigation Services

    • Get Folder Tree, Get Descendants, Get Children: Retrieve descendant objects (each one has slightly different nuances).
    • Get Folder Parent, Get Object Parents: Retrieve an object's parent folder(s).
    • Get Checkedout Docs: Retrieve list of checked out documents.
    Discovery Services

    • Query: Execute a CMIS query
    • Get Content Changes: Gets a list of changes to the repository.  The client can provide an optional change log token that would specify the first event to be included in the list.

    Inspecting Objects


    Object Services

    • Get Object, Get Object By Path: Retrieve objects
    • Get Properties, Get Allowable Actions, Get Renditions: Get information about objects
    • Get Content Stream: Retrieve an object's content stream.
    Versioning Services

    • Get Properties Of Latest Version, Get Object Of Latest Version: Get information about latest version of object
    • Get All Versions: Retrieve an object's version history.
    Relationship Services

    • Get Object Relationships: Get the relationships that an object is a part of
    Policy Services

    • Get Applied Policies: Get the policies that are applied to an object
    ACL Services

    • Get ACL: Get the permissions associated with an object

    Manipulating Objects


    Object Services

    • Create Relationship, Create Document, Create Document From Source, Create Policy, Create Folder: Create objects
    • Update Properties, Move Object: Update objects
    • Delete Object, Delete Tree: Remove objects
    • Set Content Stream, Delete Content Stream: Update content streams
    Versioning Services

    • Check Out, Check In, Cancel Check Out: Control locking/unlocking of an object for the purpose of updating
    • Delete All Versions: Remove version history.
    Multi-Filing Services

    • Add Object To Folder, Remove Object From Folder: File and un-file objects.  If Multi-filing is supported in the repository, then an object can be added to multiple folders. If un-filing is supported in the repository, then an object can be removed from all folders that it is filed in without deleting the object.
    Policy Services

    • Apply Policy, Remove Policy: Apply and remove policies to/from an object
    ACL Services

    • Apply ACL: Set the permissions associated with an object

    Alfresco CMIS API


    What we have implemented


    Content Provided From another source


    Why you would use it


    Maybe add some wording around the following:


    • Common language for accessing all repositories across the enterprise
    • Lower learning curve for building content centric applications
    • A way to do federated search
    • The ability to use Components Off The Shelf (COTS) to access content.

    How is CMIS Mapped to Alfresco?


    Content Provided From another source


    How do I get Started?


    Jeff Potts of Metaversant has created an excellent tutorial using Alfresco, to take you through an overview of the specification as well as provide you some real-world examples such as using curl to make GET, PUT, POST, and DELETE calls against Alfresco to perform CRUD functions on folders, documents, and relationships in the repository. If you’ve been dabbling with CMIS and you’ve struggled to find examples, particularly of POSTs, here you go


    Hello world approach - show me how to log in, authenticate, etc


    Add the following here:


    • Link to Jeff Potts Document
    • Code snippet like this from cmis_ls.php

    #Connect to CMIS repository
    $client=new CMISService($repo_url,$repo_username,$repo_password);

    #Get the Desired Folder
    $myfolder=$client->getObjectByPath($repo_folder);

    #Get the objects in the folder
    $objs=$client->getChildren($myfolder->id);

    #Iterate through the objects
    foreach ($objs->objectList as $obj) {
            if ($obj->properties['cmis:baseTypeId'] == 'cmis:document') {
                    print 'Document: ' . $obj->properties['cmis:name'] . '\n';
            } elseif ($obj->properties['cmis:baseTypeId'] == 'cmis:folder') {
                    print 'Folder: ' . $obj->properties['cmis:name'] . '\n';
            } else {
                    print 'Unknown Object Type: ' . $obj->properties['cmis:name'] . '\n';
            }
    }


    Use Cases / Scenarios


    Content centric, repository independent, applications


    Today most applications that rely on a database, give you a choice of which database is used on the back end.  The CMIS specification could make this possible for applications that rely on content.


    Applications to mine content across the enterprise


    Most large enterprises have content that is stored in multiple repositories, and for good reasons.  CMIS enables enterprises and system integrators to write applications that can leverage content from a heterogeneous mix of repositories.


    Transformation of consumer on line services


    Not sure if this fits in this case

    Now this may be a stretch, but as a consumer who is also a techie, I love to ponder innovative ways to use technology. Think about how much of our information we get on line, cell phone, banking, financial services, the list goes on.  Every interface is different and you have to remember a zillion passwords.  What if all of that information was exposed as CMIS compliant repositories that supported some sort of SSO like OpenID (or at least a secure version of that).  I could use one CMIS client to browse all of my information. This would also open up the possibility of creating mashups between all of my different on line accounts. What if I could link the image of the check that I wrote to pay my phone bill with the PDF of the bill. (OK so I am a dreamer!)
    CMIS
    Engineering Notes

    Attachments

      Outcomes