sugarcrm 0.8.2 → 0.9.0

data/lib/sugarcrm/connection/api/get_note_attachment.rb

@@ -2,7 +2,6 @@ module SugarCRM; class Connection
 # Retrieves an attachment from a note.
 def get_note_attachment(id)
   login! unless logged_in?
-
   json = <<-EOF
     {
       \"session\": \"#{@session}\"\,

data/lib/sugarcrm/connection/api/set_relationship.rb

@@ -19,6 +19,9 @@ module SugarCRM; class Connection
       }
     EOF
     json.gsub!(/^\s{6}/,'')
+    # TODO:  Add a handler for the response.  By default it returns a hash like:
+    # {failed => 0, deleted => 0, created => 1}.  We should add this to the 
+    # Response.handle method and return true/false depending on the outcome.
     send!(:set_relationship, json)
   end
 end; end

data/lib/sugarcrm/connection/connection.rb

@@ -0,0 +1,144 @@
+module SugarCRM; class Connection
+
+  URL = "/service/v2/rest.php"
+  # Set this to filter out debug output on a certain method (i.e. get_modules, or get_fields)
+  DONT_SHOW_DEBUG_FOR = []
+  RESPONSE_IS_NOT_JSON = [:get_user_id, :get_user_team_id]
+  
+  attr :url, true
+  attr :user, false
+  attr :pass, false
+  attr :session, true
+  attr :connection, true
+  attr :options, true
+  attr :request, true
+  attr :response, true
+  
+  # This is the singleton connection class. 
+  def initialize(url, user, pass, options={})
+    @options  = {
+      :debug => false,
+      :register_modules => true      
+    }.merge(options)
+    @url      = URI.parse(url)
+    @user     = user
+    @pass     = pass
+    @request  = ""
+    @response = ""
+    resolve_url
+    login!
+    self
+  end
+  
+  # Check to see if we are logged in
+  def logged_in?
+    connect! unless connected?
+    @session ? true : false
+  end
+  
+  # Login
+  def login!
+    @session = login["id"]
+    raise SugarCRM::LoginError, "Invalid Login" unless logged_in?
+    SugarCRM.connection = self
+    SugarCRM::Base.connection = self
+    Module.register_all if @options[:register_modules]
+  end
+
+  # Check to see if we are connected
+  def connected?
+    return false unless @connection
+    return false unless @connection.started?
+    true
+  end
+  
+  # Connect
+  def connect!
+    @connection = Net::HTTP.new(@url.host, @url.port)
+    if @url.scheme == "https"
+      @connection.use_ssl = true
+      @connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    @connection.start
+  end
+  
+  # Send a request to the Sugar Instance
+  def send!(method, json)
+    @request  = SugarCRM::Request.new(@url, method, json, @options[:debug])
+    begin
+      if @request.length > 3900
+        @response = @connection.post(@url.path, @request)
+      else
+        @response = @connection.get(@url.path.dup + "?" + @request.to_s)
+      end
+    rescue Errno::ECONNRESET
+      retry!(method, json)
+    rescue EOFError
+      retry!(method, json)
+    end
+    handle_response
+  end
+  
+  # Sometimes our connection just disappears but we still have a session.  
+  # This method forces a reconnect and relogin to update the session and resend 
+  # the request.
+  def retry!(method, json)
+    connect!
+    login!
+    send!(method,json)
+  end
+  
+  def debug=(debug)
+    options[:debug] = debug
+  end
+  
+  def debug?
+    options[:debug]
+  end
+  
+  private
+  
+  def handle_response
+    case @response
+    when Net::HTTPOK 
+      return process_response
+    when Net::HTTPNotFound
+      raise SugarCRM::InvalidSugarCRMUrl, "#{@url} is invalid"
+    when Net::HTTPInternalServerError
+      raise SugarCRM::InvalidRequest, "#{@request} is invalid"
+    else
+      if @options[:debug]
+        puts "#{@request.method}: Raw Response:"
+        puts @response.body
+        puts "\n"
+      end
+      raise SugarCRM::UnhandledResponse, "Can't handle response #{@response}"
+    end
+  end
+
+  def process_response
+    # Complain if our body is empty.
+    raise SugarCRM::EmptyResponse unless @response.body
+    # Some methods are dumb and don't return a JSON Response
+    return @response.body if RESPONSE_IS_NOT_JSON.include? @request.method
+    # Push it through the old meat grinder.
+    response_json = JSON.parse @response.body
+    # Empty result.  Is this wise?
+    return false if response_json["result_count"] == 0
+    # Filter debugging on REALLY BIG responses
+    if @options[:debug] && !(DONT_SHOW_DEBUG_FOR.include? @request.method)
+      puts "#{@request.method}: JSON Response:"
+      pp response_json
+      puts "\n"
+    end
+    return response_json
+  end
+  
+  def resolve_url
+    # Appends the rest.php path onto the end of the URL if it's not included
+    if @url.path !~ /rest.php$/
+      @url.path += URL
+    end
+  end
+  
+end; end

