sugarcrm_emp 0.10.0

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

@@ -0,0 +1,25 @@
+module SugarCRM; class Connection
+  # Returns the ID, module name and fields for specified modules. 
+  # Supported modules are Accounts, Bugs, Calls, Cases, Contacts, 
+  # Leads, Opportunities, Projects, Project Tasks, and Quotes.
+  def search_by_module(search_string, modules, opts={})
+    login! unless logged_in?
+    
+    options = { 
+      :offset => nil, 
+      :limit => nil, 
+    }.merge! opts
+    
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "search_string": "#{search_string}",
+        "modules": "#{modules}",
+        "offset": #{options[:offset]},
+        "max_results": #{options[:limit]}
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:search_by_module, json)
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module SugarCRM; class Connection
+  # Performs a mail merge for the specified campaign.
+  def set_campaign_merge(targets, campaign_id)
+    login! unless logged_in?
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "targets": #{targets.to_json},
+        "campaign-id": "#{campaign_id}"
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_campaign_merge, json)
+  end
+end; end

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

@@ -0,0 +1,35 @@
+module SugarCRM; class Connection
+  # Sets a new revision for a document.
+  def set_document_revision(document_id, revision_number, opts={})
+    options = { 
+      :file => '', 
+      :file_name => '',
+      :document_name => nil
+    }.merge! opts
+    
+    # Raise an exception of we try to pass :file, but not :file_name
+    if (!options[:file].empty? && options[:file_name].empty?)
+      raise ArgumentException, ":file_name must be specified if :file is specified"
+    end
+    
+    # If no document_name is given, use the file_name
+    options[:document_name] ||= options[:file_name]
+    
+    login! unless logged_in?
+    
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "document_revision": {
+           "id": "#{document_id}",
+           "document_name": "#{options[:document_name]}",
+           "revision": "#{revision_number}",
+           "filename": "#{options[:file_name]}",
+           "file": "#{b64_encode(options[:file])}"
+        }
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_document_revision, json)
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module SugarCRM; class Connection
+  # Creates or updates a list of SugarBeans.
+  def set_entries(module_name, name_value_lists)
+    login! unless logged_in?
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "module_name": "#{module_name}",
+        "name_value_list": #{name_value_lists.to_json}
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_entries, json)
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module SugarCRM; class Connection
+  # Creates or updates a single SugarBean.
+  def set_entry(module_name, name_value_list)
+    login! unless logged_in?
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "module_name": "#{module_name}",
+        "name_value_list": #{name_value_list.to_json}
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_entry, json)
+  end
+end; end

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

@@ -0,0 +1,25 @@
+module SugarCRM; class Connection
+  # Creates or updates an attachment on a note
+  def set_note_attachment(id, filename, file, opts={})
+    options = { 
+      :module_id => '', 
+      :module_name => '' 
+    }.merge! opts
+    
+    login! unless logged_in?
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+           "note": {
+              "id": "#{id}",
+              "filename": "#{filename}",
+              "file": "#{b64_encode(file)}",
+              "related_module_id": "#{options[:module_id]}",
+              "related_module_name": "#{options[:module_name]}" 
+           }
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_note_attachment, json)
+  end
+end; end

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

@@ -0,0 +1,27 @@
+module SugarCRM; class Connection
+  # Sets a single relationship between two SugarBeans.
+  def set_relationship(module_name, module_id, link_field_name, related_ids, opts={})
+    login! unless logged_in?
+    options = { 
+      :name_value_list => [], 
+      :delete => 0, 
+    }.merge! opts
+    raise ArgumentError, "related_ids must be an Array" unless related_ids.class == Array
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "module_name": "#{module_name}",
+        "module_id": "#{module_id}",
+        "link_field_name": "#{link_field_name}",
+        "related_ids": #{related_ids.to_json},
+        "name_value_list": #{options[:name_value_list].to_json},
+        "delete": #{options[:delete]}  
+      }
+    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/api/set_relationships.rb

