reso_transport 1.0.0

data/lib/reso_transport/entity_type.rb

@@ -0,0 +1,47 @@
+module ResoTransport
+  EntityType = Struct.new(:name, :base_type, :primary_key, :schema) do
+
+    def self.from_stream(args)
+      new(args["Name"], args["BaseType"])
+    end
+
+    def parse(record)
+      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
+      end
+    end
+
+    def parse_value(record)
+      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
+      end
+    end
+
+    def property_map
+      @property_map ||= properties.inject({}) {|hsh, p| hsh[p.name] = p; hsh }
+    end
+
+    def properties
+      @properties ||= []
+    end
+
+    def navigation_property_map
+      @navigation_property_map ||= navigation_properties.inject({}) {|hsh, p| hsh[p.name] = p; hsh }
+    end
+
+    def navigation_properties
+      @navigation_properties ||= []
+    end
+
+    def enumerations
+      @enumerations ||= []
+    end
+
+  end
+end

data/lib/reso_transport/enum.rb

@@ -0,0 +1,37 @@
+module ResoTransport
+  Member = Struct.new(:name, :value, :annotation) do
+    def self.from_stream(args)
+      new(args["Name"], args["Value"])
+    end
+  end
+
+  Enum = Struct.new(:name, :type, :is_flags) do
+    def self.from_stream(args)
+      new("#{args[:schema].namespace}.#{args["Name"]}", args["UnderlyingType"], args["IsFlags"])
+    end
+    
+    def members
+      @members ||= []
+    end
+
+    def parse_value(value)
+      mapping.fetch(value, value)
+    end
+
+    def encode_value(value)
+      "'#{mapping.invert.fetch(value, value)}'"
+    end
+
+    def mapping
+      @mapping ||= generate_member_map || {}
+    end
+
+    def generate_member_map
+      members.map {|mem|
+        { mem.name => mem.annotation || mem.name }  
+      }.reduce(:merge!)
+    end
+
+  end
+end
+

data/lib/reso_transport/metadata.rb

@@ -0,0 +1,48 @@
+module ResoTransport
+  Metadata = Struct.new(:client) do 
+
+    MIME_TYPES = {
+      xml: "application/xml",
+      json: "application/json"
+    }
+
+    def entity_sets
+      parser.entity_sets
+    end
+
+    def schemas
+      parser.schemas
+    end
+
+    def parser
+      @parser ||= MetadataParser.new.parse(get_data)
+    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
+          File.open(client.md_file, "w") {|f| f.write(raw) }
+          File.new(client.md_file)
+        end
+      else
+        raw
+      end
+    end
+
+    def raw
+      resp = 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_parser.rb

