rconomic 0.5.0 → 0.5.1

data/lib/economic/debtor_contact.rb

@@ -18,7 +18,16 @@ module Economic
   #   contact.name = 'John Appleseed'
   #   contact.save
   class DebtorContact < Entity
-    has_properties :id, :debtor_handle, :name, :number, :telephone_number, :email, :comments, :external_id, :is_to_receive_email_copy_of_order, :is_to_receive_email_copy_of_invoice
+    has_properties :id,
+      :debtor_handle,
+      :name,
+      :number,
+      :telephone_number,
+      :email,
+      :comments,
+      :external_id,
+      :is_to_receive_email_copy_of_order,
+      :is_to_receive_email_copy_of_invoice
 
     def debtor
       return nil if debtor_handle.nil?
@@ -36,29 +45,26 @@ module Economic
     end
 
     def handle
-      @handle ||= Handle.new({:id => @id})
+      @handle || Handle.new({:id => @id})
     end
 
     protected
 
-    def build_soap_data
-      data = {}
-
-      data['Handle'] = handle.to_hash
-      data['Id'] = handle.id
-      data['DebtorHandle'] = debtor.handle.to_hash unless debtor.blank?
-      data['Name'] = name
-      data['Number'] = number unless number.blank?
-      data['TelephoneNumber'] = telephone_number unless telephone_number.blank?
-      data['Email'] = email unless email.blank?
-      data['Comments'] = comments unless comments.blank?
-      data['ExternalId'] = external_id unless external_id.blank?
-      data['IsToReceiveEmailCopyOfOrder'] = is_to_receive_email_copy_of_order || false
-      data['IsToReceiveEmailCopyOfInvoice'] = is_to_receive_email_copy_of_invoice || false
-
-      return data
+    # Returns the field rules to use when mapping to SOAP data
+    def fields
+      [
+        ["Handle", :handle, Proc.new { |v| v.to_hash }, :required],
+        ["Id", :handle, Proc.new { |v| v.id }, :required],
+        ["DebtorHandle", :debtor, Proc.new { |v| v.handle.to_hash }],
+        ["Name", :name, nil, :required],
+        ["Number", :number],
+        ["TelephoneNumber", :telephone_number],
+        ["Email", :email],
+        ["Comments", :comments],
+        ["ExternalId", :external_id],
+        ["IsToReceiveEmailCopyOfOrder", :is_to_receive_email_copy_of_order, Proc.new { |v| v || false }, :required],
+        ["IsToReceiveEmailCopyOfInvoice", :is_to_receive_email_copy_of_invoice, Proc.new { |v| v || false }, :required]
+      ]
     end
-
   end
-
 end

data/lib/economic/endpoint.rb

@@ -0,0 +1,72 @@
+# Economic::Endpoint models the actual SOAP endpoint at E-conomic.
+#
+# This is where all knowledge of SOAP actions and requests exists.
+class Economic::Endpoint
+
+  # Invokes soap_action on the API endpoint with the given data.
+  #
+  # Returns a Hash with the resulting response from the endpoint as a Hash.
+  #
+  # If you need access to more details from the unparsed SOAP response, supply
+  # a block to `call`. A Savon::Response will be yielded to the block.
+  def call(soap_action, data = nil, cookies = nil)
+    # set_client_headers(headers)
+
+    response = request(soap_action, data, cookies)
+
+    if block_given?
+      yield response
+    else
+      extract_result_from_response(response, soap_action)
+    end
+  end
+
+  # Returns a Savon::Client to connect to the e-conomic endpoint
+  #
+  # Cached on class-level to avoid loading the big WSDL file more than once (can
+  # take several hundred megabytes of RAM after a while...)
+  def client
+    @@client ||= Savon.client do
+      wsdl File.expand_path(File.join(File.dirname(__FILE__), "economic.wsdl"))
+    end
+  end
+
+  # Returns the E-conomic API action name to call
+  def soap_action_name(entity_class, action)
+    [
+      class_name_without_modules(entity_class),
+      action.to_s
+    ].collect(&:snakecase).join("_").intern
+  end
+
+  private
+
+  def class_name_without_modules(entity_class)
+    class_name = entity_class.to_s
+    class_name.split('::').last
+  end
+
+  def extract_result_from_response(response, soap_action)
+    response = response.to_hash
+
+    response_key = "#{soap_action}_response".intern
+    result_key = "#{soap_action}_result".intern
+
+    if response[response_key] && response[response_key][result_key]
+      response[response_key][result_key]
+    else
+      {}
+    end
+  end
+
+  def request(soap_action, data, cookies)
+    locals = {}
+    locals[:message] = data if data && !data.empty?
+    locals[:cookies] = cookies if cookies && !cookies.empty?
+
+    client.call(
+      soap_action,
+      locals
+    )
+  end
+end

