sakai-info 0.1.0 → 0.2.0

data/lib/sakai-info/user.rb

@@ -2,7 +2,7 @@
 #   SakaiInfo::User library
 #
 # Created 2012-02-17 daveadams@gmail.com
-# Last updated 2012-02-17 daveadams@gmail.com
+# Last updated 2012-02-24 daveadams@gmail.com
 #
 # https://github.com/daveadams/sakai-info
 #
@@ -17,31 +17,50 @@ module SakaiInfo
     @@cache = {}
     def self.find(id)
       if @@cache[id].nil?
-        user_id = eid = nil
-        DB.connect.exec("select user_id, eid from sakai_user_id_map " +
-                        "where user_id=:user_id or eid=:eid", id, id) do |row|
-          user_id = row[0]
-          eid = row[1]
-        end
-        if user_id.nil? or eid.nil?
+        eid = User.get_eid(id)
+        user_id = User.get_user_id(id)
+        if eid.nil? or user_id.nil?
           raise ObjectNotFoundException.new(User, id)
         end
 
-        DB.connect.exec("select first_name, last_name, type, " +
-                        "to_char(createdon,'YYYY-MM-DD HH24:MI:SS'), " +
-                        "to_char(modifiedon,'YYYY-MM-DD HH24:MI:SS') " +
-                        "from sakai_user where user_id=:userid", user_id) do |row|
-          first_name, last_name, type, created_at, modified_at = *row
-          first_name ||= ""
-          last_name ||= ""
-          @@cache[eid] =
-            @@cache[user_id] =
-            User.new(user_id, eid, (first_name+' '+last_name), type, created_at, modified_at)
+        row = DB.connect.fetch("select first_name, last_name, type, " +
+                               "to_char(createdon,'YYYY-MM-DD HH24:MI:SS') as created_at, " +
+                               "to_char(modifiedon,'YYYY-MM-DD HH24:MI:SS') as modified_at " +
+                               "from sakai_user where user_id=?", user_id).first
+        if row.nil?
+          raise ObjectNotFoundException.new(User, id)
         end
+        @@cache[eid] =
+          @@cache[user_id] =
+          User.new(user_id, eid,
+                   ((row[:first_name] || "") + " " + (row[:last_name] || "")).strip,
+                   row[:type], row[:created_at], row[:modified_at])
       end
       @@cache[id]
     end
 
+    @@id_cache = {}
+    def self.get_ids(id)
+      @@id_cache[id] ||=
+        DB.connect[:sakai_user_id_map].where({:user_id => id, :eid => id}.sql_or).first
+    end
+
+    def self.get_eid(id)
+      if ids = User.get_ids(id)
+        ids[:eid]
+      else
+        nil
+      end
+    end
+
+    def self.get_user_id(id)
+      if ids = User.get_ids(id)
+        ids[:user_id]
+      else
+        nil
+      end
+    end
+
     def initialize(id, eid, name, type, created_at, modified_at)
       @id = id
       @eid = eid
@@ -102,56 +121,46 @@ module SakaiInfo
 
     def preferences_xml
       if @preferences_xml.nil?
-        db = DB.connect
         @preferences_xml = ""
-        db.exec("select xml from sakai_preferences " +
-                "where preferences_id=:userid", @user_id) do |row|
-          REXML::Document.new(row[0].read).write(@preferences_xml, 2)
+        row = DB.connect[:sakai_preferences].filter(:preferences_id => @user_id).first
+        if not row.nil?
+          REXML::Document.new(row[:xml].read).write(@preferences_xml, 2)
         end
       end
       @preferences_xml
     end
 
     # finders/counters
-    @@total_user_count = nil
     def self.count
-      if @@total_user_count.nil?
-        @@total_user_count = 0
-        DB.connect.exec("select count(*) from sakai_user") do |row|
-          @@total_user_count = row[0].to_i
-        end
-      end
-      @@total_user_count
+      DB.connect[:sakai_user].count
     end
 
     def self.count_by_realm_id_and_role_id(realm_id, role_id)
-      count = 0
-      DB.connect.exec("select count(*) from sakai_realm_rl_gr " +
-                      "where realm_key = :realm_id " +
-                      "and role_key = :role_id", realm_id, role_id) do |row|
-        count = row[0].to_i
-      end
-      count
+      DB.connect[:sakai_realm_rl_gr].
+        filter(:realm_key => realm_id, :role_key => role_id).count
     end
 
     def self.find_by_realm_id_and_role_id(realm_id, role_id)
