reach-ruby 1.0.0

data/lib/reach-ruby/framework/rest/domain.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    class Domain
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+        @host = nil
+        @base_url = nil
+        @port = nil
+      end
+
+      def absolute_url(uri)
+        "#{@base_url.chomp('/')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = uri.match(/^http/) ? uri : absolute_url(uri)
+        
+        baseUrl = URI(@base_url)
+        baseHost = "#{baseUrl.scheme}//#{baseUrl.host}"
+
+        @client.request(
+          baseHost,
+          @port,
+          method,
+          url,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+    end
+  end
+end

data/lib/reach-ruby/framework/rest/error.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    class ReachError < StandardError
+      # @deprecated all errors that have a body are now 'Reach::RestError's
+      def body
+        warn "'Reach::REST::ReachError#body' has been deprecated. No 'ReachError' objects are raised with a body."
+        nil
+      end
+    end
+
+    class RestError < ReachError
+      attr_reader :message, :response, :code, :status_code, :details, :more_info, :error_message
+
+      def initialize(message, response)
+        @status_code = response.status_code
+        @code = response.body.fetch('errorCode', @status_code)
+        @details = response.body.fetch('errorDetails', nil)
+        @error_message = response.body.fetch('errorMessage', nil)
+        @more_info = response.body.fetch('more_info', nil)
+        @message = format_message(message)
+        @response = response
+      end
+
+      # @deprecated use #response instead
+      def body
+        warn 'This error used to be a "Reach::REST::ReachError" but is now a "Reach::REST::RestError". ' \
+             'Please use #response instead of #body.'
+        @response
+      end
+
+      def to_s
+        message
+      end
+
+      private
+
+      def format_message(initial_message)
+        message = "[HTTP #{status_code}] #{code} : #{initial_message}"
+        message += "\n#{error_message}" if error_message
+        message += "\n#{details}" if details
+        message += "\n#{more_info}" if more_info
+        message + "\n\n"
+      end
+    end
+
+    class ObsoleteError < StandardError
+    end
+  end
+end

data/lib/reach-ruby/framework/rest/helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    def url_join(left, right)
+      left = left.sub(/\/+$/, '').sub(/^\/+/, '')
+      right = right.sub(/\/+$/, '').sub(/^\/+/, '')
+      "#{left}/#{right}"
+    end
+  end
+end

data/lib/reach-ruby/framework/rest/page.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    # Page Base Class
+    class Page
+      include Enumerable
+
+      META_KEYS = [
+        'page',
+        'pageSize',
+        'totalPages',
+        'outOfPageRange'
+      ].freeze
+
+      def initialize(url, version, response)
+        payload = process_response(response)
+
+        @url = url
+        @version = version
+        @payload = payload
+        @solution = {}
+        @records = load_page(payload)
+      end
+
+      def process_response(response)
+        if response.status_code != 200
+          raise Reach::REST::RestError.new('Unable to fetch page', response)
+        end
+
+        response.body
+      end
+
+      def load_page(payload)
+        if payload['meta'] && payload['meta']['key']
+          return payload[payload['meta']['key']]
+        else
+          keys = payload.keys
+          key = keys - META_KEYS
+          if key.size == 1
+            return payload[key.first]
+          end
+          if key.size == 2
+            key1 = key[0]
+            key2 = key[1]
+            if key1.length > key2.length
+              aux = key2
+              key2 = key1
+              key1 = aux
+            end
+            val = "total" + key1[0,1].upcase + key1[1..-1]
+            if val == key2
+              return payload[key1]
+            end
+          end
+        end
+
+        raise Reach::REST::ReachError, 'Page Records can not be deserialized'
+      end
+
+      def previous_page_url
+        page = 0
+        if @payload.key?('page')
+          page = @payload['page']
+        end
+        pageSize = 1
+        if @payload.key?('pageSize')
+          pageSize = @payload['pageSize']
+        end
+        if page > 0
+          query = "pageSize=#{pageSize}&page=#{page-1}"
+          uri = URI.parse(@url)
+          if (!(uri.query == nil || uri.query.length == 0))
+            query = uri.query + "&" + query
+          end
+          uri.query = query
+          return uri.to_s
+        end
+
+        nil
+      end
+
+      def next_page_url
+        page = 0
+        if @payload.key?('page')
+          page = @payload['page']
+        end
+        pageSize = 1
+        if @payload.key?('pageSize')
+          pageSize = @payload['pageSize']
+        end
+        outOfPageRange = true
+        if @payload.key?('outOfPageRange')
+          outOfPageRange = @payload['outOfPageRange']
+        end
+        totalPages = 1
+        if @payload.key?('totalPages')
+          totalPages = @payload['totalPages']
+        end
+        if !(outOfPageRange || (page + 1 >= totalPages))
+          query = "pageSize=#{pageSize}&page=#{page+1}"
+          uri = URI.parse(@url)
+          if (!(uri.query == nil || uri.query.length == 0))
+            query = uri.query + "&" + query
+          end
+          uri.query = query
+          return uri.to_s
+        end
+
+        nil
+      end
+
+      def get_instance(payload)
+        raise Reach::REST::ReachError, 'Page.get_instance() must be implemented in the derived class'
+      end
+
+      def previous_page
+        return nil unless previous_page_url
+
+        response = @version.domain.request('GET', previous_page_url)
+
+        self.class.new(@url, @version, response, @solution)
+      end
+
+      def next_page
+        return nil unless next_page_url
+
+        response = @version.domain.request('GET', next_page_url)
+
+        self.class.new(@url, @version, response, @solution)
+      end
+
+      def each
+        @records.each do |record|
+          yield get_instance(record)
+        end
+      end
+
+      def to_s
+        '#<Page>'
+      end
+    end
+  end
+end

data/lib/reach-ruby/framework/rest/resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    class ListResource
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceContext
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceResource
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/reach-ruby/framework/rest/version.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Reach
+  module REST
+    class Version
+      attr_accessor :domain
+
+      class RecordStream
+        include Enumerable
+
+        def initialize(page, limit: nil, page_limit: nil)
+          @page = page
+          @limit = limit
+          @page_limit = page_limit
+        end
+
+        def each
+          current_record = 0
+          current_page = 1
+
+          while @page
+            @page.each do |record|
+              yield record
+              current_record += 1
+              return nil if @limit && @limit <= current_record
+            end
+
+            return nil if @page_limit && @page_limit <= current_page
+
+            @page = @page.next_page
+            current_page += 1
+          end
+        end
+      end
+
+      def initialize(domain)
+        @domain = domain
+        @version = nil
+      end
+
+      def absolute_url(uri)
+        @domain.absolute_url(relative_uri(uri))
+      end
+
+      def url_without_pagination_info(url, params = {})
+        uri = URI.parse(url)
+        clo = params.clone
+        clo = clo.delete_if { |_k, v| v.nil? }
+        query = clo.map{|k, v| "#{k}=#{v}"}.join("&")
+        if (!(uri.query == nil || uri.query.length == 0))
+          sep = ""
+          if (query.length>0)
+            sep = "&"
+          end
+          query = uri.query + sep + query;
+        end
+        if (query.length ==0)
+          return url
+        end
+        queryParams = query.split("&")
+        idx = 0;
+        q = ["page", "pageSize"];
+        while (idx < q.length)
+          par = q[idx]
+          prefix = par + "="
+          i = 0
+          while (i < queryParams.length)
+            if (queryParams[i].start_with?(prefix))
+                queryParams.delete_at(i)
+            else
+                i = i + 1
+            end
+          end
+          idx = idx + 1
+        end
+        query = ""
+        if (queryParams.length > 0)
+          query = queryParams.join("&")
+        end
+        uri.query = query
+        return uri.to_s
+      end
+
+      def relative_uri(uri)
+        "#{@version.chomp('/').gsub(/^\//, '')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = relative_uri(uri)
+        params = params.delete_if { |_k, v| v.nil? }
+        data = data
+        @domain.request(method, url, params, data, headers, auth, timeout)
+      end
+
+      def exception(response, header)
+        Reach::REST::RestError.new(header, response)
+      end
+
+      def fetch(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        # Note that 3XX response codes are allowed for fetches.
+        if response.status_code < 200 || response.status_code >= 400
+          raise exception(response, 'Unable to fetch record')
+        end
+
+        response.body
+      end
+
+      def update(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to update record')
+        end
+
+        response.body
+      end
+
+      def unschedule(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to unschedule record')
+        end
+
+        response.body
+      end
+
+      def delete(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to delete record')
+        end
+
+        response.status_code == 204
+      end
+
+      def read_limits(limit = nil, page_size = nil)
+        unless limit.nil? || page_size
+          page_size = limit
+        end
+
+        {
+          limit: limit || nil,
+          page_size: page_size || nil
+        }
+      end
+
+      def page(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+
+      def stream(page, limit: nil, page_limit: nil)
+        RecordStream.new(page, limit: limit, page_limit: page_limit)
+      end
+
+      def create(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to create record')
+        end
+
+        response.body
+      end
+
+      def dispatch(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to dispatch record')
+        end
+
+        response.body
+      end
+
+      def start(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to start record')
+        end
+
+        response.body
+      end
+
+      def check(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to check record')
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/reach-ruby/framework/serialize.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Reach
+  def self.serialize_iso8601_date(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      date.iso8601
+    elsif date.is_a?(Time)
+      date.strftime('%Y-%m-%d')
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.serialize_iso8601_datetime(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      Time.new(date.year, date.month, date.day).utc.iso8601
+    elsif date.is_a?(Time)
+      date.utc.iso8601
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.deserialize_rfc2822(date)
+    Time.rfc2822(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_date(date)
+    Date.parse(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_datetime(date)
+    Time.parse(date) unless date.nil?
+  end
+
+  def self.serialize_object(object)
+    if object.is_a?(Hash) || object.is_a?(Array)
+      JSON.generate(object)
+    else
+      object
+    end
+  end
+
+  def self.flatten(map, result = {}, previous = [])
+    map.each do |key, value|
+      if value.is_a? Hash
+        self.flatten(value, result, previous + [key])
+      else
+        result[(previous + [key]).join('.')] = value
+      end
+    end
+
+    result
+  end
+
+  def self.prefixed_collapsible_map(map, prefix)
+    result = {}
+    if map.is_a? Hash
+      flattened = self.flatten(map)
+      result = {}
+      flattened.each do |key, value|
+        result[prefix + '.' + key] = value
+      end
+    end
+
+    result
+  end
+
+  def self.serialize_list(input_list)
+    return input_list unless input_list.is_a? Array
+    result = []
+    input_list.each do |e|
+      result.push yield e
+    end
+    result
+  end
+end

data/lib/reach-ruby/framework/values.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Reach
+  class Values
+    def self.of(hash)
+      hash.delete_if { |_, v| v.eql?(:unset) }
+    end
+  end
+end

data/lib/reach-ruby/http/http_client.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Reach
+  module HTTP
+    class Client
+      attr_accessor :adapter
+      attr_reader :timeout, :last_response, :last_request
+
+      def initialize(proxy_prot = nil, proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil,
+                     ssl_ca_file = nil, timeout: nil)
+        @proxy_prot = proxy_prot
+        @proxy_path = "#{proxy_addr}:#{proxy_port}" if proxy_addr && proxy_port
+        @proxy_auth = "#{proxy_user}:#{proxy_pass}@" if proxy_pass && proxy_user
+        @ssl_ca_file = ssl_ca_file
+        @timeout = timeout
+        @adapter = Faraday.default_adapter
+        @configure_connection_blocks = []
+      end
+
+      def configure_connection(&block)
+        raise ArgumentError, "#{__method__} must be given a block!" unless block_given?
+
+        @configure_connection_blocks << block
+        nil
+      end
+
+      def _request(request) # rubocop:disable Metrics/MethodLength
+        sslVerify = true
+        @connection = Faraday.new(url: request.host + ':' + request.port.to_s, ssl: { verify: sslVerify }) do |f|
+          f.options.params_encoder = Faraday::FlatParamsEncoder
+          f.request :url_encoded
+          f.headers = request.headers
+          #if Faraday::VERSION.start_with?('2.')
+          #  f.request(:authorization, :basic, request.auth[0], request.auth[1])
+          #else
+          #  f.request(:basic_auth, request.auth[0], request.auth[1])
+          #end
+          f.headers["ApiUser"] = request.auth[0]
+          f.headers["ApiKey"] = request.auth[1]
+          f.proxy = "#{@proxy_prot}://#{@proxy_auth}#{@proxy_path}" if @proxy_prot && @proxy_path
+          f.options.open_timeout = request.timeout || @timeout
+          f.options.timeout = request.timeout || @timeout
+
+          @configure_connection_blocks.each { |block| block.call(f) }
+          f.adapter @adapter
+        end
+
+        @last_request = request
+        @last_response = nil
+
+        response = send(request)
+        if (500..599).include?(response.status)
+          object = { message: "Server error (#{response.status})", code: response.status }.to_json
+        elsif response.body && !response.body.empty?
+          object = response.body
+        elsif response.status == 400
+          object = { message: 'Bad request', code: 400 }.to_json
+        end
+
+        reach_response = Reach::Response.new(response.status, object, headers: response.headers)
+        @last_response = reach_response
+
+        reach_response
+      end
+
+      def send(request)
+        @connection.send(request.method.downcase.to_sym,
+                         request.url,
+                         request.method == 'GET' ? request.params : request.data)
+      rescue Faraday::Error => e
+        raise Reach::REST::ReachError, e
+      end
+
+      def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        request = Reach::Request.new(host, port, method, url, params, data, headers, auth, timeout)
+        _request(request)
+      end
+    end
+  end
+end

data/lib/reach-ruby/http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'http/**/*.rb')].sort.each do |file|
+  require file
+end

data/lib/reach-ruby/rest/api/authentix/.openapi-generator/FILES

@@ -0,0 +1,10 @@
+../authentix.rb
+../authentix.rb
+../authentix.rb
+../authentix.rb
+../authentix.rb
+authentication_trial_item.rb
+authentication_trial_stat_item.rb
+configuration_item.rb
+configuration_item/authentication_control_item.rb
+configuration_item/authentication_item.rb

data/lib/reach-ruby/rest/api/authentix/.openapi-generator/VERSION

@@ -0,0 +1 @@
+unset