xero_gateway-float 2.0.15

data/lib/xero_gateway/line_item_calculations.rb

@@ -0,0 +1,55 @@
+module XeroGateway
+  module LineItemCalculations
+
+    class Error < RuntimeError; end
+    class InvalidLineItemError < Error; end
+
+    def add_line_item(params = {})
+      line_item = nil
+      case params
+        when Hash then      line_item = LineItem.new(params)
+        when LineItem then  line_item = params
+        else                raise InvalidLineItemError
+      end
+      @line_items << line_item
+      line_item
+    end
+
+    # Deprecated (but API for setter remains).
+    #
+    # As sub_total must equal SUM(line_item.line_amount) for the API call to pass, this is now
+    # automatically calculated in the sub_total method.
+    def sub_total=(value)
+    end
+
+    # Calculate the sub_total as the SUM(line_item.line_amount).
+    def sub_total
+      line_items.inject(BigDecimal.new('0')) { | sum, line_item | sum + BigDecimal.new(line_item.line_amount.to_s) }
+    end
+
+    # Deprecated (but API for setter remains).
+    #
+    # As total_tax must equal SUM(line_item.tax_amount) for the API call to pass, this is now
+    # automatically calculated in the total_tax method.
+    def total_tax=(value)
+    end
+
+    # Calculate the total_tax as the SUM(line_item.tax_amount).
+    def total_tax
+      line_items.inject(BigDecimal.new('0')) { | sum, line_item | sum + BigDecimal.new(line_item.tax_amount.to_s) }
+    end
+
+    # Deprecated (but API for setter remains).
+    #
+    # As total must equal sub_total + total_tax for the API call to pass, this is now
+    # automatically calculated in the total method.
+    def total=(value)
+    end
+
+    # Calculate the toal as sub_total + total_tax.
+    def total
+      sub_total + total_tax
+    end
+
+  end
+end

data/lib/xero_gateway/money.rb

@@ -0,0 +1,16 @@
+module XeroGateway
+  module Money
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def format_money(amount)
+        if amount.class == BigDecimal
+          return amount.to_s("F")
+        end
+        return amount
+      end
+    end
+  end
+end

data/lib/xero_gateway/oauth.rb

@@ -0,0 +1,87 @@
+module XeroGateway
+  
+  # Shamelessly based on the Twitter Gem's OAuth implementation by John Nunemaker
+  # Thanks!
+  # 
+  # http://twitter.rubyforge.org/
+  # http://github.com/jnunemaker/twitter/
+  
+  class OAuth
+    
+    class TokenExpired < StandardError; end
+    class TokenInvalid < StandardError; end
+    class RateLimitExceeded < StandardError; end
+    class UnknownError < StandardError; end
+        
+    unless defined? XERO_CONSUMER_OPTIONS
+      XERO_CONSUMER_OPTIONS = {
+        :site               => "https://api.xero.com",
+        :request_token_path => "/oauth/RequestToken",
+        :access_token_path  => "/oauth/AccessToken",
+        :authorize_path     => "/oauth/Authorize"
+      }.freeze
+    end
+    
+    extend Forwardable
+    def_delegators :access_token, :get, :post, :put, :delete
+    
+    attr_reader :ctoken, :csecret, :consumer_options, :session_handle, :authorization_expires_at
+    
+    def initialize(ctoken, csecret, options = {})
+      @ctoken, @csecret = ctoken, csecret
+      @consumer_options = XERO_CONSUMER_OPTIONS.merge(options)
+    end
+    
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@ctoken, @csecret, consumer_options)
+    end
+    
+    def request_token(params = {})
+      @request_token ||= consumer.get_request_token(params)
+    end
+    
+    def authorize_from_request(rtoken, rsecret, params = {})
+      request_token     = ::OAuth::RequestToken.new(consumer, rtoken, rsecret)
+      access_token      = request_token.get_access_token(params)
+      @atoken, @asecret = access_token.token, access_token.secret
+      
+      update_attributes_from_token(access_token)
+    end
+    
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+    
+    def authorize_from_access(atoken, asecret)
+      @atoken, @asecret = atoken, asecret
+    end
+  
+    # Renewing access tokens only works for Partner applications
+    def renew_access_token(access_token = nil, access_secret = nil, session_handle = nil)
+      access_token   ||= @atoken
+      access_secret  ||= @asecret 
+      session_handle ||= @session_handle
+      
+      old_token = ::OAuth::RequestToken.new(consumer, access_token, access_secret)
+      
+      access_token = old_token.get_access_token({
+        :oauth_session_handle => session_handle,
+        :token                => old_token
+      })
+      
+      update_attributes_from_token(access_token)
+    end
+    
+    private
+    
+      # Update instance variables with those from the AccessToken.
+      def update_attributes_from_token(access_token)
+        @expires_at               = Time.now + access_token.params[:oauth_expires_in].to_i
+        @authorization_expires_at = Time.now + access_token.params[:oauth_authorization_expires_in].to_i
+        @session_handle           = access_token.params[:oauth_session_handle]
+        @atoken, @asecret         = access_token.token, access_token.secret
+        @access_token             = nil
+      end
+    
+  end
+end

