reso_transport 1.5.1 → 1.5.7

data/lib/reso_transport/client.rb

@@ -1,36 +1,52 @@
 module ResoTransport
   class Client
-    attr_reader :connection, :uid, :vendor, :endpoint, :auth, :md_file
-    
+    attr_reader :connection, :uid, :vendor, :endpoint, :authentication, :md_file, :md_cache, :ds_file, :ds_cache,
+                :use_replication_endpoint
+
     def initialize(options)
-      @endpoint        = options.fetch(:endpoint)
-      @md_file         = options.fetch(:md_file, nil)
-      @authentication  = ensure_valid_auth_strategy(options.fetch(:authentication))
-      @vendor          = options.fetch(:vendor, {})
-      @faraday_options = options.fetch(:faraday_options, {})
-      @logger          = options.fetch(:logger, nil)
-
-      @connection = Faraday.new(@endpoint, @faraday_options) do |faraday|
+      @use_replication_endpoint = options.fetch(:use_replication_endpoint, false)
+      @endpoint                 = options.fetch(:endpoint)
+      @md_file                  = options.fetch(:md_file, nil)
+      @ds_file                  = options.fetch(:ds_file, nil)
+      @authentication           = ensure_valid_auth_strategy(options.fetch(:authentication))
+      @vendor                   = options.fetch(:vendor, {})
+      @faraday_options          = options.fetch(:faraday_options, {})
+      @logger                   = options.fetch(:logger, nil)
+      @md_cache                 = options.fetch(:md_cache, ResoTransport::MetadataCache)
+      @ds_cache                 = options.fetch(:ds_cache, ResoTransport::MetadataCache)
+      @connection               = establish_connection
+    end
+
+    def establish_connection
+      Faraday.new(@endpoint, @faraday_options) do |faraday|
         faraday.request  :url_encoded
-        # faraday.response :logger, ResoTransport.configuration.logger if ResoTransport.configuration.logger
-        # faraday.response :logger, @logger if @logger
-        faraday.response :logger
-        #yield faraday if block_given?
+        faraday.response :logger, @logger || ResoTransport.configuration.logger
         faraday.use Authentication::Middleware, @authentication
-        faraday.adapter Faraday.default_adapter #unless faraday.builder.send(:adapter_set?)
+        faraday.adapter Faraday.default_adapter # unless faraday.builder.send(:adapter_set?)
       end
     end
 
     def resources
-      @resources ||= metadata.entity_sets.map {|es| {es.name => Resource.new(self, es)} }.reduce(:merge!)
+      @resources ||= metadata.entity_sets.map { |es| { es.name => resource_for(es) } }.reduce(:merge!)
+    end
+
+    def resource_for(entity_set)
+      localizations = {}
+      localizations = datasystem.localizations_for(entity_set.entity_type) if metadata.datasystem?
+
+      Resource.new(self, entity_set, localizations)
     end
 
     def metadata
       @metadata ||= Metadata.new(self)
     end
 
+    def datasystem
+      @datasystem ||= Datasystem.new(self)
+    end
+
     def to_s
