cmis-ruby 0.2

data/lib/cmis/document.rb

@@ -0,0 +1,62 @@
+module CMIS
+  class Document < Object
+
+    def initialize(raw, repository)
+      super
+      cmis_properties %w( cmis:isImmutable cmis:isLatestVersion
+                          cmis:isMajorVersion cmis:isLatestMajorVersion
+                          cmis:isPrivateWorkingCopy cmis:versionLabel
+                          cmis:versionSeriesId cmis:isVersionSeriesCheckedOut
+                          cmis:versionSeriesCheckedOutBy
+                          cmis:versionSeriesCheckedOutId cmis:checkinComment
+                          cmis:contentStreamLength cmis:contentStreamMimeType
+                          cmis:contentStreamFileName cmis:contentStreamId )
+    end
+
+    def create_in_folder(folder)
+      r = connection.execute!({ cmisaction: 'createDocument',
+                                repositoryId: repository.id,
+                                properties: properties,
+                                objectId: folder.cmis_object_id,
+                                folderId: folder.cmis_object_id,
+                                content: @local_content })
+
+      ObjectFactory.create(r, repository)
+    end
+
+    def copy_in_folder(folder)
+      id = connection.execute!({ cmisaction: 'createDocument',
+                                 repositoryId: repository.id,
+                                 sourceId: cmis_object_id,
+                                 objectId: folder.cmis_object_id })
+
+      repository.object(id)
+    end
+
+    def content
+      connection.execute!({ cmisselector: 'content',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id })
+
+    rescue CMIS::CMISRequestError
+      nil
+    end
+
+    def set_content(stream, mime_type, filename)
+      content = { stream: stream,
+                  mime_type: mime_type,
+                  filename: filename }
+
+      if detached?
+        @local_content = content
+      else
+        update_change_token connection.execute!({ cmisaction: 'setContent',
+                                                  repositoryId: repository.id,
+                                                  objectId: cmis_object_id,
+                                                  content: content,
+                                                  changeToken: change_token })
+      end
+    end
+
+  end
+end

data/lib/cmis/folder.rb

@@ -0,0 +1,76 @@
+module CMIS
+  class Folder < Object
+
+    def initialize(raw, repository)
+      super
+      cmis_properties %w( cmis:parentId cmis:path
+                          cmis:allowedChildObjectTypeIds )
+    end
+
+    def parent
+      repository.object(parent_id) if parent_id
+    end
+
+    def allowed_child_object_types
+      return nil unless allowed_child_object_type_ids
+      allowed_child_object_type_ids.map { |type_id| repository.type(type_id) }
+    end
+
+    def children(options = {})
+      Children.new(self, options)
+    end
+
+    def create(object)
+      case object
+      when Relationship
+        raise "'cmis:relationship' is not fileable. Use Repository#create_relationship"
+
+      when Document
+        return object.create_in_folder(self)
+
+      when Folder
+        o = connection.execute!({ cmisaction: 'createFolder',
+                                  repositoryId: repository.id,
+                                  properties: object.properties,
+                                  objectId: cmis_object_id })
+
+      when Policy
+        o = connection.execute!({ cmisaction: 'createPolicy',
+                                  repositoryId: repository.id,
+                                  properties: object.properties,
+                                  objectId: cmis_object_id })
+      when Item
+        o = connection.execute!({ cmisaction: 'createItem',
+                                  repositoryId: repository.id,
+                                  properties: object.properties,
+                                  objectId: cmis_object_id })
+
+      else
+        raise "Unexpected base_type_id: #{object.base_type_id}"
+      end
+
+      ObjectFactory.create(o, repository)
+    end
+
+    def delete_tree
+      connection.execute!({ cmisaction: 'deleteTree',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id })
+    end
+
+    def add(object)
+      connection.execute!({ cmisaction: 'addObjectToFolder',
+                            repositoryId: repository.id,
+                            objectId: object.cmis_object_id,
+                            folderId: cmis_object_id })
+    end
+
+    def remove(object)
+      connection.execute!({ cmisaction: 'removeObjectFromFolder',
+                            repositoryId: repository.id,
+                            objectId: object.cmis_object_id,
+                            folderId: cmis_object_id })
+    end
+
+  end
+end

