sugarcrm 0.8.2 → 0.9.0

data/lib/sugarcrm/attributes/attribute_serializers.rb

@@ -0,0 +1,55 @@
+module SugarCRM; module AttributeSerializers
+  
+  protected
+    
+  # Serializes the id
+  def serialize_id
+    {:name => "id", :value => id.to_s}
+  end
+
+  # Converts the attributes hash into format recognizable by Sugar
+  # { :last_name => "Smith"} 
+  # becomes
+  # { :last_name => {:name => "last_name", :value => "Smith"}}
+  def serialize_attributes
+    attr_hash = {}
+    @attributes.each_pair do |name,value|
+      attr_hash[name] = serialize_attribute(name,value)
+    end
+    attr_hash[:id] = serialize_id unless new?
+    attr_hash
+  end
+
+  # Converts the modified_attributes hash into format recognizable by Sugar
+  # { :last_name => {:old => "Smit", :new => "Smith"}} 
+  # becomes
+  # { :last_name => {:name => "last_name", :value => "Smith"}}  
+  def serialize_modified_attributes
+    attr_hash = {}
+    @modified_attributes.each_pair do |name,hash|
+      attr_hash[name] = serialize_attribute(name,hash[:new])
+    end
+    attr_hash[:id] = serialize_id unless new?
+    attr_hash
+  end
+  
+  # Un-typecasts the attribute - false becomes 0
+  def serialize_attribute(name,value)
+    attr_value = value
+    attr_type  = attr_type_for(name) 
+    case attr_type
+    when :bool
+      attr_value = 0
+      attr_value = 1 if value
+    when :datetime, :datetimecombo
+      begin
+        attr_value = value.strftime("%Y-%m-%d %H:%M:%S")
+      rescue
+        attr_value = value
+      end
+    when :int
+      attr_value = value.to_s
+    end
+    {:name => name, :value => attr_value}
+  end
+end; end

data/lib/sugarcrm/attributes/attribute_typecast.rb

@@ -0,0 +1,39 @@
+module SugarCRM; module AttributeTypeCast
+
+  protected
+  
+  # Returns the attribute type for a given attribute
+  def attr_type_for(attribute)
+    # sometimes the module fields aren't loaded. Why?
+    fields = self.class._module.fields
+    field  = fields[attribute]
+    raise UninitializedModule, "SugarCRM::Module #{self.class._module.name} was not initialized properly (fields.length == 0)" if fields.length == 0
+    raise InvalidAttribute, "#{self.class}_module.fields does not contain an entry for #{attribute} (of type: #{attribute.class})\nValid fields: #{self.class._module.fields.keys.sort.join(", ")}" if field.nil?
+    raise InvalidAttributeType, "#{self.class}._module.fields[#{attribute}] does not have a key for \'type\'" if field["type"].nil?
+    #return :string unless field.is_a? Hash
+    field["type"].to_sym
+  end
+
+  # Attempts to typecast each attribute based on the module field type
+  def typecast_attributes
+    @attributes.each_pair do |name,value|
+      # skip primary key columns
+      next if name == "id"
+      attr_type = attr_type_for(name)
+      case attr_type
+      when :bool
+        @attributes[name] = (value == "1")
+      when :datetime, :datetimecombo
+        begin
+          @attributes[name] = DateTime.parse(value)
+        rescue
+          @attributes[name] = value
+        end
+      when :int
+        @attributes[name] = value.to_i
+      end
+    end
+    @attributes
+  end
+
+end; end

data/lib/sugarcrm/attributes/attribute_validations.rb

@@ -0,0 +1,37 @@
+module SugarCRM; module AttributeValidations
+  # Checks to see if we have all the neccessary attributes
+  def valid?
+    @errors = Set.new
+    self.class._module.required_fields.each do |attribute|
+      valid_attribute?(attribute)
+    end
+    @errors.length == 0
+  end
+  
+  protected
+  
+  # TODO: Add test cases for validations
+  def valid_attribute?(attribute)
+    case attr_type_for(attribute)
+    when :bool
+      validate_class_for(attribute, [TrueClass, FalseClass])
+    when :datetime, :datetimecombo
+      validate_class_for(attribute, [DateTime])
+    when :int
+      validate_class_for(attribute, [Fixnum, Float])
+    else 
+      if @attributes[attribute].blank?
+        @errors.add "#{attribute} cannot be blank"
+      end
+    end
+  end
+  
+  # Compares the class of the attribute with the class or classes provided in the class array
+  # returns true if they match, otherwise adds an entry to the @errors collection, and returns false
+  def validate_class_for(attribute, class_array)
+    return true if class_array.include? @attributes[attribute].class
+    @errors.add "#{attribute} must be a #{class_array.join(" or ")} object (not #{@attributes[attribute].class})"
+    false  
+  end
+  
+end; end

data/lib/sugarcrm/base.rb

@@ -1,10 +1,7 @@
-require 'sugarcrm/attribute_methods'
-require 'sugarcrm/association_methods'
-
 module SugarCRM; class Base 
 
   # Unset all of the instance methods we don't need.
-  instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$|^define_method$|^class$|^methods$|^instance_of.$|^respond_to.$)/ }
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$|^define_method$|^class$|^nil.$|^methods$|^instance_of.$|^respond_to.$)/ }
 
   # This holds our connection
   cattr_accessor :connection, :instance_writer => false
@@ -23,7 +20,6 @@ module SugarCRM; class Base
   attr :attributes, true
   attr :modified_attributes, true
   attr :associations, true
-  attr :id, true
   attr :debug, true
   attr :errors, true
 
@@ -59,12 +55,44 @@ module SugarCRM; class Base
     def all(*args)
       find(:all, *args)
     end