-      users = []
-      DB.connect.exec("select first_name, last_name, type, " +
-                      "to_char(createdon,'YYYY-MM-DD HH24:MI:SS'), " +
-                      "to_char(modifiedon,'YYYY-MM-DD HH24:MI:SS') " +
-                      "from sakai_user where user_id in " +
-                      "(select user_id from sakai_realm_rl_gr " +
-                      "where realm_key = :realm_id " +
-                      "and role_key = :role_id)", realm_id, role_id) do |row|
-        first_name, last_name, type, created_at, modified_at = *row
-        first_name ||= ""
-        last_name ||= ""
-        @@cache[eid] =
-          @@cache[user_id] =
-          User.new(user_id, eid, (first_name+' '+last_name), type, created_at, modified_at)
-        users << @@cache[eid]
-      end
-      users
+      # TODO: implement this correctly
+      #  (code below isn't going to work)
+      # users = []
+      # DB.connect.fetch("select first_name, last_name, type, " +
+      #                  "to_char(createdon,'YYYY-MM-DD HH24:MI:SS') as created_at, " +
+      #                  "to_char(modifiedon,'YYYY-MM-DD HH24:MI:SS') as modified_at " +
+      #                  "from sakai_user where user_id in " +
+      #                  "(select user_id from sakai_realm_rl_gr " +
+      #                  "where realm_key = ? " +
+      #                  "and role_key = ?)", realm_id, role_id) do |row|
+      #   first_name, last_name, type, created_at, modified_at = *row
+      #   first_name ||= ""
+      #   last_name ||= ""
+      #   @@cache[eid] =
+      #     @@cache[user_id] =
+      #     User.new(user_id, eid, (first_name+' '+last_name), type, created_at, modified_at)
+      #   users << @@cache[eid]
+      # end
+      # users
+      nil
     end
 
     # yaml/json serialization
@@ -177,13 +186,13 @@ module SakaiInfo
       }
     end
 
-    def membership_serialization
+    def sites_serialization
       {
         "sites" => self.membership.collect { |sm| sm.serialize(:user_summary) }
       }
     end
 