@@ -0,0 +1,104 @@
+module ResoTransport
+  class MetadataParser
+    include REXML::StreamListener
+
+    attr_reader :schemas, :entity_sets, :enumerations
+
+    def initialize
+      @schemas = []
+      @entity_sets = []
+      @entity_types = []
+      @enumerations = []
+
+      @current_entity_type = nil
+      @current_complex_type = nil
+      @current_enum_type = nil
+      @current_member = nil
+    end
+
+    def parse(doc)
+      REXML::Document.parse_stream(doc, self)
+      finalize
+      return self
+    end
+
+    def finalize
+      schemas.each do |s|
+        s.entity_types.each do |et|
+          et.properties.each do |p|
+            p.finalize_type(self)
+          end
+
+          et.navigation_properties.each do |p|
+            p.finalize_type(self)
+          end
+        end
+
+        s.complex_types.each do |et|
+          et.properties.each do |p|
+            p.finalize_type(self)
+          end
+        end
+      end
+    end
+
+    # Schema ->
+    #   EnumType ->
+    #     Members ->
+    #       Annotation
+    #   EntityType ->
+    #     Key
+    #     Properties ->
+    #       enumerations
+    #
+
+    def tag_start(name, args)
+      case name
+      when "Schema"
+        @schemas << ResoTransport::Schema.from_stream(args)
+      when "EntitySet"
+        @entity_sets << ResoTransport::EntitySet.from_stream(args)
+      when "EntityType"
+        @current_entity_type = ResoTransport::EntityType.from_stream(args)
+      when "ComplexType"
+        @current_complex_type = ResoTransport::EntityType.from_stream(args)
+      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"
+        @current_entity_type.navigation_properties << ResoTransport::Property.from_stream(args)
+      when "EnumType"
+        @current_enum_type = ResoTransport::Enum.from_stream(args.merge(schema: @schemas.last))
+      when "Member"
+        @current_member = ResoTransport::Member.from_stream(args)
+      when "Annotation"
+        if @current_enum_type && @current_member
+          @current_member.annotation = args['String']
+        end
+      end
+    rescue => e
+      puts e.inspect
+      puts "Error processing Tag: #{[name, args].inspect}"
+    end
+
+    def tag_end(name)
+      case name
+      when "EntityType"
+        @current_entity_type.schema = @schemas.last.namespace
+        @schemas.last.entity_types << @current_entity_type
+      when "ComplexType"
+        @current_complex_type.schema = @schemas.last.namespace
+        @schemas.last.complex_types << @current_complex_type
+      when "EnumType"
+        @enumerations << @current_enum_type
+        @current_enum_type = nil
+      when "Member"
+        @current_enum_type.members << @current_member
+        @current_member = nil
+      end
+    end
+
+  end
+end

data/lib/reso_transport/property.rb

@@ -0,0 +1,101 @@
+module ResoTransport
+  Property = Struct.new(:name, :data_type, :attrs, :multi, :enum, :complex_type, :entity_type) do
+
+    def self.from_stream(args)
+      new(args["Name"], args["Type"], args)
+    end
+
+    def parse(value)
+      case value
+      when Array
+        value.map {|v| parser_object.parse_value(v) }
+      else
+        if multi
+          value.split(',').map(&:strip).map {|v| parser_object.parse_value(v) }
+        else
+          parser_object.parse_value(value)
+        end
+      end
+    end
+
+    def parse_value(value)
+      case data_type
+      when "Edm.DateTimeOffset"
+        DateTime.parse(value)
+      when "Edm.Date"
+        Date.parse(value)
+      else
+        value
+      end
+    end
+
+    def encode(value)
+      case value
+      when Array
+        value.map {|v| parser_object.encode_value(v) }
+      else
+        parser_object.encode_value(value)
+      end
+    end
+
+    def encode_value(value)
+      case data_type
+      when "Edm.String"
+        "'#{value}'"
+      when "Edm.DateTimeOffset"
+        if value.respond_to?(:to_datetime)
+          value.to_datetime.strftime(ODATA_TIME_FORMAT)
+        else
+          DateTime.parse(value).strftime(ODATA_TIME_FORMAT)
+        end
+      else
+        value
+      end
+    end
+
+    def parser_object
+      enum || complex_type || entity_type || self
+    end
+
+    def finalize_type(parser)
+      type_name, is_collection = case self.data_type
+      when /^Collection\((.*)\)$/ 
+        [$1, true]
+      when /^Edm\.(.*)$/
+        [$1, false]
+      else
+        [self.data_type, false]
+      end
+
+      if enum = parser.enumerations.detect {|e| e.name == type_name }
+        self.multi = is_collection || enum.is_flags
+        self.enum = enum
+      end
+
+      schema_name, collection_name = ResoTransport.split_schema_and_class_name(type_name)
+      if schema = parser.schemas.detect {|e| e.namespace == schema_name }
+        if complex_type = schema.complex_types.detect {|c| c.name == collection_name }
+          self.multi = is_collection
+          self.complex_type = complex_type
+        end
+
+        if entity_type = schema.entity_types.detect {|et| et.name == collection_name }
+          self.multi = is_collection
+          self.entity_type = entity_type
+        end
+      end
+
+    end
+
+    def method_missing(name, *args, &block)
+      self.attrs[name] || self.attrs[camelize(name)] || super
+    end
+
+    private
+
+    def camelize(name)
+      name.to_s.split("_").map(&:capitalize).join
+    end
+
+  end
+end