data/lib/economic/entity/handle.rb

@@ -1,13 +1,29 @@
 class Economic::Entity
   class Handle
-    attr_accessor :id, :id1, :id2, :number, :serial_number
-
     def self.build(options)
       return options if options.is_a?(Handle)
       return nil if options.nil?
       new(options)
     end
 
+    def self.id_properties
+      {
+        :code => 'Code',
+        :id => 'Id',
+        :id1 => 'Id1',
+        :id2 => 'Id2',
+        :number => 'Number',
+        :serial_number => 'SerialNumber',
+        :vat_code => 'VatCode'
+      }
+    end
+
+    def self.supported_keys
+      id_properties.keys
+    end
+
+    attr_accessor *supported_keys
+
     # Returns true if Handle hasn't been initialized with any values yet. This
     # usually happens when the handle is constructed for an entity whose id
     # properties (id, number, etc) haven't been set yet.
@@ -19,26 +35,26 @@ class Economic::Entity
       verify_sanity_of_arguments!(hash)
       hash = prepare_hash_argument(hash) unless hash.is_a?(self.class)
 
-      @id = hash[:id].to_i if hash[:id]
-      @id1 = hash[:id1].to_i if hash[:id1]
-      @id2 = hash[:id2].to_i if hash[:id2]
-      @number = hash[:number].to_i if hash[:number]
-      @serial_number = hash[:serial_number].to_i if hash[:serial_number]
+      [:code, :vat_code].each do |key|
+        instance_variable_set("@#{key}", hash[key]) if hash[key]
+      end
+      [:id, :id1, :id2, :number, :serial_number].each do |key|
+        instance_variable_set("@#{key}", hash[key].to_i) if hash[key]
+      end
     end
 
     def to_hash(only_keys = id_properties.keys)
       only_keys = [only_keys].flatten
-      hash = {}
-      hash['Id'] = id if only_keys.include?(:id) && !id.blank?
-      hash['Id1'] = id1 unless id1.blank? if only_keys.include?(:id1)
-      hash['Id2'] = id2 unless id2.blank? if only_keys.include?(:id2)
-      hash['Number'] = number unless number.blank? if only_keys.include?(:number)
-      hash['SerialNumber'] = serial_number unless serial_number.blank? if only_keys.include?(:serial_number)
-      hash
+      only_keys.each_with_object({}) do |key, hash|
+        property = id_properties[key]
+        value = self.send(key)
+        next if value.blank?
+        hash[property] = value
+      end
     end
 
     def [](key)
-      {:id => @id, :id1 => @id1, :id2 => @id2, :number => @number, :serial_number => @serial_number}[key]
+      instance_variable_get("@#{key}")
     end
 
     def ==(other)
@@ -49,13 +65,14 @@ class Economic::Entity
       self.id == other.id && self.number == other.number && self.id1 == other.id1 && self.id2 == other.id2
     end
 
-  private
+    private
 
     def id_properties
-      {:id => 'Id', :id1 => 'Id1', :id2 => 'Id2', :number => 'Number', :serial_number => 'SerialNumber'}
+      self.class.id_properties
     end
 
-    # Raises exceptions if hash doesn't contain values we can use to construct a new handle
+    # Raises exceptions if hash doesn't contain values we can use to construct a
+    # new handle
     def verify_sanity_of_arguments!(hash)
       return if hash.is_a?(self.class)
 
@@ -66,9 +83,6 @@ class Economic::Entity
       if hash.respond_to?(:keys)
         unknown_keys = hash.keys - id_properties.keys - id_properties.values
         raise ArgumentError.new("Unknown keys in handle: #{unknown_keys.inspect}") unless unknown_keys.empty?
-
-        not_to_iable = hash.select { |k, v| !v.respond_to?(:to_i) }
-        raise ArgumentError.new("All values must respond to to_i. #{not_to_iable.inspect} didn't") unless not_to_iable.empty?
       end
     end
 

data/lib/economic/entity/mapper.rb

@@ -0,0 +1,41 @@
+module Economic
+  # Entity::Mapper provides a generic way of building SOAP data structures for
+  # entities.
+  #
+  # Based on an Entity and a set of rules that define the fields to map to, it
+  # returns a Hash named and ordered properly, ready for passing to the
+  # endpoint as SOAP data.
+  class Entity::Mapper
+    attr_reader :entity, :fields
+
+    def initialize(entity, fields = [])
+      @entity = entity
+      @fields = fields
+    end
+
+    def to_hash
+      data = {}
+
+      fields.each do |field, method, formatter, required|
+        value = entity.send(method)
+        present = present?(value)
+
+        if present || required
+          value = formatter.call(value) if formatter
+          data[field] = value
+        end
+      end
+
+      return data
+    end
+
+    private
+
+    def present?(value)
+      !(
+        (value.respond_to?(:blank?) && value.blank?) ||
+        (value.respond_to?(:empty?) && value.empty?)
+      )
+    end
+  end
+end

