active_documentum 0.3.2-java

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 'Luke
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= Active Documentum
+
+Active Documentum is a gem designed to enable interactions with Documentum. Particularly using DQL (Documentum Query Language) to be more Active Record like. It was written quite some time ago to help me do administrative tasks.
+
+== Copyright
+
+Copyright (c) 2009 'Luke Chadwick'. See LICENSE for details.

data/lib/active_documentum.rb

@@ -0,0 +1 @@
+#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
  require entry
  autoload :DocbaseConfig, 'active_documentum/docbase_config'
  autoload :Session, 'active_documentum/session'
  autoload :Base, 'active_documentum/base'
  autoload :Schema, 'active_documentum/schema'
  
  autoload :QueryClient, 'active_documentum/query_client'
  autoload :SchemaClient, 'active_documentum/schema_client'
  autoload :ObjectClient, 'active_documentum/object_client'
  autoload :SearchClient, 'active_documentum/search_client'
  autoload :AccessControlClient, 'active_documentum/access_control_client'  
  ActiveDocumentum::DocbaseConfig.load
  Dir[File.join(File.dirname(__FILE__),'active_documentum/types')+'/*'].each do |file_name|
    autoload camelize(File.basename(file_name,'.rb')).intern, file_name
  end

data/lib/active_documentum/access_control_client.rb

@@ -0,0 +1 @@
+

data/lib/active_documentum/base.rb