-      %(#<ResoTransport::Client endpoint="#{endpoint}", md_file="#{md_file}">)
+      %(#<ResoTransport::Client endpoint="#{endpoint}", md_file="#{md_file}", ds_file="#{ds_file}">)
     end
 
     def inspect
@@ -42,7 +58,7 @@ module ResoTransport
     def ensure_valid_auth_strategy(options)
       case options
       when Hash
-        if options.has_key?(:endpoint)
+        if options.key?(:endpoint)
           Authentication::FetchTokenAuth.new(options)
         else
           Authentication::StaticTokenAuth.new(options)
@@ -51,6 +67,5 @@ module ResoTransport
         raise ArgumentError, "#{options.inspect} invalid:  cannot determine strategy"
       end
     end
-
   end
 end

data/lib/reso_transport/datasystem.rb

@@ -0,0 +1,22 @@
+require_relative 'base_metadata'
+
+module ResoTransport
+  class Datasystem < BaseMetadata
+    def initialize(client)
+      super client
+      @prefix = 'ds'
+      @classname = self.class.name
+    end
+
+    def localizations_for(resource_name)
+      localizations = parser.resources.dig(resource_name, 'Localizations') || []
+      localizations.map { |l| [l['Name'], l] }.to_h
+    end
+
+    def response
+      @response ||= client.connection.get('DataSystem') do |req|
+        req.headers['Accept'] = 'application/json'
+      end
+    end
+  end
+end

data/lib/reso_transport/datasystem_parser.rb

@@ -0,0 +1,26 @@
+module ResoTransport
+  class DatasystemParser
+    def parse(doc)
+      begin
+        data = doc.is_a?(File) ? doc.read : doc
+        @json = JSON.parse data
+      rescue JSON::ParserError => e
+        @json = {}
+        puts e.message
+      end
+      self
+    end
+
+    # value ->
+    #   Resources ->
+    #     Name ->
+    #     ResourcePath ->
+    #     Localizations ->
+    #       Name ->
+    #       ResourcePath ->
+
+    def resources
+      @resources ||= @json['value'].map { |v| v['Resources'] }.flatten.compact.map { |r| [r['Name'], r] }.to_h
+    end
+  end
+end

data/lib/reso_transport/entity_set.rb

@@ -1,11 +1,9 @@
 module ResoTransport
   EntitySet = Struct.new(:name, :schema, :entity_type) do
-
     def self.from_stream(args)
-      schema, entity_type = ResoTransport.split_schema_and_class_name(args["EntityType"])
+      schema, entity_type = ResoTransport.split_schema_and_class_name(args['EntityType'])
 
-      new(args["Name"], schema, entity_type)
+      new(args['Name'], schema, entity_type)
     end
-
   end
 end

data/lib/reso_transport/entity_type.rb

@@ -1,30 +1,29 @@
 module ResoTransport
   EntityType = Struct.new(:name, :base_type, :primary_key, :schema) do
-
     def self.from_stream(args)
-      new(args["Name"], args["BaseType"])
+      new(args['Name'], args['BaseType'])
     end
 
     def parse(record)
-      record.each_pair do |k,v|
+      record.each_pair do |k, v|
         next if v.nil?
-        if property = (property_map[k] || navigation_property_map[k])
-          record[k] = property.parse(v)
-        end
+
+        property = property_map[k] || navigation_property_map[k]
+        record[k] = property.parse(v) if property
       end
     end
 
     def parse_value(record)
-      record.each_pair do |k,v|
+      record.each_pair do |k, v|
         next if v.nil?
-        if property = (property_map[k] || navigation_property_map[k])
-          record[k] = property.parse(v)
-        end
+
+        property = property_map[k] || navigation_property_map[k]
+        record[k] = property.parse(v) if property
       end
     end
 
     def property_map
-      @property_map ||= properties.inject({}) {|hsh, p| hsh[p.name] = p; hsh }
+      @property_map ||= properties.each_with_object({}) { |p, hsh| hsh[p.name] = p; }
     end
 
     def properties
@@ -32,7 +31,7 @@ module ResoTransport
     end
 
     def navigation_property_map
-      @navigation_property_map ||= navigation_properties.inject({}) {|hsh, p| hsh[p.name] = p; hsh }
+      @navigation_property_map ||= navigation_properties.each_with_object({}) { |p, hsh| hsh[p.name] = p; }
     end
 
     def navigation_properties
@@ -42,6 +41,5 @@ module ResoTransport
     def enumerations
       @enumerations ||= []
     end
-
   end
 end

data/lib/reso_transport/metadata.rb

@@ -1,10 +1,12 @@
-module ResoTransport
-  Metadata = Struct.new(:client) do 
+require_relative 'base_metadata'
 
-    MIME_TYPES = {
-      xml: "application/xml",
-      json: "application/json"
-    }
+module ResoTransport
+  class Metadata < BaseMetadata
+    def initialize(client)
+      super client
+      @prefix = 'md'
+      @classname = self.class.name
+    end
 
     def entity_sets
       parser.entity_sets
@@ -14,36 +16,14 @@ module ResoTransport
       parser.schemas
     end
 
-    def parser
-      @parser ||= MetadataParser.new.parse(get_data)
+    def datasystem?
+      parser.datasystem?
     end
 
-    def get_data
-      if client.md_file 
-        if File.exist?(client.md_file) && File.size(client.md_file) > 0
-          File.new(client.md_file)
-        else
-          raw_md = raw
-          File.open(client.md_file, "w") {|f| f.write(raw.force_encoding("UTF-8")) } unless raw_md.length == 0
-          File.new(client.md_file)
-        end
-      else
-        raw
-      end
-    end
-
-    def raw
-      resp = client.connection.get("$metadata") do |req|
+    def response
+      @response ||= client.connection.get('$metadata') do |req|
         req.headers['Accept'] = MIME_TYPES[client.vendor.fetch(:metadata_format, :xml).to_sym]
       end
-
-      if resp.success?
-        resp.body
-      else
-        puts resp.body
-        raise "Error getting metadata!"
-      end
     end
-
   end
 end

data/lib/reso_transport/metadata_cache.rb

@@ -0,0 +1,20 @@
+module ResoTransport
+  class MetadataCache
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def read
+      return nil if !File.exist?(name) || File.size(name).zero?
+
+      File.new(name)
+    end
+
+    def write(raw)
+      File.open(name, 'w') { |f| f.write(raw.force_encoding('UTF-8')) } if raw.length.positive?
+      File.new(name)
+    end
+  end
+end

data/lib/reso_transport/metadata_parser.rb

@@ -14,12 +14,14 @@ module ResoTransport
       @current_complex_type = nil
       @current_enum_type = nil
       @current_member = nil
+
+      @datasystem = nil
     end
 
     def parse(doc)
       REXML::Document.parse_stream(doc, self)
       finalize
-      return self
+      self
     end
 
     def finalize
@@ -54,55 +56,62 @@ module ResoTransport
 
     def tag_start(name, args)
       case name
-      when "Schema"
+      when 'Schema'
         @schemas << ResoTransport::Schema.from_stream(args)
-      when "EntitySet"
+      when 'EntitySet'
         @entity_sets << ResoTransport::EntitySet.from_stream(args)
-      when "EntityType"
+      when 'EntityType'
         @current_entity_type = ResoTransport::EntityType.from_stream(args)
-      when "ComplexType"
+      when 'ComplexType'
         @current_complex_type = ResoTransport::EntityType.from_stream(args)
-      when "PropertyRef"
+      when 'PropertyRef'
         @current_entity_type.primary_key = args['Name']
-      when "Property"
-        @current_entity_type.properties << ResoTransport::Property.from_stream(args.merge(schema: @schemas.last)) if @current_entity_type
-        @current_complex_type.properties << ResoTransport::Property.from_stream(args.merge(schema: @schemas.last)) if @current_complex_type
-      when "NavigationProperty"
+      when 'Property'
+        if @current_entity_type
+          @current_entity_type.properties << ResoTransport::Property.from_stream(args.merge(schema: @schemas.last))
+        end
+        if @current_complex_type
+          @current_complex_type.properties << ResoTransport::Property.from_stream(args.merge(schema: @schemas.last))
+        end
+      when 'NavigationProperty'
         @current_entity_type.navigation_properties << ResoTransport::Property.from_stream(args)
-      when "EnumType"
+      when 'EnumType'
         @current_enum_type = ResoTransport::Enum.from_stream(args.merge(schema: @schemas.last))
-      when "Member"
+      when 'Member'
         @current_member = ResoTransport::Member.from_stream(args)
-      when "Annotation"
+      when 'Annotation'
         if @current_enum_type && @current_member
           @current_member.annotation = args['String']
-        else
-          if @current_entity_type || @current_complex_type
-            #raise args.inspect
-          end
+        elsif @current_entity_type || @current_complex_type
+          # raise args.inspect
         end
       end
-    rescue => e
+    rescue StandardError => e
       puts e.inspect
       puts "Error processing Tag: #{[name, args].inspect}"
     end
 
     def tag_end(name)
       case name
-      when "EntityType"
+      when 'EntityType'
         @current_entity_type.schema = @schemas.last.namespace
         @schemas.last.entity_types << @current_entity_type
-      when "ComplexType"
+      when 'ComplexType'
         @current_complex_type.schema = @schemas.last.namespace
         @schemas.last.complex_types << @current_complex_type
-      when "EnumType"
+      when 'EnumType'
         @enumerations << @current_enum_type
         @current_enum_type = nil
-      when "Member"
+      when 'Member'
         @current_enum_type.members << @current_member
         @current_member = nil
       end
     end
 
+    def datasystem?
+      return @datasystem unless @datasystem.nil?
+
+      @datasystem = @schemas.any? { |s| s.entity_types.any? { |t| t.name == 'DataSystem' } }
+    end
   end
 end

data/lib/reso_transport/query.rb

@@ -1,23 +1,22 @@
 module ResoTransport
   Query = Struct.new(:resource) do
-
-    def all(*contexts, &block)
+    def all(*_contexts, &block)
       new_query_context('and')
       instance_eval(&block)
       clear_query_context
-      return self
+      self
     end
 
     def any(&block)
       new_query_context('or')
       instance_eval(&block)
       clear_query_context
-      return self
+      self
     end
 
-    [:eq, :ne, :gt, :ge, :lt, :le].each do |op|
+    %i[eq ne gt ge lt le].each do |op|
       define_method(op) do |conditions|
-        conditions.each_pair do |k,v|
+        conditions.each_pair do |k, v|
           current_query_context << "#{k} #{op} #{encode_value(k, v)}"
         end
         return self
@@ -26,36 +25,36 @@ module ResoTransport
 
     def limit(size)
       options[:top] = size
-      return self
+      self
     end
 
     def offset(size)
       options[:skip] = size
-      return self
+      self
     end
 
-    def order(field, dir=nil)
-      options[:orderby] = [field, dir].join(" ").strip
-      return self
+    def order(field, dir = nil)
+      options[:orderby] = [field, dir].join(' ').strip
+      self
     end
 
     def include_count
       options[:count] = true
-      return self
+      self
     end
 
     def select(*fields)
-      os = options.fetch(:select, "").split(",")
-      options[:select] = (os + Array(fields)).uniq.join(",")
+      os = options.fetch(:select, '').split(',')
+      options[:select] = (os + Array(fields)).uniq.join(',')
 
-      return self
+      self
     end
 
     def expand(*names)
-      ex = options.fetch(:expand, "").split(",")
-      options[:expand] = (ex + Array(names)).uniq.join(",")
+      ex = options.fetch(:expand, '').split(',')
+      options[:expand] = (ex + Array(names)).uniq.join(',')
 
-      return self
+      self
     end
 
     def count
@@ -63,7 +62,7 @@ module ResoTransport
       limit(1).include_count
       resp = resource.get(compile_params)
       parsed_body = JSON.parse(resp.body)
-      parsed_body.fetch("@odata.count", 0)
+      parsed_body.fetch('@odata.count', 0)
     end
 
     def results
@@ -73,20 +72,27 @@ module ResoTransport
         resp[:results]
       else
         puts resp[:meta]
-        raise "Request Failed"
+        raise 'Request Failed'
       end
     end
 
     def execute
       resp = resource.get(compile_params)
-      parsed_body = JSON.parse(resp.body)
-      results = Array(parsed_body.delete("value"))
-
-      {
-        success: resp.success? && !parsed_body.has_key?("error"),
-        meta: parsed_body,
-        results: resource.parse(results)
-      }
+      if resp.success?
+        parsed_body = JSON.parse(resp.body)
+        results = Array(parsed_body.delete('value'))
+
+        {
+          success: resp.success? && !parsed_body.key?('error'),
+          meta: parsed_body,
+          results: resource.parse(results)
+        }
+      else
+        {
+          success: false,
+          meta: resp.body
+        }
+      end
     end
 
     def new_query_context(context)
@@ -110,7 +116,7 @@ module ResoTransport
     end
 
     def sub_queries
-      @sub_queries ||= Hash.new {|h,k| h[k] = { context: 'and', criteria: [] } }
+      @sub_queries ||= Hash.new { |h, k| h[k] = { context: 'and', criteria: [] } }
     end
 
     def compile_filters
@@ -120,36 +126,32 @@ module ResoTransport
 
       filter_chunks = []
 
-      if global && global[:criteria]&.any?
-        filter_chunks << global[:criteria].join(" #{global[:context]} ")  
-      end
+      filter_chunks << global[:criteria].join(" #{global[:context]} ") if global && global[:criteria]&.any?
 
       filter_chunks << filter_groups.map do |g|
         "(#{g[:criteria].join(" #{g[:context]} ")})"
-      end.join(" and ")
+      end.join(' and ')
 
-      filter_chunks.reject {|c| c == ""}.join(" and ")
+      filter_chunks.reject { |c| c == '' }.join(' and ')
     end
 
     def compile_params
       params = {}
 
-      options.each_pair do |k,v|
+      options.each_pair do |k, v|
         params["$#{k}"] = v
       end
 
-      if !sub_queries.empty?
-        params["$filter"] = compile_filters
-      end
+      params['$filter'] = compile_filters unless sub_queries.empty?
 
       params
     end
 
-    def encode_value(key, v)
+    def encode_value(key, val)
       field = resource.property(key.to_s)
       raise "Couldn't find property #{key} for #{resource.name}" if field.nil?
-      field.encode(v)
-    end
 
+      field.encode(val)
+    end
   end
 end