activeforce 1.5.0

data/lib/salesforce/bulk/batch.rb

@@ -0,0 +1,77 @@
+module Salesforce
+  module Bulk
+    class Batch
+      Result = Struct.new :id, :success, :created, :error
+      include ::Salesforce::Attributes
+      
+      attr_accessor :id, :job, :number_records_failed, :number_records_processed, :state, :state_message, :total_time_processed, :filename, :csv
+
+      include Blockenspiel::DSL
+      
+      def initialize(job)
+        self.job = job
+        self.filename = temporary_csv_file
+        self.csv = FasterCSV.open(self.filename, 'w+')
+        self.csv << csv_header
+      end
+            
+      def record(record)
+        if record.is_a?(Hash)
+          self.csv << ordered_values(record)
+        else
+          self.csv << ordered_values(record.attributes)
+        end
+      end
+      
+      def ordered_values(record)
+        job.csv_columns.map do |col|
+          raw_value = record[col.name.to_sym]
+          Column.to_csv_value Column.typecast(col.type, raw_value)
+        end
+      end
+        
+      def create!
+        self.csv.close
+        response = ::Salesforce.connection.async_post("job/#{job.id}/batch", File.read(self.filename), :format => :xml, :content_type => 'text/csv')
+        assign_attributes!(response)
+      end
+      
+      def update_status
+        return state if completed?
+        response = ::Salesforce.connection.async_get("job/#{job.id}/batch/#{id}", :format => :xml)
+        self.state = response[:state]
+      end
+      
+      def results
+        parse_csv_results ::Salesforce.connection.async_get("job/#{job.id}/batch/#{id}/result")
+      end
+      
+      [ :queued, :in_progress, :completed, :failed, :not_processed ].each do |status|
+        define_method "#{status}?" do
+          self.state == status.to_s.titleize
+        end
+      end
+      
+      def temporary_csv_file
+        if Object.const_defined?(:Rails)
+          Rails.root.join('tmp', 'files', "#{ Time.now.to_i}#{rand(10000)}.csv")
+        else
+          File.join("/tmp/#{ Time.now.to_i}#{rand(10000)}.csv")
+        end
+      end
+      
+      private
+      
+      def parse_csv_results(results)
+         parsed_results = FasterCSV.parse(results)
+         parsed_results[1..-1].map { |row| Result.new(*row) }
+      end
+      
+      def csv_header
+        self.job.csv_columns.map(&:original_name)
+      end
+      
+      
+    end
+  end
+end

data/lib/salesforce/bulk/job.rb

@@ -0,0 +1,103 @@
+module Salesforce
+  module Bulk
+    class Job
+      include ::Salesforce::Attributes
+      
+      include Blockenspiel::DSL
+      
+      attr_accessor :id, :operation, :object, :state, :concurrency_mode, :content_type, :number_of_batches_queued, 
+                    :number_batches_in_progress, :number_batches_completed, :number_batches_failed, :number_batches_total,
+                    :number_records_processed, :number_retries, :object_type, :batches, :columns
+      
+      [ :open, :closed, :aborted, :failed ].each do |status|
+        define_method "#{status}?" do
+          self.state == status.to_s.titleize
+        end
+      end
+      
+      def initialize(object_type, operation, columns = :all)
+        self.object_type = object_type
+        self.object = object_type.table_name
+        self.operation = operation.to_s.downcase
+        self.parallel!
+        self.batches = []
+        self.columns = columns
+      end
+      
+      def parallel!
+        self.concurrency_mode = "Parallel"
+      end
+      
+      def serial!
+        self.concurrency_mode = "Serial"
+      end
+      
+      def batch(&block)
+        Batch.new(self).tap do |batch|
+          Blockenspiel.invoke(block, batch)
+          self.batches << batch
+        end
+      end
+            
+      def process!
+        create_job!
+        create_batches!
+        close_job!
+      end
+      
+      def completed?
+        self.batches.each(&:update_status)
+        self.batches.all? { |batch| batch.completed? || batch.failed? }
+      end
+      
+      def results
+        self.batches.map(&:results).flatten
+      end
+      
+      private
+      
+      def create_job!
+        response = ::Salesforce.connection.async_post("job", create_job_xml, :format => :xml)
+        assign_attributes!(response)
+      end
+      
+      def create_batches!
+        batches.each(&:create!)
+      end
+      
+      def close_job!
+        response = ::Salesforce.connection.async_post("job/#{id}", close_job_xml, :format => :xml)
+        assign_attributes!(response)
+      end
+      
+      def create_job_xml
+        job_xml do |job_info|
+          job_info.operation self.operation
+          job_info.object    self.object
+          job_info.contentType "CSV"
+        end
+      end
+      
+      def close_job_xml
+        job_xml do |job_info|
+          job_info.state "Closed"
+        end
+      end
+      
+      def job_xml(&block)
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct!
+        xml.jobInfo :xmlns => "http://www.force.com/2009/06/asyncapi/dataload" do |job_info|
+          block.call(job_info)
+        end
+        xml.target!
+      end
+      
+      def csv_header
+        csv_columns.map(&:original_name)
+      end
+      
+      
+    end
+  end
+end