@@ -0,0 +1 @@
+module ActiveDocumentum
   class Base
    @@table_name = nil 
    attr_accessor :attributes
  class << self # Class methods
  
    def establish_connection(attributes = {})
      DocbaseConfig.url = attributes[:url] unless attributes[:url].nil?
      DocbaseConfig.docbase = attributes[:docbase] unless attributes[:docbase].nil?
      DocbaseConfig.username = attributes[:username] unless attributes[:username].nil?
      DocbaseConfig.password = attributes[:password] unless attributes[:password].nil?
      nil
    end
    
    def find(*args)
      sym = args.first
      options = {}
      options = args.last if args.size > 1
      #validate_find_options(options)
      #set_readonly_option!(options)
      case sym
        when :first then find_initial(options)
        when :all   then find_every(options)
        else            find_from_ids(args, options)
      end
    end
    
    # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
    # same arguments to this method as you can to <tt>find(:first)</tt>.
    def first(*args)
      find(:first, *args)
    end
    # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
    # same arguments to this method as you can to <tt>find(:last)</tt>.
    def last(*args)
      find(:last, *args)
    end
    # This is an alias for find(:all).  You can pass in all the same arguments to this method as you can
    # to find(:all)
    def all(*args)
      find(:all, *args)
    end
    
    private
        def find_initial(options)
          options[:limit] = 1
          result = find_every(options)
          result.first if result.size > 0
        end
        def find_every(options)
          columns = (options[:columns] || "*")
          conditions = options[:conditions]
          order = options[:order]
          offset = (options[:offset] || 0).to_i
          page_size = (options[:page_size] || 500).to_i
          limit = options[:limit]
          query = "SELECT #{columns} FROM #{self.table_name}"
          where = ""
          unless conditions.nil?
            if conditions.is_a? Hash
              where = " WHERE "
              conditions.keys.each do |key|
              where += "#{key.to_s} = '#{conditions[key]}' AND "
              end
            where.chomp!(" AND ")
            elsif conditions.is_a? String
              where = " WHERE " + conditions
            end
          end
          query += where
          query += " ORDER BY " + order unless order.nil?
          @@connection ||= QueryClient.new
          total_results = @@connection.result_count(query).to_i
          unless limit.nil?
            total_results = limit.to_i
            page_size = limit.to_i if page_size.to_i > limit.to_i
          end
          results = []
          while(offset < total_results)
            execute(query, :page_size => page_size, :start_index => offset).each do |row|
            a = self.new(row)
              results << a
            end
            offset += page_size
          end
          return results
        end
        def find_from_ids(ids, options)
          expects_array = ids.first.kind_of?(Array)
          return ids.first if expects_array && ids.first.empty?
          ids = ids.flatten.compact.uniq
          case ids.size
            when 0
              raise StandardError, "Couldn't find #{name} without an ID"
            when 1
              result = find_one(ids.first, options)
              expects_array ? [ result ] : result
            else
              find_some(ids, options)
          end
        end
        def find_one(id, options)
          conditions = " AND (#{options[:conditions]})" if options[:conditions]
          options[:conditions] = "r_object_id = '#{id}'#{conditions}"
          # Use find_every(options).first since the primary key condition
          # already ensures we have a single record. Using find_initial adds
          # a superfluous :limit => 1.
          if result = find_every(options).first
            result
          else
            raise StandardError, "Couldn't find #{name} with ID=#{id}#{conditions}"
          end
        end
        def find_some(ids, options)
          conditions = " AND (#{options[:conditions]})" if options[:conditions]
          ids_list   = ids.map { |id| "'#{id}'" }.join(',')
          options[:conditions] = "r_object_id IN (#{ids_list})#{conditions}"
          result = find_every(options)
          # Determine expected size from limit and offset, not just ids.size.
          expected_size =
            if options[:limit] && ids.size > options[:limit]
              options[:limit]
            else
              ids.size
            end
          # 11 ids with limit 3, offset 9 should give 2 results.
          if options[:offset] && (ids.size - options[:offset] < expected_size)
            expected_size = ids.size - options[:offset]
          end
          if result.size == expected_size
            result
          else
            raise StandardError, "Couldn't find all IDs (#{ids_list})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
          end
        end
        
        # Drying up executes to a single QueryClient instance
        def execute(query, options = {})
          @@connection ||= QueryClient.new
          $log.debug query
          result = @@connection.execute(query, options)
          result
        end
  
  end
   model = self.new(attributes)
   result = model.save
  def delete
    query = "DELETE #{self.class.table_name} OBJECT"
    query += " WHERE r_object_id = '#{self.r_object_id}'"
    result = execute(query).first
  end
  
    @table_name = value
    return @table_name unless @table_name.nil?
    return self.name.gsub(/([A-Z])/, '_\1').downcase.reverse.chop.reverse
  # Method missing in this case returns an existing attribute if it exists
  # and can assign attributes, but only if they already exist. Will need
  # some work to round it out eventually.
  def method_missing(meth,*args)
      unless meth.to_s.include?('=') #TODO dodgy
        super if @attributes_cache[meth.to_s].nil?
        return @attributes_cache[meth.to_s]
      end
      key = meth.to_s.gsub("=", "")
      @attributes_cache[key] = args.first
      return @attributes_cache[key]
  end
    "<#{self.class.to_s} @attributes=#{@attributes_cache.inspect}/>"
  private
      #raise ReadOnlyRecord if readonly?
      new_record? ? create_record : update
  end
    # Updates the associated record with values matching those of the instance attributes.
    # Returns the number of affected rows.
    def update(attribute_names = @attributes.keys)
      query = "UPDATE #{self.class.table_name} OBJECT"
      @attributes_cache.keys.each do |key|
        query += " SET #{key.to_s} = '#{@attributes_cache[key]}'" 
      end
      query += " WHERE r_object_id = '#{self.r_object_id}'"
      result = execute(query).first
    end
    # Creates a record with values matching those of the instance attributes
    # and returns its id.
    def create_record
      query = "CREATE #{self.class.table_name} OBJECT"
      @attributes_cache.keys.each do |key|
        query += " SET #{key.to_s} = '#{@attributes_cache[key]}'" 
      end
      result = execute(query).first
      @new_record = false
      result
    end
    
    # Drying up executes to a single QueryClient instance
    def execute(query, options = {})
      @@connection ||= QueryClient.new
      $log.debug query
      result = @@connection.execute(query, options)
      result
    end
  end

data/lib/active_documentum/docbase_config.rb