data/lib/cmis/helpers.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext'
+
+module CMIS
+  module Helpers
+
+    def initialize_properties(raw)
+      @properties = get_properties_map(raw)
+    end
+
+    def cmis_properties(properties)
+      properties.each do |property_name|
+        method_name = method_name(property_name)
+        class_eval "def #{method_name};@properties['#{property_name}'];end"
+        class_eval "def #{method_name}=(value);@properties['#{property_name}']=value;end"
+      end
+    end
+
+    def update_change_token(r)
+      if r['properties']
+        @change_token = r['properties']['cmis:changeToken']['value']
+      elsif r['succinctProperties']
+        @change_token = r['succinctProperties']['cmis:changeToken']
+      else
+        raise "Unexpected hash: #{r}"
+      end
+    end
+
+    private
+
+    def method_name(property_name)
+      if property_name == 'cmis:objectId'
+        'cmis_object_id'
+      else
+        property_name.gsub('cmis:', '').underscore
+      end
+    end
+
+    def get_properties_map(raw)
+      raw = raw.with_indifferent_access
+
+      if raw['succinctProperties']
+        result = raw['succinctProperties']
+      elsif raw['properties']
+        result = raw['properties'].reduce({}) do |h, (k, v)|
+          val = v['value']
+          val = v['value'].first if v['value'].is_a?(Array) and v['cardinality'] == 'single'
+          val = Time.at(val / 1000) if val and v['type'] == 'datetime'
+          h.merge(k => val)
+        end
+      else
+        result = {}
+      end
+
+      result.with_indifferent_access
+    end
+
+  end
+end

data/lib/cmis/item.rb

@@ -0,0 +1,11 @@
+module CMIS
+
+  class Item < Object
+
+    def initialize(raw, repository)
+      super
+    end
+
+  end
+
+end

data/lib/cmis/object.rb

@@ -0,0 +1,120 @@
+module CMIS
+  class Object
+
+    include Helpers
+
+    attr_reader :connection
+    attr_reader :repository
+    attr_accessor :properties
+
+    def initialize(raw, repository)
+      initialize_properties(raw)
+      cmis_properties %w( cmis:objectId cmis:baseTypeId cmis:objectTypeId
+                          cmis:secondaryObjectTypeIds cmis:name cmis:description
+                          cmis:createdBy cmis:creationDate cmis:lastModifiedBy
+                          cmis:lastModificationDate cmis:changeToken )
+
+      @repository = repository
+      @connection = repository.connection
+    end
+
+    def object_type
+      repository.type(object_type_id)
+    end
+
+    def delete
+      connection.execute!({ cmisaction: 'delete',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id,
+                            allVersions: true })
+    end
+
+    def update_properties(properties)
+      update_change_token connection.execute!({ cmisaction: 'update',
+                                                repositoryId: repository.id,
+                                                objectId: cmis_object_id,
+                                                properties: properties,
+                                                changeToken: change_token })
+    end
+
+    def parents
+      result = connection.execute!({ cmisselector: 'parents',
+                                     repositoryId: repository.id,
+                                     objectId: cmis_object_id })
+
+      result.map { |o| ObjectFactory.create(o['object'], repository) }
+    end
+
+    def allowable_actions
+      connection.execute!({ cmisselector: 'allowableActions',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id })
+    end
+
+    def relationships(direction = :either)
+      result = connection.execute!({ cmisselector: 'relationships',
+                                     repositoryId: repository.id,
+                                     objectId: cmis_object_id,
+                                     relationshipDirection: direction })
+
+      result['objects'].map { |r| Relationship.new(r, repository) }
+    end
+
+    def policies
+      result = connection.execute!({ cmisselector: 'policies',
+                                     repositoryId: repository.id,
+                                     objectId: cmis_object_id })
+
+      result.map { |r| Policy.new(r, repository) }
+    end
+
+    # By default removes from all folders
+    def unfile(folder = nil)
+      options = { repositoryId: repository.id,
+                  cmisaction: 'removeObjectFromFolder',
+                  objectId: cmis_object_id }
+      options[:folderId] = folder.cmis_object_id if folder
+
+      connection.execute!(options)
+    end
+
+    def move(target_folder)
+      object_parents = parents
+
+      unless object_parents.size == 1
+        raise 'Cannot move object because it is not in excatly one folder'
+      end
+
+      connection.execute!({ cmisaction: 'move',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id,
+                            targetFolderId: target_folder.cmis_object_id,
+                            sourceFolderId: object_parents.first.cmis_object_id })
+    end
+
+    def acls
+      connection.execute!({ cmisselector: 'acl',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id })
+    end
+
+    def add_aces(aces)
+      connection.execute!({ cmisaction: 'applyACL',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id,
+                            addACEs: aces })
+    end
+
+    def remove_aces(aces)
+      connection.execute!({ cmisaction: 'applyACL',
+                            repositoryId: repository.id,
+                            objectId: cmis_object_id,
+                            removeACEs: aces })
+    end
+
+    def detached?
+      cmis_object_id.nil?
+    end
+
+  end
+end

