sugarcrm 0.9.10 → 0.9.11

data/lib/sugarcrm/module.rb

@@ -12,7 +12,8 @@ module SugarCRM
     # Dynamically register objects based on Module name
     # I.e. a SugarCRM Module named Users will generate
     # a SugarCRM::User class.
-    def initialize(name)
+    def initialize(session, name)
+      @session = session # the session from which this module was retrieved
       @name   = name
       @klass  = name.classify
       unless custom_module?
@@ -50,7 +51,7 @@ module SugarCRM
     # Returns the fields associated with the module
     def fields
       return @fields if fields_registered?
-      all_fields  = SugarCRM.connection.get_fields(@name)
+      all_fields  = @session.connection.get_fields(@name)
       @fields     = all_fields["module_fields"].with_indifferent_access
       @link_fields= all_fields["link_fields"]
       handle_empty_arrays
@@ -94,20 +95,30 @@ module SugarCRM
     def register
       return self if registered?
       mod_instance = self
+      sess = @session
       # class Class < SugarCRM::Base
       #   module_name = "Accounts"
       # end
       klass = Class.new(SugarCRM::Base) do
         self._module = mod_instance
-      end 
+        self.session = sess
+      end
       
       # class Account < SugarCRM::Base
-      SugarCRM.const_set self.klass, klass
+      @session.namespace_const.const_set self.klass, klass
       self
     end
+    
+    # Deregisters the module
+    def deregister
+      return true unless registered?
+      klass = self.klass
+      @session.namespace_const.instance_eval{ remove_const klass }
+      true
+    end
 
     def registered?
-      SugarCRM.const_defined? @klass
+      @session.namespace_const.const_defined? @klass
     end  
       
     def to_s
@@ -122,18 +133,31 @@ module SugarCRM
       @initialized = false
       
       # Registers all of the SugarCRM Modules
-      def register_all
-        SugarCRM.connection.get_modules.each do |m|
-          SugarCRM.modules << m.register
+      def register_all(session)
+        namespace = session.namespace_const
+        session.connection.get_modules.each do |m|
+          session.modules << m.register
         end
         @initialized = true
         true
       end
+      
+      # Deregisters all of the SugarCRM Modules
+      def deregister_all(session)
+        namespace = session.namespace_const
+        session.modules.each do |m|
+          m.deregister
+        end
+        session.modules = []
+        @initialized = false
+        true
+      end
 
       # Finds a module by name, or klass name
-      def find(name)
-        register_all unless initialized?
-        SugarCRM.modules.each do |m|
+      def find(name, session=nil)
+        session ||= SugarCRM.session
+        register_all(session) unless initialized?
+        session.modules.each do |m|
           return m if m.name  == name
           return m if m.klass == name
         end

data/lib/sugarcrm/module_methods.rb

@@ -1,29 +1,69 @@
 module SugarCRM
+  # store the namespaces that have been used to prevent namespace collision
+  @@used_namespaces = []
+  def self.used_namespaces
+    @@used_namespaces
+  end
   
-  @@connection = nil
-  def self.connection
-    @@connection
+  # return the namespaces linked to active sessions
+  def self.namespaces
+    result = []
+    @@used_namespaces.each{|n|
+      result << n if SugarCRM.const_defined? n
+    }
+    result
+  end
+  
+  # store the various connected sessions
+  # key = session.id, value = session instance
+  @@sessions = {}
+  def self.sessions
+    @@sessions
+  end
+  
+  def self.add_session(session)
+    @@used_namespaces << session.namespace unless @@used_namespaces.include? session.namespace
+    @@sessions[session.id] = session
+  end
+  
+  def self.remove_session(session)
+    @@sessions.delete(session.id)
+  end
+  
+  def self.session
+    return nil if @@sessions.size < 1
+    (raise SugarCRM::MultipleSessions, "There are multiple active sessions: use the session namespace instead of SugarCRM") if @@sessions.size > 1
+    @@sessions.values.first
   end
-  def self.connection=(connection)
-    @@connection = connection
+  
+  def self.connection
+    return nil unless self.session
+    self.session.connection
   end