+    
+    # Creates an object (or multiple objects) and saves it to SugarCRM, if validations pass.
+    # The resulting object is returned whether the object was saved successfully to the database or not.
+    #
+    # The +attributes+ parameter can be either be a Hash or an Array of Hashes.  These Hashes describe the
+    # attributes on the objects that are to be created.
+    #
+    # ==== Examples
+    #   # Create a single new object
+    #   User.create(:first_name => 'Jamie')
+    #
+    #   # Create an Array of new objects
+    #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+    #
+    #   # Create a single object and pass it into a block to set other attributes.
+    #   User.create(:first_name => 'Jamie') do |u|
+    #     u.is_admin = false
+    #   end
+    #
+    #   # Creating an Array of new objects using a block, where the block is executed for each object:
+    #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
+    #     u.is_admin = false
+    #   end
+    def create(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| create(attr, &block) }
+      else
+        object = new(attributes)
+        yield(object) if block_given?
+        object.save
+        object
+      end
+    end
 
     private 
     
     def find_initial(options)
-      # TODO: Look into fixing this to actually work
-      #options.update(:max_results => 1)
+      options.update(:limit => 1)
       find_every(options)
     end
   
@@ -142,7 +170,7 @@ module SugarCRM; class Base
           unless column =~ /_c$/ # attribute name ending with _c implies a custom attribute
             condition_attribute = "#{self._module.table_name}.#{column}"
           else
-            condition_attribute = column # if setting a condition on a customer attribute, don't add model table name (or query breaks)
+            condition_attribute = column # if setting a condition on a custom attribute (i.e. created by user in Studio), don't add model table name (or query breaks)
           end
           conditions << "#{condition_attribute} #{operator} \'#{value}\'"
         }
@@ -298,12 +326,11 @@ module SugarCRM; class Base
   # are using Base.establish_connection, you should be fine.  But if you are 
   # using the Connection class by itself, you may need to prime the pump with
   # a call to Module.register_all
-  def initialize(id=nil, attributes={})
-    @id = id
-    @attributes = self.class.attributes_from_module_fields.merge(attributes)
+  def initialize(attributes={})
     @modified_attributes = {}
+    merge_attributes(attributes.with_indifferent_access)
+    clear_association_cache
     @associations = self.class.associations_from_module_link_fields
-    @errors = Set.new
     define_attribute_methods
     define_association_methods
     typecast_attributes
@@ -325,28 +352,54 @@ module SugarCRM; class Base
   # Saves the current object, checks that required fields are present.
   # returns true or false
   def save
-    return false unless changed?
-    return false unless valid?
-    # If we get a Hash back, return true.  Otherwise return false.
-    (SugarCRM.connection.set_entry(self.class._module.name, serialize_modified_attributes).class == Hash)
+    return false if !changed?
+    return false if !valid?
+    begin
+      save!
+    rescue
+      return false
+    end
+    true
   end
   
   # Saves the current object, checks that required fields are present.
   # raises an exception if a save fails
   def save!
-    raise InvalidRecord, errors.to_a.join(", ") unless valid?
-    # If we get a Hash back, return true.  Otherwise return false.
-    (SugarCRM.connection.set_entry(self.class._module.name, serialize_modified_attributes).class == Hash)   
+    save_modified_attributes
+    save_modified_associations
+    true
   end
   
   def delete
-    return false if @id.blank?
+    return false if id.blank?
     params          = {}
     params[:id]     = serialize_id
     params[:deleted]= {:name => "deleted", :value => "1"}
     (SugarCRM.connection.set_entry(self.class._module.name, params).class == Hash)       
   end
-    
+  
+  # Returns true if +comparison_object+ is the same exact object, or +comparison_object+ 
+  # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+  #
+  # Note that new records are different from any other record by definition, unless the
+  # other record is the receiver itself. Besides, if you fetch existing records with
+  # +select+ and leave the ID out, you're on your own, this predicate will return false.
+  #
+  # Note also that destroying a record preserves its ID in the model instance, so deleted
+  # models are still comparable.
+  def ==(comparison_object)
+      comparison_object.instance_of?(self.class) &&
+      id.present? &&
+      comparison_object.id == id
+  end
+  
+  
+  # Delegates to id in order to allow two records of the same type and id to work with something like:
+  #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+  def hash
+    id.hash
+  end
+  
   
   # Wrapper around class attribute
   def attribute_methods_generated?
@@ -360,6 +413,9 @@ module SugarCRM; class Base
   Base.class_eval do
     include AttributeMethods
     extend  AttributeMethods::ClassMethods
+    include AttributeValidations
+    include AttributeTypeCast
+    include AttributeSerializers
     include AssociationMethods
     extend  AssociationMethods::ClassMethods
   end

data/lib/sugarcrm/connection.rb

@@ -1,139 +1,5 @@
-require 'uri'
-require 'net/https'
-
-require 'rubygems'
-# TODO: Remove this dependency - ActiveSupport should cover it.
-require 'json'
-
 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) }
-
-module SugarCRM; class Connection
-
-  URL = "/service/v2/rest.php"
-  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?
-    @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])
-    if @request.length > 3900
-      @response = @connection.post(@url.path, @request)
-    else
-      @response = @connection.get(@url.path.dup + "?" + @request.to_s)
-    end
-    handle_response
-  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/connection/api/get_entry_list.rb

@@ -2,7 +2,7 @@ module SugarCRM; class Connection
 # Retrieve a list of SugarBeans.  This is the primary method for getting 
 # a list of SugarBeans using the REST API.
 def get_entry_list(module_name, query, opts={})
-  login! unless logged_in?  
+  login! unless logged_in?
   options = {
     :order_by => '', 
     :offset => '',