xero_exporter 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bde627d6af9da6d7c27966b98a072973cfdd6f379e24112dd99a6412fbbf07e5
+  data.tar.gz: 35363a38bd97be4bef05ce1baab513c4b88998ebe8c467a0b5fd6f0d76648abb
+SHA512:
+  metadata.gz: afbea5fce74d9c032f2835cf37cc19e007b37d0192197abf432904512f77bd7bd6233fd1db44deb91fd695495d3ed126f9fb950a43238f36cdde278ad3f4986b
+  data.tar.gz: 33feef318188bb760c235a55684d3684db8d6b919a0e5875563632cd54688b67a0a459f39984186a8e4cf3ae99574a20f534709c65c6408fbf17d688a770e8ed

data/VERSION

@@ -0,0 +1 @@
+v1.3.0

data/lib/xero_exporter/api.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module XeroExporter
+  class API
+
+    class APIConnectionError < Error
+    end
+
+    class APIError < Error
+
+      attr_reader :status, :body
+
+      def initialize(status, message, body = nil)
+        @status = status
+        @message = message
+        @body = body
+      end
+
+      def message
+        to_s
+      end
+
+      def to_s
+        "[#{@status}] #{@message}"
+      end
+
+    end
+
+    METHOD_MAP = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put
+    }.freeze
+
+    def initialize(access_token, tenant_id, **options)
+      @access_token = access_token
+      @tenant_id = tenant_id
+      @logger = options[:logger]
+    end
+
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    def post(path, params = {})
+      request(:post, path, params)
+    end
+
+    def put(path, params = {})
+      request(:put, path, params)
+    end
+
+    private
+
+    def request(method, path, params = {})
+      http = Net::HTTP.new('api.xero.com', 443)
+      http.use_ssl = true
+
+      path = "/api.xro/2.0/#{path}"
+
+      if method == :get && !params.empty?
+        query_string = URI.encode_www_form(params)
+        path = "#{path}?#{query_string}"
+      end
+
+      request = METHOD_MAP[method].new(path)
+      request['Authorization'] = "Bearer #{@access_token}"
+      request['Xero-Tenant-ID'] = @tenant_id
+      request['Accept'] = 'application/json'
+
+      if method != :get && !params.empty?
+        request['Content-Type'] = 'application/json'
+        request.body = params.to_json
+      end
+
+      logger.debug "[#{method.to_s.upcase}] to #{path}"
+      response = make_request_with_error_handling(http, request)
+
+      if response.is_a?(Net::HTTPOK)
+        logger.debug 'Status: 200 OK'
+        JSON.parse(response.body)
+      elsif response.code.to_i == 429
+        logger.debug 'Status: 429 Rate Limit Exceeded'
+        handle_retry(response, method, path, params)
+      else
+        handle_error(response)
+      end
+    end
+
+    def make_request_with_error_handling(http, request)
+      http.request(request)
+    rescue StandardError => e
+      logger.error "#{e.class}: #{e.message}"
+      raise APIConnectionError, "#{e.class}: #{e.message}"
+    end
+
+    def handle_retry(response, method, path, params)
+      problem = response['X-Rate-Limit-Problem']
+      if problem != 'minute'
+        raise APIConnectionError, "Rate limit exceeded (retry not possible) (problem: #{problem})"
+      end
+
+      retry_after = response['Retry-After'].to_i + 2
+      logger.debug "Waiting #{retry_after} seconds"
+      sleep retry_after
+
+      logger.debug 'Retrying after rate limit pause'
+      request(method, path, params)
+    end
+
+    def handle_error(response)
+      logger.error "Status: #{response.code}"
+      logger.debug response.body
+
+      if response['Content-Type'] =~ /application\/json/
+        json = JSON.parse(response.body)
+        logger.debug 'Error was JSON encoded'
+        raise APIError.new(response.code.to_i, "#{json['Type']}: #{json['Message']}", response.body)
+      end
+
+      raise APIError.new(response.code.to_i, response.body)
+    end
+
+    def logger
+      @logger || XeroExporter.logger
+    end
+
+  end
+end

data/lib/xero_exporter/country.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module XeroExporter
+  class Country
+
+    CODES_TO_NAMES = JSON.parse(File.read(File.expand_path('../../resource/country-codes.json', __dir__)))
+
+    attr_reader :code
+
+    def initialize(code)
+      @code = code
+    end
+
+    def to_s
+      @code
+    end
+
+    def name
+      CODES_TO_NAMES[@code.upcase] || @code.upcase
+    end
+
+    def eql?(other)
+      @code == other.code
+    end
+
+    def hash
+      @code.hash
+    end
+
+  end
+end

