active_zuora 1.3.0 → 2.6.0

data/lib/active_zuora.rb

@@ -1,13 +1,45 @@
-require 'delegate'
-require 'zuora_client'
-require 'zuora/zobject'
-require 'zuora/account'
-require 'zuora/contact'
-require 'zuora/rate_plan'
-require 'zuora/rate_plan_data'
-require 'zuora/subscribe_options'
-require 'zuora/subscribe_request'
-require 'zuora/subscribe_with_existing_account_request'
-require 'zuora/subscription'
-require 'zuora/subscription_data'
+require 'savon'
+require 'active_model'
+require 'active_support/all'
 
+require 'active_zuora/connection'
+require 'active_zuora/generator'
+require 'active_zuora/fields'
+require 'active_zuora/belongs_to_associations'
+require 'active_zuora/base'
+require 'active_zuora/relation'
+require 'active_zuora/scoping'
+require 'active_zuora/persistence'
+require 'active_zuora/has_many_proxy'
+require 'active_zuora/has_many_associations'
+require 'active_zuora/z_object'
+require 'active_zuora/subscribe'
+require 'active_zuora/amend'
+require 'active_zuora/generate'
+require 'active_zuora/billing_preview'
+require 'active_zuora/batch_subscribe'
+require 'active_zuora/collection_proxy'
+require 'active_zuora/lazy_attr'
+
+module ActiveZuora
+
+  # Setup configuration.  None of this sends a request.
+  def self.configure(configuration)
+    # Set some sensible defaults with the savon SOAP client.
+    Savon.configure do |config|
+      config.log = HTTPI.log = configuration[:log] || false
+      config.log_level = configuration[:log_level] || :info
+      config.logger = configuration[:logger] if configuration[:logger]
+      config.logger.filter = configuration[:log_filters] || [:password, :SessionHeader]
+      config.raise_errors = true
+    end
+    # Create a default connection on Base
+    Base.connection = Connection.new(configuration)
+  end
+
+  def self.generate_classes(options={})
+    generator = Generator.new(Base.connection.soap_client.wsdl.parser, options)
+    generator.generate_classes
+  end
+
+end

data/lib/active_zuora/amend.rb

@@ -0,0 +1,43 @@
+module ActiveZuora
+  module Amend
+
+    # This is meant to be included onto a AmendRequest class.
+    # Returns true/false on success.
+    # Result hash is stored in #result.
+    # If success, the ids will be set in the given amendments.
+    # If failure, errors will be present on object.
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      attr_accessor :result
+    end
+
+    def amend
+      self.result = self.class.connection.request(:amend) do |soap|
+        soap.body do |xml| 
+          build_xml(xml, soap, 
+            :namespace => soap.namespace,
+            :element_name => :requests,
+            :force_type => true)
+        end
+      end[:amend_response][:results]
+      if result[:success]
+        [result[:amendment_ids]].flatten.compact.each_with_index do |id, i|
+          amendments[i].id = id
+        end
+        clear_changed_attributes
+        true
+      else
+        add_zuora_errors(result[:errors])
+        false
+      end
+    end
+
+    def amend!
+      raise "Could not amend: #{errors.full_messages.join ', '}" unless amend
+    end
+
+  end
+end

data/lib/active_zuora/base.rb

