usps-imis-api 0.11.25 → 1.0.0.pre.rc.1

data/lib/usps/imis/party_data.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-require 'stringio'
-
-require_relative 'base_data'
-
-module Usps
-  module Imis
-    # Convenience wrapper for accessing specific properties within an API data response for the
-    # Party Business Object, which has a different internal structure than others
-    #
-    class PartyData < BaseData
-      # The Business Object name
-      #
-      def entity = 'Party'
-
-      # Access the iMIS ID property
-      #
-      def imis_id = self['Id'].to_i
-      alias id imis_id
-
-      # Access the certificate number
-      #
-      def certificate = self['AlternateIds'].find { it['IdType'] == 'MajorKey' }['Id']
-
-      # Access an individual property value by name
-      #
-      def [](property_name) = properties[property_name]
-
-      # Hash of all property names to values
-      #
-      def properties
-        @properties ||= format_extracted(extract_hash(raw))
-      end
-
-    private
-
-      def pretty_print_data
-        { entity:, imis_id: }.compact
-      end
-
-      def extract_hash(hash)
-        hash.filter_map do |key, value|
-          next if key == '$type'
-
-          [key, extract_value(value)]
-        end
-      end
-
-      def extract_value(value)
-        case value
-        when String, Integer, true, false, nil then value
-        when Array then value.map { extract_value(it) }
-        when Hash then extract_hash_value(value)
-        else
-          raise Errors::ApiError, "Unrecognized value type: #{value.inspect}"
-        end
-      end
-
-      def extract_hash_value(value)
-        return value['$value'] if value.key?('$value')
-        return extract_value(value['$values']) if value.key?('$values')
-        return [value['Name'], extract_value(value['Value'])] if value.key?('Name') && value.key?('Value')
-
-        extract_hash(value)
-      end
-
-      def format_extracted(data)
-        hash = data.to_h
-
-        hash.each do |key, value|
-          case value
-          when String, Integer, true, false then next
-          end
-
-          if %w[Addresses AlternateIds CommunicationPreferences Emails Salutations].include?(key)
-            hash[key] = value.map { format_extracted(it.to_h) }
-          elsif value.all? { it.is_a?(String) }
-            # Do nothing
-          else
-            hash[key] = format_extracted(value.to_h)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/usps/imis/properties.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Usps
-  module Imis
-    # Constructor for the Properties field
-    #
-    class Properties
-      # Build the data for a new Properties field
-      #
-      def self.build(&) = new.build(&)
-
-      # Wrap value in the API-internal type structure
-      #
-      def self.wrap(value)
-        case value
-        when String then value
-        when Time, DateTime then value.strftime('%Y-%m-%dT%H:%I:%S')
-        when Integer then { '$type' => 'System.Int32', '$value' => value }
-        when true, false then { '$type' => 'System.Boolean', '$value' => value }
-        else
-          raise Errors::UnexpectedPropertyTypeError.from(value)
-        end
-      end
-
-      # Build the data for the Properties field
-      #
-      def build
-        yield(self)
-
-        {
-          'Properties' => {
-            '$type' => 'Asi.Soa.Core.DataContracts.GenericPropertyDataCollection, Asi.Contracts',
-            '$values' => @properties
-          }
-        }
-      end
-
-      # Add an individual property to the field
-      #
-      def add(name, value)
-        @properties ||= []
-        @properties << {
-          '$type' => 'Asi.Soa.Core.DataContracts.GenericPropertyData, Asi.Contracts',
-          'Name' => name,
-          'Value' => self.class.wrap(value)
-        }
-      end
-    end
-  end
-end