-    def question_pools_serialization
+    def pools_serialization
       if self.question_pool_count > 0
         {
           "question_pools" => self.question_pools.collect { |qp| qp.serialize(:user_summary) }
@@ -192,27 +201,27 @@ module SakaiInfo
         {}
       end
     end
+
+    def self.all_serializations
+      [:default, :sites, :pools]
+    end
   end
 
   class UserProperty
     def self.get(user_id, property_name)
-      db = DB.connect
-      value = nil
-      db.exec("select value from sakai_user_property " +
-              "where user_id=:user_id and name=:name", user_id, property_name) do |row|
-        value = row[0].read
+      row = DB.connect[:sakai_user_property].
+        filter(:user_id => user_id, :name => property_name).first
+      if row.nil?
+        nil
+      else
+        row[:value].read
       end
-      return value
     end
 
     def self.find_by_user_id(user_id)
-      db = DB.connect
       properties = {}
-      db.exec("select name, value from sakai_user_property " +
-              "where user_id=:user_id", user_id) do |row|
-        name = row[0]
-        value = row[1].read
-        properties[name] = value
+      DB.connect[:sakai_user_property].where(:user_id => user_id).all.each do |row|
+        properties[row[:name]] = row[:value].read
       end
       return properties
     end

data/lib/sakai-info/version.rb

@@ -1,3 +1,3 @@
 module SakaiInfo
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sakai-info
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - David Adams
@@ -15,10 +15,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-19 00:00:00 -06:00
+date: 2012-02-24 00:00:00 -06:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: A command line tool and a suite of libraries for representing the objects and relationships defined by a Sakai CLE database.
 email: daveadams@gmail.com
 executables: 
@@ -40,12 +67,10 @@ files:
 - lib/sakai-info/user.rb
 - lib/sakai-info/version.rb
 - lib/sakai-info/announcement.rb
+- lib/sakai-info/database.rb
 - lib/sakai-info/cli.rb
-- lib/sakai-info/instance.rb
-- lib/sakai-info/configuration.rb
 - lib/sakai-info/message.rb
 - lib/sakai-info/content.rb
-- lib/sakai-info/db.rb
 - lib/sakai-info/sakai_xml_entity.rb
 - bin/sakai-info
 - README.md
@@ -54,8 +79,8 @@ files:
 - ROADMAP.md
 has_rdoc: true
 homepage: https://github.com/daveadams/sakai-info
-licenses: []
-
+licenses: 
+- Public Domain
 post_install_message: 
 rdoc_options: []
 

data/lib/sakai-info/configuration.rb

@@ -1,288 +0,0 @@
-# sakai-info/configuration.rb
-#   SakaiInfo::Configuration library
-#
-# Created 2012-02-15 daveadams@gmail.com
-# Last updated 2012-02-19 daveadams@gmail.com
-#
-# https://github.com/daveadams/sakai-info
-#
-# This software is public domain.
-#
-
-module SakaiInfo
-  class NoConfigFoundException < SakaiException; end
-  class AlreadyConfiguredException < SakaiException; end
-  class InvalidInstanceNameException < SakaiException; end
-  class InvalidConfigException < SakaiException; end
-  class UnsupportedConfigException < InvalidConfigException; end
-  class MultipleConfigException < InvalidConfigException
-    def initialize
-      @exceptions = []
-    end
-
-    def add(instance_name, exception)
-      @exceptions << [instance_name, exception]
-    end
-
-    def count
-      @exceptions.length
-    end
-
-    def message
-      "Multiple config exceptions were found:\n  " +
-        @exceptions.collect{ |e| "#{e[0]}: #{e[1].message}" }.join("\n  ")
-    end
-  end
-
-  # config format assumptions:
-  #   a YAML string containing one of the following options:
-  #     - a single database connection spec
-  #     - eg:
-  #         ---
-  #         dbtype: oracle
-  #         dbsid: PROD
-  #         username: sakai
-  #         password: Sekrit1
-  #   OR:
-  #     - an "instances" key containing a hash of named connection specs
-  #     - with a "default" key naming the spec to use if none is specified
-  #     - eg:
-  #         ---
-  #         default: production
-  #         instances:
-  #           production:
-  #             dbtype: oracle
-  #             service: PROD
-  #             username: sakai
-  #             password: prodpass
-  #           test:
-  #             dbtype: oracle
-  #             service: TEST
-  #             host: testdb.host
-  #             port: 1521
-  #             username: sakai
-  #             password: testpass
-  #           dev:
-  #             dbtype: mysql
-  #             host: dbserver.hostname.int
-  #             port: 3306
-  #             username: sakai
-  #             password: ironchef
-  #             dbname: sakaidev
-  #           localdev:
-  #             dbtype: mysql
-  #             host: localhost
-  #             port: 3306
-  #             username: sakai
-  #             password: ironchef
-  #             dbname: sakailocal
-  #
-  #
-  # NOTES:
-  #  - Oracle connections should use either an alias defined in the
-  #    driver's tnsnames.ora file, or specify the host and port as the
-  #    test instance example above does
-  #
-  class Configuration
-    @@config = nil
-
-    # validate just a single database connection configuration hash
-    def self.validate_single_connection_config(config)
-      if config.nil?
-        raise InvalidConfigException.new("The config provided was nil")
-      end
-
-      if not config.is_a? Hash
-        raise InvalidConfigException.new("The config provided must be a Hash")
-      end
-
-      # we have to have a dbtype value or we can't validate
-      if config["dbtype"].nil?
-        raise InvalidConfigException.new("The config does not specify 'dbtype'")
-      end
-
-      # force lowercase to simplify comparisons
-      dbtype = config["dbtype"].downcase
-
-      if not %w(oracle mysql).include? dbtype
-        raise UnsupportedConfigException.new("Database type '#{dbtype}' is not supported.")
-      end
-
-      # now check per-dbtype requirements
-      if dbtype == "oracle"
-        %w(service username password).each do |required_key|
-          if config[required_key].nil? or config[required_key] == ""
-            raise InvalidConfigException.new("Oracle config requires values for 'service', 'username', and 'password'.")
-          end
-        end
-      elsif dbtype == "mysql"
-        %w(host username password dbname).each do |required_key|
-          if config[required_key].nil? or config[required_key] == ""
-            raise InvalidConfigException.new("MySQL config requires values for 'host', 'username', 'password', and 'dbname'.")
-          end
-        end
-      else
-        # we should never have made it here
-        raise UnsupportedConfigException.new("Database type '#{dbtype}' is not supported.")
-      end
-
-      # for both types, 'port' is optional but if it exists it must be a valid TCP port
-      if not config["port"].nil?
-        begin
-          port = config["port"].to_i
-          if port < 1 or port > 65535
-            raise
-          end
-        rescue
-          raise InvalidConfigException.new("Config value 'port' must be a valid TCP port number.")
-        end
-      end
-
-      # if we made it here the config is complete and well-formed
-      return true
-    end
-
-    # validate that configuration is complete and well-formed
-    def self.validate_config(config)
-      if config.nil?
-        raise InvalidConfigException.new("The config provided was nil")
-      end
-
-      if not config.is_a? Hash
-        raise InvalidConfigException.new("The config provided must be a Hash")
-      end
-
-      # if 'dbtype' exists, it will be a single database configuration
-      if config["dbtype"]
-        self.validate_single_connection_config(config)
-      else
-        # otherwise both 'default' and 'instances' keys are required
-        if config.keys.sort != ["default","instances"]
-          raise InvalidConfigException.new("The config must specify either 'dbtype' or both 'default' and 'instances'.")
-        end
-
-        # enforce types on the values of 'default' and 'instances'
-        if not config["default"].is_a? String
-          raise InvalidConfigException.new("The value of 'default' must be a String.")
-        end
-        if not config["instances"].is_a? Hash
-          raise InvalidConfigException.new("The value of 'instances' must be a Hash.")
-        end
-
-        # 'default' must be a string pointing to one of the 'instances' keys
-        if not config["instances"].keys.include? config["default"]
-          raise InvalidConfigException.new("The default instance '#{config["default"]}' was not among the instance names given: #{config["instances"].keys.inspect}")
-        end
-
-        # check the validity of each instance, collecting exceptions as we go
-        multi_exceptions = nil
-        config["instances"].keys.each do |instance_name|
-          begin
-            self.validate_single_connection_config(config["instances"][instance_name])
-          rescue InvalidConfigException => e
-            # create the object if it doesn't already exist
-            multi_exceptions ||= MultipleConfigException.new
-
-            # add this exception to the list
-            multi_exceptions.add(instance_name, e)
-          end
-          # continue the loop no matter what
-        end
-
-        # if this object was created, the exception needs to be raised
-        if not multi_exceptions.nil?
-          raise multi_exceptions
-        end
-      end
-
-      # if we've made it this far, the configuration must be fine
-      return true
-    end
-
-    def initialize(config)
-      begin
-        if config.is_a? Hash
-          @config = config
-        elsif config.is_a? String and File.exist?(config)
-          # try to parse as a filename first
-          if File.exist?(config)
-            @config = YAML::load_file(config)
-          end
-        else
-          # otherwise try to parse it generically
-          @config = YAML::load(config)
-        end
-      rescue Exception => e
-        raise InvalidConfigException.new("Unable to parse configuration: #{e}")
-      end
-
-      # check that the configuration specified is well formed
-      if not Configuration.validate_config(@config)
-        raise InvalidConfigException.new("Config provided is either incomplete or poorly formed.")
-      end
-
-      # create instance objects
-      @instances = {}
-      if not @config["instances"].nil?
-        @config["instances"].keys.each do |instance_name|
-          @instances[instance_name] = Instance.create(@config["instances"][instance_name])
-          if instance_name == @config["default"]
-            @instances[:default] = @instances[instance_name]
-          end
-        end
-      else
-        @instances[:default] = Instance.create(@config)
-      end
-    end
-
-    # instance accessibility
-    def get_instance(instance_name)
-      @instances[instance_name] or raise InvalidInstanceNameException
-    end
-
-    def default_instance
-      @instances[:default]
-    end
-
-    DEFAULT_CONFIG_FILE = File.expand_path("~/.sakai-info")
-    # check to see if configuration file exists
-    # by default ~/.sakai-info
-    def self.config_file_path
-      if File.readable? DEFAULT_CONFIG_FILE
-        DEFAULT_CONFIG_FILE
-      else
-        nil
-      end
-    end
-
-    # are we already configured?
-    def self.configured?
-      not @@config.nil?
-    end
-
-    # load configuration as a class variable (and return it as well)
-    def self.load_config(alternate_config_file = nil)
-      if Configuration.configured?
-        raise AlreadyConfiguredException
-      end
-
-      unless(config_file = alternate_config_file || Configuration.config_file_path)
-        raise NoConfigFoundException
-      end
-
-      @@config = Configuration.new(config_file)
-    end
-
-    # return specified database connection configuration
-    def self.get_instance(instance_name = nil)
-      Configuration.load_config unless Configuration.configured?
-
-      if instance_name.nil?
-        @@config.default_instance
-      else
-        @@config.get_instance(instance_name)
-      end
-    end
-  end
-end
-