@@ -0,0 +1,84 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module ActiveZuora
+  module Base
+
+    extend ActiveSupport::Concern
+
+    # This is the default connection object to use for all Base classes.
+    # Each individual Base class can overwrite it.
+    class << self
+      attr_accessor :connection
+    end
+
+    included do
+      include Fields
+      include ActiveModel::Validations
+      include BelongsToAssociations
+      class << self
+        attr_accessor :namespace
+        attr_writer :zuora_object_name
+        attr_writer :connection
+      end
+      delegate :namespace, :zuora_object_name, :to => 'self.class'
+    end
+
+    def xml_field_names
+      # Which field names should be rendered during build_xml.
+      # Choose only field names that have been changed.
+      # Make sure the order in fields is maintained.
+      field_names & changed.map(&:to_sym)
+    end
+
+    def build_xml(xml, soap, options={})
+      namespace = options.delete(:namespace) || self.namespace
+      qualifier = soap.namespace_by_uri(namespace)
+      custom_element_name = options.delete(:element_name)
+      element_name = custom_element_name || zuora_object_name
+      attributes = options.delete(:force_type) ? 
+        { "xsi:type" => "#{qualifier}:#{zuora_object_name}" } : {}
+
+      xml.tag!(qualifier, element_name.to_sym, attributes) do
+        xml_field_names.map { |field_name| get_field!(field_name) }.sort(&method(:fields_order)).each do |field|
+          field.build_xml(xml, soap, send(field.name), options)
+        end
+      end
+    end
+
+    def fields_order(a, b)
+      if send(a.name) == nil
+        send(b.name) == nil ? 0 : -1
+      elsif a.name.to_sym == :id
+        send(b.name) == nil ? 1 : -1
+      else
+        (b.name.to_sym == :id || send(b.name) == nil) ? 1 : 0
+      end
+    end
+
+    def add_zuora_errors(zuora_errors)
+      return if zuora_errors.blank?
+      zuora_errors = [zuora_errors] unless zuora_errors.is_a?(Array)
+      zuora_errors.each { |error| errors.add(:base, error[:message].capitalize) }
+    end
+
+    module ClassMethods
+
+      def zuora_object_name
+        @zuora_object_name ||= self.name.split("::").last
+      end
+
+      def connection
+        @connection || Base.connection
+      end
+
+      def nested_class_name(unnested_class_name)
+        # This helper method will take a class name, and nest it inside
+        # the same module/class as self.
+        (name.split("::")[0..-2] << unnested_class_name).join("::")
+      end
+
+    end
+
+  end
+end

data/lib/active_zuora/batch_subscribe.rb

@@ -0,0 +1,53 @@
+module ActiveZuora
+  module BatchSubscribe
+
+    # This is meant to be included onto the CollectionProxy class.
+    # Returns true if every SubscribeRequest was a success
+    # Returns false if any single subsciption Request fails
+    # Result hash of each subscribe request is stored in the Subscribe Request #result.
+    # If success, the subscription id and account id will be set in those objects.
+    # If failure, errors will be present on the request object(s) that had error(s).
+    
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      attr_accessor :result
+    end
+    
+    def batch_subscribe
+      raise "object must be an ActiveZuora::CollectionProxy object instance" unless self.zuora_object_name == "CollectionProxy"
+      self.result = self.class.connection.request(:subscribe) do |soap|
+        soap.body do |xml| 
+          inject(xml) do |memo, el|
+            el.build_xml(xml, soap, 
+              :namespace => soap.namespace,
+              :element_name => :subscribes,
+              :force_type => true)
+          end
+        end
+      end[:subscribe_response][:result]
+      
+      self.result = [result] unless result.is_a?(Array)
+      result.each_with_index do |result, i|
+        self.records[i].result = result
+        if result[:success]
+          #we assume order is maintained by zuora.  is it?
+          self.records[i].account.id = result[:account_id]
+          self.records[i].subscription_data.subscription.id = result[:subscription_id]
+          self.records[i].clear_changed_attributes
+          @status = true
+        else
+          add_zuora_errors(result[:errors])
+          @status = false
+        end
+      end
+      @status
+    end
+    
+    def batch_subscribe!
+      raise "Could not batch subscribe: #{errors.full_messages.join ', '}" unless batch_subscribe
+    end
+  
+  end
+end

data/lib/active_zuora/belongs_to_associations.rb

@@ -0,0 +1,56 @@
+module ActiveZuora
+  module BelongsToAssociations
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def belongs_to(item, options={})
+        class_name = options[:class_name] || nested_class_name(item.to_s.camelize)
+        foreign_key = options[:foreign_key] || :"#{item}_id"
+        # Add the field if it doesn't already exist.
+        field foreign_key, :string unless field? foreign_key
+        ivar = "@#{item}"
+        loaded_ivar = "@#{item}_loaded"
+        # Define the methods on an included module, so we can override
+        # them using super.
+        generated_attribute_methods.module_eval do
+          define_method(item) do
+            # Return the object if it was already loaded.
+            if instance_variable_get(loaded_ivar)
+              return instance_variable_get(ivar)
+            else
+              # Otherwise find it.
+              record = class_name.constantize.find self.send(foreign_key)
+              send("#{item}=", record)
+              record
+            end
+          end
+          define_method("#{item}=") do |record|
+            instance_variable_set(loaded_ivar, true)
+            instance_variable_set(ivar, record)
+            # Set the foreign key id attribute as well.
+            write_attribute(foreign_key, record.try(:id))
+            record          
+          end
+          redefine_method("#{foreign_key}=") do |item_id|
+            item_id = write_attribute(foreign_key, item_id)
+            # Unload the object if the id is different.
+            if send("#{item}_loaded?") && send(item).id != item_id
+              instance_variable_set(loaded_ivar, false)
+            end
+            item_id
+          end
+          define_method("#{item}_loaded?") do
+            instance_variable_get(loaded_ivar) || false
+          end
+          define_method("reload_#{item}") do
+            instance_variable_set(loaded_ivar, false)
+            send(item)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_zuora/billing_preview.rb