data/lib/cmis/object_factory.rb

@@ -0,0 +1,27 @@
+module CMIS
+  class ObjectFactory
+
+    def self.create(raw, repository)
+      case base_type_id(raw)
+      when 'cmis:folder' then Folder.new(raw, repository)
+      when 'cmis:document' then Document.new(raw, repository)
+      when 'cmis:relationship' then Relationship.new(raw, repository)
+      when 'cmis:policy' then Policy.new(raw, repository)
+      when 'cmis:item' then Item.new(raw, repository)
+      else raise "Unexpected baseTypeId: #{base_type_id}."
+      end
+    end
+
+    private
+
+    def self.base_type_id(raw)
+      if raw['properties']
+        raw['properties']['cmis:baseTypeId']['value']
+      elsif raw['succinctProperties']
+        raw['succinctProperties']['cmis:baseTypeId']
+      else
+        raise "Unexpected json: #{raw}"
+      end
+    end
+  end
+end

data/lib/cmis/policy.rb

@@ -0,0 +1,26 @@
+module CMIS
+  class Policy < Object
+
+    attr_reader :policy_text
+
+    def initialize(raw, repository)
+      super
+      cmis_properties %w( cmis:policyText )
+    end
+
+    def apply_to(object)
+      connection.execute!({ cmisaction: 'applyPolicy',
+                            repositoryId: repository_id,
+                            policyId: cmis_object_id,
+                            objectId: object.cmis_object_id })
+    end
+
+    def remove_from(object)
+      connection.execute!({ cmisaction: 'removePolicy',
+                            repositoryId: repository_id,
+                            policyId: cmis_object_id,
+                            objectId: object.cmis_object_id })
+    end
+
+  end
+end

data/lib/cmis/property_definition.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext'
+
+module CMIS
+  class PropertyDefinition
+
+    def initialize(hash = {})
+      @hash = hash.with_indifferent_access
+
+      @hash.each_key do |key|
+        class_eval "def #{key.underscore};@hash['#{key}'];end"
+        class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"
+      end
+    end
+
+    def readonly?
+      updatability == 'readonly'
+    end
+
+    def oncreate?
+      updatability == 'oncreate'
+    end
+
+    def readwrite?
+      updatability == 'readwrite'
+    end
+
+    def to_hash
+      @hash
+    end
+
+  end
+end

data/lib/cmis/query.rb

@@ -0,0 +1,100 @@
+module CMIS
+  class Query
+
+    # Options: from, page_size
+    def initialize(repository, statement, options = {})
+      @repository = repository
+      @statement = statement
+      @options = options.stringify_keys
+
+      init_options
+    end
+
+    # Options: limit
+    def each_result(options = {}, &block)
+      return enum_for(:each_result, options) unless block_given?
+
+      init_options
+      limit = parse_limit(options)
+      counter = 0
+
+      while has_next?
+        results.each do |object|
+          break unless counter < limit
+          yield object
+          counter = counter.next
+        end
+      end
+    end
+
+    # Options: limit
+    def each_page(options = {}, &block)
+      return enum_for(:each_page, options) unless block_given?
+
+      init_options
+      limit = parse_limit(options)
+      counter = 0
+
+      while has_next?
+        break unless counter < limit
+        yield r = results
+        counter += r.size
+      end
+    end
+
+    def results
+      result = do_query
+
+      @skip_count += result.results.size
+      @has_next = result.has_more_items
+      @total = result.num_items
+
+      result.results
+    end
+
+    def has_next?
+      @has_next
+    end
+
+    def total
+      @total ||= do_query.num_items
+    end
+
+    private
+
+    def init_options
+      @method = (@options['method'] || 'get').to_s.downcase
+      @max_items = @options['page_size'] || 10
+      @skip_count = @options['from'] || 0
+      @has_next = true
+    end
+
+    def parse_limit(options)
+      options.stringify_keys!
+      limit = options['limit'] || 10
+      limit = BigDecimal::INFINITY if limit == :all
+      raise 'Not a valid limit' unless limit.is_a? Numeric
+      limit
+    end
+
+    def do_query
+      params = { repositoryId: @repository.id,
+                 maxItems: @max_items,
+                 skipCount: @skip_count }
+      if @method == 'post'
+        params.merge!(cmisselector: 'query', q: @statement)
+      else
+        params.merge!(cmisaction: 'query', statement: @statement)
+      end
+
+      result = @repository.connection.execute!(params)
+
+      results = result['results'].map do |r|
+        ObjectFactory.create(r, @repository)
+      end
+
+      QueryResult.new(results, result['numItems'], result['hasMoreItems'])
+    end
+
+  end
+end