data/lib/sugarcrm/{request.rb → connection/request.rb}

@@ -1,7 +1,4 @@
-module SugarCRM
-  
-class Request
-
+module SugarCRM; class Request
   attr :request, true
   attr :url, true
   attr :method, true
@@ -12,12 +9,10 @@ class Request
     @url      = url
     @method   = method
     @json     = json
-
     @request  = 'method=' << @method.to_s
     @request << '&input_type=JSON'
     @request << '&response_type=JSON'
     @request << '&rest_data=' << @json
-    
     if debug
       puts "#{method}: Request:"
       pp @request 
@@ -33,7 +28,4 @@ class Request
   def to_s
     URI.escape(@request)
   end
-  
-end
-
-end
+end; end

data/lib/sugarcrm/{response.rb → connection/response.rb}

@@ -1,5 +1,4 @@
 module SugarCRM; class Response
-  
   class << self
     # This class handles the response from the server.
     # It tries to convert the response into an object such as User
@@ -8,11 +7,17 @@ module SugarCRM; class Response
       r = new(json)
       begin
         return r.to_obj
+      rescue UninitializedModule => e
+        raise e
+      rescue InvalidAttribute => e
+        raise e
+      rescue InvalidAttributeType => e
+        raise e
       rescue => e
         if SugarCRM.connection.debug?
           puts "Failed to process JSON:"
           pp json
-          puts e
+          raise e
         end
         return json
       end
@@ -23,6 +28,7 @@ module SugarCRM; class Response
   
   def initialize(json)
     @response = json
+    @response = json.with_indifferent_access if json.is_a? Hash
   end
   
   # Tries to instantiate and return an object with the values
@@ -35,13 +41,13 @@ module SugarCRM; class Response
     @response["entry_list"].each do |object|
       attributes = []
       _module    = resolve_module(object)
-      id         = object["id"]
+      #id         = object["id"]
       attributes = flatten_name_value_list(object)
       if SugarCRM.const_get(_module)
         if attributes.length == 0
           raise AttributeParsingError, "response contains objects without attributes!"
         end
-        objects << SugarCRM.const_get(_module).new(id, attributes) 
+        objects << SugarCRM.const_get(_module).new(attributes) 
       else
         raise InvalidModule, "#{_module} does not exist, or is not accessible"
       end

data/lib/sugarcrm/exceptions.rb

@@ -1,28 +1,16 @@
 module SugarCRM
-  class LoginError < RuntimeError
-  end
-
-  class EmptyResponse < RuntimeError
-  end
-
-  class UnhandledResponse < RuntimeError
-  end
-
-  class InvalidSugarCRMUrl < RuntimeError
-  end
-  
-  class InvalidRequest < RuntimeError
-  end
-  
-  class InvalidModule <RuntimeError
-  end
-  
-  class AttributeParsingError < RuntimeError
-  end
-  
-  class RecordNotFound < RuntimeError
-  end
-  
-  class InvalidRecord < RuntimeError
-  end
+  class LoginError < RuntimeError; end
+  class EmptyResponse < RuntimeError; end
+  class UnhandledResponse < RuntimeError; end
+  class InvalidSugarCRMUrl < RuntimeError; end
+  class InvalidRequest < RuntimeError; end
+  class InvalidModule <RuntimeError; end
+  class AttributeParsingError < RuntimeError; end
+  class RecordNotFound < RuntimeError; end
+  class InvalidRecord < RuntimeError; end
+  class RecordSaveFailed < RuntimeError; end
+  class AssociationFailed < RuntimeError; end
+  class UninitializedModule < RuntimeError; end
+  class InvalidAttribute < RuntimeError; end
+  class InvalidAttributeType < RuntimeError; end
 end

data/lib/sugarcrm/module.rb

@@ -15,48 +15,49 @@ module SugarCRM
       @klass  = name.classify
       @table_name = name.tableize
       @fields = {}
-      @link_fields  = {}
+      @link_fields = {}
       @fields_registered = false
       self
     end
     
+    # Returns the fields associated with the module
     def fields
-      return @fields if fields?
+      return @fields if fields_registered?
       all_fields  = SugarCRM.connection.get_fields(@name)
-      @fields     = all_fields["module_fields"]
-      @link_fields= all_fields["link_fields"] 
+      @fields     = all_fields["module_fields"].with_indifferent_access
+      @link_fields= all_fields["link_fields"]
+      handle_empty_arrays
       @fields_registered = true
       @fields
     end
     
-    def fields?
+    def fields_registered?
       @fields_registered
     end
     
+    alias :link_fields_registered? :fields_registered?
+    
+    # Returns the required fields
     def required_fields
       required_fields = []
-      ignore_fields = ["id", "date_entered", "date_modified"]
+      ignore_fields = [:id, :date_entered, :date_modified]
       self.fields.each_value do |field|