data/lib/salesforce/bulk/operations.rb

@@ -0,0 +1,25 @@
+module Salesforce
+  module Bulk
+    module Operations
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+# Create a bulk update job
+# job = Salesforce::Account.bulk_update do
+#   batch do
+#     record account_1
+#     record account_2
+#   end
+# end
+# 
+
+        def bulk_update(columns = [], &block)
+          UpdateJob.new(self, columns).tap do |job|
+            Blockenspiel.invoke(block, job)
+            job.process!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/salesforce/bulk/update_job.rb

@@ -0,0 +1,24 @@
+module Salesforce
+  module Bulk
+    class UpdateJob < Job
+      
+      def initialize(object_type, columns = :all)
+        super(object_type, 'update', columns)
+      end
+      
+      def csv_columns
+        [ object_type.columns.id_column ] + if columns.blank? || columns == :all
+          object_type.columns.updateable
+        else
+          columns.map do |col|
+            sf_col = object_type.columns.find { |scol| scol.name == col.to_s  }
+            raise UnrecognizedColumn.new("#{col} is not a valid column.") unless sf_col
+            sf_col
+          end
+        end
+      end
+        
+      
+    end
+  end
+end

data/lib/salesforce/column.rb

@@ -0,0 +1,98 @@
+module Salesforce
+  class Column
+    attr_accessor :name, :original_name, :createable, :updateable, :type
+
+    def initialize(field)
+      self.original_name = field["name"]
+      self.name          = field["name"].gsub(/\_\_c$/, '').underscore
+      self.type          = field["type"].to_sym
+      self.createable    = field['createable']
+      self.updateable    = field["updateable"]
+    end
+
+    def createable?
+      createable
+    end
+
+    def updateable?
+      updateable
+    end
+
+    def editable?
+      createable? || updateable?
+    end
+
+
+    def self.to_soql_value(obj)
+      case (obj)
+        when Date
+          obj.strftime("%Y-%m-%d")
+        when TrueClass
+          'TRUE'
+        when FalseClass
+          'FALSE'
+        when Time
+          obj.xmlschema
+        when nil
+          'NULL'
+        when Numeric
+          "#{obj.to_s}"
+        when Array
+          "(#{obj.map { |sobj| to_soql_value(sobj) }.join(',')})"
+        else
+          "'#{obj.to_s}'"
+      end
+    end
+
+    def self.to_csv_value(obj)
+      case (obj)
+        when Date;
+          obj.strftime("%Y-%m-%d")
+        when TrueClass;
+          'TRUE'
+        when FalseClass;
+          'FALSE'
+        when Time;
+          obj.xmlschema
+        else
+          "#{obj.to_s}"
+      end
+    end
+
+    def self.typecast(type, value)
+      case (type)
+        when :id, :reference
+          if Config.use_full_length_ids?
+            value
+          else
+            value.to_s.size == 15 ? value : value.to_s[0..14]
+          end
+        when :date
+          begin
+            Date.parse(value);
+          rescue
+            value if value.is_a?(Date)
+          end
+        when :datetime
+          begin
+            Time.parse(value)
+          rescue
+            value if value.is_a?(Time)
+          end
+        when :double
+          begin
+            BigDecimal(value.to_s)
+          rescue
+            value if value.is_a?(Numeric)
+          end
+        else
+          value
+      end
+    end
+
+    def ==(other)
+      return false unless other
+      self.name == other.name && self.original_name == other.original_name
+    end
+  end
+end