@@ -0,0 +1 @@
+module ActiveDocumentum
  class DocbaseConfig
    @@config = {}
    def self.docbase
      load if @@config.empty?
      @@config[$environment]["docbase"] 
    end
    def self.docbase=(value)
      @@config[$environment] ||= {}
      @@config[$environment]["docbase"] = value
    end
    def self.username
      load if @@config.empty? or @@config.nil?
      @@config[$environment]["username"] 
    end
    def self.username=(value)
      @@config[$environment] ||= {}
      @@config[$environment]["username"] = value
    end
    def self.password
      load if @@config.empty? or @@config.nil?
      @@config[$environment]["password"] 
    end
    def self.password=(value)
      @@config[$environment] ||= {}
      @@config[$environment]["password"] = value
    end
    def self.url
      load if @@config.empty? or @@config.nil?
      @@config[$environment]["url"] 
    end
    def self.url=(value)
      @@config[$environment] ||= {}
      @@config[$environment]["url"] = value
    end
    def self.load
      $log.debug "Loading config"
      @@config.merge!(YAML.load(File.open('config/environment.yml')))
    end
  end

data/lib/active_documentum/logging.rb

@@ -0,0 +1,21 @@
+# Author::    Luke Chadwick  (mailto:luke.a.chadwick@gmail.com)
+# Copyright:: Copyright (c) 2010 Luke Chadwick
+# License::   Distributes under the same terms as Ruby
+#
+# The class handles logging for ActiveDocumentum
+module ActiveDocumentum
+  class Logging
+    def initialize()
+      include Log4r
+      $log = Logger.new($environment)
+      #$log.level = Log4r::INFO
+      format = PatternFormatter.new(:pattern => "[%l] %d :: %m")
+      stdout_outputter = Outputter.stdout
+      stdout_outputter.formatter = format
+      FileUtils.mkdir_p('log')
+      file = FileOutputter.new('fileOutputter', :filename => "log/#{$environment}.log",:trunc => false)
+      file.formatter = format
+      $log.outputters = stdout_outputter, file
+    end
+  end
+end

data/lib/active_documentum/object_client.rb

@@ -0,0 +1 @@
+module ActiveDocumentum
    def get(object_id)
      objIdentity = ObjectIdentity.new(ObjectId.new(object_id), ActiveDocumentum::DocbaseConfig.docbase)
      objectIdSet = ObjectIdentitySet.new()
      objectIdSet.addIdentity(objIdentity)
      operationOptions = OperationOptions.new()
      
      propertyProfile = PropertyProfile.new(PropertyFilterMode.const_get("ALL"))
      contentProfile = ContentProfile.new
      contentTransferProfile = ContentTransferProfile.new
    
      permissionProfile = PermissionProfile.new
      permissionProfile.setPermissionTypeFilter(PermissionTypeFilter.const_get("ANY"))
      operationOptions.setPermissionProfile(permissionProfile)
      contentTransferProfile.setTransferMode(ContentTransferMode.const_get("MTOM"))
      contentProfile.setFormatFilter(FormatFilter.const_get("ANY"))
      operationOptions.setContentTransferProfile(contentTransferProfile)
      operationOptions.setPropertyProfile(propertyProfile)
      operationOptions.setContentProfile(contentProfile)
      operationOptions.setProfile(contentProfile);
      
      dataPackage = @service.get(objectIdSet, operationOptions)
      return dataPackage.getDataObjects().get(0)
    end
    
    # Not finished!
    def create(object_type, name, folder_path, properties = {})
      # create a contentless document to link into folder
      #String repositoryName = defaultRepositoryName;
      obj_identity = ObjectIdentity.new(ActiveDocumentum::DocbaseConfig.docbase)
      dataObject = DataObject.new(obj_identity, object_type)
      dataObject.getProperties().set("object_name", name)
      # properties.each_pair do |key, value|
        # dataObject.getProperties().set(key, value)
      # end
      # add the folder to link to as a ReferenceRelationship
      object_path = ObjectPath.new(folder_path)
      folder_identity = ObjectIdentity.new(object_path,
      ActiveDocumentum::DocbaseConfig.docbase)
      folderRelationship = ReferenceRelationship.new()
      folderRelationship.setName(Relationship.const_get("RELATIONSHIP_FOLDER"))
      folderRelationship.setTarget(folder_identity)
      folderRelationship.setTargetRole(Relationship.const_get("ROLE_PARENT"))
      dataObject.getRelationships().add(folderRelationship)
      # create a new document linked into parent folder
      operationOptions = nil
      dataPackage = DataPackage.new(dataObject)
      result = @service.create(dataPackage, operationOptions)
      return result
    end
    
    # Not finished!
    # Expected format of an objects entry is {:object_type => "", :name => "", :path => "", :properties => {}}
    def create_many(objects = [])
      return if objects.empty?
      dataPackage = DataPackage.new
      obj_identity = ObjectIdentity.new(ActiveDocumentum::DocbaseConfig.docbase)
      objects.each do |object|
        dataObject = DataObject.new(obj_identity, object[:object_type])
        dataObject.getProperties().set("object_name", object[:name])
        # add the folder to link to as a ReferenceRelationship
        object_path = ObjectPath.new(object[:path])
        folder_identity = ObjectIdentity.new(object_path,
        ActiveDocumentum::DocbaseConfig.docbase)
        folderRelationship = ReferenceRelationship.new()
        folderRelationship.setName(Relationship.const_get("RELATIONSHIP_FOLDER"))
        folderRelationship.setTarget(folder_identity)
        folderRelationship.setTargetRole(Relationship.const_get("ROLE_PARENT"))
        unless object[:content].nil?
          dataObject.getProperties().set("a_content_type", "crtext")
          dataObject.getContents().add(FileContent.new("C:\\dummy_doc.txt", "crtext"))
        end
        dataObject.getRelationships().add(folderRelationship)
        dataPackage.addDataObject(dataObject)
      end
      # create a new document linked into parent folder
      operationOptions = nil
      
      result = @service.create(dataPackage, operationOptions)
      return result
    end