@@ -0,0 +1,49 @@
+module ActiveZuora
+  module BillingPreview
+
+    # This is meant to be included onto an BillingPreviewRequest class.
+    # Returns a BillingPreviewResponse object on success.
+    # Result hash is stored in #result.
+    # If failure, errors will be present on object.
+
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      attr_accessor :result
+    end
+
+    def billing_preview
+      self.result = self.class.connection.request(:billing_preview) do |soap|
+        soap.body do |xml|
+          build_xml(xml, soap,
+            :namespace => soap.namespace,
+            :element_name => :requests,
+            :force_type => true)
+        end
+      end[:billing_preview_response][:results]
+
+      if result[:success]
+        clear_changed_attributes
+        filtered_invoice_items = self.result[:invoice_item].map do |invoice_item|
+          #Filter out data in the return value that are not valid invoice item fields such as
+          #    :"@xmlns:ns2"=>"http://object.api.zuora.com/",
+          #    :"@xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          #    :"@xsi:type"=>"ns2:InvoiceItem"
+          invoice_item.select{|key, v| ActiveZuora::InvoiceItem.field_names.include?(key)}
+        end
+        ActiveZuora::BillingPreviewResult.new(self.result.merge(invoice_item: filtered_invoice_items))
+      else
+        add_zuora_errors(result[:errors])
+        false
+      end
+    end
+
+    def billing_preview!
+      billing_preview.tap do |preview|
+        raise "Could not billing preview: #{errors.full_messages.join ', '}" unless preview
+      end
+    end
+
+  end
+end

data/lib/active_zuora/collection_proxy.rb

@@ -0,0 +1,38 @@
+module ActiveZuora
+  class CollectionProxy
+    
+    include ZObject
+    include Enumerable
+    include BatchSubscribe
+    
+    attr_reader :records, :zobject_class
+
+    def initialize(ary = [])
+      unless ary.empty?
+        raise "objects in collection must be ActiveZuora object instances" unless class_names = ary.map{|object| object.zuora_object_name}.uniq
+        raise "objects in collection must be ActiveZuora object instances of the same class" unless class_names.length == 1
+        @zobject_class = class_names.first
+      end
+      @records = ary
+    end
+    
+    def add object
+      raise "object must be an ActiveZuora object instance" unless object.zuora_object_name
+      if records.empty?
+        @zobject_class = object.zuora_object_name
+      else
+        raise "object must be must be ActiveZuora object instances of the same class as other elements in the Collection" unless object.zuora_object_name == zobject_class
+      end
+      @records.push object
+    end
+
+    def each
+      records.each { |r| yield r }
+    end
+     
+    def empty?
+      records.empty?
+    end
+    
+  end
+end

data/lib/active_zuora/connection.rb

@@ -0,0 +1,47 @@
+module ActiveZuora
+  class Connection
+
+    attr_reader :soap_client
+    attr_accessor :custom_header
+
+    WSDL = File.expand_path('../../../wsdl/zuora.wsdl', __FILE__)
+
+    def initialize(configuration={})
+      # Store login credentials and create SOAP client.
+      @username = configuration[:username]
+      @password = configuration[:password]
+      @soap_client = Savon::Client.new do
+        wsdl.document = configuration[:wsdl] || WSDL
+        http.proxy = configuration[:http_proxy] if configuration[:http_proxy]
+      end
+    end
+
+    def login
+      # Returns a session_id upon success, raises an exception on failure.
+      # Instance variables aren't available within the soap request block.
+      body = { :username => @username, :password => @password }
+      header = @custom_header
+      @soap_client.request(:login) do
+        soap.body = body
+        soap.header = header
+      end[:login_response][:result][:session]
+    end
+
+    def request(*args, &block)
+      # instance variables aren't available within the soap request block for some reason.
+      header = { 'SessionHeader' => { 'session' => @session_id } }
+      header.merge!(@custom_header) if @custom_header
+
+      @soap_client.request(*args) do
+        soap.header = header
+        yield(soap)
+      end
+    rescue Savon::SOAP::Fault => exception
+      # Catch invalid sessions, and re-issue the request.
+      raise unless exception.message =~ /INVALID_SESSION/
+      @session_id = login
+      request(*args, &block)
+    end
+
+  end
+end