data/lib/xero_exporter/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class Error < StandardError
+  end
+end

data/lib/xero_exporter/executor.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'xero_exporter/proposal'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module XeroExporter
+  class Executor
+
+    attr_accessor :state_reader
+    attr_accessor :state_writer
+
+    def initialize(export, api, **options)
+      @export = export
+      @api = api
+      @logger = options[:logger]
+      @proposal = Proposal.new(export)
+    end
+
+    # Execute all actions required to perform this export
+    #
+    # @return [void]
+    def execute_all
+      create_invoice
+      create_invoice_payment
+      create_credit_note
+      create_credit_note_payment
+      add_payments
+      add_refunds
+      add_fees
+      true
+    end
+
+    # Create an invoice for all invoice lines in the export
+    #
+    # @return [void]
+    def create_invoice
+      run_task :create_invoice do
+        line_items = create_xero_line_items(@proposal.invoice_lines)
+        if line_items.empty?
+          logger.debug 'Not creating an invoice because there are no invoice lines'
+          current_state[:status] = 'not required because no invoice lines'
+          return false
+        end
+
+        logger.debug 'Creating new invoice'
+
+        spec = {
+          'Type' => 'ACCREC',
+          'Contact' => {
+            'ContactID' => find_or_create_xero_contact(@export.invoice_contact_name)
+          },
+          'Date' => @export.date.strftime('%Y-%m-%d'),
+          'DueDate' => @export.date.strftime('%Y-%m-%d'),
+          'InvoiceNumber' => @export.invoice_number,
+          'Reference' => @export.invoice_reference || @export.reference,
+          'CurrencyCode' => @export.currency,
+          'Status' => 'AUTHORISED',
+          'LineItems' => line_items
+        }
+
+        invoice = @api.post('Invoices', spec)['Invoices'].first
+
+        logger.debug "Invoice created with ID #{invoice['InvoiceID']} for #{invoice['AmountDue']}"
+        current_state[:status] = 'invoice created'
+        current_state[:invoice_id] = invoice['InvoiceID']
+        current_state[:amount] = invoice['AmountDue']
+      end
+    end
+
+    # Create a credit note for all credit note lines in the export
+    #
+    # @return [void]
+    def create_credit_note
+      run_task :create_credit_note do
+        line_items = create_xero_line_items(@proposal.credit_note_lines)
+        if line_items.empty?
+          logger.debug 'Not creating a credit note because there are no lines'
+          current_state[:status] = 'not required because no credit note lines'
+          return false
+        end
+
+        logger.debug 'Creating new credit note'
+        spec = {
+          'Type' => 'ACCRECCREDIT',
+          'Contact' => {
+            'ContactID' => find_or_create_xero_contact(@export.invoice_contact_name)
+          },
+          'Date' => @export.date.strftime('%Y-%m-%d'),
+          'Reference' => @export.reference,
+          'CurrencyCode' => @export.currency,
+          'Status' => 'AUTHORISED',
+          'LineItems' => line_items
+        }
+
+        credit_note = @api.post('CreditNotes', spec)['CreditNotes'].first
+
+        logger.debug "Credit note created with ID #{credit_note['CreditNoteID']} for #{credit_note['RemainingCredit']}"
+        current_state[:credit_note_id] = credit_note['CreditNoteID']
+        current_state[:amount] = credit_note['RemainingCredit']
+      end
+    end
+
+    # Create payments for all payments in the export
+    #
+    # @return [void]
+    def add_payments
+      @proposal.payments.each do |bank_account, amount|
+        run_task "add_payments_#{bank_account}" do
+          transfer = add_bank_transfer(@export.receivables_account, bank_account, amount)
+          current_state[:transfer_id] = transfer['BankTransferID']
+        end
+      end
+    end
+
+    # Create refunds for all payments in the export
+    #
+    # @return [void]
+    def add_refunds
+      @proposal.refunds.each do |bank_account, amount|
+        run_task "add_refunds_#{bank_account}" do
+          if transfer = add_bank_transfer(bank_account, @export.receivables_account, amount)
+            current_state[:transfer_id] = transfer['BankTransferID']
+          end
+        end
+      end
+    end
+
+    # Create payments for all payments in the export
+    #
+    # @return [void]
+    def add_fees
+      @proposal.fees.each do |bank_account, amounts_by_category|
+        amounts_by_category.each do |category, amount|
+          category_for_key = category&.downcase&.gsub(' ', '_') || 'none'
+          run_task "add_fees_#{bank_account}_#{category_for_key}" do
+            if transaction = add_fee_transaction(bank_account, amount, category)
+              current_state[:transaction_id] = transaction['BankTransactionID']
+            end
+          end
+        end
+      end
+    end
+
+    # Create a new payment that fully pays the given invoice
+    #
+    # @param invoice [Hash]
+    # @return [void]
+    def create_invoice_payment
+      run_task :create_invoice_payment do
+        if state[:create_invoice].nil?
+          raise Error, 'create_invoice task must be executed before this action'
+        end
+
+        if state[:create_invoice][:amount].nil? || !state[:create_invoice][:amount].positive?
+          logger.debug 'Not adding a payment because the amount is not present or not positive'
+          return
+        end
+
+        logger.debug "Creating payment for invoice #{state[:create_invoice][:invoice_id]} " \
+                        "for #{state[:create_invoice][:amount]}"
+        logger.debug "Using receivables account: #{@export.receivables_account}"
+
+        payment = @api.put('Payments', {
+          'Invoice' => { 'InvoiceID' => state[:create_invoice][:invoice_id] },
+          'Account' => { 'Code' => @export.receivables_account },
+          'Date' => @export.date.strftime('%Y-%m-%d'),
+          'Amount' => state[:create_invoice][:amount],
+          'Reference' => @export.reference
+        })['Payments'].first
+
+        current_state[:payment_id] = payment['PaymentID']
+        current_state[:amount] = payment['Amount']
+      end
+    end
+
+    # Create a new payment that fully pays a given credit note
+    #
+    # @param credit_note [Hash]
+    # @return [void]
+    def create_credit_note_payment
+      run_task :create_credit_note_payment do
+        if state[:create_credit_note].nil?
+          raise Error, 'create_credit_note task must be executed before this action'
+        end
+
+        if state[:create_credit_note][:amount].nil? || !state[:create_credit_note][:amount].positive?
+          logger.debug 'Not adding a payment because the amount is not present or not positive'
+          return
+        end
+
+        logger.debug "Creating payment for credit note #{state[:create_credit_note][:credit_note_id]} " \
+                        "for #{state[:create_credit_note][:amount]}"
+        logger.debug "Using receivables account: #{@export.receivables_account}"
+
+        payment = @api.put('Payments', {
+          'CreditNote' => { 'CreditNoteID' => state[:create_credit_note][:credit_note_id] },
+          'Account' => { 'Code' => @export.receivables_account },
+          'Date' => @export.date.strftime('%Y-%m-%d'),
+          'Amount' => state[:create_credit_note][:amount],
+          'Reference' => @export.reference
+        })['Payments'].first
+        current_state[:payment_id] = payment['PaymentID']
+        current_state[:amount] = payment['Amount']
+      end
+    end
+
+    private
+
+    # Transfer an amount of money from one bank account to another
+    #
+    # @param from [String]
+    # @param to [String]
+    # @param amount [Float]
+    # @return [void]
+    def add_bank_transfer(from, to, amount)
+      amount = amount.round(2)
+      logger.debug "Transferring #{amount} from #{from} to #{to}"
+      @api.put('BankTransfers', {
+        'FromBankAccount' => { 'Code' => from },
+        'ToBankAccount' => { 'Code' => to },
+        'Amount' => amount,
+        'Date' => @export.date.strftime('%Y-%m-%d')
+      })['BankTransfers'].first
+    end
+
+    # Create an array of line item hashes which can be submitted to the Xero
+    # API for the given array of lines
+    #
+    # @param lines [Hash]
+    # @return [Array<Hash>]
+    def create_xero_line_items(lines)
+      lines.map do |(account, country, tax_rate), amounts|
+        xero_tax_rate = find_or_create_tax_rate(country, tax_rate)
+
+        if xero_tax_rate.nil?
+          raise Error, "Could not determine tax rate for #{country} (#{tax_rate})"
+        end
+
+        {
+          'Description' => @proposal.invoice_line_description(account, country, tax_rate),
+          'Quantity' => 1,
+          'AccountCode' => account,
+          'TaxAmount' => amounts[:tax],
+          'LineAmount' => amounts[:amount],
+          'TaxType' => xero_tax_rate,
+          'Tracking' => tracking_options
+        }
+      end
+    end
+
+    # Return an array of tracking options
+    #
+    # @return [Array<Hash>]
+    def tracking_options
+      return [] if @export.tracking.empty?
+
+      @export.tracking.map do |key, value|
+        {
+          'Name' => key,
+          'Option' => value
+        }
+      end
+    end
+
+    # Add a fee transaction for a given amount to a given bank account
+    #
+    # @param bank_account [String]
+    # @param amount [Float]
+    # @return [void]
+    def add_fee_transaction(bank_account, amount, description = nil)
+      return if amount.zero?
+
+      logger.debug "Creating fee transaction for #{amount} from #{bank_account} (#{description})"
+
+      @api.post('BankTransactions', {
+        'Type' => amount.negative? ? 'RECEIVE' : 'SPEND',
+        'Contact' => {
+          'ContactID' => find_or_create_xero_contact(@export.payment_providers[bank_account] ||
+                                                          'Generic Payment Processor')
+        },
+        'Date' => @export.date.strftime('%Y-%m-%d'),
+        'BankAccount' => { 'Code' => bank_account },
+        'Reference' => @export.reference,
+        'LineItems' => [
+          {
+            'Description' => description || 'Fees',
+            'UnitAmount' => amount.abs,
+            'AccountCode' => @export.fee_accounts[bank_account] || '404',
+            'Tracking' => tracking_options
+          }
+        ]
+      })['BankTransactions'].first
+    end
+
+    # Find or create a contact with a given name and return the ID of that
+    # contact
+    #
+    # @param name [String]
+    # @return [String]
+    def find_or_create_xero_contact(name)
+      existing = @api.get('Contacts', where: "Name=\"#{name}\"")['Contacts']&.first
+      if existing
+        logger.debug "Found existing contact with name: #{name}"
+        logger.debug "ID: #{existing['ContactID']}"
+        return existing['ContactID']
+      end
+
+      logger.debug "Creating new contact with name: #{name}"
+      response = @api.post('Contacts', 'Name' => name)
+      id = response['Contacts'].first['ContactID']
+      logger.debug "Contact created with ID: #{id}"
+      id
+    end
+
+    # Find or create a tax rate for the given country and tax rate.
+    #
+    # @param country [XeroExporter::Country]
+    # @param tax_rate [XeroExporter::TaxRate]
+    # @return [String]
+    def find_or_create_tax_rate(country, tax_rate)
+      @tax_rate_cache ||= {}
+      if cached_rate = @tax_rate_cache[[country, tax_rate]]
+        return cached_rate
+      end
+
+      existing = tax_rates.find do |rate|
+        rate['Status'] == 'ACTIVE' &&
+          rate['ReportTaxType'] == tax_rate.xero_report_type &&
+          rate['EffectiveRate'].to_d == tax_rate.rate.to_d &&
+          (rate['Name'].include?(country.name) || rate['Name'].include?(country.code.upcase))
+      end
+
+      if existing
+        @tax_rate_cache[[country, tax_rate]] = existing['TaxType']
+        return existing['TaxType']
+      end
+
+      rates = @api.post('TaxRates', {
+        'Name' => tax_rate.xero_name(country),
+        'ReportTaxType' => tax_rate.xero_report_type,
+        'TaxComponents' => [
+          {
+            'Name' => 'Tax',
+            'Rate' => tax_rate.rate
+          }
+        ]
+      })
+
+      type = rates['TaxRates'].first['TaxType']
+      @tax_rate_cache[[country, tax_rate]] = type
+      type
+    end
+
+    # Return a full list of all tax rates currently stored within the API
+    #
+    # @return [Array<Hash>]
+    def tax_rates
+      @tax_rates ||= @api.get('TaxRates')['TaxRates'] || []
+    end
+
+    # Return the logger instance
+    #
+    # @return [Logger]
+    def logger
+      @logger || XeroExporter.logger
+    end
+
+    # Executes a named task if it is suitable to be executed
+    #
+    # @return [void]
+    def run_task(name)
+      if @state.nil?
+        @state = load_state
+      end
+
+      if @state[name.to_sym] && @state[name.to_sym][:state] == 'complete'
+        logger.debug "Not executing #{name} because it has already been run"
+        return
+      end
+
+      logger.debug "Running #{name} task"
+
+      @current_state = @state[name.to_sym] ||= {}
+      @current_state[:state] = 'running'
+      @current_state.delete(:error)
+      yield if block_given?
+    rescue StandardError => e
+      if @current_state
+        @current_state[:state] = 'error'
+        @current_state[:error] = { class: e.class.name, message: e.message }
+      end
+      raise
+    ensure
+      if @current_state && @current_state[:state] == 'running'
+        @current_state[:state] = 'complete'
+      end
+
+      @current_state = nil
+      save_state
+    end
+
+    # Loads state as apprppriate
+    #
+    # @return [Hash]
+    def load_state
+      return {} unless @state_reader
+
+      @state_reader.call
+    end
+
+    # Saves the current state as appropriate
+    #
+    # @return [void]
+    def save_state
+      return unless @state_writer
+
+      @state_writer.call(@state)
+    end
+
+    attr_reader :state
+    attr_reader :current_state
+
+  end
+end

