yaccl 0.1.5 → 1.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2be620b3ea23dd8af7f061906eb36770615248c4
-  data.tar.gz: df9cc9ddcb337eae01a20c6b844637c83071ff39
+  metadata.gz: 9199d278a1744c0fcfd31a290d40171fbba57a9d
+  data.tar.gz: 40f3bae9069f48696fe544760a44b90bf263d9c2
 SHA512:
-  metadata.gz: 9a0d541919670208cd3609a2f3a7ce82752f6e4834c94cdaa7bd35bef2d664da23e057ce500efc82f86b7738c21d6de9f44bf047e74a2cfc1e0179636ce0a976
-  data.tar.gz: 8af874ca863f0773d96c32f091eac49ea499d58db61aaff7ad214bf11d64126518fea02241e576e94bdfef442668c133076b11b1e33a629ef9ad6c7b66390636
+  metadata.gz: 0dc47bf5bb0cc9d71f5eb37fedc6f2dec2f204665d3d82bb0d2921583f225727136fb78c01d30f875fc69a32466ffadf6017d28eab17669886060dc035707d59
+  data.tar.gz: fb01d554a6688a03804b950df00a72eafb3d01a461d42feae11265cdfd2046c70f891439a01fa44eab98f4b8f5c021bfa1392a13cb2b4bd1daf22be2d00694ad

data/lib/yaccl/children.rb

@@ -0,0 +1,55 @@
+module YACCL
+  class Children
+
+    def initialize(folder, options)
+      options.stringify_keys!
+
+      @folder = folder
+      @repository = folder.repository
+      @connection = folder.repository.connection
+
+      @max_items = options['max_items'] || 10
+      @skip_count = options['skip_count'] || 0
+      @order_by = options['order_by']
+
+      @has_next = true
+    end
+
+    def next_results
+      result = do_get_children
+
+      @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_get_children.num_items
+    end
+
+
+    private
+
+    def do_get_children
+      result = @connection.execute!({ cmisselector: 'children',
+                                      repositoryId: @repository.id,
+                                      objectId: @folder.cmis_object_id,
+                                      maxItems: @max_items,
+                                      skipCount: @skip_count,
+                                      orderBy: @order_by })
+
+      results = result['objects'].map do |r|
+        ObjectFactory.create(r['object'], @repository)
+      end
+
+      QueryResult.new(results, result['numItems'], result['hasMoreItems'])
+    end
+
+  end
+end

data/lib/yaccl/connection.rb