@@ -0,0 +1,22 @@
+module SugarCRM; class Connection
+  # Sets multiple relationships between two SugarBeans.
+  def set_relationships(module_names, module_ids, link_field_names, related_ids)
+    login! unless logged_in?
+    
+    [module_names, module_ids, link_field_names, related_ids].each do |arg|
+      raise ArgumentError, "argument must be an Array" unless arg.class == Array
+    end
+    
+    json = <<-EOF
+      {
+        "session": "#{@sugar_session_id}",
+        "module_names": "#{module_names.to_json}",
+        "module_ids": #{module_ids.to_json},
+        "link_field_names": #{link_field_names.to_json},
+        "related_ids": #{related_ids.to_json}   
+      }
+    EOF
+    json.gsub!(/^\s{6}/,'')
+    send!(:set_relationships, json)
+  end
+end; end

data/lib/sugarcrm/connection/connection.rb

@@ -0,0 +1,201 @@
+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 :sugar_session_id, true
+  attr :connection, true
+  attr :options, true
+  attr :request, true
+  attr :response, true
+  attr :errors, true
+
+  # This is the singleton connection class.
+  def initialize(url, user, pass, options={})
+    @options  = {
+      :debug => false,
+      :register_modules => true,
+      :load_environment => true
+    }.merge(options)
+    @errors   = []
+    @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?
+    @sugar_session_id ? true : false
+  end
+
+  # Login
+  def login!
+    @sugar_session_id = login["id"]
+    raise SugarCRM::LoginError, "Invalid Login" unless logged_in?
+  end
+
+  def logout
+    logout
+    @sugar_session_id = nil
+  end
+
+  # Check to see if we are connected
+  def connected?
+    return false unless @connection
+    true
+  end
+
+  # Connect
+  def connect!
+    @connection = HTTPClient.new
+  end
+  alias :reconnect! :connect!
+
+  # Send a request to the Sugar Instance
+  def send!(method, json, max_retry=3)
+    if max_retry == 0
+      raise SugarCRM::RetryLimitExceeded, "SugarCRM::Connection Errors: \n#{@errors.reverse.join "\n\s\s"}"
+    end
+    @request  = SugarCRM::Request.new(@url, method, json, @options[:debug])
+    # Send Ze Reques
+    begin
+      if @request.length > 3900
+        @response = @connection.post(@url, @request)
+      else
+        @response = @connection.get(@url,  @request)
+      end
+      return handle_response
+    # Timeouts are usually a server side issue
+    rescue Timeout::Error => error
+      @errors << error
+      send!(method, json, max_retry.pred)
+    # Lower level errors requiring a reconnect
+    rescue Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE, EOFError => error
+      @errors << error
+      reconnect!
+      send!(method, json, max_retry.pred)
+    # Handle invalid sessions
+    rescue SugarCRM::InvalidSession => error
+      @errors << error
+      old_session = @sugar_session_id.dup
+      login!
+      # Update the session id in the request that we want to retry.
+      json.gsub!(old_session, @sugar_session_id)
+      send!(method, json, max_retry.pred)
+    end
+  end
+  alias :retry! :send!
+
+  def debug=(debug)
+    options[:debug] = debug
+  end
+
+  def debug?
+    options[:debug]
+  end
+
+  private
+
+  def handle_response
+    case @response.status
+    when 200
+      return process_response
+    when 404
+      raise SugarCRM::InvalidSugarCRMUrl, "#{@url} is invalid"
+    when 500
+      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
+    empty_body?
+    if response_contains_json?
+      return parse_response
+    else
+      return @response.body
+    end
+  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
+
+  # Complain if our body is empty.
+  def empty_body?
+    raise SugarCRM::EmptyResponse unless @response.body
+  end
+
+  # Some methods are dumb and don't return a JSON Response
+  def response_contains_json?
+    if RESPONSE_IS_NOT_JSON.include? @request.method
+      return false
+    end
+    true
+  end
+
+  def parse_response
+    begin
+      # Push it through the old meat grinder.
+      json = JSON.parse(@response.body)
+    rescue StandardError => e
+      # Complain if we can't parse
+      raise UnhandledResponse, @response.body
+    end
+    # Do ze debugs!
+    nice_debugging_for json
+    # Check for an invalid session
+    invalid_session? json
+    # Check for an empty result set
+    if zero_results? json
+      return nil
+    end
+    json
+  end
+
+  # Check if we got an invalid session error back
+  # something like:
+  # {"name"=>"Invalid Session ID",
+  #  "number"=>11,
+  #  "description"=>"The session ID is invalid"}
+  def invalid_session?(json)
+    return false unless json["name"]
+    return false if @request.method == :logout
+    raise SugarCRM::InvalidSession if json["name"] == "Invalid Session ID"
+  end
+
+  def zero_results?(json)
+    json["result_count"] == 0
+  end
+
+  # Filter debugging on REALLY BIG responses
+  def nice_debugging_for(json)
+    if @options[:debug] && !(DONT_SHOW_DEBUG_FOR.include? @request.method)
+      puts "#{@request.method}: JSON Response:"
+      pp json
+      puts "\n"
+    end
+  end
+
+end; end