data/lib/reso_transport/query.rb

@@ -0,0 +1,147 @@
+module ResoTransport
+  Query = Struct.new(:resource) do
+
+    def all(&block)
+      new_query_context('and')
+      instance_eval(&block)
+      clear_query_context
+      return self
+    end
+
+    def any(&block)
+      new_query_context('or')
+      instance_eval(&block)
+      clear_query_context
+      return self
+    end
+
+    [:eq, :ne, :gt, :ge, :lt, :le].each do |op|
+      define_method(op) do |conditions|
+        conditions.each_pair do |k,v|
+          current_query_context << "#{k} #{op} #{encode_value(k, v)}"
+        end
+        return self
+      end
+    end
+
+    def limit(size)
+      options[:top] = size
+      return self
+    end
+
+    def offset(size)
+      options[:skip] = size
+      return self
+    end
+
+    def order(field, dir=nil)
+      options[:orderby] = [field, dir].join(" ").strip
+      return self
+    end
+
+    def include_count
+      options[:count] = true
+      return self
+    end
+
+    def select(*fields)
+      os = options.fetch(:select, "").split(",")
+      options[:select] = (os + Array(fields)).uniq.join(",")
+
+      return self
+    end
+
+    def expand(*names)
+      ex = options.fetch(:expand, "").split(",")
+      options[:expand] = (ex + Array(names)).uniq.join(",")
+
+      return self
+    end
+
+    def results
+      resp = execute
+
+      if resp[:success]
+        resp[:results]
+      else
+        puts resp[:meta]
+        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)
+      }
+    end
+
+    def new_query_context(context)
+      @last_query_context ||= 0
+      @current_query_context = @last_query_context + 1
+      sub_queries[@current_query_context][:context] = context
+    end
+
+    def clear_query_context
+      @last_query_context = @current_query_context
+      @current_query_context = nil
+    end
+
+    def current_query_context
+      @current_query_context ||= nil
+      sub_queries[@current_query_context || :global][:criteria]
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def sub_queries
+      @sub_queries ||= Hash.new {|h,k| h[k] = { context: 'and', criteria: [] } }
+    end
+
+    def compile_filters
+      groups = sub_queries.dup
+      global = groups.delete(:global)
+      filter_groups = groups.values
+
+      filter_string = ""
+
+      if global && global[:criteria]&.any?
+        filter_string << global[:criteria].join(" #{global[:context]} ")  
+      end
+
+      filter_string << filter_groups.map do |g|
+        "(#{g[:criteria].join(" #{g[:context]} ")})"
+      end.join(" and ")
+
+      filter_string
+    end
+
+    def compile_params
+      params = {}
+
+      options.each_pair do |k,v|
+        params["$#{k}"] = v
+      end
+
+      if !sub_queries.empty?
+        params["$filter"] = compile_filters
+      end
+
+      params
+    end
+
+    def encode_value(key, v)
+      field = resource.property(key.to_s)
+      raise "Couldn't find property #{key} for #{resource.name}" if field.nil?
+      field.encode(v)
+    end
+
+  end
+end

data/lib/reso_transport/resource.rb

