active_zuora 1.5.2 → 2.0.0

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/connection.rb

@@ -0,0 +1,41 @@
+module ActiveZuora
+  class Connection
+
+    attr_reader :soap_client
+
+    WSDL = File.expand_path('../../../wsdl/zuora.wsdl', __FILE__)
+
+    def initialize(configuration={})
+      # Store login credentials and create SOAP client.
+      @username = configuration[:username]
+      @password = configuration[:password]
+      @session_timeout = configuration[:session_timeout] || 15.minutes
+      @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 }
+      @soap_client.request(:login){ soap.body = body }[: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 } }
+      @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,122 @@
+require 'active_zuora/fields/field'
+require 'active_zuora/fields/boolean_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
+      changed_attributes.clear
+      # 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 :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

data/lib/active_zuora/fields/array_field_decorator.rb

@@ -0,0 +1,28 @@
+module ActiveZuora
+  class ArrayFieldDecorator < SimpleDelegator
+
+    # Wraps a Field object and typecasts/builds
+    # item as an array of the given field.
+
+    def type_cast(values)
+      # Force into an array and run type_cast on each element.
+      [values].flatten.compact.map { |value| __getobj__.type_cast(value) }
+    end
+
+    def build_xml(xml, soap, values, options={})
+      # It may be wierd that we're mapping and taking the last value,
+      # But there's an issue with xml builder where if a block
+      # returns an array, it will output the array in the XML.
+      # So instead, we'll have our block return the value
+      # of the last build_xml call.
+      [values].flatten.compact.map do |value|
+        __getobj__.build_xml(xml, soap, value, options)
+      end.last
+    end
+
+    def clear_changed_attributes(values)
+      [values].flatten.compact.map { |value| __getobj__.clear_changed_attributes(value) }
+    end
+
+  end
+end

data/lib/active_zuora/fields/boolean_field.rb

@@ -0,0 +1,12 @@
+module ActiveZuora
+  class BooleanField < Field
+    
+    def type_cast(value)
+      return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      return true if value.to_s.downcase == 'true'
+      return false if value.to_s.downcase == 'false'
+      default
+    end
+
+  end
+end

data/lib/active_zuora/fields/date_time_field.rb

@@ -0,0 +1,19 @@
+module ActiveZuora
+  class DateTimeField < Field
+
+    def type_cast(value)
+      return value if value.nil? || value.is_a?(Date)
+      return value.to_datetime if value.is_a?(Time)
+      value.to_datetime rescue default
+    end
+
+    def build_xml(xml, soap, value, options={})
+      # All dates need to be in PST time.  Since all user-set attributes
+      # in Zuora are really only dates, we'll chop off the time.
+      # 2012-05-22T00:00:00-08:00
+      value = value ? value.strftime("%Y-%m-%dT00:00:00-08:00") : ''
+      super(xml, soap, value, options)
+    end
+
+  end
+end

data/lib/active_zuora/fields/decimal_field.rb

@@ -0,0 +1,12 @@
+module ActiveZuora
+  class DecimalField < Field
+
+    def type_cast(value)
+      return value if value.nil? || value.is_a?(BigDecimal)
+      return default if value.blank?
+      return value.to_d if value.respond_to?(:to_d)
+      default
+    end
+
+  end
+end

data/lib/active_zuora/fields/field.rb

