openstax_active_force 1.0.0

data/lib/active_force/association/eager_load_projection_builder.rb

@@ -0,0 +1,60 @@
+module ActiveForce
+  module Association
+    class EagerLoadProjectionBuilder
+      class << self
+        def build(association)
+          new(association).projections
+        end
+      end
+
+      attr_reader :association
+
+      def initialize(association)
+        @association = association
+      end
+
+      def projections
+        klass = association.class.name.split('::').last
+        builder_class = ActiveForce::Association.const_get "#{klass}ProjectionBuilder"
+        builder_class.new(association).projections
+      rescue NameError
+        raise "Don't know how to build projections for #{klass}"
+      end
+    end
+
+    class AbstractProjectionBuilder
+      attr_reader :association
+
+      def initialize(association)
+        @association = association
+      end
+
+      def projections
+        raise "Must define #{self.class.name}#projections"
+      end
+    end
+
+    class HasManyAssociationProjectionBuilder < AbstractProjectionBuilder
+      ###
+      # Use ActiveForce::Query to build a subquery for the SFDC
+      # relationship name. Per SFDC convention, the name needs
+      # to be pluralized
+      def projections
+        match = association.sfdc_association_field.match /__r\z/
+        # pluralize the table name, and append '__r' if it was there to begin with
+        relationship_name = association.sfdc_association_field.sub(match.to_s, '').pluralize + match.to_s
+        query = Query.new relationship_name
+        query.fields association.relation_model.fields
+        ["(#{query.to_s})"]
+      end
+    end
+
+    class BelongsToAssociationProjectionBuilder < AbstractProjectionBuilder
+      def projections
+        association.relation_model.fields.map do |field|
+          "#{ association.sfdc_association_field }.#{ field }"
+        end
+      end
+    end
+  end
+end

data/lib/active_force/association/has_many_association.rb

@@ -0,0 +1,33 @@
+module ActiveForce
+  module Association
+    class HasManyAssociation < Association
+      private
+
+      def default_foreign_key
+        infer_foreign_key_from_model @parent
+      end
+
+      def define_relation_method
+        association = self
+        _method = @relation_name
+        @parent.send :define_method, _method do
+          association_cache.fetch _method do
+            query = association.relation_model.query
+            if scope = association.options[:scoped_as]
+              if scope.arity > 0
+                query.instance_exec self, &scope
+              else
+                query.instance_exec &scope
+              end
+            end
+            association_cache[_method] = query.where association.foreign_key => self.id
+          end
+        end
+
+        @parent.send :define_method, "#{_method}=" do |associated|
+          association_cache[_method] = associated
+        end
+      end
+    end
+  end
+end

data/lib/active_force/association/relation_model_builder.rb

@@ -0,0 +1,70 @@
+module ActiveForce
+  module Association
+    class RelationModelBuilder
+      class << self
+        def build(association, value)
+          new(association, value).build_relation_model
+        end
+      end
+
+      def initialize(association, value)
+        @association = association
+        @value = value
+      end
+
+      def build_relation_model
+        klass = resolve_class
+        klass.new(@association, @value).call
+      end
+
+      private
+
+      def resolve_class
+        association_builder = @value.class.name.gsub('::', '_')
+        ActiveForce::Association.const_get "BuildFrom#{association_builder}"
+      rescue NameError
+        raise "Don't know how to build relation from #{@value.class.name}"
+      end
+    end
+
+    class AbstractBuildFrom
+      attr_reader :association, :value
+
+      def initialize(association, value)
+        @association = association
+        @value = value
+      end
+
+      def call
+        raise "Must implement #{self.class.name}#call"
+      end
+    end
+
+    class BuildFromHash < AbstractBuildFrom
+      def call
+        association.build value
+      end
+    end
+
+    class BuildFromArray < AbstractBuildFrom
+      def call
+        value.map { |mash| association.build mash }
+      end
+    end
+
+    class BuildFromNilClass < AbstractBuildFrom
+      def call
+        association.is_a?(BelongsToAssociation) ? nil : []
+      end
+    end
+
+    class BuildFromRestforce_SObject < BuildFromHash
+    end
+
+    class BuildFromRestforce_Mash < BuildFromHash
+    end
+
+    class BuildFromRestforce_Collection < BuildFromArray
+    end
+  end
+end

data/lib/active_force/association.rb

@@ -0,0 +1,28 @@
+require 'active_force/association/association'
+require 'active_force/association/eager_load_projection_builder'
+require 'active_force/association/relation_model_builder'
+require 'active_force/association/has_many_association'
+require 'active_force/association/belongs_to_association'
+
+module ActiveForce
+  module Association
+    def associations
+      @associations ||= {}
+    end
+
+    # i.e name = 'Quota__r'
+    def find_association name
+      associations.values.detect do |association|
+        association.represents_sfdc_table? name
+      end
+    end
+
+    def has_many relation_name, options = {}
+      associations[relation_name] = HasManyAssociation.new(self, relation_name, options)
+    end
+
+    def belongs_to relation_name, options = {}
+      associations[relation_name] = BelongsToAssociation.new(self, relation_name, options)
+    end
+  end
+end