data/lib/sugarcrm/connection/helper.rb

@@ -0,0 +1,50 @@
+module SugarCRM; class Connection
+  # Attempts to return a list of fields for the target of the association.
+  # i.e. if we are associating Contact -> Account, using the "contacts" link
+  # field name - this will lookup the contacts association and try to determine
+  # the target object type (Contact).  It will then pull the fields for that object
+  # and shove them in the related_fields portion of the get_relationship request.
+  def resolve_related_fields(module_name, link_field)
+    a = Association.new(class_for(module_name), link_field)
+    if a.target
+      fields = a.target.new.attributes.keys
+    else
+      fields = ["id"]
+    end
+    fields.to_json
+  end
+  
+  def resolve_fields(module_name, fields)
+    # FIXME: This is to work around a bug in SugarCRM 6.0
+    # where no fields are returned if no fields are specified
+    if fields.length == 0
+      mod = Module.find(module_name.classify, @session)
+      if mod
+        fields = mod.fields.keys
+      else
+        fields = ["id"]
+      end
+    end
+    return fields.to_json
+  end
+  
+  # Returns an instance of class for the provided module name
+  def class_for(module_name)
+    begin
+      class_const = @session.namespace_const.const_get(module_name.classify)
+      klass = class_const.new
+    rescue NameError
+      raise InvalidModule, "Module: #{module_name} is not registered"
+    end
+  end
+  
+  # We need to strip newlines from Base64 encoding for JSON validation purposes.
+  def b64_encode(file)
+    Base64.encode64(file).gsub(/\n/, '')
+  end
+  
+  def b64_decode(file)
+    Base64.decode64(file)
+  end
+    
+end; end

data/lib/sugarcrm/connection/request.rb