data/lib/usps/imis/query.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module Usps
-  module Imis
-    # API wrapper for IQA and Business Object Queries
-    #
-    class Query
-      include Enumerable
-      include Requests
-
-      # Endpoint for IQA query requests
-      #
-      IQA_PATH = 'api/Query'
-
-      # The parent +Api+ object
-      #
-      attr_reader :api
-
-      # Name of the Query to run
-      #
-      attr_reader :query_name
-
-      # Parameters for the Query
-      #
-      attr_reader :query_params
-
-      # Current page size for paging through the Query
-      #
-      attr_accessor :page_size
-
-      # Current offset for paging through the Query
-      #
-      attr_accessor :offset
-
-      # Count of records processed
-      #
-      attr_reader :count
-
-      # Whether the current query has a next page
-      #
-      attr_reader :next_page
-
-      # Tagged logger
-      #
-      attr_reader :logger
-
-      # A new instance of +Query+
-      #
-      # @param api [Api] Parent to use for making requests
-      # @param query_name [String] Full path of the query in IQA, e.g. +$/_ABC/Fiander/iMIS_ID+
-      # @param page_size [Integer] Number of records to return on each request page
-      # @param offset [Integer] Offset index of records to return on next request page
-      # @param query_params [Hash] Conforms to pattern +{ param_name => param_value }+
-      #
-      def initialize(api, query_name, page_size: 100, offset: nil, **query_params)
-        @api = api
-        @query_name = query_name
-        @query_params = query_params
-        @page_size = page_size
-        @offset = offset
-        @count = 0
-        @logger ||= Imis.logger('Query', query_type)
-
-        logger.tagged('Name').debug query_name
-        logger.tagged('Params').json query_params
-        logger.tagged('URI').debug uri
-        logger.tagged('Page Size').debug page_size
-        logger.tagged('Offset').debug offset.to_i
-      end
-
-      # Iterate through all results from the query
-      #
-      def each(&)
-        logger.info 'Running'
-
-        items = []
-        find_each { items << it }
-        items.each(&)
-      end
-
-      # Iterate through all results from the query, fetching one page at a time
-      #
-      def find_each(&)
-        reset!
-        page.each(&) while page?
-        nil
-      end
-
-      # Fetch a filtered query page, and update the current offset
-      #
-      def page = fetch_next['Items']['$values'].map { iqa? ? it.except('$type') : Imis::Data[it] }
-
-      # Fetch the next raw query page, and update the current offset
-      #
-      def fetch_next
-        return unless page?
-
-        logger.info "Fetching #{query_type} Query page"
-
-        result = fetch
-
-        @count += result['Count'] || 0
-        total = result['TotalCount']
-        logger.info "#{@count} / #{total} #{'item'.pluralize(total)}"
-        logger.debug 'Query page data:'
-        logger.json result
-
-        @offset = result['NextOffset']
-        @next_page = result['HasNext']
-
-        result
-      end
-
-      # Fetch a raw query page
-      #
-      def fetch = JSON.parse(submit(uri, authorize(http_get)).body)
-
-      # Reset query paging progress
-      #
-      def reset!
-        return if next_page.nil?
-
-        logger.debug 'Resetting progress'
-
-        @count = 0
-        @offset = 0
-        @next_page = nil
-      end
-
-      # Ruby 3.5 instance variable filter
-      #
-      def instance_variables_to_inspect = instance_variables - %i[@api @logger]
-
-    private
-
-      # Only skip if explicitly set
-      def page? = next_page.nil? || next_page
-
-      def iqa? = query_name.match?(/^\$/)
-      def query_type = iqa? ? :IQA : :'Business Object'
-      def path_params = query_params.merge({ Offset: offset, Limit: page_size }.compact)
-      def uri = URI(File.join(Imis.configuration.hostname, path))
-
-      def path
-        if iqa?
-          "#{IQA_PATH}?#{path_params.merge(QueryName: query_name).to_query}"
-        else
-          "#{Imis::BusinessObject::API_PATH}/#{query_name}?#{path_params.to_query}"
-        end
-      end
-    end
-  end
-end

data/lib/usps/imis/requests.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Usps
-  module Imis
-    # @private
-    #
-    module Requests
-    private
-
-      def logger = raise("#{self.class.name} must implement #logger")
-
-      def token = api.token
-      def token_expiration = api.token_expiration
-      def authenticate = api.send(:authenticate)
-
-      def http_get = Net::HTTP::Get.new(uri)
-      def http_put = Net::HTTP::Put.new(uri)
-      def http_post = Net::HTTP::Post.new(uri(id: ''))
-      def http_delete = Net::HTTP::Delete.new(uri)
-
-      def client(uri)
-        Net::HTTP.new(uri.host, uri.port).tap do |http|
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
-      end
-
-      # Authorize a request prior to submitting
-      #
-      # If the current token is missing/expired, request a new one
-      #
-      def authorize(request)
-        if token_expiration.nil? || token_expiration < Time.now
-          logger.debug 'Token expired: re-authenticating with iMIS'
-          authenticate
-        end
-        request.tap { it.add_field('Authorization', "Bearer #{token}") }
-      end
-
-      def submit(uri, request)
-        logger.info 'Submitting request to iMIS'
-        logger.tagged('Request') do
-          logger.debug "#{request.class.name.demodulize.upcase} #{uri}"
-          logger.multiline sanitized_request_body(request)
-
-          client(uri).request(request).tap do |result|
-            raise Errors::ResponseError.from(result) unless result.is_a?(Net::HTTPSuccess)
-
-            logger.info 'Request succeeded'
-          end
-        end
-      end
-
-      def sanitized_request_body(request)
-        return '*** empty request body ***' if request.body.nil?
-
-        body = request.body.dup
-
-        Imis.config.filtered_parameters.each do |parameter|
-          body.gsub!(Imis.config.public_send(parameter), '[FILTERED]')
-          body.gsub!(CGI.escape(Imis.config.public_send(parameter)), '[FILTERED]')
-        end
-
-        body
-      end
-    end
-  end
-end