@@ -0,0 +1,55 @@
+module ResoTransport
+  Resource = Struct.new(:client, :entity_set) do
+
+    def query
+      Query.new(self)
+    end
+
+    def name
+      entity_set.name
+    end
+
+    def property(name)
+      properties.detect {|p| p.name == name }
+    end
+
+    def properties
+      entity_type.properties
+    end
+
+    def expandable
+      entity_type.navigation_properties
+    end
+    
+    def entity_type
+      @entity_type ||= schema.entity_types.detect {|et| et.name == entity_set.entity_type }
+    end
+
+    def schema
+      @schema ||= md.schemas.detect {|s| s.namespace == entity_set.schema }
+    end
+
+    def md
+      client.metadata
+    end
+
+    def parse(results)
+      results.map {|r| entity_type.parse(r) }
+    end
+
+    def get(params)
+      client.connection.get(name, params) do |req|
+        req.headers['Accept'] = 'application/json'
+      end
+    end
+
+    def to_s
+      %(#<ResoTransport::Resource entity_set="#{name}", schema="#{schema&.namespace}">)
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+end

data/lib/reso_transport/schema.rb

@@ -0,0 +1,21 @@
+module ResoTransport
+  Schema = Struct.new(:namespace) do
+
+    def self.from_stream(args)
+      new(args["Namespace"])
+    end
+
+    def entity_types
+      @entity_types ||= []
+    end
+
+    def complex_types
+      @complex_types ||= []
+    end
+
+    def enumerations
+      @enumerations ||= []
+    end
+
+  end
+end

data/lib/reso_transport/version.rb

@@ -0,0 +1,3 @@
+module ResoTransport
+  VERSION = "1.0.0"
+end

data/lib/reso_transport.rb

@@ -0,0 +1,57 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'logger'
+require 'faraday'
+require 'json'
+require 'time'
+
+require "reso_transport/version"
+require "reso_transport/configuration"
+require "reso_transport/authentication"
+require "reso_transport/client"
+require "reso_transport/resource"
+require "reso_transport/metadata"
+require "reso_transport/metadata_parser"
+require "reso_transport/schema"
+require "reso_transport/entity_set"
+require "reso_transport/entity_type"
+require "reso_transport/enum"
+require "reso_transport/property"
+require "reso_transport/query"
+
+
+
+module Faraday
+  module Utils
+
+    def escape(str)
+      str.to_s.gsub(ESCAPE_RE) do |match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      end.gsub(" ","%20")
+
+    end
+  end
+end
+
+module ResoTransport
+  class Error < StandardError; end
+  class AccessDenied < StandardError; end
+  ODATA_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S%Z"
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.split_schema_and_class_name(s)
+    s.partition(/(\w+)$/).first(2).map {|s| s.sub(/\.$/, '') }
+  end
+
+end

data/reso_transport.gemspec

@@ -0,0 +1,35 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "reso_transport/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "reso_transport"
+  spec.version       = ResoTransport::VERSION
+  spec.authors       = ["Jon Druse"]
+  spec.email         = ["jon@wrstudios.com"]
+
+  spec.summary       = "A utility for consuming RESO Web API connections"
+  spec.description   = "Supports Trestle, Spark, Bridge Interactive, MLS Grid"
+  spec.homepage      = "http://github.com/wrstudios/reso_transport"
+  spec.license       = "MIT"
+
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 0.17.0"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-rg", "~> 5.0"
+  spec.add_development_dependency "vcr", "~> 5.0"
+  spec.add_development_dependency "byebug"
+end

data/sample_secrets.yml

@@ -0,0 +1,26 @@
+:bridge:
+  :md_file: PATH_TO_METADATA_FILE
+  :vendor:
+    :name: bridge_interactive
+  :endpoint: ENDPOINT_URL_HERE
+  :authentication:
+    :access_token: ACCESS_TOKEN_HERE
+
+:trestle:
+  :md_file: PATH_TO_METADATA_FILE
+  :vendor:
+    :name: trestle
+  :endpoint: ENDPOINT_URL_HERE
+  :authentication:
+    :endpoint: AUTH_ENDPOINT_HERE
+    :client_id: CLIENT_ID_HERE
+    :client_secret: CLIENT_SECRET_HERE
+
+:spark:
+  :md_file: PATH_TO_METADATA_FILE
+  :vendor: 
+    :name: fbs
+  :endpoint: ENDPOINT_URL_HERE
+  :authentication:
+    :access_token: ACCESS_TOKEN_HERE
+