tec_doc 0.2.0

data/lib/tec_doc/article_attribute.rb

@@ -0,0 +1,17 @@
+module TecDoc
+  class ArticleAttribute
+    attr_accessor :block_no, :id, :is_conditional, :is_interval, :name, :short_name, :successor_id, :type, :unit, :value, :value_id
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name.to_s.gsub(/^attr_/, '')}=", value)
+      end
+
+      @id             = @id.to_i                       if @id
+      @value_id       = @value_id.to_i                 if @value_id
+      @value          = DateParser.new(@value).to_date if @type == "D"
+      @is_interval    = (@is_interval == "true")       if @is_interval.is_a?(String)
+      @is_conditional = (@is_conditional == "true")    if @is_conditional.is_a?(String)
+    end
+  end
+end

data/lib/tec_doc/article_document.rb

@@ -0,0 +1,49 @@
+module TecDoc
+  class ArticleDocument
+    attr_accessor :id, :file_name, :file_type_name, :link_id, :description, :type_id, :type_name
+
+    # Find document descriptions to an article
+    #
+    # @option options [Integer] :article_id article ID
+    # @option options [Integer] :article_link_id article link ID (optional)
+    # @option options [String] :country country code according to ISO 3166
+    # @option options [Integer] :doc_type_id document type (KT 141) (optional)
+    # @option options [String] :lang language code according to ISO 639
+    # @return [Array<TecDoc::ArticleDocument>] list of article documents
+    def self.all(options = {})
+      options = {
+        :country => TecDoc.client.country,
+        :lang => I18n.locale.to_s
+      }.merge(options)
+      response = TecDoc.client.request(:get_article_documents, options)
+      response.map do |attributes|
+        new attributes
+      end
+    end
+
+    def initialize(attributes = {})
+      @id             = attributes[:doc_id].to_i
+      @link_id        = attributes[:doc_link_id].to_i
+      @file_name      = attributes[:doc_file_name].to_s
+      @file_type_name = attributes[:doc_file_type_name].to_s
+      @type_id        = attributes[:doc_type_id].to_i
+      @type_name      = attributes[:doc_type_name].to_s
+    end
+
+    def url
+      base_url = TecDoc.client.connection.wsdl.endpoint.gsub("/services/TecdocToCatWL", "")
+      provider = TecDoc.client.provider
+      thumbnail_flag = self.is_a?(ArticleThumbnail) ? "1" : "0"
+      "#{base_url}/documents/#{provider}/#{id}/#{thumbnail_flag}"
+    end
+
+    def content
+      request = TecDoc.client.connection.http
+      request.url = url
+      request.body = nil
+      request.headers = {}
+      response = HTTPI.post(request)
+      response.raw_body
+    end
+  end
+end

data/lib/tec_doc/article_oe_number.rb

@@ -0,0 +1,11 @@
+module TecDoc
+  class ArticleOENumber
+    attr_accessor :block_number, :brand_name, :oe_number, :sort_number
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/tec_doc/article_thumbnail.rb

@@ -0,0 +1,18 @@
+module TecDoc
+  class ArticleThumbnail < ArticleDocument
+    # Find article thumbnail documents
+    # 
+    # @option options [Integer] :article_id Article ID
+    # @return [Array<TecDoc::ArticleThumbnail>] list of article thumbnails
+    def self.all(options = {})
+      response = TecDoc.client.request(:get_thumbnail_by_article_id, options)
+      response.map do |attributes|
+        thumbnail = new
+        thumbnail.id        = attributes[:thumb_doc_id].to_i
+        thumbnail.file_name = attributes[:thumb_file_name].to_s
+        thumbnail.type_id   = attributes[:thumb_type_id].to_i
+        thumbnail
+      end
+    end
+  end
+end

data/lib/tec_doc/assembly_group.rb