@@ -0,0 +1,76 @@
+module ActiveZuora
+  class Field
+
+    attr_accessor :name, :zuora_name, :default, :namespace
+
+    def initialize(name, namespace, options={})
+      @name = name.to_s
+      @namespace = namespace
+      @zuora_name = options[:zuora_name] || @name.camelize
+      @default = options[:default]
+    end
+
+    def type_cast(value)
+      value
+    end
+
+    def define_instance_methods(zuora_class)
+      # We store this into a variable so we can use it in our
+      # class eval below.
+      field_name = name
+      # Add dirty helpers
+      # The value will still be stored in an instance
+      # variable with the name of the field.
+      # But we'll define extra writer methods so that we
+      # can handle any input from savon.
+      # Savon just calls underscore on the element names,
+      # but our fields allow for any combination
+      # of field name and Zuora name.
+      # This is especially useful for custom fields which
+      # are named like CustomField__c.  You might choose
+      # to make this field :custom_field, and therefore
+      # we'll need a writer for :custom_field, :custom_field_c,
+      # and I threw in a :CustomField__c just for good measure.      
+      writers = [field_name, zuora_name, zuora_name.underscore].uniq
+      zuora_class.class_eval do
+        # Define the methods on an included module, so we can override
+        # them using super.
+        generated_attribute_methods.module_eval do
+          # Getter
+          attr_reader field_name
+          # Boolean check.
+          define_method "#{field_name}?" do
+            !!send(field_name)
+          end
+          # Writers
+          writers.each do |writer_name|
+            define_method "#{writer_name}=" do |value|
+              write_attribute(field_name, value)
+            end
+          end
+        end
+        # Dirty attribute helpers.
+        define_attribute_methods [field_name]
+      end
+    end
+
+    def build_xml(xml, soap, value, options={})
+      qualifier = soap.namespace_by_uri(namespace)
+      nil_strategy = options[:nil_strategy] || :omit
+      # The extra qualifiers attribute needs to be passed in
+      # in case the field is another complexType that needs
+      # to be namespaced.
+      if !value.nil? || nil_strategy == :whitespace
+        xml.tag!(qualifier, zuora_name.to_sym, value.to_s)
+      elsif nil_strategy == :fields_to_null
+        xml.tag!(qualifier, :fieldsToNull, zuora_name.to_sym)
+      end
+    end
+
+    def clear_changed_attributes(value)
+      # If the value of this field has attribute changes to clear,
+      # override this function.
+    end
+
+  end
+end

data/lib/active_zuora/fields/integer_field.rb

@@ -0,0 +1,11 @@
+module ActiveZuora
+  class IntegerField < Field
+    
+    def type_cast(value)
+      return value if value.nil? || value.is_a?(Integer)
+      return value.to_i if value.respond_to?(:to_i)
+      default
+    end
+
+  end
+end

data/lib/active_zuora/fields/object_field.rb

@@ -0,0 +1,31 @@
+module ActiveZuora
+  class ObjectField < Field
+
+    # A field that is itself another Zuora complex type.
+    # Hashes will automatically be converted to an instance of the given class.
+
+    attr_accessor :class_name
+
+    def initialize(name, namespace, class_name, options={})
+      @class_name = class_name
+      super(name, namespace, options)
+    end
+
+    def type_cast(value)
+      if value.is_a?(Hash)
+        value = class_name.constantize.new(value)
+      end
+      value
+    end
+
+    def build_xml(xml, soap, value, options={})
+      # For complex types, simply omit it if it's nil.
+      value.build_xml(xml, soap, :namespace => namespace, :element_name => zuora_name) if value
+    end
+
+    def clear_changed_attributes(value)
+      value.clear_changed_attributes if value
+    end
+
+  end
+end

data/lib/active_zuora/fields/string_field.rb

@@ -0,0 +1,11 @@
+module ActiveZuora
+  class StringField < Field
+
+    def type_cast(value)
+      return value if value.nil? || value.is_a?(String)
+      return value.to_s if value.respond_to?(:to_s)
+      default
+    end
+
+  end
+end

data/lib/active_zuora/generate.rb

@@ -0,0 +1,43 @@
+module ActiveZuora
+  module Generate
+
+    # 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
+      attr_accessor :result
+    end
+
+    def generate
+      self.result = self.class.connection.request(:generate) do |soap|
+        soap.body do |xml|
+          build_xml(xml, soap,
+            :namespace => soap.namespace,
+            :element_name => :zObjects,
+            :force_type => true)
+        end
+      end[:generate_response][:result]
+
+      if result[:success]
+        self.id = result[:id]
+        self.status = 'Draft'
+        clear_changed_attributes
+        true
+      else
+        add_zuora_errors(result[:errors])
+        false
+      end
+    end
+
+    def generate!
+      raise "Could not generate: #{errors.full_messages.join ', '}" unless generate
+    end
+
+  end
+end