data/lib/active_force/attribute.rb

@@ -0,0 +1,30 @@
+module ActiveForce
+  class Attribute
+
+    attr_accessor :local_name, :sfdc_name, :as
+
+    def initialize name, options = {}
+      self.local_name = name
+      self.sfdc_name  = options[:sfdc_name] || options[:from] || default_api_name
+      self.as         = options[:as]        || :string
+    end
+
+    def value_for_hash value
+      case as
+      when :multi_picklist
+        value.reject(&:empty?).join(';')
+      else
+        value
+      end
+    end
+
+    private
+
+    ###
+    # Transforms +attribute+ to the conventional Salesforce API name.
+    #
+    def default_api_name
+      local_name.to_s.split('_').map(&:capitalize).join('_') << '__c'
+    end
+  end
+end

data/lib/active_force/mapping.rb

@@ -0,0 +1,78 @@
+require 'active_force/attribute'
+require 'active_force/table'
+require 'forwardable'
+
+module ActiveForce
+  class Mapping
+    extend Forwardable
+
+    STRINGLIKE_TYPES = [
+      nil, :string, :base64, :byte, :ID, :reference, :currency, :textarea,
+      :phone, :url, :email, :combobox, :picklist, :multipicklist, :anyType,
+      :location
+    ]
+
+    def_delegators :table, :custom_table?, :table_name
+
+    def initialize model
+      @model = model
+    end
+
+    def mappings
+      Hash[fields.map { |field, attr| [field, attr.sfdc_name] }]
+    end
+
+    def sfdc_names
+      mappings.values
+    end
+
+    def field name, options
+      fields.merge!({ name => ActiveForce::Attribute.new(name, options) })
+    end
+
+    def table
+      @table ||= ActiveForce::Table.new @model
+    end
+
+    def translate_to_sf attributes
+      attrs = attributes.map do |attribute, value|
+        attr = fields[attribute.to_sym]
+        [attr.sfdc_name, attr.value_for_hash(value)]
+      end
+      Hash[attrs]
+    end
+
+    def translate_value value, field_name
+      return value unless !!field_name
+      typecast_value value, fields[field_name].as
+    end
+
+
+    private
+
+    def fields
+      @fields ||= {}
+    end
+
+    # Handles Salesforce FieldTypes as described here:
+    # http://www.salesforce.com/us/developer/docs/api/Content/sforce_api_calls_describesobjects_describesobjectresult.htm#i1427700
+    def typecast_value value, type
+      case type
+      when *STRINGLIKE_TYPES
+        value.to_s
+      when :boolean
+        !['false','0','f'].include? value.to_s.downcase
+      when :int
+        value.to_i
+      when :double, :percent
+        value.to_f
+      when :date
+        Date.parse value
+      when :datetime
+        DateTime.parse value
+      else
+        value
+      end
+    end
+  end
+end

data/lib/active_force/query.rb

@@ -0,0 +1,110 @@
+module ActiveForce
+  class Query
+    attr_reader :table
+
+    def initialize table
+      @table = table
+      @conditions = []
+      @table_id = 'Id'
+      @query_fields = [@table_id]
+    end
+
+    def fields fields_collection = []
+      @query_fields += fields_collection.to_a
+    end
+
+    def all
+      self
+    end
+
+    def to_s
+      <<-SOQL.gsub(/\s+/, " ").strip
+        SELECT
+          #{ build_select }
+        FROM
+          #{ @table }
+        #{ build_where }
+        #{ build_order }
+        #{ build_limit }
+        #{ build_offset }
+      SOQL
+    end
+
+    def select *columns
+      @query_fields = columns
+      self
+    end
+
+    def where condition
+      @conditions << condition if condition
+      self
+    end
+
+    def order order
+      @order = order if order
+      self
+    end
+
+    def limit size
+      @size = size if size
+      self
+    end
+
+    def limit_value
+      @size
+    end
+
+    def offset offset
+      @offset = offset
+      self
+    end
+
+    def offset_value
+      @offset
+    end
+
+    def find id
+      where "#{ @table_id } = '#{ id }'"
+      limit 1
+    end
+
+    def first
+      limit 1
+    end
+
+    def last
+      order("Id DESC").limit(1)
+    end
+
+    def join object_query
+      fields ["(#{ object_query.to_s })"]
+      self
+    end
+
+    def count
+      @query_fields = ["count(Id)"]
+      self
+    end
+
+    protected
+      def build_select
+        @query_fields.compact.uniq.join(', ')
+      end
+
+      def build_where
+        "WHERE (#{ @conditions.join(') AND (') })" unless @conditions.empty?
+      end
+
+      def build_limit
+        "LIMIT #{ @size }" if @size
+      end
+
+      def build_order
+        "ORDER BY #{ @order }" if @order
+      end
+
+      def build_offset
+        "OFFSET #{ @offset }" if @offset
+      end
+  end
+end

