Labbeemint / syspro-ruby

  # frozen_string_literal: true
  

  module Syspro

    # This class is the main syspro client
    class SysproClient # rubocop:disable Metrics/ClassLength

      attr_accessor :conn, :api_base
  

      @verify_ssl_warned = false
  

      def initialize(conn = nil)
        self.conn = conn || self.class.default_conn
        @system_profiler = SystemProfiler.new
      end
  

      def logon(username, password, company_id, company_password)

        Syspro::Logon.logon(username, password, company_id, company_password)

      end
  

      def get_syspro_version # rubocop:disable Naming/AccessorMethodName

        Syspro::GetVersion.get_version

      end
  

      def self.active_client
        Thread.current[:syspro_client] || default_client
      end
  
      def self.default_client

        Thread.current[:syspro_client_default_client] ||= SysproClient.new(default_conn) # rubocop:disable Metrics/LineLength

      end
  

      # A default Faraday connection to be used when one isn't configured. This
      # object should never be mutated, and instead instantiating your own
      # connection and wrapping it in a SysproClient object should be preferred.

      def self.default_conn # rubocop:disable Metrics/MethodLength

        # We're going to keep connections around so that we can take advantage
        # of connection re-use, so make sure that we have a separate connection
        # object per thread.
        Thread.current[:syspro_client_default_conn] ||= begin
          conn = Faraday.new do |c|
            c.use Faraday::Request::Multipart
            c.use Faraday::Request::UrlEncoded
            c.use Faraday::Response::RaiseError
            c.adapter Faraday.default_adapter
          end
  

          # For now, we're not verifying SSL certificates.
          # The warning will appear.
          # if Syspro.verify_ssl_certs
          # conn.ssl.verify = true
          # conn.ssl.cert_store = Syspro.ca_store
          # else

          conn.ssl.verify = false
  
          unless @verify_ssl_warned
            @verify_ssl_warned = true

            warn('WARNING: Running without SSL cert verification. ' \
              'You should never do this in production. ' \

              "Execute 'Syspro.verify_ssl_certs = true' to enable verification.")
          end

          # end

  
          conn
        end
      end
  

      # Executes the API call within the given block. Usage looks like:
      #

      #     client = SysproClient.new

      #     charge, resp = client.request { Charge.create }
      #
      def request
        @last_response = nil

        old_syspro_client = Thread.current[:syspro_client]
        Thread.current[:syspro_client] = self

  
        begin
          res = yield
          [res, @last_response]
        ensure

          Thread.current[:syspro_client] = old_syspro_client

        end
      end
  

      def execute_request(method, path, user_id: nil, api_base: nil, headers: {}, params: {}) # rubocop:disable Metrics/LineLength, Metrics/MethodLength

        api_base ||= Syspro.api_base

        user_id  ||= ''

  
        params = Util.objects_to_ids(params)
        url = api_url(path, api_base)
  
        body = nil
        query_params = nil
  
        case method.to_s.downcase.to_sym
        when :get, :head, :delete
          query_params = params
        else

          body = if headers[:content_type] && headers[:content_type] == 'multipart/form-data' # rubocop:disable Metrics/LineLength

                   params
                 else
                   Util.encode_parameters(params)
                 end
        end
  
        headers = request_headers(method)
                  .update(Util.normalize_headers(headers))
  
        # stores information on the request we're about to make so that we don't
        # have to pass as many parameters around for logging.
        context = RequestLogContext.new
        context.body            = body
        context.method          = method
        context.path            = path

        context.user_id         = user_id

        context.query_params    = query_params ? Util.encode_parameters(query_params) : nil # rubocop:disable Metrics/LineLength

  
        http_resp = execute_request_with_rescues(api_base, context) do
          conn.run_request(method, url, body, headers) do |req|
            req.options.open_timeout = Syspro.open_timeout
            req.options.timeout = Syspro.read_timeout
            req.params = query_params unless query_params.nil?
          end
        end
  
        begin
          resp = SysproResponse.from_faraday_response(http_resp)
        rescue JSON::ParserError
          raise general_api_error(http_resp.status, http_resp.body)
        end
  
        # Allows SysproClient#request to return a response object to a caller.
        @last_response = resp
        [resp]
      end
  
      def general_api_error(status, body)

        ApiError.new("Invalid response object from API: #{body.inspect} " \

                     "(HTTP response code was #{status})",
                     http_status: status, http_body: body)
      end
  

      def api_url(url = '', api_base = nil)

        (api_base || Syspro.api_base) + url
      end
  

      def request_headers(_method)

        user_agent = "Syspro/7 RubyBindings/#{Syspro::VERSION}"
  
        headers = {

          'User-Agent' => user_agent,
          'Content-Type' => 'application/x-www-form-urlencoded'

        }
  
        headers
      end
  

      def execute_request_with_rescues(api_base, context) # rubocop:disable Metrics/LineLength, Metrics/MethodLength

        num_retries = 0
        begin
          request_start = Time.now
          log_request(context, num_retries)
          resp = yield

          log_response(context, request_start, resp.status, resp.body)
  
        # We rescue all exceptions from a request so that we have an easy spot to

        # implement our retry logic across the board. We'll re-raise if it's a
        # type of exception that we didn't expect to handle.

        rescue StandardError => e

          if e.respond_to?(:response) && e.response

            log_response(context, request_start,

                         e.response[:status], e.response[:body])
          else

            log_response_error(context, request_start, e)

          end
  
          if self.class.should_retry?(e, num_retries)
            num_retries += 1
            sleep self.class.sleep_time(num_retries)
            retry
          end
  
          case e
          when Faraday::ClientError
            if e.response

              handle_error_response(e.response, context)

            else

              handle_network_error(e, context, num_retries, api_base)

            end
  
          # Only handle errors when we know we can do so, and re-raise otherwise.
          # This should be pretty infrequent.
          else
            raise
          end
        end
  
        resp
      end
  

      def handle_network_error(e, context, num_retries, api_base = nil) # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Naming/UncommunicativeMethodParamName
        Util.log_error('Syspro network error',

                       error_message: e.message,
                       request_id: context.request_id)
  
        case e
        when Faraday::ConnectionFailed

          message = 'Unexpected error communicating when trying to connect to Syspro.' # rubocop:disable Metrics/LineLength

  
        when Faraday::SSLError

          message = 'Could not establish a secure connection to Syspro.'

  
        when Faraday::TimeoutError
          api_base ||= Syspro.api_base
          message = "Could not connect to Syspro (#{api_base}). " \

            'Please check your internet connection and try again. ' \
            'If this problem persists, you should check your Syspro service status.' # rubocop:disable Metrics/LineLength

  
        else

          message = 'Unexpected error communicating with Syspro. ' \
            'If this problem persists, talk to your Syspro implementation team.'

  
        end
  

        message += " Request was retried #{num_retries} times." if num_retries.positive? # rubocop:disable Metrics/LineLength

  
        raise ApiConnectionError, message + "\n\n(Network error: #{e.message})"
      end
  

      def self.should_retry?(e, num_retries) # rubocop:disable Metrics/LineLength, Naming/UncommunicativeMethodParamName

        return false if num_retries >= Syspro.max_network_retries
  

        # Retry on timeout-related problems (either on open or read).
        return true if e.is_a?(Faraday::TimeoutError)
  
        # Destination refused the connection, the connection was reset, or a
        # variety of other connection failures. This could occur from a single
        # saturated server, so retry in case it's intermittent.
        return true if e.is_a?(Faraday::ConnectionFailed)
  
        if e.is_a?(Faraday::ClientError) && e.response
          # 409 conflict
          return true if e.response[:status] == 409
        end
  
        false
      end
  
      def log_request(context, num_retries)

        Util.log_info('Request to Syspro API',

                      account: context.account,
                      api_version: context.api_version,
                      method: context.method,
                      num_retries: num_retries,
                      path: context.path)

        Util.log_debug('Request details',

                       body: context.body,
                       query_params: context.query_params)
      end
      private :log_request
  

      def log_response(context, request_start, status, body) # rubocop:disable Metrics/LineLength, Metrics/MethodLength
        Util.log_info('Response from Syspro API',

                      account: context.account,
                      api_version: context.api_version,
                      elapsed: Time.now - request_start,
                      method: context.method,
                      path: context.path,
                      request_id: context.request_id,
                      status: status)

        Util.log_debug('Response details',

                       body: body,
                       request_id: context.request_id)
      end
      private :log_response
  

      def log_response_error(context, request_start, e) # rubocop:disable Metrics/LineLength, Naming/UncommunicativeMethodParamName
        Util.log_error('Request error',

                       elapsed: Time.now - request_start,
                       error_message: e.message,
                       method: context.method,
                       path: context.path)
      end
      private :log_response_error
  

      def handle_error_response(http_resp, context) # rubocop:disable Metrics/LineLength, Metrics/MethodLength

        begin
          resp = SysproResponse.from_faraday_hash(http_resp)
          error_data = resp.data[:error]
  

          raise SysproError, 'Indeterminate error' unless error_data

        rescue Nokogiri::XML::SyntaxError, SysproError
          raise general_api_error(http_resp[:status], http_resp[:body])
        end
  
        error = if error_data.is_a?(String)
                  specific_oauth_error(resp, error_data, context)
                else
                  specific_api_error(resp, error_data, context)
                end
  
        error.response = resp
        raise(error)
      end
  

      # RequestLogContext stores information about a request that's begin made so
      # that we can log certain information. It's useful because it means that we
      # don't have to pass around as many parameters.
      class RequestLogContext
        attr_accessor :body
        attr_accessor :account
        attr_accessor :api_version
        attr_accessor :method
        attr_accessor :path
        attr_accessor :query_params
        attr_accessor :request_id

        attr_accessor :user_id

      end
  
      # SystemProfiler extracts information about the system that we're running
      # in so that we can generate a rich user agent header to help debug
      # integrations.
      class SystemProfiler

        def self.uname # rubocop:disable Metrics/MethodLength
          if File.exist?('/proc/version')
            File.read('/proc/version').strip

          else

            case RbConfig::CONFIG['host_os']

            when /linux|darwin|bsd|sunos|solaris|cygwin/i
              uname_from_system
            when /mswin|mingw/i
              uname_from_system_ver
            else

              'unknown platform'

            end
          end
        end
  
        def self.uname_from_system

          (`uname -a 2>/dev/null` || '').strip

        rescue Errno::ENOENT

          'uname executable not found'

        rescue Errno::ENOMEM # couldn't create subprocess

          'uname lookup failed'

        end
  
        def self.uname_from_system_ver

          (`ver` || '').strip

        rescue Errno::ENOENT

          'ver executable not found'

        rescue Errno::ENOMEM # couldn't create subprocess

          'uname lookup failed'

        end
  
        def initialize
          @uname = self.class.uname
        end
  

        def user_agent # rubocop:disable Metrics/MethodLength
          lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})" # rubocop:disable Metrics/LineLength

          {
            application: Syspro.app_info,
            bindings_version: Syspro::VERSION,

            lang: 'ruby',

            lang_version: lang_version,
            platform: RUBY_PLATFORM,

            engine: defined?(RUBY_ENGINE) ? RUBY_ENGINE : '',

            uname: @uname,

            hostname: Socket.gethostname

          }.delete_if { |_k, v| v.nil? }
        end

      end
    end
  end