data/lib/xero_exporter/export.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'xero_exporter/invoice'
+require 'xero_exporter/payment'
+require 'xero_exporter/refund'
+require 'xero_exporter/fee'
+require 'xero_exporter/executor'
+
+module XeroExporter
+  class Export
+
+    attr_accessor :id
+    attr_accessor :date
+    attr_accessor :currency
+    attr_accessor :invoice_contact_name
+    attr_accessor :invoice_number
+    attr_accessor :invoice_reference
+
+    attr_accessor :receivables_account
+    attr_accessor :fee_accounts
+
+    attr_reader :invoices
+    attr_reader :payments
+    attr_reader :refunds
+    attr_reader :fees
+
+    attr_reader :payment_providers
+    attr_reader :account_names
+    attr_reader :tracking
+
+    def initialize
+      @date = Date.today
+      @currency = 'GBP'
+      @invoice_contact_name = 'Generic Customer'
+      @invoices = []
+      @payments = []
+      @refunds = []
+      @fees = []
+      @payment_providers = {}
+      @fee_accounts = {}
+      @account_names = {}
+      @tracking = {}
+    end
+
+    def reference
+      "#{@date&.strftime('%Y%m%d')}-#{@currency&.upcase}-#{@id}"
+    end
+
+    def add_invoice
+      invoice = Invoice.new
+      yield invoice if block_given?
+      @invoices << invoice
+      invoice
+    end
+
+    def add_credit_note
+      invoice = Invoice.new
+      invoice.type = :credit_note
+      yield invoice if block_given?
+      @invoices << invoice
+      invoice
+    end
+
+    def add_payment
+      payment = Payment.new
+      yield payment if block_given?
+      @payments << payment
+      payment
+    end
+
+    def add_refund
+      refund = Refund.new
+      yield refund if block_given?
+      @refunds << refund
+      refund
+    end
+
+    def add_fee
+      fee = Fee.new
+      yield fee if block_given?
+      @fees << fee
+      fee
+    end
+
+    def execute(api, **options)
+      executor = Executor.new(self, api, **options)
+      yield executor if block_given?
+      executor.execute_all
+    end
+
+    private
+
+    def logger
+      XeroExporter.logger
+    end
+
+  end
+end