@@ -0,0 +1,77 @@
+module TecDoc
+  class AssemblyGroup
+    attr_accessor :id, :parent_id, :name, :has_children, :parent
+    attr_writer :children
+
+    attr_accessor :scope
+    
+    def initialize(attributes={})
+      @id = attributes[:assembly_group_node_id].to_i
+      @name = attributes[:assembly_group_name].to_s
+      @has_children = attributes[:has_childs]
+      @scope = attributes[:scope]
+      if attributes[:parent_node_id]
+        @parent_id = attributes[:parent_node_id].to_i
+      end
+    end
+
+    # Find vehicle, axle, motor or universal assembly groups for the search tree
+    # 
+    # @option options [TrueClass, FalseClass] :child_nodes include child nodes
+    # @option options [String] :lang language code according to ISO 639
+    # @option options [String] :linking_target_type linking target (C: Vehicle type, M: Motor, A: Axle, K: Body Type, U: Universal)
+    # @option options [Integer] :parent_node_id parent node id (optional)
+    # @return [Array<TecDoc::AssemblyGroup>] list of languages
+    def self.all(options = {})
+      options = {
+        :lang => I18n.locale.to_s
+      }.merge(options)
+      
+      if options[:linking_target_id]
+        options[:country] ||= TecDoc.client.country
+        response = TecDoc.client.request(:get_linked_child_nodes_all_linking_target, options)
+      else
+        response = TecDoc.client.request(:get_child_nodes_all_linking_target2, options)
+      end
+      
+      groups = response.map do |attributes|
+        attributes[:scope] = options
+        new(attributes)
+      end
+      
+      if options[:child_nodes]
+        group_ids_map = {}
+        groups.each do |group|
+          group_ids_map[group.id] = group
+        end
+        groups.each do |group|
+          parent = group_ids_map[group.parent_id]
+          if parent
+            parent.add_child(group)
+          end
+        end
+      end
+      
+      groups
+    end
+
+    def children
+      @children ||= if has_children
+        self.class.
+          all(scope.merge(:parent_node_id => id)).
+          each { |child| child.parent = self }
+      else
+        []
+      end
+    end
+
+    def add_child(child)
+      @children ||= []
+      @children << child
+    end
+
+    def inspect
+      "#<#{self.class} @id=#{id.inspect}, @parent_id=#{parent_id.inspect}, @name=#{name.inspect}, @has_children=#{has_children.inspect}>"
+    end
+  end
+end

data/lib/tec_doc/brand.rb

@@ -0,0 +1,18 @@
+module TecDoc
+  class Brand
+    attr_accessor :number, :name
+
+    # Get all brands available for provider.
+    # 
+    # @return [Array<TecDoc::Brand>] list of brands
+    def self.all
+      response = TecDoc.client.request(:get_brands_for_assortment)
+      response.map do |attributes|
+        manufacturer = new
+        manufacturer.number = attributes[:brand_no].to_i
+        manufacturer.name = attributes[:brand_name].to_s
+        manufacturer
+      end
+    end
+  end
+end

data/lib/tec_doc/client.rb

@@ -0,0 +1,84 @@
+module TecDoc
+  class Client
+    attr_accessor :provider, :country, :connection
+
+    def initialize(options = {})
+      self.provider = options[:provider]
+      self.country  = options[:country]
+      self.connection = Savon::Client.new do |wsdl, http|
+        proxy = options[:proxy] || ENV['http_proxy']
+        http.proxy = proxy if proxy
+      end
+      self.mode = options[:mode] || :live
+    end
+
+    def request(operation, options = {})
+      log operation, options do
+        response = connection.request(operation) do
+          soap.body = { :in => { :provider => provider }.merge(options) }
+        end
+        # Parse errors
+        status_node = response.doc.xpath("//status").first
+        if status_node.text != "200"
+          status_text_node = response.doc.xpath("//statusText").first
+          raise Error.new(status_text_node.text)
+        end
+        # Parse the document
+        response.doc.xpath("//data/array/array").map do |node|
+          node_to_hash(node)
+        end
+        # response
+      end
+    end
+
+    def mode=(value)
+      if value == :test
+        connection.wsdl.endpoint = "http://webservicepilot.tecdoc.net/pegasus-2-0/services/TecdocToCatWL"
+        connection.wsdl.namespace = connection.wsdl.endpoint
+        @mode = :test
+      else
+        connection.wsdl.endpoint = "http://webservice-cs.tecdoc.net/pegasus-2-0/services/TecdocToCatWL"
+        connection.wsdl.namespace = connection.wsdl.endpoint
+        @mode = :live
+      end
+    end
+
+    attr_reader :mode
+
+    # Sets the logger to use.
+    attr_writer :logger
+
+    # Returns the logger. Defaults to an instance of +Logger+ writing to STDOUT.
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+
+    def log(operation, options)
+      t = Time.now
+      results = yield
+      duration = 1000.0 * (Time.now - t)
+      logger.info "TecDoc: #{operation.inspect} #{options.inspect} #{'(%.1fms)' % duration}"
+      results
+    end
+
+    private
+
+    def node_to_hash(node)
+      attributes = {}
+      node.children.each do |n|
+        if n.xpath("empty").text == "true"
+          attributes[n.name.snakecase.to_sym] = []
+        elsif (n_array = n.xpath("array/array")).size > 0
+          attributes[n.name.snakecase.to_sym] = n_array.map { |nn| node_to_hash(nn) }
+        elsif n.children.reject { |nn| nn.is_a?(Nokogiri::XML::Text) }.size > 0
+          attributes[n.name.snakecase.to_sym] = node_to_hash(n)
+        elsif n.text == ""
+          attributes[n.name.snakecase.to_sym] = nil
+        else
+          attributes[n.name.snakecase.to_sym] = n.text
+        end
+      end
+      attributes
+    end
+  end
+end