-  def self.connect(url=SugarCRM::Environment.config[:base_url], user=SugarCRM::Environment.config[:username], pass=SugarCRM::Environment.config[:password], options={})
-    SugarCRM::Base.establish_connection(url, user, pass, options)
+  
+  def self.connect(url, user, pass, options={})
+    session = SugarCRM::Session.new(url, user, pass, options)
+    # return the namespace module
+    session.namespace_const
   end
+  
   class << self
     alias :connect! :connect
   end
   
-  @@modules = []
-  def self.modules
-    @@modules
-  end
-  def self.modules=(modules)
-    @@modules = modules
+  def respond_to?(sym)
+    return true if @@sessions.size == 1 && SugarCRM.session.namespace_const.respond_to?(sym)
+    super
   end
   
-  def self.current_user
-    SugarCRM::User.find_by_user_name(connection.user)
+  def self.method_missing(sym, *args, &block)
+    (raise SugarCRM::NoActiveSession, "No session is active. Create a new session with 'SugarCRM.connect(...)'") if @@sessions.size < 1
+    (raise SugarCRM::MultipleSessions, "There are multiple active sessions: call methods on the session namespace instead of SugarCRM") if @@sessions.size > 1
+    if SugarCRM.session.namespace_const.respond_to? sym
+      SugarCRM.session.namespace_const.send(sym, *args, &block)
+    else
+      super
+    end
   end
   
   # If a user tries to access a SugarCRM class before they're logged in,
@@ -31,16 +71,21 @@ module SugarCRM
   # This will trigger module loading,
   # and we can then attempt to return the requested class automagically
   def self.const_missing(sym)
-    # if we're logged in, modules should be loaded and available
-    if SugarCRM.connection && SugarCRM.connection.logged_in?
+    (raise SugarCRM::MultipleSessions, "There are multiple active sessions: use the session namespace instead of SugarCRM") if @@sessions.size > 1
+    # make sure we have an active session
+    begin
+      Session.new unless SugarCRM.connection && SugarCRM.connection.logged_in?
+    rescue SugarCRM::MissingCredentials => e
+      # unable to load necessary login credentials from config file => pass exception on
       super
+    end
+    
+    # if user calls (e.g.) SugarCRM::Account, delegate to SugarCRM::Namespace0::Account
+    namespace_const = SugarCRM.session.namespace_const
+    if namespace_const.const_defined? sym
+      namespace_const.const_get(sym)
     else
-      # here, we initialize the environment (which happens on any method call, if singleton hasn't already been initialized)
-      # initializing the environment will log user in if credentials present in config file
-      # if it isn't possible to log in and access modules, pass the exception on
-      super unless SugarCRM::Environment.connection_info_loaded?
-      # try and return the requested module
-      SugarCRM.const_get(sym)
+      super
     end
   end
 end

data/lib/sugarcrm/session.rb