data/lib/xero_exporter/fee.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class Fee
+
+    attr_accessor :amount
+    attr_accessor :category
+    attr_accessor :bank_account
+
+  end
+end

data/lib/xero_exporter/invoice.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'xero_exporter/invoice_line'
+require 'xero_exporter/tax_rate'
+require 'xero_exporter/country'
+
+module XeroExporter
+  class Invoice
+
+    attr_accessor :id
+    attr_accessor :number
+    attr_accessor :type
+    attr_writer :country
+    attr_writer :tax_rate
+    attr_writer :tax_type
+
+    attr_reader :lines
+
+    def initialize
+      @type = :invoice
+      @lines = []
+      @tax_type = :normal
+    end
+
+    def tax_rate
+      TaxRate.new(@tax_rate, @tax_type)
+    end
+
+    def country
+      Country.new(@country)
+    end
+
+    def add_line(account_code:, amount:, tax: 0.0)
+      line = InvoiceLine.new
+      line.account_code = account_code
+      line.amount = amount
+      line.tax = tax
+      @lines << line
+      line
+    end
+
+  end
+end

data/lib/xero_exporter/invoice_line.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class InvoiceLine
+
+    attr_accessor :account_code
+    attr_accessor :amount
+    attr_accessor :tax
+
+  end
+end

