active_zuora 1.5.2 → 2.0.0

data/lib/active_zuora/relation.rb

@@ -0,0 +1,253 @@
+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, []
+      @order_attribute, @order_direction = :created_date, :asc
+    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 => response[: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.
+        zobject_class.new(attributes).tap { |record| record.clear_changed_attributes }
+      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
+
+
+
+
+    
+
+

data/lib/active_zuora/scoping.rb

@@ -0,0 +1,50 @@
+module ActiveZuora
+  module Scoping
+
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+
+        # Delegate to :scoped
+        delegate :find, :all, :find_each, :to => :scoped
+        delegate :select, :where, :and, :or, :order, :to => :scoped
+        delegate :first, :last, :each, :map, :any?, :empty?, :blank?, :present?, :size, :count, :to => :scoped
+
+        # Keep track of a current scope.
+        attr_accessor :current_scope
+
+      end
+    end
+
+    module ClassMethods
+
+      def scoped
+        current_scope || relation
+      end
+
+      def unscoped
+        block_given? ? relation.scoped { yield } : relation
+      end
+
+      def exclude_from_queries(*field_names)
+        (@excluded_from_queries ||= []).concat field_names.map(&:to_sym)
+      end
+
+      def relation
+        query_field_names = field_names - (@excluded_from_queries ||= [])
+        Relation.new(self, query_field_names)
+      end
+
+      def scope(name, body)
+        # Body can be a Relation or a lambda that returns a relation.
+        define_singleton_method(name) do |*args|
+          body.respond_to?(:call) ? body.call(*args) : scoped.merge(body)
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/active_zuora/subscribe.rb

@@ -0,0 +1,42 @@
+module ActiveZuora
+  module Subscribe
+
+    # This is meant to be included onto a SubscribeRequest class.
+    # Returns true/false on success.
+    # Result hash is stored in #result.
+    # If success, the subscription id and account id will be set in those objects.
+    # If failure, errors will be present on object.
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      attr_accessor :result
+    end
+
+    def subscribe
+      self.result = self.class.connection.request(:subscribe) do |soap|
+        soap.body do |xml| 
+          build_xml(xml, soap, 
+            :namespace => soap.namespace,
+            :element_name => :subscribes,
+            :force_type => true)
+        end
+      end[:subscribe_response][:result]
+      if result[:success]
+        account.id = result[:account_id]
+        subscription_data.subscription.id = result[:subscription_id]
+        clear_changed_attributes
+        true
+      else
+        add_zuora_errors(result[:errors])
+        false
+      end
+    end
+
+    def subscribe!
+      raise "Could not subscribe: #{errors.full_messages.join ', '}" unless subscribe
+    end
+
+  end
+end

data/lib/active_zuora/version.rb

@@ -0,0 +1,3 @@
+module ActiveZuora
+  VERSION = "2.0.0"
+end

data/lib/active_zuora/z_object.rb

@@ -0,0 +1,21 @@
+module ActiveZuora
+  module ZObject
+    
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      include Scoping
+      include HasManyAssociations
+      include Persistence
+      field :id, :string
+    end
+ 
+    def ==(another_zobject)
+      another_zobject.is_a?(ZObject) &&
+        zuora_object_name == another_zobject.zuora_object_name && 
+        id == another_zobject.id
+    end
+
+  end
+end

data/spec/belongs_to_associations_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "BelongsToAssociations" do
+
+  class Blog
+    include ActiveZuora::ZObject
+  end
+
+  class Comment
+    include ActiveZuora::Base
+    belongs_to :blog
+  end
+
+  it "should define a attribute assignment method method for the object" do
+    blog = Blog.new :id => "blog1"
+    comment = Comment.new :blog => blog
+    comment.blog_loaded?.should be_true
+    comment.blog.should == blog
+    comment.blog_id.should == blog.id
+    comment.blog = nil
+    comment.blog_loaded?.should be_true
+    comment.blog.should be_nil
+    comment.blog_id.should be_nil
+  end
+
+  it "should define a attribute assignment method for the object id" do
+    blog = Blog.new :id => "blog1"
+    comment = Comment.new :blog => blog
+    comment.blog_loaded?.should be_true
+    comment.blog_id = "blog2"
+    comment.blog_loaded?.should be_false
+  end
+
+end
+

data/spec/has_many_integration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "HasManyRelations" do
+
+  integration_test do
+
+    before :all do
+      @account = Z::Account.create!(
+        :name => "ZObject Integration Test Account", 
+        :status => "Draft",
+        :currency => "USD", 
+        :bill_cycle_day => 1)
+      @billy = Z::Contact.create!(
+        :account => @account,
+        :first_name => "Billy",
+        :last_name => "Blanks")
+      @franky = Z::Contact.create!(
+        :account => @account,
+        :first_name => "Franky",
+        :last_name => "Funhouse")
+    end
+
+    after :all do
+      # Delete the account to cleanup in case a test failed.
+      @account.delete if @account
+    end
+
+    it "can specify conditions and order" do
+      Z::Account.instance_eval do
+        has_many :billies, :conditions => { :first_name => "Billy" }, :order => [:first_name, :desc], :class_name => 'Z::Contact'
+      end
+      @account.billies.to_a == [@billy]
+      @account.billies.scope.order_attribute.should == :first_name
+      @account.billies.scope.order_direction.should == :desc
+    end
+
+    it "can behave like an array" do
+      @account.contacts.size.should == 2
+      @account.contacts.map(&:first_name).should =~ %w{Billy Franky}
+    end
+
+    it "can respond to functions on the Relation" do
+      @account.contacts.unload
+      @account.contacts.loaded?.should be_false
+      @account.contacts.reload
+      @account.contacts.loaded?.should be_true
+      @account.contacts.where(:last_name => "Funhouse").to_a.should == [@franky]
+      @account.contacts.loaded?.should be_true
+      @account.contacts.to_a.should =~ [@billy, @franky]
+    end
+
+  end
+end