@@ -0,0 +1,179 @@
+# This class hold an individual connection to a SugarCRM server.
+# There can be several such simultaneous connections
+module SugarCRM; class Session
+  attr_reader :config, :connection, :extensions_path, :id, :namespace, :namespace_const
+  attr_accessor :modules
+  def initialize(url, user, pass, opts={})
+    options = { 
+      :debug  => false,
+      :register_modules => true
+    }.merge(opts)
+    
+    @modules    = []
+    @namespace  = "Namespace#{SugarCRM.used_namespaces.size}"
+    @config     = {:base_url => url,:username => user,:password => pass,:options => options}
+    @extensions_path = File.join(File.dirname(__FILE__), 'extensions')
+    
+    setup_connection
+    register_namespace
+    connect_and_add_session
+  end
+  
+  # create a new session from the credentials present in a file
+  def self.new_from_file(path, opts={})
+    config = load_and_parse_config(path)
+    begin
+      session = self.new(config[:base_url], config[:username], config[:password], opts)
+    rescue MissingCredentials => e
+      return false
+    end
+    session.namespace_const
+  end
+  
+  def setup_connection
+    load_config_files unless connection_info_loaded?
+    raise MissingCredentials, "Missing login credentials. Make sure you provide the SugarCRM URL, username, and password" unless connection_info_loaded?
+  end
+  
+  # re-use this session and namespace if the user wants to connect with different credentials
+  def connect(url=nil, user=nil, pass=nil, opts={})
+    options = { 
+      :debug  => (@connection && @connection.debug?),
+      :register_modules => true
+    }.merge(opts)
+    
+    {:base_url => url, :username => user, :password => pass}.each{|k,v|
+      @config[k] = v  unless v.nil?
+    }
+    
+    SugarCRM::Module.deregister_all(self)
+    SugarCRM.remove_session(self)
+    @connection = SugarCRM::Connection.new(@config[:base_url], @config[:username], @config[:password], options) if connection_info_loaded?
+    @connection.session = self
+    @id = @connection.session_id
+    SugarCRM.add_session(self) # must be removed and added back, as the session id (used as the hash key) changes
+    SugarCRM::Module.register_all(self)
+    load_extensions
+    true
+  end
+  alias :connect! :connect
+  alias :reconnect :connect
+  alias :reconnect! :connect
+  alias :reload! :connect
+  
+  # log out from SugarCRM and cleanup (deregister modules, remove session, etc.)
+  def disconnect
+    @connection.logout
+    SugarCRM::Module.deregister_all(self)
+    namespace = @namespace
+    SugarCRM.instance_eval{ remove_const namespace } # remove NamespaceX from SugarCRM
+    SugarCRM.remove_session(self)
+  end
+  alias :disconnect! :disconnect
+  
+  def extensions_folder=(folder, dirstring=nil)
+    path = File.expand_path(folder, dirstring)
+    @extensions_path = path
+    load_extensions
+  end
+  
+  # load credentials from file, and (re)connect to SugarCRM
+  def load_config(path)
+    @config = self.class.load_and_parse_config(path)
+    reconnect(@config[:base_url], @config[:username], @config[:password]) if connection_info_loaded?
+    @config
+  end
+  
+  def update_config(params)
+    params.each{|k,v|
+      @config[k.to_sym] = v
+    }
+    @config
+  end
+  
+  # lazy load the SugarCRM version we're connecting to
+  def sugar_version
+    @version ||= @connection.get_server_info["version"]
+  end
+  
+  private
+  def self.load_and_parse_config(path)
+    validate_path path
+    hash = {}
+    config = YAML.load_file(path)
+    if config && config["config"]
+      config["config"].each{|k,v|
+        hash[k.to_sym] = v
+      }
+    end
+    hash
+  end
+  
+  def self.validate_path(path)
+    raise "Invalid path: #{path}" unless File.exists? path
+  end
+  
+  def config_file_paths
+    # see README for reasoning behind the priorization
+    paths = ['/etc/sugarcrm.yaml', File.expand_path('~/.sugarcrm.yaml'), File.join(File.dirname(__FILE__), 'config', 'sugarcrm.yaml')]
+    paths.insert(1, File.join(ENV['USERPROFILE'], 'sugarcrm.yaml')) if ENV['USERPROFILE']
+    paths
+  end
+  
+  def connection_info_loaded?
+    @config[:base_url] && @config[:username] && @config[:password]
+  end
+  
+  def generate_namespace_module
+    # Create a new module to have a separate namespace in which to register the SugarCRM modules.
+    # This will prevent issues with modules from separate SugarCRM instances colliding within the same namespace
+    # (e.g. 2 SugarCRM instances where only one has custom fields on the Account module)
+    namespace_module = Object::Module.new do
+      @session = nil
+      def self.session
+        @session
+      end
+      def self.session=(sess)
+        @session = sess
+      end
+      def self.current_user
+        (@session.namespace_const)::User.find_by_user_name(@session.config[:username])
+      end
+      def self.respond_to?(sym)
+        return true if @session.respond_to? sym
+        super
+      end
+      def self.method_missing(sym, *args, &block)
+        raise unless @session.respond_to? sym
+        @session.send(sym, *args, &block)
+      end
+    end
+    # set the session: will be needed in SugarCRM::Base to call the API methods on the correct session
+    namespace_module.session = self
+    namespace_module
+  end
+  
+  def load_config_files
+    # see README for reasoning behind the priorization
+    config_file_paths.each{|path|
+      load_config path if File.exists? path
+    }
+  end
+  
+  def register_namespace
+    SugarCRM.const_set(@namespace, generate_namespace_module)
+    @namespace_const = SugarCRM.const_get(@namespace)
+  end
+  
+  # load all the monkey patch extension files in the provided folder
+  def load_extensions
+    self.class.validate_path @extensions_path
+    Dir[File.join(@extensions_path, '**', '*.rb').to_s].each { |f| load(f) }
+  end  
+  
+  def connect_and_add_session
+    connect(@config[:base_url], @config[:username], @config[:password], @config[:options])
+    SugarCRM.add_session(self)
+  end
+  
+end; end

