active_zuora 1.3.0 → 2.6.0

data/lib/active_zuora/has_many_associations.rb

@@ -0,0 +1,37 @@
+module ActiveZuora
+  module HasManyAssociations
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def has_many(items, options={})
+        class_name = options[:class_name] || nested_class_name(items.to_s.singularize.camelize)
+        foreign_key = options[:foreign_key] || :"#{zuora_object_name.underscore}_id"
+        conditions = options[:conditions]
+        # :order => :name
+        # :order => [:name, :desc]
+        order_attribute, order_direction = [*options[:order]]
+        ivar = "@#{items}"
+        # Define the methods on an included module, so we can override
+        # them using super.
+        generated_attribute_methods.module_eval do
+          define_method(items) do
+            if instance_variable_get(ivar)
+              return instance_variable_get(ivar)
+            else
+              relation = class_name.constantize.where(foreign_key => self.id)
+              relation = relation.merge(conditions) if conditions.present?
+              relation.order_attribute = order_attribute if order_attribute.present?
+              relation.order_direction = order_direction if order_direction.present?
+              proxy = HasManyProxy.new(self, relation, options)
+              instance_variable_set(ivar, proxy)
+              proxy
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_zuora/has_many_proxy.rb

@@ -0,0 +1,50 @@
+module ActiveZuora
+  class HasManyProxy
+
+    # Wraps around the Relation representing a has_many association
+    # to add features like inverse_of loading.
+
+    attr_reader :scope, :owner
+
+    delegate :"==", :"===", :"=~", :inspect, :to_s, :to => :to_a
+    
+    def initialize(owner, scope, options={})
+      @owner, @scope = owner, scope
+      # inverse_of by default. You can opt out with :inverse_of => false
+      @inverse_of = (options[:inverse_of] || owner.zuora_object_name.underscore) unless options[:inverse_of] == false
+    end
+
+    def to_a
+      if @scope.loaded? || !@inverse_of
+        @scope.to_a
+      else
+        @scope.to_a.each { |record| record.send("#{@inverse_of}=", owner) }
+        @scope.to_a
+      end
+    end
+
+    alias :all :to_a
+
+    def reload
+      # If reload is called directly on the scope, it will reload
+      # without our extra functionality, like inverse_of loading.
+      @scope.unload
+      to_a
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      # If we do anything that needs loading the scope, then we'll load it.
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      else
+        # Otherwise send all messages to the @scope.
+        @scope.send(method, *args, &block)
+      end
+    end
+
+  end
+end
+
+

data/lib/active_zuora/lazy_attr.rb

@@ -0,0 +1,52 @@
+module ActiveZuora
+  module LazyAttr
+
+    # This is meant to be included onto an Invoice class.
+    # Returns true/false on success.
+    # Result hash is stored in #result.
+    # If success, the id will be set in the object.
+    # If failure, errors will be present on object.
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+    end
+
+
+    def fetch_field(field_name)
+      return nil unless self.id
+
+      records = fetch_field_records("select #{self.class.get_field!(field_name).zuora_name} from #{zuora_object_name} where Id = '#{self.id}'")
+      type_cast_fetched_field(field_name, records.nil? ? nil : records[field_name.to_sym])
+    end
+    private :fetch_field
+
+    def fetch_field_records(query_string)
+      response = self.class.connection.request(:query){ |soap| soap.body = { :query_string => query_string } }
+      response[:query_response][:result][:records]
+    end
+    private :fetch_field_records
+
+    def type_cast_fetched_field(field_name, value)
+      get_field!(field_name).type_cast(value)
+    end
+    private :type_cast_fetched_field
+
+    module ClassMethods
+      def lazy_load(*field_names)
+        Array(field_names).map(&:to_sym).each do |field_name|
+          define_lazy_field field_name
+        end
+      end
+
+      def define_lazy_field(field)
+        instance_eval do
+          define_method field do
+            instance_variable_get("@#{field}") || instance_variable_set("@#{field}", fetch_field(field))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_zuora/persistence.rb