data/lib/tec_doc/date_parser.rb

@@ -0,0 +1,14 @@
+module TecDoc
+  class DateParser
+    def initialize(value)
+      @value = value
+    end
+
+    def to_date
+      if @value
+        year, month = @value.to_i.divmod(100)
+        Date.new(year, month, 1)
+      end
+    end
+  end
+end

data/lib/tec_doc/error.rb

@@ -0,0 +1,4 @@
+module TecDoc
+  class Error < StandardError
+  end
+end

data/lib/tec_doc/generic_article.rb

@@ -0,0 +1,47 @@
+module TecDoc
+  class GenericArticle
+    attr_accessor :id, :name
+    attr_accessor :scope
+    
+    # getGenericArticlesByManufacturer5()
+    
+    # Get generic articles
+    #
+    # @option options [Integer] :assembly_group_node_id (optional)
+    # @option options [LongList] :generic_article_id (optional)
+    # @option options [LongList] :brand_no result of brand selection (optional)
+    # @option options [String] :linking_target_type - "C", "M", "A", "K", "U"
+    # @option options [Integer] :linking_target_id - null if "U"
+    # @option options [Integer] :result_mode - 1: Distinct brand numbers, 2: Distinct generic articles, 3: Both (optional)
+    # @option options [Integer] :sort_mode - 1: Brand name, 2: Article norm name (optional)
+    # @return [Array<TecDoc::GenericArticle>] list of generic articles
+    def self.all(options = {})
+      options[:result_mode] = 2
+      options[:sort_mode] = 2
+      options = {
+        :lang => I18n.locale.to_s,
+        :country => TecDoc.client.country
+      }.merge(options)
+      TecDoc.client.request(:get_generic_articles_by_manufacturer6, options).map do |attributes|
+        new(attributes, options)
+      end
+    end
+    
+    def initialize(attributes = {}, scope = {})
+      @id    = (attributes[:id] || attributes[:generic_article_id]).to_i
+      @name  = attributes[:article_norm_name]
+      @scope = scope
+    end
+
+    # Generic article linked articles
+    def articles(options = {})
+      options = {
+        :linking_target_type => scope[:linking_target_type],
+        :linking_target_id   => scope[:linking_target_id]
+      }.merge(options).merge({
+        :generic_article_id => { :array => { :id => [id] } }
+      })
+      Article.all(options)
+    end
+  end
+end

data/lib/tec_doc/language.rb

@@ -0,0 +1,22 @@
+module TecDoc
+  class Language
+    attr_accessor :code, :name
+
+    # Get all languages available for provider.
+    # 
+    # @option options [String] :lang language code according to ISO 639
+    # @return [Array<TecDoc::Language>] list of languages
+    def self.all(options = {})
+      options = {
+        :lang => I18n.locale.to_s
+      }.merge(options)
+      response = TecDoc.client.request(:get_languages, options)
+      response.map do |attributes|
+        language = new
+        language.code = attributes[:language_code].to_s
+        language.name = attributes[:language_name].to_s
+        language
+      end
+    end
+  end
+end

data/lib/tec_doc/vehicle.rb

