module Prestashop::Api::Converter

Public Class Methods

build(resource, model, hash) click to toggle source

Build XML from given params and hash. This XML is compatible with Prestashop WebService

Converter.build :customers, :customer, { name: 'Steve' }  # => <prestashop><customers><customer>....</customer></customers></prestashop>
# File lib/prestashop/api/converter.rb, line 11
def self.build resource, model, hash
  Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |ml|
    ml.prestashop("xmlns:xlink" => "http://www.w3.org/1999/xlink") {
      ml.send(model.to_s) {
        build_nodes ml, hash
      }
    }
  end.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::AS_XML | Nokogiri::XML::Node::SaveOptions::NO_DECLARATION).strip
end
build_nodes(ml, source, mkey = nil) click to toggle source

Build XML nodes based from given source parameter, skipping attr or val keys if source is Hash

Parameters:

  • ml - Current XML

  • source - Source, which will be converted into the XML

# File lib/prestashop/api/converter.rb, line 51
def self.build_nodes ml, source, mkey = nil
  unless source[:attr] and source[:val]
    source.each do |key, value| 
      if value.kind_of? Hash
        if value[:attr]
          ml.send(key, value[:attr]){
            cdata ml, value[:val]
            build_nodes ml, value
          }
        elsif key != :attr
          ml.send(key){
            unless value.kind_of? Hash
              cdata ml, value
            end
            build_nodes ml, value
          }
        end
      elsif value.kind_of? Array
        value.each do |item|
          hash = {}
          hash[key] = item
          build_nodes ml, hash
        end
      elsif key != :val
        ml.send(key){
          cdata ml, value
        }
      end
    end if source.kind_of? Hash
  end
end
cdata(ml, value) click to toggle source

Create CDATA tag into XML, when is not empty

# File lib/prestashop/api/converter.rb, line 85
def self.cdata ml, value
  if value and value != ''
    ml.cdata value
  end
end
parse(xml) click to toggle source

Parse XML (response from WebService call) to Hash, skipping first <prestashop> node.

Converter.parse('<prestashop><customers><customer><name>Steve</customer></customers></prestashop>')
# => {customers: [ customer: { name: 'Steve' } ]}
# File lib/prestashop/api/converter.rb, line 26
def self.parse xml
  result = Nokogiri::XML xml

  raise ParserError unless result.root

  xml_node_to_hash result.root
end
parse_error(response) click to toggle source

Parse XML to Hash, call parse and skip everything to error message

# File lib/prestashop/api/converter.rb, line 36
def self.parse_error response
  parsed = parse(response)
  if parsed[:errors] and parsed[:errors][:error] and parsed[:errors][:error][:message]
    parsed[:errors][:error][:message]
  else
    raise ParserError
  end
end
prepare(data) click to toggle source
# File lib/prestashop/api/converter.rb, line 147
def self.prepare data
  (data.class == String && data.to_i.to_s == data) ? data.to_i : data
end
xml_node_to_hash(node) click to toggle source

Parse XML node and covert it to hash

Converter.xml_node_to_hash '<customer id_lang="1">Steve</customer>'
# => { attr: { id_lang: 1 }, val: 'Steve'  }
# File lib/prestashop/api/converter.rb, line 96
def self.xml_node_to_hash node 
  # If we are at the root of the document, start the hash
  if node.element?
    result_hash = {}
    if node.attributes != {}
       if node.attributes
        node.attributes.each do |key, value|
          unless value.name == 'href'
            result_hash[:attr] = {} unless result_hash[:attr]
            result_hash[:attr][value.name.to_sym] = prepare(value.value)
          end
        end
      end
    end
    if node.children.size > 0
      node.children.each do |child|
        result = xml_node_to_hash(child)
        if child.name == "text"
          unless child.next_sibling || child.previous_sibling
            if !result_hash.empty?
              result_hash[:val] = prepare(result)
              return result_hash
            end
            return prepare(result)
          end
        elsif child.name == "#cdata-section"
          if !result_hash.empty?
            result_hash[:val] = prepare(result)
            return result_hash
          end
          return prepare(result)
        elsif result_hash[child.name.to_sym]
          if result_hash[child.name.to_sym].is_a?(Object::Array)
            result_hash[child.name.to_sym] << prepare(result)
          else
            result_hash[child.name.to_sym] = [result_hash[child.name.to_sym]] << prepare(result)
          end
        else 
          result_hash[child.name.to_sym] = prepare(result)
        end
      end
   
      return result_hash
    else
      return result_hash
    end 
  else 
    return prepare(node.content.to_s) 
  end 
end