data/test/connection/test_get_available_modules.rb

@@ -1,10 +1,7 @@
 require 'helper'
 
-class TestGetAvailableModules < Test::Unit::TestCase
+class TestGetAvailableModules < ActiveSupport::TestCase
   context "A SugarCRM.connection" do
-    setup do
-      SugarCRM::Connection.new(URL, USER, PASS, {:debug => false})
-    end
     should "return an array of modules when #get_modules" do
       assert_instance_of SugarCRM::Module, SugarCRM.connection.get_modules[0]
     end

data/test/connection/test_get_entries.rb

@@ -1,19 +1,13 @@
 require 'helper'
 
-class TestGetEntries < Test::Unit::TestCase
+class TestGetEntries < ActiveSupport::TestCase
   context "A SugarCRM.connection" do
-    setup do
-      SugarCRM::Connection.new(URL, USER, PASS, {:register_modules => true, :debug => false})
+    should "return an object when #get_entries" do
       @response = SugarCRM.connection.get_entries(
         "Users",
         [1,"seed_sally_id"],
         {:fields => ["first_name", "last_name"]} 
       )
-    end
-#    should "return a list of entries when sent #get_entries." do
-#      assert @response.response.key? "entry_list"
-#    end
-    should "return an object when #get_entries" do
       assert_instance_of Array, @response
       assert_instance_of SugarCRM::User, @response[0]
     end

data/test/connection/test_get_entry.rb

@@ -1,9 +1,8 @@
 require 'helper'
 
-class TestGetEntry < Test::Unit::TestCase
+class TestGetEntry < ActiveSupport::TestCase
   context "A SugarCRM.connection" do
     setup do
-      SugarCRM::Connection.new(URL, USER, PASS, {:debug => false })
       @response = SugarCRM.connection.get_entry(
         "Users",
         1,

data/test/connection/test_get_entry_list.rb

@@ -1,18 +1,7 @@
 require 'helper'
 
-class TestGetEntryList < Test::Unit::TestCase
+class TestGetEntryList < ActiveSupport::TestCase
   context "A SugarCRM.connection" do
-    setup do
-      SugarCRM::Connection.new(URL, USER, PASS, {:register_modules => true, :debug => false})
-      @response = SugarCRM.connection.get_entry_list(
-        "Users",
-        "users.deleted = 0",
-        {:fields => ["first_name", "last_name"]} 
-      )
-    end
-#    should "return a list of entries when sent #get_entry_list." do
-#      assert @response.response.key? "entry_list"
-#    end
     should "return a list of entries when sent #get_entry_list and no fields." do
       users = SugarCRM.connection.get_entry_list(
         "Users",
@@ -21,6 +10,11 @@ class TestGetEntryList < Test::Unit::TestCase
       assert_equal "admin", users.first.user_name
     end
     should "return an object when #get_entry_list" do
+      @response = SugarCRM.connection.get_entry_list(
+        "Users",
+        "users.deleted = 0",
+        {:fields => ["first_name", "last_name"]} 
+      )
       assert_instance_of Array, @response
       assert_instance_of SugarCRM::User, @response[0]
     end