data/spec/support/usps/vcr/config.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Usps
-  module Vcr
-    module Config
-      class << self
-        def configure!
-          WebMock.disable_net_connect!
-
-          VCR.configure do |config|
-            config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-            config.hook_into :webmock
-            default_options(config)
-            config.configure_rspec_metadata!
-            apply_filters(config)
-
-            yield(config) if block_given?
-          end
-        end
-
-        def vcr_record_ordered
-          ENV['VCR'] == 'all' ? :defined : :random
-        end
-
-      private
-
-        def default_options(config)
-          config.default_cassette_options = {
-            record: ENV['VCR'] ? ENV['VCR'].to_sym : :once,
-            match_requests_on: %i[method uri]
-          }
-        end
-
-        def apply_filters(config)
-          Filters.apply!(
-            config,
-            *%i[
-              username password access_token bearer_token
-              ignore_response_headers cf_ray cookie date
-              issued expires
-            ]
-          )
-        end
-      end
-    end
-  end
-end

data/spec/support/usps/vcr/filters.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Usps
-  module Vcr
-    module Filters
-      class << self
-        def apply!(config, *filters)
-          filters.each { public_send(it, config) }
-        end
-
-        def username(config)
-          value = Usps::Imis.config.username || '<USERNAME>'
-          config.filter_sensitive_data('<USERNAME>') { value }
-          config.filter_sensitive_data('<USERNAME>') { CGI.escape(value) }
-          config.filter_sensitive_data('<USERNAME>') { value.upcase }
-          config.filter_sensitive_data('<USERNAME>') { CGI.escape(value).upcase }
-        end
-
-        def password(config)
-          value = Usps::Imis.config.password || '<PASSWORD>'
-          config.filter_sensitive_data('<PASSWORD>') { value }
-          config.filter_sensitive_data('<PASSWORD>') { CGI.escape(value) }
-        end
-
-        def access_token(config)
-          filter_json_field(config, 'access_token', '<ACCESS_TOKEN>')
-        end
-
-        def bearer_token(config)
-          config.filter_sensitive_data('<BEARER_TOKEN>') do |interaction|
-            if interaction.request.headers['Authorization']
-              authorization = interaction.request.headers['Authorization'].first
-              if (match = authorization.match(/^Bearer\s+([^,\s]+)/))
-                match.captures.first
-              end
-            end
-          end
-        end
-
-        def ignore_response_headers(config)
-          config.before_record do |interaction|
-            interaction.response.headers.delete('Report-To')
-            interaction.response.headers.delete('Content-Security-Policy-Report-Only')
-          end
-        end
-
-        def cf_ray(config)
-          config.filter_sensitive_data('<CF_RAY>') do |interaction|
-            interaction.response.headers['Cf-Ray']&.first
-          end
-        end
-
-        def cookie(config)
-          config.filter_sensitive_data('<COOKIE>') do |interaction|
-            interaction.response.headers['Set-Cookie']&.first
-          end
-        end
-
-        def date(config)
-          config.filter_sensitive_data('<DATE>') do |interaction|
-            interaction.response.headers['Date']&.first
-          end
-        end
-
-        def issued(config)
-          filter_json_field(config, '.issued', '<ISSUED>')
-        end
-
-        def expires(config)
-          filter_json_field(config, '.expires', '<EXPIRES>')
-        end
-
-      private
-
-        def filter_json_field(config, field_name, placeholder)
-          config.filter_sensitive_data(placeholder) do |interaction|
-            if interaction.response.headers['Content-Type']&.first&.include?('application/json')
-              begin
-                JSON.parse(interaction.response.body)[field_name]
-              rescue JSON::ParserError
-                nil
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/usps/vcr.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'vcr'
-require 'webmock/rspec'
-require 'usps/imis'
-
-require_relative 'vcr/filters'
-require_relative 'vcr/config'