data/lib/salesforce/columns.rb

@@ -0,0 +1,60 @@
+module Salesforce
+  class Columns
+    include Enumerable
+    attr_accessor :by_name, :by_original_name, :table_name
+
+    def initialize(table_name)
+      self.table_name = table_name
+      fields = Connection.fields(table_name)
+      self.by_name          = {}
+      self.by_original_name = {}
+      fields.each do |field|
+        column = Column.new(field)
+        by_name[column.name] = column
+        by_original_name[column.original_name] = column
+      end
+    end
+    
+    def each(&block)
+      all.each(&block)
+    end
+    
+    def all
+      @all ||= by_name.values.flatten
+    end
+    
+    def editable
+      @editable ||= select(&:editable?)
+    end
+    
+    def createable
+      select(&:createable?)
+    end
+    
+    def updateable
+      select(&:updateable?)
+    end
+    
+    def id_column
+      find { |col| col.name.to_sym == :id }
+    end
+    
+    def names
+      map(&:name)
+    end
+    
+    def soql_selector
+      @soql_selector ||= by_original_name.keys.sort.join(',')
+    end
+    
+    def ==(other)
+      other && self.all.map(&:name) == other.all.map(&:name)
+    end
+    
+    def find_by_name(name)
+      column = by_name[name.to_s]
+      raise ColumnNotFound.new(name, table_name) unless column
+      column
+    end
+  end
+end

data/lib/salesforce/config.rb

@@ -0,0 +1,110 @@
+module Salesforce
+  class Config
+
+    DEFAULT_API_VERSION = "22.0"
+
+    include Blockenspiel::DSL
+    include Blockenspiel::DSLSetupMethods
+
+    dsl_attr_accessor :session_id, :server_instance, :user_id, :soap_endpoint_url
+
+    [
+      :username, :password, :api_version, :use_sandbox?, :use_full_length_ids?,
+      :login_url, :session_id, :server_instance, :soap_endpoint_url, :soap_enterprise_namespace,
+      :user_id, :server_url, :server_host, :async_url, :configured?, :on_login_failure ].each do |method_name|
+      eval <<-RUBY
+      def self.#{method_name}
+        instance.#{method_name}
+      end
+      RUBY
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def username(*args, &block)
+      if block.present?
+        @username = Proc.new { block.call }
+      elsif args.present?
+        @username = args.first
+      elsif @username.respond_to?(:call)
+        @username.call
+      else
+        @username
+      end
+    end
+
+    def password(*args, &block)
+      if block.present?
+        @password = Proc.new { block.call }
+      elsif args.present?
+        @password = args.first
+      elsif @password.respond_to?(:call)
+        @password.call
+      else
+        @password
+      end
+    end
+
+    def api_version(val = nil)
+      if val
+        @api_version = val.to_f.to_s
+      else
+        @api_version || DEFAULT_API_VERSION
+      end
+    end
+
+    def use_sandbox?
+      @use_sandbox || false
+    end
+
+    def use_full_length_ids?
+      @use_full_length_ids || false
+    end
+
+    def use_full_length_ids
+      @use_full_length_ids = true
+    end
+
+    def use_sandbox
+      @use_sandbox = true
+    end
+
+    def on_login_failure(&block)
+      if block.present?
+        @on_login_failure = Proc.new { block.call }
+      else
+        @on_login_failure.try(:call)
+      end
+    end
+
+    def configured?
+      username.present? && password.present?
+    end
+
+    def soap_enterprise_namespace
+      'urn:enterprise.soap.sforce.com'
+    end
+
+    def server_url
+      "https://#{server_instance}.salesforce.com/services/data/v#{api_version}"
+    end
+
+    def server_host
+      "https://#{server_instance}.salesforce.com"
+    end
+
+    def async_url
+      "https://#{server_instance}.salesforce.com/services/async/#{api_version}"
+    end
+
+    def login_url
+      login_url_base + api_version
+    end
+
+    def login_url_base
+      use_sandbox? ? 'https://test.salesforce.com/services/Soap/c/' : 'https://login.salesforce.com/services/Soap/c/'
+    end
+  end
+end