data/lib/xero_gateway/organisation.rb

@@ -0,0 +1,75 @@
+module XeroGateway
+  class Organisation
+    
+    unless defined? ATTRS
+      ATTRS = {
+        "Name" 	                => :string,     # Display name of organisation shown in Xero
+        "LegalName"             => :string,	   # Organisation name shown on Reports
+        "PaysTax" 	            => :boolean,    # Boolean to describe if organisation is registered with a local tax authority i.e. true, false
+        "Version"   	          => :string,     # See Version Types
+        "BaseCurrency"          => :string,     # Default currency for organisation. See Currency types
+        "OrganisationType"      => :string,     # UNDOCUMENTED parameter, only returned for "real" (i.e non-demo) companies
+        "OrganisationStatus"    => :string,   # UNDOCUMENTED parameter
+        "IsDemoCompany"         => :boolean,    # UNDOCUMENTED parameter
+        "APIKey"                => :string,     # UNDOCUMENTED paramater, returned if organisations are linked via Xero Network
+        "CountryCode"           => :string,      # UNDOCUMENTED parameter
+        "TaxNumber"             => :string,
+        "FinancialYearEndDay"   => :string,
+        "FinancialYearEndMonth" => :string,
+        "PeriodLockDate"        => :string,
+        "CreatedDateUTC"        => :string        
+      }
+    end
+    
+    attr_accessor *ATTRS.keys.map(&:underscore)
+    
+    def initialize(params = {})
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def ==(other)
+      ATTRS.keys.map(&:underscore).each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+    
+    def to_xml
+      b = Builder::XmlMarkup.new
+      
+      b.Organisation do
+        ATTRS.keys.each do |attr|
+          eval("b.#{attr} '#{self.send(attr.underscore.to_sym)}'")
+        end
+      end
+    end
+    
+    def self.from_xml(organisation_element)
+      Organisation.new.tap do |org|
+        organisation_element.children.each do |element|
+        
+          attribute             = element.name
+          underscored_attribute = element.name.underscore
+        
+          if ATTRS.keys.include?(attribute)
+                  
+            case (ATTRS[attribute])
+              when :boolean then  org.send("#{underscored_attribute}=", (element.text == "true"))
+              when :float   then  org.send("#{underscored_attribute}=", element.text.to_f)
+              else                org.send("#{underscored_attribute}=", element.text)
+            end
+            
+          else
+            
+            warn "Ignoring unknown attribute: #{attribute}" 
+            
+          end
+          
+        end
+      end
+    end
+    
+  end
+end

data/lib/xero_gateway/partner_app.rb

@@ -0,0 +1,30 @@
+module XeroGateway
+  class PartnerApp < Gateway
+    
+    class CertificateRequired < StandardError; end
+    
+    NO_SSL_CLIENT_CERT_MESSAGE   = "You need to provide a client ssl certificate and key pair (these are the ones you got from Entrust and should not be password protected) as :ssl_client_cert and :ssl_client_key (should be .crt or .pem files)"
+    NO_PRIVATE_KEY_ERROR_MESSAGE = "You need to provide your private key (corresponds to the public key you uploaded at api.xero.com) as :private_key_file (should be .crt or .pem files)"
+    
+    def_delegators :client, :session_handle, :renew_access_token
+     
+    def initialize(consumer_key, consumer_secret, options = {})
+      
+      raise CertificateRequired.new(NO_SSL_CLIENT_CERT_MESSAGE)   unless options[:ssl_client_cert]
+      raise CertificateRequired.new(NO_SSL_CLIENT_CERT_MESSAGE)   unless options[:ssl_client_key]
+      raise CertificateRequired.new(NO_PRIVATE_KEY_ERROR_MESSAGE) unless options[:private_key_file]
+      
+      options.merge!(
+        :site             => "https://api-partner.network.xero.com",
+        :authorize_url    => 'https://api.xero.com/oauth/Authorize', 
+        :signature_method => 'RSA-SHA1',
+        :ssl_client_cert  => OpenSSL::X509::Certificate.new(File.read(options[:ssl_client_cert])),
+        :ssl_client_key   => OpenSSL::PKey::RSA.new(File.read(options[:ssl_client_key])),
+        :private_key_file => options[:private_key_file]
+      )
+      
+      @xero_url = options[:xero_url] || "https://api-partner.xero.com/api.xro/2.0"  
+      @client   = OAuth.new(consumer_key, consumer_secret, options)
+    end
+  end
+end