@@ -0,0 +1,172 @@
+module ActiveZuora
+  module Persistence
+
+    extend ActiveSupport::Concern
+
+    MAX_BATCH_SIZE = 50
+
+    def new_record?
+      id.blank?
+    end
+
+    def save
+      new_record? ? create : update
+    end
+
+    def save!
+      raise "Could Not Save Zuora Object: #{errors.full_messages.join ', '}" unless save
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    def delete
+      self.class.delete(id) > 0
+    end
+
+    def reload
+      raise ArgumentError.new("You can't reload a new record") if new_record?
+      self.untracked_attributes = self.class.find(id).attributes
+      self
+    end
+
+    def xml_field_names
+      # If we're rendering an existing record, always include the id.
+      new_record? ? super : ([:id] + super).uniq
+    end
+
+    private
+
+    def create
+      return false unless new_record? && valid?
+      result = self.class.connection.request(:create) do |soap|
+        soap.body do |xml|
+          build_xml(xml, soap, 
+            :namespace => soap.namespace, 
+            :element_name => :zObjects,
+            :force_type => true)
+        end
+      end[:create_response][:result]
+      if result[:success]
+        self.id = result[:id]
+        clear_changed_attributes
+        true
+      else
+        errors.add(:base, result[:errors][:message]) if result[:errors]
+        false
+      end
+    end
+
+    def update
+      self.class.update(self)
+      self.errors.blank?
+    end
+
+    module ClassMethods
+
+      def create(attributes={})
+        new(attributes).tap(&:save)
+      end
+
+      def create!(attributes={})
+        new(attributes).tap(&:save!)
+      end
+
+      # Takes an array of zobjects and batch saves new and updated records separately
+      def save(*zobjects)
+        new_records = 0
+        updated_records = 0
+
+        # Get all new objects
+        new_objects = zobjects.flatten.select do |zobject|
+          zobject.new_record? && zobject.changed.present? && zobject.valid?
+        end
+
+        # Get all updated objects
+        updated_objects = zobjects.flatten.select do |zobject|
+          !zobject.new_record? && zobject.changed.present? && zobject.valid?
+        end
+
+        # Make calls in batches of 50
+        new_objects.each_slice(MAX_BATCH_SIZE) do |batch|
+          new_records += process_save(batch, :create)
+        end
+
+        updated_objects.each_slice(MAX_BATCH_SIZE) do |batch|
+          updated_records += process_save(batch, :update)
+        end
+
+        new_records + updated_records
+      end
+
+      # For backwards compatability
+      def update(*zobjects)
+        save(zobjects)
+      end
+
+      def process_save(zobjects, action)
+        unless [:create, :update].include? action
+          raise "Invalid action type for saving. Must be create or update." 
+        end
+
+        return 0 if zobjects.empty?
+
+        results = connection.request(action) do |soap|
+          soap.body do |xml|
+            zobjects.map do |zobject|
+              zobject.build_xml(xml, soap,
+                :namespace => soap.namespace,
+                :element_name => :zObjects,
+                :force_type => true,
+                :nil_strategy => :fields_to_null)
+            end.last
+          end
+        end["#{action.to_s}_response".to_sym][:result]
+
+        results = [results] unless results.is_a?(Array)
+        zobjects.zip(results).each do |zobject, result|
+          if result[:success]
+            zobject.clear_changed_attributes
+          else
+            zobject.add_zuora_errors result[:errors]
+          end
+        end
+
+        # Return the count of updates that succeeded.
+        results.select{ |result| result[:success] }.size
+      end
+
+      def delete(*ids)
+        ids.flatten!
+        deleted_records = 0
+        ids.each_slice(MAX_BATCH_SIZE) do |batch|
+          deleted_records += process_delete(batch)
+        end
+        deleted_records
+      end
+
+      def process_delete(*ids)
+        ids.flatten!
+        results = connection.request(:delete) do |soap|
+          qualifier = soap.namespace_by_uri(soap.namespace)
+          soap.body do |xml|
+            xml.tag!(qualifier, :type, zuora_object_name)
+            ids.map { |id| xml.tag!(qualifier, :ids, id) }.last
+          end
+        end[:delete_response][:result]
+        results = [results] unless results.is_a?(Array)
+        # Return the count of deletes that succeeded.
+        results.select{ |result| result[:success] }.size
+      end
+
+    end
+
+  end
+end

