xero_gateway-float 2.0.18 → 2.1.1

data/lib/xero_gateway/http.rb

@@ -7,26 +7,28 @@ module XeroGateway
     def log(str)
       XeroGateway.log("HTTP : "+str)
     end
-    def http_get(client, url, extra_params = {})
+
+    def http_get(client, url, extra_params = {}, headers = {})
       log "get  | #{url} :: #{extra_params.inspect}"
-      http_request(client, :get, url, nil, extra_params)
+      http_request(client, :get, url, nil, extra_params, headers)
     end
 
-    def http_post(client, url, body, extra_params = {})
+    def http_post(client, url, body, extra_params = {}, headers = {})
       log "post | #{url} :: #{extra_params.inspect}"
-      http_request(client, :post, url, body, extra_params)
+      http_request(client, :post, url, body, extra_params, headers)
     end
 
-    def http_put(client, url, body, extra_params = {})
+    def http_put(client, url, body, extra_params = {}, headers = {})
       log "put | #{url} :: #{extra_params.inspect}"
-      http_request(client, :put, url, body, extra_params)
+      http_request(client, :put, url, body, extra_params, headers)
     end
 
     private
-    
-      def http_request(client, method, url, body, params = {})
+
+      def http_request(client, method, url, body, params = {}, headers = {})
         # headers = {'Accept-Encoding' => 'gzip, deflate'}
-        headers = { 'charset' => 'utf-8' }
+
+        headers = headers.merge!('charset' => 'utf-8')
 
         if method != :get
           headers['Content-Type'] ||= "application/x-www-form-urlencoded"
@@ -45,39 +47,43 @@ module XeroGateway
 
         # # Only setup @cached_http once on first use as loading the CA file is quite expensive computationally.
         # unless @cached_http && @cached_http.address == uri.host && @cached_http.port == uri.port
-        #   @cached_http = Net::HTTP.new(uri.host, uri.port) 
+        #   @cached_http = Net::HTTP.new(uri.host, uri.port)
         #   @cached_http.open_timeout = OPEN_TIMEOUT
         #   @cached_http.read_timeout = READ_TIMEOUT
         #   @cached_http.use_ssl      = true
-        # 
+        #
         #   # Need to validate server's certificate against root certificate authority to prevent man-in-the-middle attacks.
         #   @cached_http.ca_file        = ROOT_CA_FILE
         #   # http.verify_mode    = OpenSSL::SSL::VERIFY_NONE
         #   @cached_http.verify_mode    = OpenSSL::SSL::VERIFY_PEER
         #   @cached_http.verify_depth   = 5
         # end
-        
+
         logger.info("\n== [#{Time.now.to_s}] XeroGateway Request: #{uri.request_uri} ") if self.logger
-        
+
         response = case method
           when :get   then    client.get(uri.request_uri, headers)
           when :post  then    client.post(uri.request_uri, { :xml => body }, headers)
           when :put   then    client.put(uri.request_uri, { :xml => body }, headers)
         end
-        
+
         if self.logger
           logger.info("== [#{Time.now.to_s}] XeroGateway Response (#{response.code})")
-          
+
           unless response.code.to_i == 200
             logger.info("== #{uri.request_uri} Response Body \n\n #{response.plain_body} \n == End Response Body")
           end
         end
-        
+
         case response.code.to_i
           when 200
-            response.plain_body
+            if RUBY_VERSION >= "1.9"
+              response.plain_body.force_encoding("UTF-8")
+            else
+              response.plain_body
+            end
           when 400
-            handle_error!(body, response)  
+            handle_error!(body, response)
           when 401
             handle_oauth_error!(response)
           when 404
@@ -88,11 +94,11 @@ module XeroGateway
             raise "Unknown response code: #{response.code.to_i}"
         end
       end
-       
+
       def handle_oauth_error!(response)
         error_details = CGI.parse(response.plain_body)
         description   = error_details["oauth_problem_advice"].first
-      
+
         # see http://oauth.pbworks.com/ProblemReporting
         # In addition to token_expired and token_rejected, Xero also returns
         # 'rate limit exceeded' when more than 60 requests have been made in
@@ -105,32 +111,32 @@ module XeroGateway
           else raise OAuth::UnknownError.new(error_details["oauth_problem"].first + ':' + description)
         end
       end