data/lib/xero_exporter/logger.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module XeroExporter
+
+  class << self
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+
+  end
+
+end

data/lib/xero_exporter/payment.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class Payment
+
+    attr_accessor :id
+    attr_accessor :bank_account
+    attr_accessor :amount
+
+  end
+end

data/lib/xero_exporter/proposal.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class Proposal
+
+    def initialize(export)
+      @export = export
+    end
+
+    # Returns an array of lines which need to be included on the invoice that will
+    # be generated in Xero.
+    #
+    # @return [Hash]
+    def invoice_lines
+      get_invoice_lines_from_invoices(@export.invoices.select { |i| i.type == :invoice })
+    end
+
+    # Returns an array of lines which need to be included on the credit note that will
+    # be generated in Xero.
+    #
+    # @return [Hash]
+    def credit_note_lines
+      get_invoice_lines_from_invoices(@export.invoices.select { |i| i.type == :credit_note })
+    end
+
+    # Return the total number of payments per bank account which
+    #
+    # @return [Hash]
+    def payments
+      export_payments = Hash.new(0.0)
+      @export.payments.each do |payment|
+        key = payment.bank_account
+        export_payments[key] += payment.amount || 0.0
+      end
+      export_payments
+    end
+
+    # Return the total number of refund per bank account which
+    #
+    # @return [Hash]
+    def refunds
+      export_refunds = Hash.new(0.0)
+      @export.refunds.each do |refund|
+        key = refund.bank_account
+        export_refunds[key] += refund.amount || 0.0
+      end
+      export_refunds
+    end
+
+    # Return the fees grouped by bank account & category
+    #
+    # @return [Hash]
+    def fees
+      initial_hash = Hash.new { |h, k| h[k] = Hash.new(0.0) }
+      @export.fees.each_with_object(initial_hash) do |fee, hash|
+        hash[fee.bank_account][fee.category] += fee.amount || 0.0
+      end
+    end
+
+    # Return the text to go with an invoice line
+    #
+    # @return [String]
+    def invoice_line_description(account, country, tax_rate)
+      name = @export.account_names[account.to_s] || "#{account} Sales"
+      "#{name} (#{country.code}, #{tax_rate.rate}%)"
+    end
+
+    private
+
+    def get_invoice_lines_from_invoices(invoices)
+      export_lines = Hash.new { |h, k| h[k] = { amount: 0.0, tax: 0.0 } }
+      invoices.each do |invoice|
+        invoice.lines.each do |line|
+          key = [line.account_code, invoice.country, invoice.tax_rate]
+          export_lines[key][:amount] += line.amount || 0.0
+          export_lines[key][:tax] += line.tax || 0.0
+        end
+      end
+      export_lines
+    end
+
+  end
+end