data/lib/active_zuora/relation.rb

@@ -0,0 +1,260 @@
+module ActiveZuora
+  class Relation
+
+    attr_accessor :selected_field_names, :filters, :order_attribute, :order_direction
+
+    attr_reader :zobject_class
+
+    def initialize(zobject_class, selected_field_names=[:id])
+      @zobject_class, @selected_field_names, @filters = zobject_class, selected_field_names, []
+
+      if field?(:created_date)
+        @order_attribute, @order_direction = :created_date, :asc
+      end
+    end
+
+    def dup
+      dup = super
+      dup.selected_field_names = dup.selected_field_names.dup
+      dup.filters = dup.filters.dup
+      dup.unload
+      dup
+    end
+
+    #
+    # Conditions / Selecting
+    #
+
+    def select(*field_names)
+      dup.tap { |dup| dup.selected_field_names = field_names.flatten }
+    end
+
+    def where(conditions)
+      dup.tap { |dup| dup.filters << ['and', conditions] }
+    end
+
+    alias :and :where
+
+    def or(conditions)
+      dup.tap { |dup| dup.filters << ['or', conditions] }\
+    end
+
+    def order(attribute, direction = :asc)
+      dup.tap do |dup|
+        dup.order_attribute = attribute
+        dup.order_direction = direction
+      end
+    end
+
+    def scoped
+      # Account.select(:id).where(:status => "Draft") do
+      #   Account.all # => select id from Account where status = "Draft"
+      # end
+      previous_scope, zobject_class.current_scope = zobject_class.current_scope, self
+      yield
+    ensure
+      zobject_class.current_scope = previous_scope
+    end
+
+    def merge(relation)
+      if relation.is_a?(Hash)
+        where(relation)
+      else
+        dup.tap do |dup|
+          dup.filters.concat relation.filters
+          dup.filters.uniq!
+          dup.order_attribute = relation.order_attribute
+          dup.order_direction = relation.order_direction
+        end
+      end
+    end
+
+    #
+    # Finding / Loading
+    #
+
+    def to_zql
+      select_statement + " from " + zobject_class.zuora_object_name + " " + where_statement
+    end
+
+    def find(id)
+      return nil if id.blank?
+      where(:id => id).first
+    end
+
+    def find_each(&block)
+      # Iterate through each item, but don't save the results in memory.
+      if loaded?
+        # If we're already loaded, iterate through the cached records.
+        to_a.each(&block)
+      else
+        query.each(&block)
+      end
+    end
+
+    def to_a
+      @records ||= query
+    end
+
+    alias :all :to_a
+
+    def loaded?
+      !@records.nil?
+    end
+
+    def unload
+      @records = nil
+      self
+    end
+
+    def reload
+      unload.to_a
+      self
+    end
+
+    def query(&block)
+      # Keep querying until all pages are retrieved.
+      # Throws an exception for an invalid query.
+      response = zobject_class.connection.request(:query){ |soap| soap.body = { :query_string => to_zql } }
+      query_response = response[:query_response]
+      records = objectify_query_results(query_response[:result][:records])
+      records.each(&:block) if block_given?
+      # If there are more pages of records, keep fetching
+      # them until done.
+      until query_response[:result][:done]
+        query_response = zobject_class.connection.request(:query_more) do |soap|
+          soap.body = { :query_locator => query_response[:result][:query_locator] }
+        end[:query_more_response]
+        more_records = objectify_query_results(query_response[:result][:records])
+        more_records.each(&:block) if block_given?
+        records.concat more_records
+      end
+      sort_records!(records)
+    rescue Savon::SOAP::Fault => exception
+      # Add the zql to the exception message and re-raise.
+      exception.message << ": #{to_zql}"
+      raise
+    end
+
+    #
+    # Updating / Deleting
+    #
+
+    def update_all(attributes={})
+      # Update using an attribute hash, or you can pass a block
+      # and update the attributes directly on the objects.
+      if block_given?
+        to_a.each { |record| yield record }
+      else
+        to_a.each { |record| record.attributes = attributes }
+      end
+      zobject_class.update(to_a)
+    end
+
+    def delete_all
+      zobject_class.delete(to_a.map(&:id))
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      # This is how the chaing can happen on class methods or named scopes on the
+      # ZObject class.
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif zobject_class.respond_to?(method)
+        scoped { zobject_class.send(method, *args, &block) }
+      else
+        super
+      end
+    end
+
+    #
+    # Helper methods to build the ZQL.
+    #
+
+    def select_statement
+      "select " + selected_field_names.map { |field_name| zuora_field_name(field_name) }.join(', ')
+    end
+
+    def where_statement
+      return '' if @filters.empty?
+      tokens = []
+      @filters.each do |logical_operator, conditions|
+        if conditions.is_a?(Hash)
+          conditions.each do |field_name, comparisons|
+            zuora_field_name = zuora_field_name(field_name)
+            comparisons = { '=' => comparisons } unless comparisons.is_a?(Hash)
+            comparisons.each do |operator, value|
+              tokens.concat [logical_operator, zuora_field_name, operator, escape_filter_value(value)]
+            end
+          end
+        else
+          tokens.concat [logical_operator, conditions.to_s]
+        end
+      end
+      tokens[0] = "where"
+      tokens.join ' '
+    end
+
+    def zuora_field_name(name)
+      zobject_class.get_field!(name).zuora_name
+    end
+
+    def escape_filter_value(value)
+      if value.nil?
+        "null"
+      elsif value.is_a?(String)
+        "'#{value.gsub("'","\\\\'")}'"
+      elsif value.is_a?(DateTime) || value.is_a?(Time)
+        # If we already have a DateTime or Time, use the zone it already has.
+        escape_filter_value(value.strftime("%FT%T%:z")) # 2007-11-19T08:37:48-06:00
+      elsif value.is_a?(Date)
+        # Create a DateTime from the date using Zuora's timezone.
+        escape_filter_value(value.to_datetime.change(:offset => "+0800"))
+      else
+        value
+      end
+    end
+
+    def objectify_query_results(results)
+      return [] if results.blank?
+      # Sometimes Zuora will return only a single record, not in an array.
+      results = [results] unless results.is_a?(Array)
+      results.map do |attributes|
+        # Strip any noisy attributes from the results that have to do with
+        # SOAP namespaces.
+        attributes.delete_if { |key, value| key.to_s.start_with? "@" }
+        # Instantiate the zobject class, but don't track the changes.
+        if ActiveSupport.version.to_s.to_f >= 5.2
+          zobject_class.new(attributes).tap { |record| record.clear_changes_information }
+        else
+          zobject_class.new(attributes).tap { |record| record.changed_attributes.clear }
+        end
+      end
+    end
+
+    def sort_records!(records)
+      return records unless order_attribute.present?
+      records.sort! do |a, b|
+        if a.nil?
+          -1
+        elsif b.nil?
+          1
+        else
+          a.send(order_attribute) <=> b.send(order_attribute)
+        end
+      end
+      records.reverse! if order_direction == :desc
+      records
+    end
+
+  end
+end
+
+
+
+
+
+
+