rconomic 0.1.0

data/lib/economic/entity.rb

@@ -0,0 +1,167 @@
+
+
+module Economic
+
+  class Entity
+
+    # Internal accessors
+    attr_accessor :persisted, :session, :partial
+
+    class << self
+      def properties_not_triggering_full_load
+        [:id, :number, :handle]
+      end
+
+      def has_properties(*properties)
+        @properties = properties
+        properties.each do |property|
+          unless properties_not_triggering_full_load.include?(property) || instance_methods.collect(&:to_s).include?(property.to_s)
+            # 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
+          end
+
+          # Just use regular writers
+          attr_writer property
+        end
+      end
+
+      def properties
+        @properties || []
+      end
+
+      # Returns the E-conomic API action name to call
+      def soap_action(action)
+        class_name = self.name
+        class_name_without_modules = class_name.split('::').last
+        "#{class_name_without_modules.snakecase}_#{action.to_s.snakecase}".intern
+      end
+    end
+
+    def initialize(properties = {})
+      initialize_defaults
+      update_properties(properties)
+      @persisted = false
+      @partial = true
+    end
+
+    def initialize_defaults
+      nil
+    end
+
+    # Updates Entity with its data from the API
+    def get_data
+      response = session.request soap_action(:get_data) do
+        soap.body = {
+          'entityHandle' => {
+            'Number' => number
+          }
+        }
+      end
+      self.update_properties(response)
+      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
+    def number
+      @number
+    end
+
+    # Returns the id of Entity. This does not trigger a load from the API even if Entity is partial
+    def id
+      @id
+    end
+
+    def handle
+      handle = {}
+      handle[:id] = id unless id.blank?
+      handle[:number] = number unless number.blank?
+      handle
+    end
+
+    # Returns true if CurrentInvoiceLine has been persisted in e-conomic
+    def persisted?
+      !!@persisted
+    end
+
+    # Returns true if Entity has not been fully loaded from API yet
+    def partial?
+      # TODO: Can this be introspected somehow?
+      !!@partial
+    end
+
+    def inspect
+      props = self.class.properties.collect { |p| "#{p}=#{self.send(p).inspect}" }
+      "#<#{self.class}:#{self.object_id} partial=#{partial?}, persisted=#{persisted?}, #{props.join(', ')}>"
+    end
+
+    # Persist the Entity to the API
+    def save
+      create_or_update
+    end
+
+    # Updates properties of Entity with the values from hash
+    def update_properties(hash)
+      hash.each do |key, value|
+        setter_method = "#{key}="
+        if self.respond_to?(setter_method)
+          self.send(setter_method, value)
+        end
+      end
+    end
+
+  protected
+
+    def create_or_update
+      if persisted?
+        update
+      else
+        create
+      end
+    end
+
+    def create
+      response = session.request soap_action('CreateFromData') do
+        soap.body = {'data' => build_soap_data}
+      end
+
+      if response
+        @number = response[:number]
+        @id = response[:id]
+      end
+
+      @persisted = true
+      @partial = false
+
+      return response
+    end
+
+    def update
+      response = session.request soap_action(:update_from_data) do
+        soap.body = {'data' => build_soap_data}
+      end
+
+      @persisted = true
+      @partial = false
+
+      return response
+    end
+
+    # Returns OrderedHash with the data structure to send to the API
+    def build_soap_data
+    end
+
+    def soap_action(action)
+      self.class.soap_action(action)
+    end
+
+  end
+
+end

data/lib/economic/proxies/current_invoice_line_proxy.rb

@@ -0,0 +1,28 @@
+require 'economic/proxies/entity_proxy'
+
+module Economic
+  class CurrentInvoiceLineProxy < EntityProxy
+    class << self
+      # Returns the class this proxy is a proxy for
+      def entity_class
+        CurrentInvoiceLine
+      end
+    end
+
+    # Returns a new, unpersisted Economic::CurrentInvoiceLine
+    def build(properties = {})
+      invoice_line = super
+      initialize_properties_with_values_from_owner(invoice_line) if owner.is_a?(CurrentInvoice)
+      invoice_line
+    end
+
+  private
+
+    # Initialize properties in invoice_line with values from owner
+    def initialize_properties_with_values_from_owner(invoice_line)
+      invoice_line.invoice_handle = owner.handle
+      invoice_line
+    end
+
+  end
+end

data/lib/economic/proxies/current_invoice_proxy.rb