data/lib/active_force/sobject.rb

@@ -0,0 +1,210 @@
+require 'active_model'
+require 'active_attr'
+require 'active_attr/dirty'
+require 'active_force/active_query'
+require 'active_force/association'
+require 'active_force/mapping'
+require 'yaml'
+require 'forwardable'
+require 'logger'
+require 'restforce'
+
+module ActiveForce
+  class RecordInvalid < StandardError;end
+
+  class SObject
+    include ActiveAttr::Model
+    include ActiveAttr::Dirty
+    extend ActiveForce::Association
+    extend ActiveModel::Callbacks
+
+    define_model_callbacks :save, :create, :update
+
+    class_attribute :mappings, :table_name
+
+    class << self
+      extend Forwardable
+      def_delegators :query, :where, :first, :last, :all, :find, :find_by, :count, :includes, :limit, :order, :select, :none
+      def_delegators :mapping, :table, :table_name, :custom_table?, :mappings
+
+      private
+
+      ###
+      # Provide each subclass with a default id field. Can be overridden
+      # in the subclass if needed
+      def inherited(subclass)
+        subclass.field :id, from: 'Id'
+      end
+    end
+
+    def self.mapping
+      @mapping ||= ActiveForce::Mapping.new name
+    end
+
+    def self.fields
+      mapping.sfdc_names
+    end
+
+    def self.query
+      ActiveForce::ActiveQuery.new self
+    end
+
+    def self.build mash
+      return unless mash
+      sobject = new
+      mash.each do |column, sf_value|
+        sobject.write_value column, sf_value
+      end
+      sobject.clear_changes_information
+      sobject
+    end
+
+    def update_attributes! attributes = {}
+      assign_attributes attributes
+      validate!
+      run_callbacks :save do
+        run_callbacks :update do
+          sfdc_client.update! table_name, attributes_for_sfdb
+          changes_applied
+        end
+      end
+      true
+    end
+
+    alias_method :update!, :update_attributes!
+
+    def update_attributes attributes = {}
+      update_attributes! attributes
+    rescue Faraday::Error::ClientError, RecordInvalid => error
+      handle_save_error error
+    end
+
+    alias_method :update, :update_attributes
+
+    def create!
+      validate!
+      run_callbacks :save do
+        run_callbacks :create do
+          self.id = sfdc_client.create! table_name, attributes_for_sfdb
+          changes_applied
+        end
+      end
+      self
+    end
+
+    def create
+      create!
+    rescue Faraday::Error::ClientError, RecordInvalid => error
+      handle_save_error error
+      self
+    end
+
+    def destroy
+      sfdc_client.destroy! self.class.table_name, id
+    end
+
+    def self.create args
+      new(args).create
+    end
+
+    def self.create! args
+      new(args).create!
+    end
+
+    def save!
+      run_callbacks :save do
+        if persisted?
+          !!update!
+        else
+          !!create!
+        end
+      end
+    end
+
+    def save
+      save!
+    rescue Faraday::Error::ClientError, RecordInvalid => error
+      handle_save_error error
+    end
+
+    def to_param
+      id
+    end
+
+    def persisted?
+      !!id
+    end
+
+    def self.field field_name, args = {}
+      mapping.field field_name, args
+      attribute field_name
+    end
+
+    def reload
+      association_cache.clear
+      reloaded = self.class.find(id)
+      self.attributes = reloaded.attributes
+      clear_changes_information
+      self
+    end
+
+    def write_value column, value
+      if association = self.class.find_association(column)
+        field = association.relation_name
+        value = Association::RelationModelBuilder.build(association, value)
+      else
+        field = mappings.invert[column]
+        value = self.class.mapping.translate_value value, field unless value.nil?
+      end
+      send "#{field}=", value if field
+    end
+
+   private
+
+    def validate!
+      unless valid?
+        raise RecordInvalid.new(
+          "Validation failed: #{errors.full_messages.join(', ')}"
+        )
+      end
+    end
+
+    def handle_save_error error
+      return false if error.class == RecordInvalid
+      logger_output __method__, error, attributes
+    end
+
+    def association_cache
+      @association_cache ||= {}
+    end
+
+    def logger_output action, exception, params = {}
+      logger = Logger.new($stdout)
+      logger.info("[SFDC] [#{self.class.model_name}] [#{self.class.table_name}] Error while #{ action }, params: #{params}, error: #{exception.inspect}")
+      errors[:base] << exception.message
+      false
+    end
+
+    def attributes_for_sfdb
+      attrs = self.class.mapping.translate_to_sf(attributes_and_changes)
+      attrs.merge!({'Id' => id }) if persisted?
+      attrs
+    end
+
+    def self.picklist field
+      picks = sfdc_client.picklist_values(table_name, mappings[field])
+      picks.map do |value|
+        [value[:label], value[:value]]
+      end
+    end
+
+    def self.sfdc_client
+      ActiveForce.sfdc_client
+    end
+
+    def sfdc_client
+      self.class.sfdc_client
+    end
+  end
+
+end