reso_transport 1.5.2 → 1.5.8

data/lib/reso_transport/authentication/middleware.rb

@@ -18,10 +18,11 @@ module ResoTransport
           authorize_request(request_env)
 
           @app.call(request_env).on_complete do |response_env|
-            raise_if_unauthorized(response_env)
+            raise_if_unauthorized(request_env, response_env)
           end
         rescue ResoTransport::AccessDenied
-          raise if retries == 0
+          raise if retries.zero?
+
           @auth.reset
           retries -= 1
           retry
@@ -38,8 +39,8 @@ module ResoTransport
         )
       end
 
-      def raise_if_unauthorized(response_env)
-        raise ResoTransport::AccessDenied if response_env[:status] == 401
+      def raise_if_unauthorized(request_env, response_env)
+        raise ResoTransport::AccessDenied.new(request_env.to_h, response_env) if response_env[:status] == 401
       end
     end
   end

data/lib/reso_transport/base_metadata.rb

@@ -0,0 +1,64 @@
+module ResoTransport
+  class BaseMetadata
+    MIME_TYPES = {
+      xml: 'application/xml',
+      json: 'application/json'
+    }.freeze
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+      @prefix = nil
+      @classname = nil
+    end
+
+    def prefix
+      raise 'prefix not set' unless @prefix
+
+      @prefix
+    end
+
+    def classname
+      raise 'classname not set' unless @classname
+
+      @classname
+    end
+
+    def parser
+      @parser ||= Object::const_get("#{classname}Parser").new.parse(data)
+    end
+
+    def data
+      if cache_file
+        cache.read || cache.write(raw)
+      else
+        raw
+      end
+    end
+
+    def cache
+      @cache ||= client.send("#{prefix}_cache").new(cache_file)
+    end
+
+    def cache_file
+      @cache_file ||= client.send "#{prefix}_file"
+    end
+
+    def raw
+      return response.body if response.success?
+
+      raise RequestError.new(request, response, classname)
+    end
+
+    def response
+      raise 'Must implement response method'
+    end
+
+    def request
+      return @request.to_h if @request.respond_to? :to_h
+
+      {}
+    end
+  end
+end

data/lib/reso_transport/client.rb

@@ -1,34 +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, @logger || ResoTransport.configuration.logger
-        #yield faraday if block_given? 
         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
@@ -40,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)
@@ -49,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,25 @@
+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'
+        @request = req
+      end
+    rescue Faraday::ConnectionFailed
+      raise NoResponse.new(request, nil, 'DataSystem')
+    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/errors.rb

@@ -0,0 +1,69 @@
+module ResoTransport
+  class ResourceError < StandardError
+    attr_reader :resource
+
+    def initialize(resource)
+      @resource = resource
+      super message
+    end
+
+    def resource_name
+      return resource.name if resource.respond_to?(:name)
+
+      resource || 'unknown'
+    end
+
+    def message
+      "Request error for #{resource_name}"
+    end
+  end
+
+  class EncodeError < ResourceError
+    def initialize(resource, property)
+      @property = property
+      super resource
+    end
+
+    def message
+      "Property #{@property} not found for #{resource_name}"
+    end
+  end
+
+  class LocalizationRequired < ResourceError
+    def message
+      "Localization required for #{resource_name}"
+    end
+  end
+
+  class RequestError < ResourceError
+    attr_reader :request, :response
+
+    def initialize(request, response, resource = nil)
+      @response = response.respond_to?(:to_hash) ? response.to_hash : response
+      @request = request
+      super resource
+    end
+
+    def message
+      "Received #{response[:status]} for #{resource_name}"
+    end
+  end
+
+  class NoResponse < RequestError
+    def message
+      "No response for #{resource_name}"
+    end
+  end
+
+  class ResponseError < RequestError
+    def message
+      "Request succeeded for #{resource_name} with response errors"
+    end
+  end
+
+  class AccessDenied < RequestError
+    def message
+      "Access denied: #{response.reason_phrase}"
+    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,17 @@ 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]
+        @request = req
       end
-
-      if resp.success?
-        resp.body
-      else
-        puts resp.body
-        raise "Error getting metadata!"
-      end
+    rescue Faraday::ConnectionFailed
+      raise NoResponse.new(request, nil, '$metadata')
     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