@@ -0,0 +1,61 @@
+module SugarCRM; class Request
+  attr :request, true
+  attr :url, true
+  attr :method, true
+  attr :json, true
+  attr :http_method
+
+  def initialize(url, method, json, debug=false)
+    @url      = url
+    @method   = method
+    @json     = escape(json)
+    @request  = 'method=' << @method.to_s
+    @request << '&input_type=JSON'
+    @request << '&response_type=JSON'
+    @request << '&rest_data=' << @json
+    if debug
+      puts "#{method}: Request:"
+      puts json 
+      puts "\n"
+    end
+    self
+  end
+  
+  def escape(json)
+    # BUG: SugarCRM doesn't properly handle '&quot;' inside of JSON for some reason.  Let's unescape any html elements.
+    j = convert_reserved_characters(json)
+    # Now we escape the resulting string.
+    j = CGI.escape(j)
+    j
+  end
+  
+  # TODO: Fix this so that it JSON.parse will consume it.
+  def unescape
+    j = CGI.unescape(@json)
+    j.gsub!(/\n/, '')
+  end
+  
+  def bytesize
+    self.to_s.bytesize
+  end
+  
+  def length
+    self.to_s.length
+  end
+  
+  def to_s
+    @request
+  end
+  alias :to_str :to_s
+  
+  # A tiny helper for converting reserved characters for html encoding
+  def convert_reserved_characters(string)
+    string.gsub!(/&quot;/, '\"')
+    string.gsub!(/&apos;/, '\'')
+    string.gsub!(/&amp;/,  '\&')
+    string.gsub!(/&lt;/,   '\<')
+    string.gsub!(/&lt;/,   '\>')
+    string
+  end
+  
+end; end

data/lib/sugarcrm/connection/response.rb

@@ -0,0 +1,91 @@
+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
+    # or an object collection.  If it fails, it just returns the response hash
+    def handle(json, session)
+      r = new(json, session)
+      begin
+        return r.to_obj
+      rescue UninitializedModule => e
+        raise e
+      rescue InvalidAttribute => e
+        raise e
+      rescue InvalidAttributeType => e
+        raise e
+      rescue => e
+        if session.connection.debug?
+          puts "Failed to process JSON:"
+          pp json
+        end
+        raise e
+      end
+    end
+  end
+
+  attr :response, false
+  
+  def initialize(json, session, opts={})
+    @options  = { :always_return_array => false }.merge! opts
+    @response = json
+    @response = json.with_indifferent_access if json.is_a? Hash
+    @session = session
+  end
+  
+  # Tries to instantiate and return an object with the values
+  # populated from the response
+  def to_obj
+    # If this is not a "entry_list" response, just return
+    return @response unless @response && @response["entry_list"]
+    
+    objects = []
+    @response["entry_list"].each do |object|
+      attributes = []
+      _module    = resolve_module(object)
+      attributes = flatten_name_value_list(object)
+      namespace = @session.namespace_const
+      if namespace.const_get(_module)
+        if attributes.length == 0
+          raise AttributeParsingError, "response contains objects without attributes!"
+        end
+        objects << namespace.const_get(_module).new(attributes) 
+      else
+        raise InvalidModule, "#{_module} does not exist, or is not accessible"
+      end
+    end
+    # If we only have one result, just return the object
+    if objects.length == 1 && !@options[:always_return_array]
+      return objects[0]
+    else
+      return objects
+    end
+  end
+  
+  def to_json
+    @response.to_json
+  end
+    
+  def resolve_module(list)
+    list["module_name"].classify
+  end
+  
+  def flatten_name_value_list(list)
+    if list["name_value_list"]
+      return flatten(list["name_value_list"])
+    else
+      return false
+    end
+  end
+  
+  # Takes a hash like { "first_name" => {"name" => "first_name", "value" => "John"}}
+  # And flattens it into {"first_name" => "John"}
+  def flatten(list)
+    raise ArgumentError, list[0]['value'] if list[0] && list[0]['name'] == 'warning'
+    raise ArgumentError, 'method parameter must respond to #each_pair' unless list.respond_to? :each_pair
+    flat_list = {}
+    list.each_pair do |k,v|
+      flat_list[k.to_sym] = v["value"]
+    end
+    flat_list
+  end
+end; end

data/lib/sugarcrm/connection.rb

@@ -0,0 +1,5 @@
+require 'sugarcrm/connection/helper'
+require 'sugarcrm/connection/connection'
+require 'sugarcrm/connection/request'
+require 'sugarcrm/connection/response'
+Dir["#{File.dirname(__FILE__)}/connection/api/*.rb"].each { |f| load(f) }