rdomino 0.0.2

data/lib/rdomino/database_collection.rb

@@ -0,0 +1,43 @@
+module Rdomino
+  
+  # Replicated
+  class DatabaseCollection
+    attr_reader :databases
+    include Enumerable
+    
+    class << self
+      def create_by_path *db_strings
+        dbs = db_strings.flatten.map do |db_string|
+          Database.new( nil, db_string)            
+        end
+        new dbs
+      end
+    end
+    
+    def initialize(databases)
+      @databases = databases
+    end
+    
+    def each
+      @databases.each do |database|
+        yield database
+      end
+    end
+    
+    def get_all_documents_by_key(view,key)
+      @databases.each do |database|
+        database[view].get_all_documents_by_key(key).each do|doc|
+          yield database.server, doc
+        end
+      end
+    end
+    
+    def method_missing(m,*args)
+      @databases.map do |database|
+        database.__send__(m,*args)
+      end
+    end
+      
+  end
+      
+end

data/lib/rdomino/database_directory.rb

@@ -0,0 +1,20 @@
+module Rdomino
+
+  class DatabaseDirectory
+    include DomObject, Enumerable
+    def initialize(server,pattern=//)
+      @obj = Session.session.getdbdirectory(server)
+      @pattern = pattern
+    end
+    
+    def each(pattern=nil)
+      db = @obj.getfirstdatabase(1247) # Any Notes database (NSF, NSG, or NSH file)
+      while db
+        yield(Database.new(nil,db)) if db.filepath.match(@pattern) 
+        db = @obj.getnextdatabase
+      end 
+    end
+        
+  end
+    
+end

data/lib/rdomino/database_library.rb

@@ -0,0 +1,34 @@
+module Rdomino
+
+  class DatabaseLibrary
+    
+    include Enumerable
+    attr_reader :database,:view
+    
+    def initialize(db)
+      @database = Database.new(db)
+      @view = database.get_view("DS2000/all")
+      @databases = {}
+      @views = {}
+    end
+    
+    def find(dbkey,key=nil)
+      unless @databases[dbkey]
+        doc = view.get_document_by_key(dbkey)
+        @databases[dbkey] = Database.new(database.server,doc.getItemValue("pathname")[0])
+      end
+      if key 
+        unless @views[dbkey]
+          @views[dbkey] = @databases[dbkey].get_view("(DirSync-G2)")
+          puts "| init view in #{dbkey}"
+        end
+        @views[dbkey].get_document_by_key(key)
+      else
+        @databases[dbkey]
+      end
+      #Openbyreplicaid(byval server as string, byval replicaid as string) as variant
+    end
+    
+  end  
+    
+end

data/lib/rdomino/databases/testdb.rb

@@ -0,0 +1,9 @@
+module Rdomino
+  module Databases
+    module Testdb
+      def foo
+        "bar"
+      end
+    end
+  end
+end

data/lib/rdomino/document.rb

@@ -0,0 +1,112 @@
+module Rdomino
+
+  class Document
+  
+    include DomObject, Enumerable, DbDcDoc
+    
+    def created
+      DateTime.strptime(obj.created,'%Y/%m/%d %H:%M:%S')
+    end
+    
+    def replace(h)
+      # puts "#{@obj}.send #{m} #{args.inspect}"
+      h.each do |item,value|
+        @obj.replaceItemValue(item.to_s,value)
+      end
+      self
+    end
+    
+    def get(item)
+      # puts "#{@obj}.send #{m} #{args.inspect}"
+      @obj.getItemValue(item.to_s)
+    end
+    
+    def g(item)
+      get(item)[0]
+    end
+
+    def form
+      getItemValue('Form')[0]
+    end
+    
+    # returns array of changed items
+    def update_attributes(h)
+      changed = []
+      h.each do |key,value|
+        unless g(key) == value 
+          changed << "#{key}:#{ self.g(key) }->#{value}"
+          @obj.replaceItemValue(key.to_s, value)
+        end
+      end
+      unless changed.empty?
+        save
+        changed.join(', ')
+      end 
+    end
+    
+    # 
+    def pp(by_type=nil)
+      if @obj
+        puts "\n#{self.getItemValue('Form')[0]}"
+        puts " %-22s %-32s" % ['id',id]
+        puts " %-22s %-32s" % ['unid',unid]
+        items = self.items.map{|i| [i.name,i.type,i.text]}.sort_by{|a| ( by_type ? a[1].to_s : "" )+a[0] }
+        items.each do |i| 
+          puts " %-22s %-10s %-30s" % i 
+        end
+      else
+        puts "empty!"
+      end
+      self
+    end
+    
+    def items
+      @obj.items.map{|i| Item.new(i)}
+    end
+    
+    def find_or_create_item(i)
+      replace i => '' unless obj.hasitem i.to_s 
+      self.[](i)
+    end
+    
+    def [](itemname)
+      Item.new(@obj.getfirstitem(itemname.to_s))
+    end
+    
+    def copy_to_database(destination) #as notesdocument
+      Document.new( obj.CopyToDatabase(destination.obj) )
+    end
+    
+    def move_to_database(destination)
+      target = copy_to_database(destination)
+      obj.remove(true)
+      target
+    end
+    
+    def create_empty_fields(fields)
+      changed = 0
+      fields.each do |field|
+        unless @obj.hasItem(field)
+          @obj.replaceItemValue(field,'')
+          changed += 1
+        end
+      end
+      save if changed > 0
+      changed 
+    end
+    
+    def save( force=true, make_response=false )
+      @obj.save(force, make_response)
+    end
+    
+    def id
+      obj.noteid
+    end
+
+    def unid
+      obj.universalid
+    end
+        
+  end
+
+end

data/lib/rdomino/document_collection.rb

@@ -0,0 +1,41 @@
+module Rdomino
+  
+  class DocumentCollection
+    include DomObject, Enumerable, DcView, DbDcDoc
+    def initialize(o)
+      @obj = o
+    end
+
+    def first
+      Document.new(@obj.getfirstdocument )
+    end
+
+    def last
+      Document.new(@obj.getlastdocument )
+    end
+            
+    def update_attributes( hash )
+      message = hash.map { |k,v| "FIELD #{k}:=#{v}"}.join("; ")
+      if obj.count == 0
+        0
+      elsif ask("Should I stamp #{obj.count} Documents in #{obj.parent.title} () ?  (y/n)") == "y"
+        update_attributes!( hash )
+      end
+    end
+    
+    def each_limit(limit=2)
+      each_with_index do |doc,index|
+        break if index >= limit
+        yield doc
+      end
+    end
+
+    def update_attributes!( hash )
+      hash.each do |k,v|
+          obj.stampall(k.to_s, v )
+      end
+      obj.count
+    end
+  end
+  
+end

data/lib/rdomino/item.rb

@@ -0,0 +1,57 @@
+module Rdomino
+  
+  class Item
+    include DomObject
+    TYPES = {16 => :actioncd,
+      17 => :assistantinfo,
+      1084 => :attachment,
+      1076 => :authors,
+      2 => :collation,
+      1024 => :datetimes,
+      1090 => :embeddedobject,
+      256 => :erroritem,
+      1536 => :formula,
+      21 => :html,
+      6 => :icon,
+      20 => :lsobject,
+      25 => :mime_part,
+      1074 => :names,
+      7 => :notelinks,
+      4 => :noterefs,
+      768 => :numbers,
+      1085 => :otherobject,
+      15 => :querycd,
+      1075 => :readers,
+      1282 => :rfc822text,
+      1 => :richtext,
+      8 => :signature,
+      1280 => :text,
+      512 => :unavailable,
+      0 => :unknown,
+      14 => :userdata,
+      1792 => :userid,
+      18 => :viewmapdata,
+      19 => :viewmaplayout}
+
+    def initialize(obj)
+      @obj = obj
+    end
+    
+    def type
+      a = @obj.Type
+      TYPES[a] || a
+    end
+    
+    def <<(s)
+      obj.AppendToTextList s 
+    end
+    
+#      RTELEM_TYPE_DOCLINK (5)
+#      RTELEM_TYPE_FILEATTACHMENT (8)
+#      RTELEM_TYPE_OLE (9)
+#      RTELEM_TYPE_SECTION (6)
+#      RTELEM_TYPE_TABLE (1)
+    
+  end
+
+end

data/lib/rdomino/name.rb

@@ -0,0 +1,9 @@
+module Rdomino
+  class Name
+    class << self
+      def abbreviated(s)
+        Session.session.Createname(s).abbreviated
+      end
+    end
+  end
+end

data/lib/rdomino/richtext_item.rb

@@ -0,0 +1,7 @@
+module Rdomino
+  
+  class RichtextItem
+    include DomObject
+  end
+
+end

data/lib/rdomino/server.rb

@@ -0,0 +1,22 @@
+module Rdomino
+  class Server
+    class << self
+      def [](a)
+        new(a)
+      end  
+    end
+    
+    # :days_ago
+    def log(pattern,time)
+      s = "Form='Events'"
+      @log.search(s,time).each{|d|
+        puts d.getItemValue("Eventlist").select{|line| line.match(pattern)}
+      }  
+    end
+    
+    def initialize(server='BY0000')
+      @log = Session.get["#{server}!!log.nsf"]
+    end
+  end
+
+end

data/lib/rdomino/session.rb

@@ -0,0 +1,115 @@
+module Rdomino
+  
+  class Session
+
+    class << self
+      
+      attr_reader :session
+      
+      # This is the entrypoint to the library. Without a parameter it load the RAILS environment
+      # or the test environment
+      # * production,plog
+      # * development: !!imbeh/server/path
+      # * test: !!imbeh/test/server/path
+      #
+      #   Session.get 'plog'
+      def get(env = ((defined? RAILS_ENV) ? RAILS_ENV.downcase : "test"), user=nil )
+        @session ||= begin
+          if env.kind_of? Symbol
+            user = env
+            env = "plog"
+          end
+          pw = prepare_notes_ini(user)
+          print "opening domino session in #{env} environment..."
+          s = WIN32OLE.new('Lotus.NotesSession')
+          s.Initialize( pw )
+          puts "#{s.commonUserName} logged in"
+          s
+        end
+        @singleton ||= new(env)
+      end
+      
+      def reload!
+        env = @singleton.env
+        @singleton = @session = nil
+        get(env)
+      end
+      
+      def prepare_notes_ini(user)
+        authentification = YAML.load_file(File.dirname(__FILE__)+"/../config/auth.yml")
+        unless user
+          return (respond_to?(:mypw) ? mypw : ask('Domino password ?') { |q| q.echo = '*' } )
+        end 
+        authentification[:me][:pw] = mypw
+        content = nil
+        File.open( authentification[:notes_ini], 'r') { |f| content = f.readlines }
+        File.open( authentification[:notes_ini], 'w') do |f|
+          content.each do |line|
+            key = line.split('=')[0]
+            if authentification[user].keys.include?(key)
+              f.write("#{key}=#{authentification[user][key]}\n")
+            else    
+              f.write(line)
+            end
+          end 
+        end
+        authentification[user][:pw]
+      end
+      
+      def addressbooks
+        @addressbooks ||= session.Addressbooks.map{|db| Database.new(nil,db) }
+      end
+      
+      def private_addressbooks
+        addressbooks.select{|db| db.Isprivateaddressbook }
+      end
+      
+      def locations
+        private_addressbooks[0].open!['search:form="Location"']
+      end
+      
+    end
+    
+    def initialize(env)
+      @env = env
+      @configuration = YAML.load_file(File.dirname(__FILE__)+"/../config/database.yml")
+      @configuration['test']={}
+      @configuration['development']={}
+      @configuration['production'].each do |k,v|
+        server = v.match(/^([^\/]*)/)[1]
+        path = v.split("!!")[1]
+        @configuration['test'][k] = "!!imbeh\\test\\#{server}\\#{path}" unless @configuration['test'][k]
+        @configuration['development'][k] = "!!imbeh\\#{server}\\#{path}" unless @configuration['development'][k]
+      end   
+      @db_view_cache = {} #{ :testdb => { nil => db, :key => view,  }, ....}
+    end
+    
+    attr_reader :configuration, :env
+    # ses = Session.get "test"
+    # ses[:db], d['server!!path'] => Database
+    # ses[:db,:viewname], d[:name, 'All Documents'] => View
+    # Databases and views will be cached in @@db { :db { nil => LotusDatabase, :view => LotusView, .. }, ...} 
+    def [](name, view=nil, key=nil)
+      if value = @db_view_cache[name]
+        db = value[nil]
+      else
+        db = Database.new(name,server_path(name))
+        value = @db_view_cache[name] = { nil => db}
+      end
+      unless cached = value[view]
+        view_string = ( view.kind_of?(Symbol) ? @configuration[name][view] : view )
+        cached = db[ view_string ] 
+        @db_view_cache[name][view] = cached if view.kind_of?(Symbol)
+      end 
+      ( key ?
+        cached.get_document_by_key(key,true) :
+        cached )
+    end
+  
+    def server_path(name)
+      name.kind_of?(Symbol) ? @configuration[@env][name] : name   
+    end
+         
+  end
+
+end