@@ -0,0 +1,121 @@
+module TecDoc
+  class Vehicle
+    attr_accessor \
+      :id,
+      :name,
+      :cylinder_capacity,
+      :first_country,
+      :linked,
+      :power_hp_from,
+      :power_hp_to,
+      :power_kw_from,
+      :power_kw_to,
+      :date_of_construction_from,
+      :date_of_construction_to,
+      :motor_codes,
+      :manu_id,
+      :mod_id,
+      :attributes,
+      :article_link_id
+
+    # Find vehicles for simplified selection with motor codes
+    #
+    # @option options [Integer] :car_type vehicle type (1: Passenger car, 2: Commercial vehicle, 3: Light commercial)
+    # @option options [String] :countries_car_selection country code according to ISO 3166
+    # @option options [TrueClass, FalseClass] :country_group_flag country group selection
+    # @option options [String] :country_user_setting country for article assignments, country code according to assignments ISO 3166 (optional)
+    # @option options [Integer, NilClass] :favoured_list simplified vehicle selection (1: first list selection, 0: rest)
+    # @option options [String] :lang language code according to ISO 639
+    # @option options [TrueClass, FalseClass] :linked selection with/without article assignments (false: all, true: only linked articles)
+    # @option options [Integer] :manu_id manufacturer ID
+    # @option options [Integer] :mod_id vehicle ID
+    # @return [Array<TecDoc::VehicleManufacturer>] list of vehicles with motor codes
+    def self.all(options = {})
+      options = {
+        :car_type => 1,
+        :countries_car_selection => TecDoc.client.country,
+        :country_group_flag => false,
+        :favoured_list => 1,
+        :lang => I18n.locale.to_s,
+        :linked => false
+      }.merge(options)
+      response = TecDoc.client.request(:get_vehicle_simplified_selection4, options)
+      response.map do |attributes|
+        vehicle = new
+        car_attributes = attributes[:car_details]
+        if car_attributes
+          vehicle.manu_id                   = options[:manu_id].to_i
+          vehicle.mod_id                    = options[:mod_id].to_i
+          vehicle.id                        = car_attributes[:car_id].to_i
+          vehicle.name                      = car_attributes[:car_name].to_s
+          vehicle.cylinder_capacity         = car_attributes[:cylinder_capacity].to_i
+          vehicle.first_country             = car_attributes[:first_country].to_s
+          vehicle.linked                    = car_attributes[:linked]
+          vehicle.power_hp_from             = car_attributes[:power_hp_from].to_i
+          vehicle.power_hp_to               = car_attributes[:power_hp_to].to_i
+          vehicle.power_kw_from             = car_attributes[:power_kw_from].to_i
+          vehicle.power_kw_to               = car_attributes[:power_kw_to].to_i
+          vehicle.date_of_construction_from = DateParser.new(car_attributes[:year_of_constr_from]).to_date
+          vehicle.date_of_construction_to   = DateParser.new(car_attributes[:year_of_constr_to]).to_date
+        end
+        vehicle.motor_codes = attributes[:motor_codes].map { |mc| mc[:motor_code] }
+        vehicle
+      end
+    end
+    
+    def self.find(options = {})
+      id = options.delete(:id)
+      options = {
+        :car_ids => { :array => { :ids => [id] } },
+        :countries_car_selection => TecDoc.client.country,
+        :country_user_setting => TecDoc.client.country,
+        :country => TecDoc.client.country,
+        :lang => TecDoc.client.country,
+        :axles => false,
+        :cabs => false,
+        :country_group_flag => false,
+        :motor_codes => true,
+        :vehicle_details_2 => false,
+        :vehicle_terms => true
+      }.merge(options)
+      response = TecDoc.client.request(:get_vehicle_by_ids_2, options)
+      if attrs = response.first
+        details  = attrs[:vehicle_details]  || {}
+        terms    = attrs[:vehicle_terms]    || {}
+        vehicle  = new
+        vehicle.id                        = attrs[:car_id].to_i
+        vehicle.name                      = terms[:car_type].to_s
+        vehicle.cylinder_capacity         = details[:ccm_tech].to_i
+        vehicle.power_hp_from             = details[:power_hp_from].to_i
+        vehicle.power_hp_to               = details[:power_hp_to].to_i
+        vehicle.power_kw_from             = details[:power_kw_from].to_i
+        vehicle.power_kw_to               = details[:power_kw_to].to_i
+        vehicle.date_of_construction_from = DateParser.new(details[:year_of_constr_from]).to_date
+        vehicle.date_of_construction_to   = DateParser.new(details[:year_of_constr_to]).to_date
+        vehicle.manu_id                   = details[:manu_id].to_i
+        vehicle.mod_id                    = details[:mod_id].to_i
+        vehicle.motor_codes = attrs[:motor_codes].map { |mc| mc[:motor_code] }
+        vehicle
+      else
+        nil
+      end
+    end
+
+    def attributes
+      @attributes || []
+    end
+
+    def attributes=(attrs)
+      @attributes = attrs.map{ |attr| ArticleAttribute.new(attr) }
+    end
+    
+    # Vehicle linked assembly parent groups
+    def assembly_groups(options = {})
+      options.merge!({
+        :linking_target_type => "C",
+        :linking_target_id => id,
+      })
+      AssemblyGroup.all(options)
+    end
+  end
+end