data/lib/xero_exporter/refund.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class Refund
+
+    attr_accessor :id
+    attr_accessor :bank_account
+    attr_accessor :amount
+
+  end
+end

data/lib/xero_exporter/tax_rate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module XeroExporter
+  class TaxRate
+
+    attr_reader :rate
+    attr_reader :type
+
+    def initialize(rate, type)
+      @rate = rate&.to_f || 0.0
+      @type = type
+    end
+
+    def to_s
+      "#{@rate}[#{@type}]"
+    end
+
+    def eql?(other)
+      @rate == other.rate && @type == other.type
+    end
+
+    def hash
+      [@rate, @type].hash
+    end
+
+    def xero_name(country)
+      case @type
+      when :moss
+        "MOSS #{country.name} #{@rate}%"
+      when :reverse_charge
+        "Reverse Charge (#{country.code})"
+      when :ec_services
+        "EC Services for #{country.code} (#{@rate}%)"
+      else
+        "Tax for #{country.code} (#{@rate}%)"
+      end
+    end
+
+    def xero_report_type
+      return 'MOSSSALES' if @type == :moss
+      return 'ECOUTPUTSERVICES' if @type == :ec_services
+
+      'OUTPUT'
+    end
+
+  end
+end

data/lib/xero_exporter/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module XeroExporter
+
+  VERSION_FILE_ROOT = File.expand_path('../../VERSION', __dir__)
+  if File.file?(VERSION_FILE_ROOT)
+    VERSION = File.read(VERSION_FILE_ROOT).strip.sub(/\Av/, '')
+  else
+    VERSION = '0.0.0.dev'
+  end
+
+end

data/lib/xero_exporter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'xero_exporter/logger'
+require 'xero_exporter/error'
+
+require 'xero_exporter/export'
+require 'xero_exporter/api'
+require 'xero_exporter/executor'

data/resource/country-codes.json