data/lib/active_documentum/query_client.rb

@@ -0,0 +1 @@
+module ActiveDocumentum
    results = []
    begin
     rescue RuntimeError => e
      $log.error e.message
      results << {:error => e.message}
     end
     return results
     elsif k.include?('ObjectId')
      return value.getValueAsString()

data/lib/active_documentum/schema.rb

@@ -0,0 +1,51 @@
+# Author::    Luke Chadwick  (mailto:luke.a.chadwick@gmail.com)
+# Copyright:: Copyright (c) 2010 Luke Chadwick
+# License::   Distributes under the same terms as Ruby
+#
+# This class handles high level access to Documentum schemas. It supports caching
+# of the schemas to the 'tmp/types' directory
+module ActiveDocumentum
+  class Schema
+    include Support
+  
+    @@sc = nil
+    @@schema = nil
+    
+    def initialize
+      @@sc ||= ActiveDocumentum::SchemaClient.new
+      @@schema ||= @@sc.schema_info
+      @base_dir = "lib/active_documentum/types/" #TODO find better way of doing this
+    end
+    
+    def load_type(type_name)
+      file_name = @base_dir + type_name + '.rb'
+      unless File.exists?(file_name)
+        type = @@sc.type_info(type_name)
+        class_name = camelize(type_name) 
+        parent_name = camelize(type[:parent_name]) unless type[:parent_name].empty?
+        parent_name ||= "ActiveDocumentum::Base"
+        # FIXME Needs to be cleaner
+        class_def = "# Author::    Luke Chadwick  (mailto:luke.a.chadwick@gmail.com)\n"
+        class_def += "# Copyright:: Copyright (c) 2010 Luke Chadwick\n"
+        class_def += "# License::   Distributes under the same terms as Ruby\n"
+        class_def += "#\n"
+        class_def += "# This class is an auto generated documentum object type\n"
+        class_def += "class #{class_name} < #{parent_name}\n"
+        type[:properties].each do |property|
+          class_def += "  # #{property[:name]} => #{property.inspect}\n"
+        end
+        class_def += "end"
+        FileUtils.mkdir_p(@base_dir)
+        File.open(file_name, 'w') {|file| file.puts class_def }
+      end
+      autoload class_name.intern, file_name
+    end
+    
+    def load
+      @@schema[:types].each do |name|
+        load_type(name)
+      end
+    end
+    
+  end
+end