data/lib/economic/entity.rb

@@ -1,4 +1,6 @@
+require 'economic/endpoint'
 require 'economic/entity/handle'
+require 'economic/entity/mapper'
 
 module Economic
   class Entity
@@ -16,27 +18,51 @@ module Economic
         @default_values || {}
       end
 
+      # Create a setter method for property that converts its input to a Handle
+      def handle_writer(property)
+        define_method "#{property}=" do |value|
+          value = Economic::Entity::Handle.new(value) if value
+          instance_variable_set("@#{property}", value)
+        end
+      end
+
       def properties_not_triggering_full_load
         [:id, :number, :handle]
       end
 
+      # Create a property getter that loads the full Entity from the API if
+      # necessary
+      def property_reader(property)
+        define_method "#{property}" do
+          value = instance_variable_get("@#{property}")
+          if value.nil? && partial? && persisted?
+            instance_variable_get("@#{property}")
+          else
+            value
+          end
+        end
+      end
+
+      # Create a property setter for property
+      def property_writer(property)
+        if property.to_s.end_with?("_handle")
+          handle_writer property
+        else
+          # Just use regular writers
+          attr_writer property
+        end
+      end
+
       def has_properties(*properties)
         @properties = properties
         properties.each do |property|
+          # Create a getter for property
           unless properties_not_triggering_full_load.include?(property)
-            # Create property accessors that loads the full Entity from the API if necessary
-            define_method "#{property}" do
-              value = instance_variable_get("@#{property}")
-              if value.nil? && partial? && persisted?
-                instance_variable_get("@#{property}")
-              else
-                value
-              end
-            end
+            property_reader property
           end
 
-          # Just use regular writers
-          attr_writer property
+          # Create a setter for property
+          property_writer property
         end
       end
 
@@ -51,14 +77,8 @@ module Economic
         Economic.const_get(proxy_class_name)
       end
 
-      # Returns the E-conomic API action name to call
-      def soap_action_name(action)
-        class_name = self.name
-        class_name_without_modules = class_name.split('::').last
-        "#{class_name_without_modules.snakecase}_#{action.to_s.snakecase}".intern
-      end
-
-      # Returns a symbol based on the name of the entity. Used to request and read data responses.
+      # Returns a symbol based on the name of the entity. Used to request and
+      # read data responses.
       #
       #   Entity.key #=> :entity
       #   CurrentInvoice.key #=> :current_invoice
@@ -71,7 +91,7 @@ module Economic
     end
 
     def handle
-      @handle ||= Handle.build({:number => @number, :id => @id})
+      @handle || Handle.build({:number => @number, :id => @id})
     end
 
     def handle=(handle)
@@ -92,13 +112,15 @@ module Economic
       self.partial = false
       self.persisted = true
     end
-    
-    # Returns the number of Entity. This does not trigger a load from the API even if Entity is partial
+
+    # Returns the number of Entity. This does not trigger a load from the API
+    # even if Entity is partial
     def number
       @number
     end
 
-    # Returns the id of Entity. This does not trigger a load from the API even if Entity is partial
+    # Returns the id of Entity. This does not trigger a load from the API even
+    # if Entity is partial
     def id
       @id
     end
@@ -114,9 +136,9 @@ module Economic
       !!@partial
     end
 
-    # Returns a proxy for entities of the current class. For example if called on an
-    # Economic::Debtor it returns an instance of Economic::DebtorProxy with the Debtors session as
-    # owner.
+    # Returns a proxy for entities of the current class. For example if called
+    # on an Economic::Debtor it returns an instance of Economic::DebtorProxy
+    # with the Debtors session as owner.
     def proxy
       self.class.proxy.new(session)
     end
@@ -157,7 +179,7 @@ module Economic
       self.handle == other.handle && other.is_a?(self.class)
     end
 
-  protected
+    protected
 
     def create_or_update
       if persisted?
@@ -202,16 +224,19 @@ module Economic
 
     # Returns Hash with the data structure to send to the API
     def build_soap_data
-      raise NotImplementedError, "Subclasses of Economic::Entity must implement `build_soap_data`"
+      Entity::Mapper.new(self, fields).to_hash
     end
 
-    # Requests an action from the API endpoint
-    def request(action, data = nil)
-      session.request(soap_action_name(action), data)
+    def fields
+      raise NotImplementedError, "Subclasses of Economic::Entity must implement `fields`"
     end
 
-    def soap_action_name(action)
-      self.class.soap_action_name(action)
+    # Requests an action from the API endpoint
+    def request(action, data = nil)
+      session.request(
+        Endpoint.new.soap_action_name(self.class, action),
+        data
+      )
     end
 
     def class_name