@@ -0,0 +1,147 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'date'
+require 'typhoeus'
+require 'net/http/post/multipart'
+require 'multi_json'
+
+module YACCL
+
+  class CMISRequestError < Exception; end
+
+  class Connection
+
+    def initialize(service_url, username, password, headers = {})
+      @service_url = service_url
+      @username = username
+      @password = password
+      @headers = headers
+
+      @url_cache = {}
+    end
+
+    def execute!(params = {}, query = {}, headers = {})
+
+      url = get_url(params.delete(:repositoryId), params[:objectId])
+
+      params = transform_hash(params)
+
+      if params.has_key?(:cmisaction)
+        method = params.has_key?(:content) ? 'multipart_post' : 'post'
+        body = params
+      else
+        method = 'get'
+        body = nil
+        query.merge!(params)
+      end
+
+      response = perform_request(method: method,
+                                 url: url,
+                                 query: query,
+                                 body: body,
+                                 headers: headers)
+
+      result = response.body
+
+      content_type = if response.respond_to?(:content_type)
+        response.content_type
+      else
+        response.headers['Content-Type']
+      end
+
+      result = MultiJson.load(result) if content_type =~ /application\/json/
+      result = result.with_indifferent_access if result.is_a? Hash
+
+      unless (200...300).include?(response.code.to_i)
+        if result.is_a?(Hash) && result.has_key?(:exception)
+          raise CMISRequestError, "#{response.code} -- #{result[:exception]} -- #{result[:message]}"
+        else
+          raise CMISRequestError, "#{response.code} -- #{result}"
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def get_url(repository_id, cmis_object_id)
+      if repository_id.nil?
+        @service_url
+      else
+        urls = repository_urls(repository_id)
+        if cmis_object_id
+          urls[:root_folder_url]
+        else
+          urls[:repository_url]
+        end
+      end
+    end
+
+    def repository_urls(repository_id)
+      if @url_cache[repository_id].nil?
+        repository_infos = MultiJson.load(perform_request(url: @service_url).body , symbolize_keys: false)
+        raise "No repository found with ID #{repository_id}." unless repository_infos.has_key?(repository_id)
+        repository_info = repository_infos[repository_id]
+        @url_cache[repository_id] = { repository_url:  repository_info['repositoryUrl'],
+                                      root_folder_url: repository_info['rootFolderUrl'] }
+      end
+      @url_cache[repository_id]
+    end
+
+    def transform_hash(hash)
+      hash.reject! { |_, v| v.nil? }
+
+      if hash.has_key?(:content)
+        content = hash.delete(:content)
+        hash[:content] = UploadIO.new(content[:stream],
+                                      content[:mime_type],
+                                      content[:filename])
+      end # Move to multipart_post?
+
+      if hash.has_key?(:properties)
+        props = hash.delete(:properties)
+        if props.is_a?(Hash)
+          props.each_with_index do |(id, value), index|
+            value = value.to_time if value.is_a?(Date) or value.is_a?(DateTime)
+            value = (value.to_f * 1000).to_i if value.is_a?(Time)
+            if value.is_a?(Array)
+              hash.merge!("propertyId[#{index}]" => id)
+              value.each_with_index { |v, idx|
+                hash.merge!("propertyValue[#{index}][#{idx}]" => value[idx])
+              }
+            else
+              hash.merge!("propertyId[#{index}]" => id,
+                          "propertyValue[#{index}]" => value)
+            end
+          end
+        end
+      end
+      hash
+    end
+
+    def perform_request(options)
+      if options[:method] == 'multipart_post'
+        multipart_post(options)
+      else
+        typhoeus_request(options)
+      end
+    end
+
+    def typhoeus_request(options)
+      options[:params] = options.delete(:query)
+      options[:followlocation] = true
+      options[:userpwd] = "#{@username}:#{@password}" if @username
+      Typhoeus::Request.new(options.delete(:url), options).run
+    end
+
+    def multipart_post(options)
+      url = URI.parse(options[:url])
+      req = Net::HTTP::Post::Multipart.new(url.path, options[:body])
+      options[:headers].each {|key, value| req[key] = value }
+      req.basic_auth @username, @password if @username
+      opts = url.scheme == 'https' ? { use_ssl: true , verify_mode: OpenSSL::SSL::VERIFY_NONE } : {}
+      Net::HTTP.start(url.host, url.port, opts) { |http| http.request(req) }
+    end
+
+  end
+end

data/lib/yaccl/document.rb

@@ -0,0 +1,62 @@
+module YACCL
+  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 YACCL::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/yaccl/folder.rb

@@ -0,0 +1,76 @@
+module YACCL
+  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/yaccl/helpers.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext'
+
+module YACCL
+  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'].inject({}) 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/yaccl/item.rb

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

data/lib/yaccl/object.rb

@@ -0,0 +1,122 @@
+module YACCL
+  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/yaccl/object_factory.rb

@@ -0,0 +1,27 @@
+module YACCL
+  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/yaccl/policy.rb

@@ -0,0 +1,26 @@
+module YACCL
+  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/yaccl/property_definition.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext'
+
+module YACCL
+  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/yaccl/query.rb

@@ -0,0 +1,53 @@
+module YACCL
+  class Query
+
+    def initialize(repository, statement, options)
+      options.stringify_keys!
+
+      @repository = repository
+      @connection = repository.connection
+
+      @statement = statement
+      @max_items = options['max_items'] || 10
+      @skip_count = options['skip_count'] || 0
+
+      @has_next = true
+    end
+
+    def next_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 do_query
+      result = @connection.execute!({ cmisselector: 'query',
+                                      repositoryId: @repository.id,
+                                      q: @statement,
+                                      maxItems: @max_items,
+                                      skipCount: @skip_count })
+
+      results = result['results'].map do |r|
+        ObjectFactory.create(r, @repository)
+      end
+
+      QueryResult.new(results, result['numItems'], result['hasMoreItems'])
+    end
+
+  end
+end