@@ -0,0 +1,38 @@
+require 'economic/proxies/entity_proxy'
+
+module Economic
+  class CurrentInvoiceProxy < EntityProxy
+    class << self
+      # Returns the class this proxy is a proxy for
+      def entity_class
+        CurrentInvoice
+      end
+    end
+
+    # Returns a new, unpersisted Economic::CurrentInvoice
+    def build(properties = {})
+      invoice = super
+      initialize_properties_with_values_from_owner(invoice) if owner.is_a?(Debtor)
+      invoice
+    end
+
+  private
+
+    # Initialize properties in invoice with values from owner
+    def initialize_properties_with_values_from_owner(invoice)
+      invoice.debtor_handle = owner.handle
+
+      invoice.debtor_name         ||= owner.name
+      invoice.debtor_address      ||= owner.address
+      invoice.debtor_postal_code  ||= owner.postal_code
+      invoice.debtor_city         ||= owner.city
+
+      invoice.term_of_payment_handle  ||= owner.term_of_payment_handle
+      invoice.layout_handle           ||= owner.layout_handle
+      invoice.currency_handle         ||= owner.currency_handle
+
+      invoice
+    end
+
+  end
+end

data/lib/economic/proxies/debtor_proxy.rb

@@ -0,0 +1,40 @@
+require 'economic/proxies/entity_proxy'
+
+module Economic
+  class DebtorProxy < EntityProxy
+    class << self
+      # Returns the class this proxy is a proxy for
+      def entity_class
+        Debtor
+      end
+    end
+
+    # 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 DebtorHandles from e-conomic
+      response = session.request self.class.entity_class.soap_action('FindByCINumber') do
+        soap.body = {
+          'ciNumber' => ci_number
+        }
+      end
+
+      # Make sure we always have an array of handles even if the result only contains one
+      handles = [response[:debtor_handle]].flatten.reject(&:blank?)
+
+      # Create partial Debtor entities
+      handles.collect do |handle|
+        debtor = build
+        debtor.partial = true
+        debtor.persisted = true
+        debtor.handle = handle
+        debtor.number = handle[:number]
+        debtor
+      end
+    end
+
+    # Returns the next available debtor number
+    def next_available_number
+      session.request Debtor.soap_action(:get_next_available_number)
+    end
+  end
+end

data/lib/economic/proxies/entity_proxy.rb

@@ -0,0 +1,61 @@
+module Economic
+  class EntityProxy
+    class << self
+      # Returns the class this Proxy is a proxy for
+      def entity_class
+        Entity
+      end
+    end
+
+    include Enumerable
+
+    attr_reader :owner, :items
+
+    def initialize(owner)
+      @owner = owner
+      @items = []
+    end
+
+    def session
+      owner.session
+    end
+
+    # Returns a new, unpersisted Economic::Entity
+    def build(properties = {})
+      entity = self.class.entity_class.new(:session => session)
+
+      entity.update_properties(properties)
+      entity.partial = false
+
+      entity
+    end
+
+    # Gets data for Entity from the API
+    def find(number)
+      entity_hash = session.request self.class.entity_class.soap_action(:get_data)  do
+        soap.body = {
+          'entityHandle' => {
+            'Number' => number
+          }
+        }
+      end
+      entity = build(entity_hash)
+      entity.persisted = true
+      entity
+    end
+
+    # Add item to proxy
+    def <<(item)
+      items << item
+    end
+
+    def each
+      items.each { |i| yield i }
+    end
+
+    def empty?
+      items.empty?
+    end
+
+  end
+end

data/lib/economic/session.rb

@@ -0,0 +1,59 @@
+module Economic
+  class Session
+    attr_accessor :agreement_number, :user_name, :password
+
+    def initialize(agreement_number, user_name, password)
+      self.agreement_number = agreement_number
+      self.user_name = user_name
+      self.password = password
+    end
+
+    # Returns the Savon::Client used to connect to e-conomic
+    def client
+      @client ||= Savon::Client.new do
+        wsdl.document = File.expand_path(File.join(File.dirname(__FILE__), "economic.wsdl"))
+      end
+    end
+
+    # Authenticates with e-conomic
+    def connect
+      response = client.request :economic, :connect do
+        soap.body = {
+          :agreementNumber => self.agreement_number,
+          :userName => self.user_name,
+          :password => self.password,
+          :order! => [:agreementNumber, :userName, :password]
+        }
+      end
+      client.http.headers["Cookie"] = response.http.headers["Set-Cookie"]
+    end
+
+    # Provides access to the current invoices - ie invoices that haven't yet been booked
+    def current_invoices
+      @current_invoices ||= CurrentInvoiceProxy.new(self)
+    end
+
+    # Provides access to the debtors
+    def debtors
+      @debtors ||= DebtorProxy.new(self)
+    end
+
+    def request(action, &block)
+      response = client.request :economic, action, &block
+      response_hash = response.to_hash
+
+      response_key = "#{action}_response".intern
+      result_key = "#{action}_result".intern
+      if response_hash[response_key] && response_hash[response_key][result_key]
+        response_hash[response_key][result_key]
+      else
+        {}
+      end
+    end
+
+    # Returns self - used by proxies to access the session of their owner
+    def session
+      self
+    end
+  end
+end

data/lib/rconomic/version.rb

@@ -0,0 +1,3 @@
+module Rconomic
+  VERSION = "0.1.0"
+end

data/lib/rconomic.rb