@@ -224,5 +249,4 @@ module Economic
       end
     end
   end
-
 end

data/lib/economic/invoice.rb

@@ -2,7 +2,20 @@ require 'economic/entity'
 
 module Economic
   class Invoice < Entity
-    has_properties :number, :net_amount, :vat_amount, :due_date, :debtor_handle, :debtor_name, :debtor_name, :debtor_address, :debtor_postal_code, :debtor_city, :debtor_country, :debtor_ean, :attention_handle, :heading
+    has_properties :number,
+      :net_amount,
+      :vat_amount,
+      :due_date,
+      :debtor_handle,
+      :debtor_name,
+      :debtor_name,
+      :debtor_address,
+      :debtor_postal_code,
+      :debtor_city,
+      :debtor_country,
+      :debtor_ean,
+      :attention_handle,
+      :heading
 
     def attention
       return nil if attention_handle.nil?
@@ -49,7 +62,7 @@ module Economic
     #   end
     def pdf
       response = request(:get_pdf, {
-        "invoiceHandle" => handle.to_hash
+                           "invoiceHandle" => handle.to_hash
       })
 
       Base64.decode64(response)

data/lib/economic/proxies/account_proxy.rb

@@ -6,15 +6,14 @@ module Economic
       response = request('FindByName', {
         'name' => name
       })
-      
+
       handle = response[:account_handle]
-      
+
       entity = build(response)
       entity.name = name
       entity.number = handle[:number]
       entity.persisted = true
       entity
-      
     end
   end
 end

data/lib/economic/proxies/actions/find_by_ci_number.rb

@@ -1,12 +1,14 @@
 module FindByCiNumber
-  # Returns Debtors that have the given ci_number. The Debtor objects will only be partially loaded
+  # Returns Debtors that have the given ci_number. The Debtor objects will only
+  # be partially loaded
   def find_by_ci_number(ci_number)
     # Get a list of handles from e-conomic
     response = request(:find_by_ci_number, {
       'ciNumber' => ci_number
     })
 
-    # Make sure we always have an array of handles even if the result only contains one
+    # Make sure we always have an array of handles even if the result only
+    # contains one
     handle_key = "#{entity_class_name.downcase}_handle".intern
     handles = [response[handle_key]].flatten.reject(&:blank?)
 

data/lib/economic/proxies/actions/find_by_date_interval.rb

@@ -19,6 +19,5 @@ module Economic
         entity
       end
     end
-
   end
 end

data/lib/economic/proxies/actions/find_by_name.rb

@@ -7,6 +7,7 @@ module Economic
         def initialize(caller, name)
           @caller = caller
           @name = name
+          @session = caller.session
         end
 
         def call
@@ -45,7 +46,10 @@ module Economic
         end
 
         def request(action, data)
-          @caller.request(action, data)
+          @session.request(
+            Endpoint.new.soap_action_name(@caller.entity_class, action),
+            data
+          )
         end
 
         def response

data/lib/economic/proxies/cash_book_entry_proxy.rb

@@ -4,7 +4,7 @@ module Economic
   class CashBookEntryProxy < EntityProxy
     def all
       entity_hash = session.request(
-        CashBookProxy.entity_class.soap_action_name(:get_entries),
+        Endpoint.new.soap_action_name(CashBook, :get_entries),
         {"cashBookHandle" => owner.handle.to_hash}
       )
 

data/lib/economic/proxies/entity_proxy.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Economic
   class EntityProxy
     class << self
@@ -73,7 +75,8 @@ module Economic
       self.class.entity_class_name
     end
 
-    # Fetches Entity data from API and returns an Entity initialized with that data added to Proxy
+    # Fetches Entity data from API and returns an Entity initialized with that
+    # data added to Proxy
     def find(handle)
       handle = Entity::Handle.new(handle)
       entity_hash = get_data(handle)
@@ -98,18 +101,14 @@ module Economic
     end
     alias :<< :append
 
-    # Requests an action from the API endpoint
-    def request(action, data = nil)
-      session.request(entity_class.soap_action_name(action), data)
-    end
-
-  protected
+    protected
 
     def items
       @items
     end
 
-    # Fetches all data for the given handles. Returns Array with hashes of entity data
+    # Fetches all data for the given handles. Returns Array with hashes of
+    # entity data
     def get_data_array(handles)
       return [] unless handles && handles.any?
 
@@ -122,5 +121,13 @@ module Economic
     def initialize_properties_with_values_from_owner(entity)
       entity
     end
+
+    # Requests an action from the API endpoint
+    def request(action, data = nil)
+      session.request(
+        Endpoint.new.soap_action_name(entity_class, action),
+        data
+      )
+    end
   end
 end