@@ -0,0 +1,252 @@
+{
+  "AD": "Andorra",
+  "AE": "United Arab Emirates",
+  "AF": "Afghanistan",
+  "AG": "Antigua and Barbuda",
+  "AI": "Anguilla",
+  "AL": "Albania",
+  "AM": "Armenia",
+  "AO": "Angola",
+  "AQ": "Antarctica",
+  "AR": "Argentina",
+  "AS": "American Samoa",
+  "AT": "Austria",
+  "AU": "Australia",
+  "AW": "Aruba",
+  "AX": "Aland Islands",
+  "AZ": "Azerbaijan",
+  "BA": "Bosnia and Herzegovina",
+  "BB": "Barbados",
+  "BD": "Bangladesh",
+  "BE": "Belgium",
+  "BF": "Burkina Faso",
+  "BG": "Bulgaria",
+  "BH": "Bahrain",
+  "BI": "Burundi",
+  "BJ": "Benin",
+  "BL": "Saint Barthelemy",
+  "BM": "Bermuda",
+  "BN": "Brunei",
+  "BO": "Bolivia",
+  "BQ": "Bonaire, Saint Eustatius and Saba ",
+  "BR": "Brazil",
+  "BS": "Bahamas",
+  "BT": "Bhutan",
+  "BV": "Bouvet Island",
+  "BW": "Botswana",
+  "BY": "Belarus",
+  "BZ": "Belize",
+  "CA": "Canada",
+  "CC": "Cocos Islands",
+  "CD": "Democratic Republic of the Congo",
+  "CF": "Central African Republic",
+  "CG": "Republic of the Congo",
+  "CH": "Switzerland",
+  "CI": "Ivory Coast",
+  "CK": "Cook Islands",
+  "CL": "Chile",
+  "CM": "Cameroon",
+  "CN": "China",
+  "CO": "Colombia",
+  "CR": "Costa Rica",
+  "CU": "Cuba",
+  "CV": "Cape Verde",
+  "CW": "Curacao",
+  "CX": "Christmas Island",
+  "CY": "Cyprus",
+  "CZ": "Czech Republic",
+  "DE": "Germany",
+  "DJ": "Djibouti",
+  "DK": "Denmark",
+  "DM": "Dominica",
+  "DO": "Dominican Republic",
+  "DZ": "Algeria",
+  "EC": "Ecuador",
+  "EE": "Estonia",
+  "EG": "Egypt",
+  "EH": "Western Sahara",
+  "ER": "Eritrea",
+  "ES": "Spain",
+  "ET": "Ethiopia",
+  "FI": "Finland",
+  "FJ": "Fiji",
+  "FK": "Falkland Islands",
+  "FM": "Micronesia",
+  "FO": "Faroe Islands",
+  "FR": "France",
+  "GA": "Gabon",
+  "GB": "United Kingdom",
+  "GD": "Grenada",
+  "GE": "Georgia",
+  "GF": "French Guiana",
+  "GG": "Guernsey",
+  "GH": "Ghana",
+  "GI": "Gibraltar",
+  "GL": "Greenland",
+  "GM": "Gambia",
+  "GN": "Guinea",
+  "GP": "Guadeloupe",
+  "GQ": "Equatorial Guinea",
+  "GR": "Greece",
+  "GS": "South Georgia and the South Sandwich Islands",
+  "GT": "Guatemala",
+  "GU": "Guam",
+  "GW": "Guinea-Bissau",
+  "GY": "Guyana",
+  "HK": "Hong Kong",
+  "HM": "Heard Island and McDonald Islands",
+  "HN": "Honduras",
+  "HR": "Croatia",
+  "HT": "Haiti",
+  "HU": "Hungary",
+  "ID": "Indonesia",
+  "IE": "Ireland",
+  "IL": "Israel",
+  "IM": "Isle of Man",
+  "IN": "India",
+  "IO": "British Indian Ocean Territory",
+  "IQ": "Iraq",
+  "IR": "Iran",
+  "IS": "Iceland",
+  "IT": "Italy",
+  "JE": "Jersey",
+  "JM": "Jamaica",
+  "JO": "Jordan",
+  "JP": "Japan",
+  "KE": "Kenya",
+  "KG": "Kyrgyzstan",
+  "KH": "Cambodia",
+  "KI": "Kiribati",
+  "KM": "Comoros",
+  "KN": "Saint Kitts and Nevis",
+  "KP": "North Korea",
+  "KR": "South Korea",
+  "KW": "Kuwait",
+  "KY": "Cayman Islands",
+  "KZ": "Kazakhstan",
+  "LA": "Laos",
+  "LB": "Lebanon",
+  "LC": "Saint Lucia",
+  "LI": "Liechtenstein",
+  "LK": "Sri Lanka",
+  "LR": "Liberia",
+  "LS": "Lesotho",
+  "LT": "Lithuania",
+  "LU": "Luxembourg",
+  "LV": "Latvia",
+  "LY": "Libya",
+  "MA": "Morocco",
+  "MC": "Monaco",
+  "MD": "Moldova",
+  "ME": "Montenegro",
+  "MF": "Saint Martin",
+  "MG": "Madagascar",
+  "MH": "Marshall Islands",
+  "MK": "Macedonia",
+  "ML": "Mali",
+  "MM": "Myanmar",
+  "MN": "Mongolia",
+  "MO": "Macao",
+  "MP": "Northern Mariana Islands",
+  "MQ": "Martinique",
+  "MR": "Mauritania",
+  "MS": "Montserrat",
+  "MT": "Malta",
+  "MU": "Mauritius",
+  "MV": "Maldives",
+  "MW": "Malawi",
+  "MX": "Mexico",
+  "MY": "Malaysia",
+  "MZ": "Mozambique",
+  "NA": "Namibia",
+  "NC": "New Caledonia",
+  "NE": "Niger",
+  "NF": "Norfolk Island",
+  "NG": "Nigeria",
+  "NI": "Nicaragua",
+  "NL": "Netherlands",
+  "NO": "Norway",
+  "NP": "Nepal",
+  "NR": "Nauru",
+  "NU": "Niue",
+  "NZ": "New Zealand",
+  "OM": "Oman",
+  "PA": "Panama",
+  "PE": "Peru",
+  "PF": "French Polynesia",
+  "PG": "Papua New Guinea",
+  "PH": "Philippines",
+  "PK": "Pakistan",
+  "PL": "Poland",
+  "PM": "Saint Pierre and Miquelon",
+  "PN": "Pitcairn",
+  "PR": "Puerto Rico",
+  "PS": "Palestinian Territory",
+  "PT": "Portugal",
+  "PW": "Palau",
+  "PY": "Paraguay",
+  "QA": "Qatar",
+  "RE": "Reunion",
+  "RO": "Romania",
+  "RS": "Serbia",
+  "RU": "Russia",
+  "RW": "Rwanda",
+  "SA": "Saudi Arabia",
+  "SB": "Solomon Islands",
+  "SC": "Seychelles",
+  "SD": "Sudan",
+  "SE": "Sweden",
+  "SG": "Singapore",
+  "SH": "Saint Helena",
+  "SI": "Slovenia",
+  "SJ": "Svalbard and Jan Mayen",
+  "SK": "Slovakia",
+  "SL": "Sierra Leone",
+  "SM": "San Marino",
+  "SN": "Senegal",
+  "SO": "Somalia",
+  "SR": "Suriname",
+  "SS": "South Sudan",
+  "ST": "Sao Tome and Principe",
+  "SV": "El Salvador",
+  "SX": "Sint Maarten",
+  "SY": "Syria",
+  "SZ": "Swaziland",
+  "TC": "Turks and Caicos Islands",
+  "TD": "Chad",
+  "TF": "French Southern Territories",
+  "TG": "Togo",
+  "TH": "Thailand",
+  "TJ": "Tajikistan",
+  "TK": "Tokelau",
+  "TL": "East Timor",
+  "TM": "Turkmenistan",
+  "TN": "Tunisia",
+  "TO": "Tonga",
+  "TR": "Turkey",
+  "TT": "Trinidad and Tobago",
+  "TV": "Tuvalu",
+  "TW": "Taiwan",
+  "TZ": "Tanzania",
+  "UA": "Ukraine",
+  "UG": "Uganda",
+  "UM": "United States Minor Outlying Islands",
+  "US": "United States",
+  "UY": "Uruguay",
+  "UZ": "Uzbekistan",
+  "VA": "Vatican",
+  "VC": "Saint Vincent and the Grenadines",
+  "VE": "Venezuela",
+  "VG": "British Virgin Islands",
+  "VI": "U.S. Virgin Islands",
+  "VN": "Vietnam",
+  "VU": "Vanuatu",
+  "WF": "Wallis and Futuna",
+  "WS": "Samoa",
+  "XK": "Kosovo",
+  "YE": "Yemen",
+  "YT": "Mayotte",
+  "ZA": "South Africa",
+  "ZM": "Zambia",
+  "ZW": "Zimbabwe"
+}

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: xero_exporter
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library for exporting financial data to the Xero API.
+email:
+- adam@krystal.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- lib/xero_exporter.rb
+- lib/xero_exporter/api.rb
+- lib/xero_exporter/country.rb
+- lib/xero_exporter/error.rb
+- lib/xero_exporter/executor.rb
+- lib/xero_exporter/export.rb
+- lib/xero_exporter/fee.rb
+- lib/xero_exporter/invoice.rb
+- lib/xero_exporter/invoice_line.rb
+- lib/xero_exporter/logger.rb
+- lib/xero_exporter/payment.rb
+- lib/xero_exporter/proposal.rb
+- lib/xero_exporter/refund.rb
+- lib/xero_exporter/tax_rate.rb
+- lib/xero_exporter/version.rb
+- resource/country-codes.json
+homepage: https://github.com/krystal/xero_exporter
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.21
+signing_key: 
+specification_version: 4
+summary: A library for exporting financial data to the Xero API.
+test_files: []