data/lib/xero_gateway/payment.rb

@@ -0,0 +1,40 @@
+module XeroGateway
+  class Payment
+    include Money
+    include Dates
+
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # All accessible fields
+    attr_accessor :date, :amount
+        
+    def initialize(params = {})
+      @errors ||= []
+            
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def self.from_xml(payment_element)
+      payment = Payment.new
+      payment_element.children.each do | element |
+        case element.name
+          when 'Date' then    payment.date = parse_date_time(element.text)
+          when 'Amount' then  payment.amount = BigDecimal.new(element.text)
+        end    
+      end
+      payment
+    end 
+    
+    def ==(other)
+      [:date, :amount].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+    
+
+  end
+end

data/lib/xero_gateway/phone.rb

@@ -0,0 +1,77 @@
+module XeroGateway
+  class Phone
+    
+    PHONE_TYPE = {
+      'DEFAULT' =>    'Default',
+      'DDI' =>        'Direct Dial-In',
+      'MOBILE' =>     'Mobile',
+      'FAX' =>        'Fax'
+    } unless defined?(PHONE_TYPE)
+    
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    attr_accessor :phone_type, :number, :area_code, :country_code
+    
+    def initialize(params = {})
+      @errors ||= []
+      
+      params = {
+        :phone_type => "DEFAULT"
+      }.merge(params)
+      
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    # Validate the Phone record according to what will be valid by the gateway.
+    #
+    # Usage: 
+    #  phone.valid?     # Returns true/false
+    #  
+    #  Additionally sets phone.errors array to an array of field/error.
+    def valid?
+      @errors = []
+            
+      unless number
+        @errors << ['number', "can't be blank"]
+      end
+      
+      if phone_type && !PHONE_TYPE[phone_type]
+        @errors << ['phone_type', "must be one of #{PHONE_TYPE.keys.join('/')}"]
+      end
+      
+      @errors.size == 0
+    end
+    
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.Phone {
+        b.PhoneType phone_type
+        b.PhoneNumber number
+        b.PhoneAreaCode area_code if area_code
+        b.PhoneCountryCode country_code if country_code
+      }
+    end
+    
+    def self.from_xml(phone_element)
+      phone = Phone.new
+      phone_element.children.each do |element|
+        case(element.name)
+          when "PhoneType" then phone.phone_type = element.text
+          when "PhoneNumber" then phone.number = element.text
+          when "PhoneAreaCode" then phone.area_code = element.text
+          when "PhoneCountryCode" then phone.country_code = element.text      
+        end
+      end
+      phone
+    end
+    
+    def ==(other)
+      [:phone_type, :number, :area_code, :country_code].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end    
+  end
+end

data/lib/xero_gateway/private_app.rb

@@ -0,0 +1,17 @@
+module XeroGateway
+  class PrivateApp < Gateway
+    #
+    # The consumer key and secret here correspond to those provided
+    # to you by Xero inside the API Previewer. 
+    def initialize(consumer_key, consumer_secret, path_to_private_key, options = {})
+      options.merge!(
+        :signature_method => 'RSA-SHA1',
+        :private_key_file => path_to_private_key
+      )
+      
+      @xero_url = options[:xero_url] || "https://api.xero.com/api.xro/2.0"
+      @client   = OAuth.new(consumer_key, consumer_secret, options)
+      @client.authorize_from_access(consumer_key, consumer_secret)
+    end
+  end
+end

data/lib/xero_gateway/response.rb

@@ -0,0 +1,41 @@
+module XeroGateway
+  class Response
+    attr_accessor :response_id, :status, :errors, :provider, :date_time, :response_item, :request_params, :request_xml, :response_xml
+    
+    def array_wrapped_response_item
+      Array(response_item)
+    end
+    
+    alias_method :invoice,              :response_item
+    alias_method :credit_note,          :response_item
+    alias_method :bank_transaction,     :response_item
+    alias_method :contact,              :response_item
+    alias_method :organisation,         :response_item
+    alias_method :invoices,             :array_wrapped_response_item
+    alias_method :credit_notes,         :array_wrapped_response_item
+    alias_method :bank_transactions,    :array_wrapped_response_item
+    alias_method :contacts,             :array_wrapped_response_item
+    alias_method :accounts,             :array_wrapped_response_item
+    alias_method :tracking_categories,  :array_wrapped_response_item
+    alias_method :tax_rates,            :array_wrapped_response_item
+    alias_method :currencies,           :array_wrapped_response_item
+    
+    def initialize(params = {})
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+      
+      @errors ||= []
+      @response_item ||= []
+    end
+    
+    
+    def success?
+      status == "OK"
+    end
+    
+    def error
+      errors.blank? ? nil : errors[0]
+    end
+  end
+end