data/lib/active_zuora/fields.rb

@@ -0,0 +1,129 @@
+require 'active_zuora/fields/field'
+require 'active_zuora/fields/boolean_field'
+require 'active_zuora/fields/date_field'
+require 'active_zuora/fields/date_time_field'
+require 'active_zuora/fields/decimal_field'
+require 'active_zuora/fields/integer_field'
+require 'active_zuora/fields/object_field'
+require 'active_zuora/fields/string_field'
+require 'active_zuora/fields/array_field_decorator'
+
+module ActiveZuora
+  module Fields
+
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Dirty
+      delegate :fields, :field_names, :field?, :get_field, :get_field!,
+        :default_attributes, :to => 'self.class'
+    end
+
+    def initialize(attributes={})
+      # Start with defaults, and override those with the given attributes.
+      self.attributes = default_attributes.merge(attributes)
+    end
+
+    def attributes
+      # A requirement of ActiveModel::Attributes.
+      # Hash must use string keys.
+      attributes = {}
+      fields.each { |field| attributes[field.name] = send(field.name) }
+      attributes
+    end
+
+    def attributes=(attributes)
+      attributes.each { |key, value| send("#{key}=", value) }
+    end
+
+    def untracked_attributes=(attributes)
+      # Loads attributes without tracking dirt.
+      self.attributes = attributes
+      clear_changed_attributes
+      attributes
+    end
+
+    def write_attribute(name, value)
+      field = get_field!(name)
+      value = field.type_cast(value)
+      attribute_will_change!(name) if value != send(name)
+      instance_variable_set("@#{name}", value)
+      value
+    end
+
+    def clear_changed_attributes
+      if ActiveSupport.version.to_s.to_f >= 5.2
+        clear_changes_information
+      else
+        changed_attributes.clear
+      end
+
+      # If we have any fields that are also Base objects,
+      # clear their attributes as well.
+      fields.each { |field| field.clear_changed_attributes(send(field.name)) }
+    end
+
+    module ClassMethods
+
+      def fields_by_name
+        # { :field_name_symbol => field_object }
+        @fields ||= {}
+      end
+
+      def fields
+        fields_by_name.values
+      end
+
+      def field_names
+        fields_by_name.keys
+      end
+
+      def field?(name)
+        fields_by_name.key?(name.to_sym)
+      end
+
+      def add_field(name, field)
+        fields_by_name[name.to_sym] = field
+        # Define the setters, getters, and changed helpers.
+        field.define_instance_methods(self)
+      end
+
+      def get_field(name)
+        fields_by_name[name.to_sym]
+      end
+
+      def get_field!(name)
+        get_field(name) || raise(ArgumentError.new("No field in #{self} named #{name}"))
+      end
+
+      def field(name, type, options={})
+        # Check if this field should be an array, don't pass
+        # this option down to the field.
+        field_is_array = options.delete(:array) || false
+        # Create and register the field.
+        field = case type
+          when :string   then StringField.new(name, namespace, options)
+          when :boolean  then BooleanField.new(name, namespace, options)
+          when :integer  then IntegerField.new(name, namespace, options)
+          when :decimal  then DecimalField.new(name, namespace, options)
+          when :date     then DateField.new(name, namespace, options)
+          when :datetime then DateTimeField.new(name, namespace, options)
+          when :object
+            class_name = options[:class_name] || nested_class_name(name.to_s.camelize)
+            ObjectField.new(name, namespace, class_name, options)
+          else
+            ArgumentError.new "Unknown field type: #{type}"
+          end
+        field = ArrayFieldDecorator.new(field) if field_is_array
+        add_field(name, field)
+      end
+
+      def default_attributes
+        default_attributes = {}
+        fields.each { |field| default_attributes[field.name] = field.default }
+        default_attributes
+      end
+
+    end
+  end
+end