-        next if ignore_fields.include? field["name"]
-        required_fields << field["name"] if field["required"] == 1
+        next if ignore_fields.include? field["name"].to_sym
+        required_fields << field["name"].to_sym if field["required"] == 1
       end 
       required_fields
     end
     
     def link_fields
-      self.fields unless link_fields?
-      handle_empty_array
+      self.fields unless link_fields_registered?
+      handle_empty_arrays
       @link_fields
     end
     
-    def link_fields?
-      @fields_registered
-    end  
-  
-    def handle_empty_array
-      if @link_fields.class == Array && @link_fields.length == 0
-        @link_fields = {}
-      end
+    # TODO: Refactor this to be less repetitive
+    def handle_empty_arrays
+      @fields = {}.with_indifferent_access if @fields.length == 0
+      @link_fields = {}.with_indifferent_access if @link_fields.length == 0
     end
     
     # Registers a single module by name

data/test/connection/test_get_entry.rb

@@ -7,17 +7,17 @@ class TestGetEntry < Test::Unit::TestCase
       @response = SugarCRM.connection.get_entry(
         "Users",
         1,
-        {:fields => ["first_name", "last_name"]} 
+        {:fields => ["first_name", "last_name", "deleted", "date_modified"]} 
       )
     end
-#    should "return a single entry when sent #get_entry." do
-#      assert @response.response. "entry_list"
-#    end
     should "return an object when #get_entry" do 
       assert_instance_of SugarCRM::User, @response
     end
     should "typecast boolean fields properly" do
-      assert !(@response.deleted)
+      assert_instance_of FalseClass, @response.deleted
+    end
+    should "typecast date_time fields properly" do
+      assert_instance_of DateTime, @response.date_modified
     end
   end
 end

data/test/connection/test_get_module_fields.rb

@@ -7,7 +7,7 @@ class TestModuleFields < Test::Unit::TestCase
     end
     should "return a hash of module fields when #get_module_fields" do
       fields = SugarCRM.connection.get_module_fields("Users")
-      assert_instance_of Hash, fields
+      assert_instance_of ActiveSupport::HashWithIndifferentAccess, fields
       assert "address_city", fields.keys[0]
     end
   end

data/test/connection/test_set_relationship.rb

@@ -1,27 +1,19 @@
 require 'helper'
 
-class TestSetRelationships < Test::Unit::TestCase    
+class TestSetRelationship < Test::Unit::TestCase
   context "A SugarCRM.connection" do
-    setup do
-      SugarCRM::Connection.new(URL, USER, PASS, {:register_modules => false, :debug => false})    
-      
-      #retrieve ID of ACLRole and append shove it into the @id array
-      @id = [SugarCRM::ACLRole.find_by_name("Marketing Administrator").id]
-      assert @id
-    end
-    
-    should "add the role found above to the user who's id is below when sent #set_relationship" do
-      response = SugarCRM.connection.set_relationship(
-        "Users","seed_will_id","aclroles",@id
-      )
-      assert_equal("failed0deleted0created1", response.to_s)
-    end
-    
-    should "remove the role that was previously added when sent #set_relationship and delete=1" do
-      response = SugarCRM.connection.set_relationship(
-        "Users","seed_will_id","aclroles",@id,opts={:delete => 1}
-      )
-      assert_equal("failed0deleted1created0", response.to_s)
+    should "add and remove a relationship when #set_relationship" do
+      SugarCRM.connect(URL, USER, PASS, {:debug => false})    
+      meeting  = SugarCRM::Meeting.new
+      meeting.date_start = DateTime.now
+      meeting.duration_hours = 0.5
+      meeting.name = "Stupid Meeting"
+      assert meeting.save!
+      response = SugarCRM.connection.set_relationship("Users","1","meetings", [meeting.id])
+      assert response["created"] == 1
+      response = SugarCRM.connection.set_relationship("Users","1","meetings", [meeting.id], {:delete => 1})
+      assert response["deleted"] == 1
+      assert meeting.delete
     end
   end
 end

data/test/helper.rb

@@ -8,7 +8,7 @@ require 'sugarcrm'
 
 class Test::Unit::TestCase
   # Replace these with your test instance
-  URL   = "http://valet/sugarcrm"
+  URL   = "http://localhost:8080/sugarcrm"
   USER  = "admin"
   PASS  = 'letmein' 
 

data/test/test_association_collection.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class TestAssociationCollection < Test::Unit::TestCase
+  context "A SugarCRM::AssociationCollection instance" do
+    should "create a new instance when #new" do
+      SugarCRM.connect!(URL, USER, PASS)
+      u   = SugarCRM::User.find("seed_sarah_id")
+      ac  = SugarCRM::AssociationCollection.new(u,:email_addresses)
+      assert_instance_of SugarCRM::AssociationCollection, ac
+    end
+  end
+end