@@ -0,0 +1,26 @@
+# Dependencies
+require 'time'
+require 'savon'
+require 'active_support/ordered_hash'
+
+require 'economic/session'
+require 'economic/debtor'
+require 'economic/current_invoice'
+require 'economic/current_invoice_line'
+
+require 'economic/proxies/current_invoice_proxy'
+require 'economic/proxies/current_invoice_line_proxy'
+require 'economic/proxies/debtor_proxy'
+
+# http://www.e-conomic.com/apidocs/Documentation/index.html
+# https://www.e-conomic.com/secure/api1/EconomicWebService.asmx
+#
+# TODO
+#
+# * Memoization via ActiveSupport?
+# * Basic validations; ie check for nil values before submitting to API
+# * Better Handle handling
+
+module Economic
+end
+

data/rconomic.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'rconomic/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rconomic'
+  s.summary     = "Wrapper for e-conomic.dk's SOAP API."
+  s.description = <<-EOS
+                  Ruby wrapper for the e-conomic SOAP API, that aims at making working with the API bearable.
+
+                  E-conomic is a web-based accounting system. For their marketing speak, see http://www.e-conomic.co.uk/about/. More details about their API at http://www.e-conomic.co.uk/integration/integration-partner/.
+                  EOS
+  s.authors     = ["Jakob Skjerning"]
+  s.email       = 'jakob@mentalized.net'
+  s.homepage    = 'https://github.com/lokalebasen/rconomic'
+
+  s.version     = Rconomic::VERSION
+  s.platform    = Gem::Platform::RUBY
+
+  s.add_runtime_dependency "savon", "0.9.5"
+  s.add_runtime_dependency "activesupport", "~> 3.0"
+
+  s.files         = `git ls-files`.split("\n").reject { |filename| ['.gitignore'].include?(filename) }
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/spec/economic/current_invoice_line_spec.rb

@@ -0,0 +1,10 @@
+require './spec/spec_helper'
+
+describe Economic::CurrentInvoiceLine do
+  let(:session) { make_session }
+  subject { (l = Economic::CurrentInvoiceLine.new).tap { l.session = session } }
+
+  it "inherits from Economic::Entity" do
+    Economic::CurrentInvoiceLine.ancestors.should include(Economic::Entity)
+  end
+end

data/spec/economic/current_invoice_spec.rb

@@ -0,0 +1,59 @@
+require './spec/spec_helper'
+
+describe Economic::CurrentInvoice do
+  let(:session) { make_session }
+  subject { (i = Economic::CurrentInvoice.new).tap { i.session = session } }
+
+  it "inherits from Economic::Entity" do
+    Economic::CurrentInvoice.ancestors.should include(Economic::Entity)
+  end
+
+  describe "new" do
+    it "initializes lines as an empty proxy" do
+      subject.lines.should be_instance_of(Economic::CurrentInvoiceLineProxy)
+      subject.lines.should be_empty
+    end
+  end
+
+  describe "save" do
+    context "when successful" do
+      before :each do
+        savon.stubs('CurrentInvoice_CreateFromData').returns(:success)
+      end
+
+      context "when invoice has lines" do
+        before :each do
+          2.times do
+            line = Economic::CurrentInvoiceLine.new
+            line.stubs(:save)
+            subject.lines << line
+          end
+        end
+
+        it "adds the lines to the invoice" do
+          subject.lines.each do |line|
+            line.expects(:invoice_handle=).with({:id => '42'})
+          end
+
+          subject.save
+        end
+
+        it "assigns the invoice session to each line" do
+          subject.lines.each do |line|
+            line.expects(:session=).with(subject.session)
+          end
+
+          subject.save
+        end
+
+        it "saves each line" do
+          subject.lines.each do |line|
+            line.expects(:save)
+          end
+
+          subject.save
+        end
+      end
+    end
+  end
+end

data/spec/economic/debtor_spec.rb

@@ -0,0 +1,43 @@
+require './spec/spec_helper'
+
+describe Economic::Debtor do
+  let(:session) { make_session }
+  subject { Economic::Debtor.new(:session => session) }
+
+  it "inherits from Economic::Entity" do
+    Economic::Debtor.ancestors.should include(Economic::Entity)
+  end
+
+  context "when saving" do
+    context "when debtor is new" do
+      subject { Economic::Debtor.new(:session => session) }
+
+      context "when debtor_group_handle is nil" do
+        before :each do
+          subject.debtor_group_handle = nil
+        end
+
+        it "should send request and let e-conomic return an error" do
+          session.expects(:request)
+          subject.save
+        end
+      end
+    end
+  end
+
+  describe ".current_invoices" do
+    it "returns an CurrentInvoiceProxy" do
+      subject.current_invoices.should be_instance_of(Economic::CurrentInvoiceProxy)
+    end
+
+    it "memoizes the proxy" do
+      subject.current_invoices.should === subject.current_invoices
+    end
+
+    it "should store the session" do
+      subject.session.should_not be_nil
+      subject.current_invoices.session.should == subject.session
+    end
+  end
+
+end