-      
+
       def handle_error!(request_xml, response)
-        
+
         raw_response = response.plain_body
-        
+
         # Xero Gateway API Exceptions *claim* to be UTF-16 encoded, but fail REXML/Iconv parsing...
         # So let's ignore that :)
         raw_response.gsub! '<?xml version="1.0" encoding="utf-16"?>', ''
-        
+
         doc = REXML::Document.new(raw_response, :ignore_whitespace_nodes => :all)
-        
+
         if doc.root.name == "ApiException"
 
-          raise ApiException.new(doc.root.elements["Type"].text, 
+          raise ApiException.new(doc.root.elements["Type"].text,
                                  doc.root.elements["Message"].text,
-                                 request_xml, 
+                                 request_xml,
                                  raw_response)
 
         else
-          
+
           raise "Unparseable 400 Response: #{raw_response}"
-          
+
         end
-        
+
       end
-      
+
       def handle_object_not_found!(response, request_url)
         case(request_url)
           when /Invoices/ then raise InvoiceNotFoundError.new("Invoice not found in Xero.")
@@ -139,6 +145,6 @@ module XeroGateway
           else raise ObjectNotFound.new(request_url)
         end
       end
-      
+
   end
 end

data/lib/xero_gateway/invoice.rb

@@ -4,8 +4,6 @@ module XeroGateway
     include Money
     include LineItemCalculations
     
-    class NoGatewayError < Error; end
-    
     INVOICE_TYPE = {
       'ACCREC' =>           'Accounts Receivable',
       'ACCPAY' =>           'Accounts Payable'
@@ -32,13 +30,16 @@ module XeroGateway
     attr_accessor :gateway
     
     # Any errors that occurred when the #valid? method called.
-    attr_reader :errors
+    # Or errors that were within the XML payload from Xero
+    attr_accessor :errors
 
     # Represents whether the line_items have been downloaded when getting from GET /API.XRO/2.0/INVOICES
     attr_accessor :line_items_downloaded
   
     # All accessible fields
-    attr_accessor :invoice_id, :invoice_number, :invoice_type, :invoice_status, :date, :due_date, :reference, :line_amount_types, :currency_code, :line_items, :contact, :payments, :fully_paid_on, :amount_due, :amount_paid, :amount_credited, :sent_to_contact, :url, :sub_total, :total_tax, :total, :updated_date_utc
+    attr_accessor :invoice_id, :invoice_number, :invoice_type, :invoice_status, :date, :due_date, :reference, :branding_theme_id, :line_amount_types, :currency_code, :line_items, :contact, :payments, :fully_paid_on, :amount_due, :amount_paid, :amount_credited, :sent_to_contact, :url, :updated_date_utc
+    # Are these buggy?
+    #attr_accessor :sub_total, :total_tax, :total
 
     
     def initialize(params = {})
@@ -68,6 +69,10 @@ module XeroGateway
     def valid?
       @errors = []
       
+      if !INVOICE_TYPE[invoice_type]
+        @errors << ['invoice_type', "must be one of #{INVOICE_TYPE.keys.join('/')}"]
+      end
+
       if !invoice_id.nil? && invoice_id !~ GUID_REGEX
         @errors << ['invoice_id', 'must be blank or a valid Xero GUID']
       end
@@ -165,14 +170,14 @@ module XeroGateway
     end
     
     # Creates this invoice record (using gateway.create_invoice) with the associated gateway.
-    # If no gateway set, raise a Xero::Invoice::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def create
       raise NoGatewayError unless gateway
       gateway.create_invoice(self)
     end
     
     # Updates this invoice record (using gateway.update_invoice) with the associated gateway.
-    # If no gateway set, raise a Xero::Invoice::NoGatewayError exception.
+    # If no gateway set, raise a NoGatewayError exception.
     def update
       raise NoGatewayError unless gateway
       gateway.update_invoice(self)
@@ -189,6 +194,7 @@ module XeroGateway
         b.DueDate Invoice.format_date(self.due_date) if self.due_date
         b.Status self.invoice_status if self.invoice_status
         b.Reference self.reference if self.reference
+        b.BrandingThemeID self.branding_theme_id if self.branding_theme_id
         b.LineAmountTypes self.line_amount_types
         b.LineItems {
           self.line_items.each do |line_item|
@@ -214,13 +220,14 @@ module XeroGateway
           when "FullyPaidOnDate" then invoice.fully_paid_on = parse_date(element.text)
           when "Status" then invoice.invoice_status = element.text
           when "Reference" then invoice.reference = element.text
+          when "BrandingThemeID" then invoice.branding_theme_id = element.text
           when "LineAmountTypes" then invoice.line_amount_types = element.text
           when "LineItems" then element.children.each {|line_item| invoice.line_items_downloaded = true; invoice.line_items << LineItem.from_xml(line_item) }
           when "SubTotal" then invoice.sub_total = BigDecimal.new(element.text)
           when "TotalTax" then invoice.total_tax = BigDecimal.new(element.text)
           when "Total" then invoice.total = BigDecimal.new(element.text)
           when "InvoiceID" then invoice.invoice_id = element.text
-          when "InvoiceNumber" then invoice.invoice_number = element.text            
+          when "InvoiceNumber" then invoice.invoice_number = element.text
           when "Payments" then element.children.each { | payment | invoice.payments << Payment.from_xml(payment) }
           when "AmountDue" then invoice.amount_due = BigDecimal.new(element.text)
           when "AmountPaid" then invoice.amount_paid = BigDecimal.new(element.text)
@@ -228,9 +235,10 @@ module XeroGateway
           when "SentToContact" then invoice.sent_to_contact = (element.text.strip.downcase == "true")
           when "Url" then invoice.url = element.text
           when "UpdatedDateUTC" then invoice.updated_date_utc = parse_utc_date_time(element.text)
+          when "ValidationErrors" then invoice.errors = element.children.map { |error| Error.parse(error) }
         end
-      end      
+      end
       invoice
-    end    
+    end
   end
 end

data/lib/xero_gateway/journal_line.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'account')
+
+module XeroGateway
+  class JournalLine
+    include Money
+    
+    TAX_TYPE = Account::TAX_TYPE unless defined?(TAX_TYPE)
+
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # All accessible fields
+    attr_accessor :journal_line_id, :line_amount, :account_code, :description, :tax_type, :tracking
+        
+    def initialize(params = {})
+      @errors ||= []
+      @tracking ||= []
+      
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    # Validate the JournalLineItem record according to what will be valid by the gateway.
+    #
+    # Usage: 
+    #  journal_line_item.valid?     # Returns true/false
+    #  
+    #  Additionally sets journal_line_item.errors array to an array of field/error.
+    def valid?
+      @errors = []
+      
+      if !journal_line_id.nil? && journal_line_id !~ GUID_REGEX
+        @errors << ['journal_line_id', 'must be blank or a valid Xero GUID']
+      end
+      
+      unless line_amount
+        @errors << ['line_amount', "can't be blank"]
+      end
+
+      unless account_code
+        @errors << ['account_code', "can't be blank"]
+      end
+      
+      @errors.size == 0
+    end
+    
+    def has_tracking?
+      return false if tracking.nil?
+      
+      if tracking.is_a?(Array)
+        return tracking.any?
+      else
+        return tracking.is_a?(TrackingCategory)
+      end
+    end
+    
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.JournalLine {
+        b.LineAmount line_amount # mandatory
+        b.AccountCode account_code # mandatory
+        b.Description description if description # optional
+        b.TaxType tax_type if tax_type # optional
+        if has_tracking?
+          b.Tracking { # optional
+            # Due to strange retardness in the Xero API, the XML structure for a tracking category within
+            # an invoice is different to a standalone tracking category.
+            # This means rather than going category.to_xml we need to call the special category.to_xml_for_invoice_messages
+            (tracking.is_a?(TrackingCategory) ? [tracking] : tracking).each do |category|
+              category.to_xml_for_invoice_messages(b)
+            end
+          }
+        end
+      }
+    end
+    
+    def self.from_xml(journal_line_element)
+      journal_line = JournalLine.new
+      journal_line_element.children.each do |element|
+        case(element.name)
+          when "LineAmount" then journal_line.line_amount = BigDecimal.new(element.text)
+          when "AccountCode" then journal_line.account_code = element.text
+          when "JournalLineID" then journal_line.journal_line_id = element.text
+          when "Description" then journal_line.description = element.text
+          when "TaxType" then journal_line.tax_type = element.text
+          when "Tracking" then
+            element.children.each do | tracking_element |
+              journal_line.tracking << TrackingCategory.from_xml(tracking_element)
+            end
+        end
+      end
+      journal_line
+    end    
+
+    def ==(other)
+      [:description, :line_amount, :account_code, :tax_type].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+  end  
+end

data/lib/xero_gateway/line_item_calculations.rb

@@ -1,9 +1,5 @@
 module XeroGateway
   module LineItemCalculations
-
-    class Error < RuntimeError; end
-    class InvalidLineItemError < Error; end
-
     def add_line_item(params = {})
       line_item = nil
       case params

data/lib/xero_gateway/manual_journal.rb

@@ -0,0 +1,163 @@
+module XeroGateway
+  class ManualJournal
+  	include Dates
+
+    GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
+
+    STATUSES = {
+      'DRAFT' 	=> 'Draft Manual Journal',
+      'POSTED' 	=> 'Posted Manual Journal',
+      'DELETED' => 'Deleted Draft Manual Journal',
+      'VOIDED'	=> 'Voided Posted Manual Journal'
+    } unless defined?(STATUSES)
+
+    # Xero::Gateway associated with this invoice.
+    attr_accessor :gateway
+
+    # Any errors that occurred when the #valid? method called.
+    attr_reader :errors
+
+    # Represents whether the journal lines have been downloaded when getting from GET /API.XRO/2.0/ManualJournals
+    attr_accessor :journal_lines_downloaded
+
+    # accessible fields
+    attr_accessor :manual_journal_id, :narration, :date, :status, :journal_lines, :url, :show_on_cash_basis_reports
+
+    def initialize(params = {})
+      @errors ||= []
+      @payments ||= []
+
+      # Check if the line items have been downloaded.
+      @journal_lines_downloaded = (params.delete(:journal_lines_downloaded) == true)
+
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+
+      @journal_lines ||= []
+    end
+
+    def ==(other)
+      ['narration', 'status', 'journal_lines', 'show_on_cash_basis_reports'].each do |field|
+        return false if send(field) != other.send(field)
+      end
+
+      ["date"].each do |field|
+        return false if send(field).to_s != other.send(field).to_s
+      end
+      return true
+    end
+
+    # Validate the ManualJournal record according to what will be valid by the gateway.
+    #
+    # Usage:
+    #  manual_journal.valid?     # Returns true/false
+    #
+    #  Additionally sets manual_journal.errors array to an array of field/error.
+    def valid?
+      @errors = []
+
+      if !manual_journal_id.nil? && manual_journal_id !~ GUID_REGEX
+        @errors << ['manual_journal_id', 'must be blank or a valid Xero GUID']
+      end
+
+      if narration.blank?
+      	@errors << ['narration', "can't be blank"]
+      end
+
+      unless date
+        @errors << ['date', "can't be blank"]
+      end
+
+      # Make sure all journal_items are valid.
+      unless journal_lines.all? { | journal_line | journal_line.valid? }
+        @errors << ['journal_lines', "at least one journal line invalid"]
+      end
+
+      # make sure there are at least 2 journal lines
+      unless journal_lines.length > 1
+      	@errors << ['journal_lines', "journal must contain at least two individual journal lines"]
+      end
+
+      if journal_lines.length > 100
+      	@errors << ['journal_lines', "journal must contain less than one hundred journal lines"]
+      end
+
+      unless journal_lines.sum(&:line_amount).to_f == 0.0
+      	@errors << ['journal_lines', "the total debits must be equal to total credits"]
+      end
+
+      @errors.size == 0
+    end
+
+
+    def journal_lines_downloaded?
+      @journal_lines_downloaded
+    end
+
+    # If line items are not downloaded, then attempt a download now (if this record was found to begin with).
+    def journal_lines
+      if journal_lines_downloaded?
+        @journal_lines
+
+      elsif manual_journal_id =~ GUID_REGEX && @gateway
+        # There is a manual_journal_id so we can assume this record was loaded from Xero.
+        # Let's attempt to download the journal_line records (if there is a gateway)
+
+        response = @gateway.get_manual_journal(manual_journal_id)
+        raise ManualJournalNotFoundError, "Manual Journal with ID #{manual_journal_id} not found in Xero." unless response.success? && response.manual_journal.is_a?(XeroGateway::ManualJournal)
+
+        @journal_lines = response.manual_journal.journal_lines
+        @journal_lines_downloaded = true
+
+        @journal_lines
+
+      # Otherwise, this is a new manual journal, so return the journal_lines reference.
+      else
+        @journal_lines
+      end
+    end
+
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.ManualJournal {
+        b.ManualJournalID manual_journal_id if manual_journal_id
+        b.Narration narration        
+        b.JournalLines {
+          self.journal_lines.each do |journal_line|
+            journal_line.to_xml(b)
+          end
+        }
+        b.Date ManualJournal.format_date(date || Date.today)
+        b.Status status if status
+        b.Url url if url
+      }
+    end
+
+    def self.from_xml(manual_journal_element, gateway = nil, options = {})
+      manual_journal = ManualJournal.new(options.merge({:gateway => gateway}))
+      manual_journal_element.children.each do |element|
+        case(element.name)
+          when "ManualJournalID" then manual_journal.manual_journal_id = element.text
+          when "Date" then manual_journal.date = parse_date(element.text)
+          when "Status" then manual_journal.status = element.text
+          when "Narration" then manual_journal.narration = element.text
+          when "JournalLines" then element.children.each {|journal_line| manual_journal.journal_lines_downloaded = true; manual_journal.journal_lines << JournalLine.from_xml(journal_line) }
+          when "Url" then manual_journal.url = element.text
+        end
+      end
+      manual_journal
+    end # from_xml
+
+    def add_journal_line(params = {})
+      journal_line = nil
+      case params
+        when Hash 			 then  journal_line = JournalLine.new(params)
+        when JournalLine then  journal_line = params
+        else             raise InvalidLineItemError
+      end
+      @journal_lines << journal_line
+      journal_line
+    end
+
+  end
+end

data/lib/xero_gateway/oauth.rb

@@ -1,18 +1,18 @@
 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",
@@ -21,59 +21,65 @@ module XeroGateway
         :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
-    
+
+    attr_reader   :ctoken, :csecret, :consumer_options, :authorization_expires_at
+    attr_accessor :session_handle
+
     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 
+      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)
+    rescue ::OAuth::Unauthorized => e
+      # If the original access token is for some reason invalid an OAuth::Unauthorized could be raised.
+      # In this case raise a XeroGateway::OAuth::TokenInvalid which can be captured by the caller.  In this
+      # situation the end user will need to re-authorize the application via the request token authorization URL
+      raise XeroGateway::OAuth::TokenInvalid.new(e.message)
     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
@@ -82,6 +88,6 @@ module XeroGateway
         @atoken, @asecret         = access_token.token, access_token.secret
         @access_token             = nil
       end
-    
+
   end
 end

data/lib/xero_gateway/partner_app.rb

@@ -6,7 +6,7 @@ module XeroGateway
     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_delegators :client, :session_handle, :renew_access_token, :authorization_expires_at
      
     def initialize(consumer_key, consumer_secret, options = {})
       
@@ -26,5 +26,10 @@ module XeroGateway
       @xero_url = options[:xero_url] || "https://api-partner.xero.com/api.xro/2.0"  
       @client   = OAuth.new(consumer_key, consumer_secret, options)
     end
+
+    def set_session_handle(handle)
+      client.session_handle = handle
+    end
+    
   end
 end

data/lib/xero_gateway/response.rb

@@ -9,11 +9,13 @@ module XeroGateway
     alias_method :invoice,              :response_item
     alias_method :credit_note,          :response_item
     alias_method :bank_transaction,     :response_item
+    alias_method :manual_journal,       :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 :manual_journals,      :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

data/lib/xero_gateway/tax_rate.rb

@@ -47,7 +47,7 @@ module XeroGateway
           attribute             = element.name
           underscored_attribute = element.name.underscore
         
-          raise "Unknown attribute: #{attribute}" unless ATTRS.keys.include?(attribute)
+          next if !ATTRS.keys.include?(attribute)
         
           case (ATTRS[attribute])
             when :boolean then  tax_rate.send("#{underscored_attribute}=", (element.text == "true"))