conversant 1.0.16

data/lib/conversant/v3/http_client.rb

@@ -0,0 +1,456 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    # HTTP client module for handling SSO authentication and HTTP requests
+    #
+    # This module provides low-level HTTP operations including SSO login flow,
+    # cookie management, and authenticated request handling. It's included by
+    # Base class and used by all service classes for authentication.
+    #
+    # @example Using HttpClient in a service
+    #   class MyService < Conversant::V3::Base
+    #     include HttpClient
+    #
+    #     def my_api_call
+    #       sessions = authenticate
+    #       request(:get, api_url, nil, headers)
+    #     end
+    #   end
+    #
+    # @since 1.0.0
+    module HttpClient
+      # Default login URL for SSO authentication
+      LOGIN_URL = 'https://console.swiftfederation.com/'
+
+      # Redis key for storing portal SESSION cookie
+      PORTAL_SESSION_REDIS_KEY = 'CONVERSANT.V3.PORTAL.SESSION'
+
+      # Redis key for storing SSO_GW_SESSION2 cookie
+      SSO_GW_SESSION2_REDIS_KEY = 'CONVERSANT.V3.PORTAL.SSO_GW_SESSION2'
+
+      # Gets the thread-local cookie jar for storing cookies during authentication
+      #
+      # The cookie jar is used to maintain cookies across multiple HTTP requests
+      # during the SSO login flow. Each thread has its own isolated cookie jar.
+      #
+      # @return [Hash{String => String}] Cookie name-value pairs
+      #
+      # @example
+      #   cookie_jar['SESSION'] = 'abc123'
+      #   puts cookie_jar['SESSION'] # => 'abc123'
+      #
+      # @since 1.0.0
+      def cookie_jar
+        Thread.current[:conversant_cookie_jar] ||= {}
+      end
+
+      # Sets the thread-local cookie jar
+      #
+      # @param value [Hash, nil] Cookie name-value pairs, or nil to clear
+      # @return [Hash, nil] The assigned value
+      #
+      # @example
+      #   self.cookie_jar = { 'SESSION' => 'abc123' }
+      #   self.cookie_jar = nil # Clear cookies
+      #
+      # @since 1.0.0
+      def cookie_jar=(value)
+        Thread.current[:conversant_cookie_jar] = value
+      end
+
+      # Logs a debug message if debug mode is enabled
+      #
+      # @param message [String] The message to log
+      # @return [void]
+      #
+      # @example
+      #   debug_log "Starting authentication"
+      #
+      # @since 1.0.0
+      def debug_log(message)
+        return unless configuration.debug_mode
+
+        configuration.logger.debug "Conversant::V3 - #{message}"
+      end
+
+      # Performs SSO login to obtain root SESSION and SSO_GW_SESSION2 cookies
+      #
+      # Executes a multi-step SSO authentication flow:
+      # 1. Fetches the login page
+      # 2. Extracts the form action URL
+      # 3. Submits credentials
+      # 4. Extracts and caches session cookies
+      #
+      # Sessions are cached in Redis for reuse across all services and customers.
+      #
+      # @return [Hash{Symbol => String}, nil] Hash with :session and :sso_gw_session2 keys, or nil on failure
+      #
+      # @example
+      #   sessions = sso_login
+      #   if sessions
+      #     puts "SESSION: #{sessions[:session]}"
+      #     puts "SSO_GW_SESSION2: #{sessions[:sso_gw_session2]}"
+      #   end
+      #
+      # @since 1.0.0
+      def sso_login
+        session_key = PORTAL_SESSION_REDIS_KEY
+        sso_key = SSO_GW_SESSION2_REDIS_KEY
+
+        # Check cache first
+        cached_session = redis.get(session_key)
+        cached_sso_gw = redis.get(sso_key)
+
+        if cached_session && cached_sso_gw
+          debug_log 'Using cached global SSO sessions'
+          return {
+            session: cached_session,
+            sso_gw_session2: cached_sso_gw
+          }
+        end
+
+        begin
+          # Initialize thread-safe cookie jar
+          self.cookie_jar = {}
+
+          # Step 1: Get login page and extract form action
+          debug_log "[SSO Login - Step 1] Fetching login page: #{LOGIN_URL}"
+          login_page_response = http_get(LOGIN_URL)
+          return nil unless login_page_response
+
+          debug_log "Login page loaded, status: #{login_page_response[:status]}"
+
+          # Step 2: Parse login form to get action URL
+          form_action = extract_form_action(login_page_response[:body])
+          unless form_action
+            debug_log 'Could not extract form action URL from login page'
+            return nil
+          end
+
+          debug_log "[SSO Login - Step 2] Form action extracted: #{form_action}"
+
+          # Step 3: Submit credentials
+          form_data = URI.encode_www_form(
+            username: configuration.swiftserve_identifier_id,
+            password: configuration.swiftserve_identifier_hash,
+            credentialId: ''
+          )
+
+          debug_log '[SSO Login - Step 3] Submitting login form...'
+          login_response = http_post(form_action, form_data, {
+            'Content-Type' => 'application/x-www-form-urlencoded'
+          })
+
+          return nil unless login_response
+
+          debug_log "Login completed, status: #{login_response[:status]}"
+
+          # Step 4: Extract cookies
+          session_cookie = cookie_jar['SESSION']
+          sso_gw_session2_cookie = cookie_jar['SSO_GW_SESSION2']
+
+          if session_cookie && sso_gw_session2_cookie
+            # Cache the sessions globally
+            redis.set(session_key, session_cookie, ex: configuration.cache_ttl)
+            redis.set(sso_key, sso_gw_session2_cookie, ex: configuration.cache_ttl)
+
+            configuration.logger.info 'Conversant::V3 - SSO login successful, sessions cached'
+
+            return {
+              session: session_cookie,
+              sso_gw_session2: sso_gw_session2_cookie
+            }
+          end
+
+          debug_log 'New SSO login failed - no valid sessions obtained'
+          nil
+
+        rescue StandardError => e
+          configuration.logger.error "Conversant::V3 - SSO login error: #{e.message}"
+          nil
+        ensure
+          self.cookie_jar = nil
+        end
+      end
+
+      # Authenticates and returns cached SSO sessions
+      #
+      # Wrapper around sso_login that ensures sessions are cached in Redis.
+      # This is the primary method used by service classes for authentication.
+      #
+      # @return [Hash{Symbol => String}, nil] Hash with :session and :sso_gw_session2 keys, or nil on failure
+      #
+      # @example
+      #   sessions = authenticate
+      #   if sessions
+      #     headers['Cookie'] = "SESSION=#{sessions[:session]}; SSO_GW_SESSION2=#{sessions[:sso_gw_session2]}"
+      #   end
+      #
+      # @since 1.0.0
+      def authenticate
+        result = sso_login
+
+        if result && result[:session]
+          redis.set(PORTAL_SESSION_REDIS_KEY, result[:session], ex: configuration.cache_ttl)
+          redis.set(SSO_GW_SESSION2_REDIS_KEY, result[:sso_gw_session2], ex: configuration.cache_ttl) if result[:sso_gw_session2]
+          result
+        else
+          nil
+        end
+      end
+
+      # Makes an authenticated HTTP request
+      #
+      # Handles JSON payload serialization and SSL verification based on configuration.
+      # All service classes use this method for making API calls.
+      #
+      # @param method [Symbol] HTTP method (:get, :post, :put, :delete, etc.)
+      # @param url [String] Full URL to request
+      # @param payload [Hash, String, nil] Request payload (auto-converted to JSON if Content-Type matches)
+      # @param headers [Hash{String => String}] HTTP headers
+      #
+      # @return [Array(Integer, RestClient::Response)] Status code and response object
+      #
+      # @example
+      #   code, response = request(:get, 'https://api.example.com/data', nil, headers)
+      #   if code == 200
+      #     data = JSON.parse(response.body)
+      #   end
+      #
+      # @since 1.0.0
+      def request(method, url, payload, headers)
+        debug_log "[Request] #{method} #{url}"
+        debug_log "[Request] Headers: #{headers.inspect}" if configuration.debug_mode
+
+        # Check Content-Type using string key (headers are now plain hash with string keys)
+        if headers&.[]('Content-Type') == configuration.default_content_type
+          payload = payload&.to_json
+        end
+
+        request = RestClient::Request.new(
+          method: method,
+          url: url,
+          payload: payload,
+          headers: headers,
+          verify_ssl: configuration.verify_ssl
+        )
+
+        response = request.execute do |response|
+          response
+        end
+
+        debug_log "[Response] Status: #{response.code}" if configuration.debug_mode
+        [response.code, response]
+      rescue StandardError => e
+        configuration.logger.error "Conversant::V3 - Request exception: #{e.message}"
+        [500, nil]
+      end
+
+      private
+
+      # Performs an HTTP GET request with cookie management
+      #
+      # Handles redirects automatically and updates the cookie jar from responses.
+      # Used internally during SSO login flow.
+      #
+      # @param url [String] URL to fetch
+      # @return [Hash{Symbol => untyped}, nil] Response hash with :status, :body, :headers keys, or nil on error
+      def http_get(url)
+        headers = {
+          'User-Agent' => configuration.default_ua,
+          'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
+        }
+
+        headers = add_cookies_to_headers(headers)
+
+        response = RestClient::Request.execute(
+          method: :get,
+          url: url,
+          headers: headers,
+          verify_ssl: configuration.verify_ssl,
+          max_redirects: 10
+        ) do |resp, request, result|
+          update_cookie_jar(resp)
+
+          case resp.code
+          when 200..299
+            resp
+          when 300..399
+            resp.follow_redirection
+          else
+            resp
+          end
+        end
+
+        update_cookie_jar(response)
+
+        {
+          status: response.code,
+          body: response.body,
+          headers: response.headers
+        }
+      rescue StandardError => e
+        configuration.logger.error "Conversant::V3 - HTTP GET error: #{e.message}"
+        nil
+      end
+
+      # Performs an HTTP POST request with cookie management
+      #
+      # Handles redirects automatically and updates the cookie jar from responses.
+      # Used internally during SSO login flow for form submissions.
+      #
+      # @param url [String] URL to post to
+      # @param payload [String] Request body
+      # @param extra_headers [Hash{String => String}] Additional headers to merge
+      # @return [Hash{Symbol => untyped}, nil] Response hash with :status, :body, :headers keys, or nil on error
+      def http_post(url, payload, extra_headers = {})
+        headers = {
+          'User-Agent' => configuration.default_ua,
+          'Accept' => '*/*'
+        }.merge(extra_headers)
+
+        headers = add_cookies_to_headers(headers)
+
+        response = RestClient::Request.execute(
+          method: :post,
+          url: url,
+          payload: payload,
+          headers: headers,
+          verify_ssl: configuration.verify_ssl,
+          max_redirects: 10
+        ) do |resp, request, result|
+          update_cookie_jar(resp)
+
+          case resp.code
+          when 200..299
+            resp
+          when 300..399
+            location = resp.headers[:location]
+            if location
+              get_response = http_get(location)
+              if get_response && get_response[:status] == 200
+                OpenStruct.new(
+                  code: get_response[:status],
+                  body: get_response[:body],
+                  headers: get_response[:headers]
+                )
+              else
+                resp.follow_redirection
+              end
+            else
+              resp.follow_redirection
+            end
+          else
+            resp
+          end
+        end
+
+        update_cookie_jar(response)
+
+        {
+          status: response.code,
+          body: response.body,
+          headers: response.headers
+        }
+      rescue StandardError => e
+        configuration.logger.error "Conversant::V3 - HTTP POST error: #{e.message}"
+        nil
+      end
+
+      # Adds cookies from cookie jar to request headers
+      #
+      # @param headers [Hash{String => String}] Request headers
+      # @return [Hash{String => String}] Headers with Cookie header added if cookies exist
+      def add_cookies_to_headers(headers)
+        return headers if cookie_jar.nil? || cookie_jar.empty?
+
+        cookie_string = cookie_jar.map { |name, value| "#{name}=#{value}" }.join('; ')
+        headers.merge('Cookie' => cookie_string)
+      end
+
+      # Updates cookie jar from HTTP response
+      #
+      # Extracts cookies from Set-Cookie headers and response.cookies hash.
+      #
+      # @param response [RestClient::Response] HTTP response object
+      # @return [void]
+      def update_cookie_jar(response)
+        return unless response&.headers
+
+        set_cookie_headers = response.headers[:set_cookie]
+        if set_cookie_headers
+          if set_cookie_headers.is_a?(Array)
+            set_cookie_headers.each { |cookie| parse_cookie_to_jar(cookie) }
+          elsif set_cookie_headers.is_a?(String)
+            parse_cookie_to_jar(set_cookie_headers)
+          end
+        end
+
+        if response.respond_to?(:cookies) && response.cookies.is_a?(Hash)
+          response.cookies.each do |name, value|
+            cookie_jar[name.to_s] = value.to_s
+          end
+        end
+      end
+
+      # Parses a Set-Cookie header string and stores it in the cookie jar
+      #
+      # @param cookie_string [String] Set-Cookie header value
+      # @return [void]
+      def parse_cookie_to_jar(cookie_string)
+        return unless cookie_string
+
+        cookie_parts = cookie_string.split(';')
+        return if cookie_parts.empty?
+
+        first_part = cookie_parts.first
+        parts = first_part.split('=', 2)
+        return unless parts && parts.length == 2
+
+        name, value = parts
+        cookie_jar[name.strip] = value.strip
+
+        debug_log "Parsed cookie: #{name.strip}" if configuration.debug_mode
+      end
+
+      # Extracts form action URL from HTML login page
+      #
+      # Searches for the Keycloak login form action URL in the HTML.
+      #
+      # @param html_body [String] HTML content of login page
+      # @return [String, nil] Form action URL, or nil if not found
+      def extract_form_action(html_body)
+        return nil unless html_body
+
+        # Parse HTML to find form action URL
+        match = html_body.match(/form[^>]*id=["']kc-form-login["'][^>]*action=["']([^"']*)["']/)
+        if match
+          return CGI.unescapeHTML(match[1])
+        end
+
+        # Fallback: look for any form with action
+        match = html_body.match(/form[^>]*action=["']([^"']*)["']/)
+        if match
+          return CGI.unescapeHTML(match[1])
+        end
+
+        nil
+      end
+
+      # Returns the global Conversant configuration
+      #
+      # @return [Conversant::Configuration] Configuration instance
+      def configuration
+        Conversant.configuration
+      end
+
+      # Returns the Redis client from configuration
+      #
+      # @return [Redis] Redis client instance
+      def redis
+        configuration.redis
+      end
+    end
+  end
+end

data/lib/conversant/v3/mixins/authentication.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Mixins
+      # Authentication mixin for integrating V3 authentication into existing classes
+      #
+      # This mixin provides a bridge for existing classes to use Conversant V3
+      # authentication without fully adopting the gem's service architecture.
+      # It's designed for gradual migration and backward compatibility.
+      #
+      # @example Basic usage in existing class
+      #   class MyExistingClass
+      #     include Conversant::V3::Mixins::Authentication
+      #     use_conversant_auth!
+      #
+      #     def initialize(customer_id, type = 2)
+      #       initialize_conversant_auth(customer_id, type)
+      #     end
+      #
+      #     def my_cdn_call
+      #       headers = cdn_authorized_headers
+      #       # Make API call with headers
+      #     end
+      #   end
+      #
+      # @example Drop-in replacement for ConversantHttpClientV3
+      #   module ConversantHttpClientV3
+      #     def self.included(base)
+      #       base.class_eval do
+      #         include Conversant::V3::Mixins::Authentication
+      #         use_conversant_auth!
+      #       end
+      #     end
+      #
+      #     def authenticate
+      #       conversant_authenticate
+      #     end
+      #   end
+      #
+      # @since 1.0.0
+      module Authentication
+        # Hook called when module is included
+        #
+        # @param base [Class] The class including this module
+        # @return [void]
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        # Class methods added when Authentication is included
+        module ClassMethods
+          # Enables Conversant authentication for the class
+          #
+          # Includes HttpClient module and sets up customer_id/type attributes.
+          # Call this in your class after including the Authentication mixin.
+          #
+          # @return [void]
+          #
+          # @example
+          #   class MyService
+          #     include Conversant::V3::Mixins::Authentication
+          #     use_conversant_auth!
+          #   end
+          def use_conversant_auth!
+            include Conversant::V3::HttpClient
+            attr_reader :customer_id, :type
+          end
+        end
+
+        # @return [Integer] Customer ID for API calls
+        attr_reader :customer_id
+
+        # @return [Integer] Customer type
+        attr_reader :type
+
+        # Initializes authentication with customer ID and type
+        #
+        # Call this from your class's initialize method to set up authentication.
+        #
+        # @param customer_id [Integer] Customer ID for API calls
+        # @param type [Integer] Customer type (default: 2)
+        # @return [void]
+        #
+        # @example
+        #   def initialize(customer_id, type = 2)
+        #     initialize_conversant_auth(customer_id, type)
+        #   end
+        #
+        # @since 1.0.0
+        def initialize_conversant_auth(customer_id, type = 2)
+          @customer_id = customer_id # @type [Integer]
+          @type = type # @type [Integer]
+        end
+
+        # Authenticates and returns SSO sessions
+        #
+        # Wrapper method for backward compatibility with existing code.
+        #
+        # @return [Hash{Symbol => String}, nil] Hash with :session and :sso_gw_session2 keys, or nil on failure
+        #
+        # @example
+        #   sessions = conversant_authenticate
+        #   if sessions
+        #     puts sessions[:session]
+        #   end
+        #
+        # @since 1.0.0
+        def conversant_authenticate
+          authenticate
+        end
+
+        # Returns authorized headers for Portal API calls
+        #
+        # Delegates to Portal service class which uses the Authorization module.
+        #
+        # @return [Hash{String => String}] Headers hash with 'Cookie' header containing SESSION and SSO_GW_SESSION2
+        #
+        # @raise [Conversant::AuthenticationError] if sessions cannot be obtained
+        #
+        # @example
+        #   headers = portal_authorized_headers
+        #   response = RestClient.get(url, headers)
+        #
+        # @since 1.0.0
+        def portal_authorized_headers
+          portal_service.send(:authorized_headers)
+        end
+
+        # Returns authorized headers for CDN API calls
+        #
+        # Delegates to CDN service class which uses the Authorization module.
+        #
+        # @return [Hash{String => String}] Headers hash with 'Cookie' header containing SESSION and SSO_GW_SESSION2
+        #
+        # @example
+        #   headers = cdn_authorized_headers
+        #   response = RestClient.get(cdn_url, headers)
+        #
+        # @since 1.0.0
+        def cdn_authorized_headers
+          cdn_service.send(:authorized_headers)
+        end
+
+        # Returns authorized headers for LMS API calls
+        #
+        # Delegates to LMS service class which uses the Authorization module.
+        #
+        # @return [Hash{String => String}] Headers hash with 'Cookie' header containing JSESSIONID and SSO_GW_SESSION2
+        #
+        # @example
+        #   headers = lms_authorized_headers
+        #   response = RestClient.get(lms_url, headers)
+        #
+        # @since 1.0.0
+        def lms_authorized_headers
+          lms_service.send(:authorized_headers)
+        end
+
+        # Returns authorized headers for VMS API calls
+        #
+        # Delegates to VMS service class which uses the Authorization module.
+        #
+        # @return [Hash{String => String}] Headers hash with 'Cookie' header containing JSESSIONID and SSO_GW_SESSION2
+        #
+        # @example
+        #   headers = vms_authorized_headers
+        #   response = RestClient.get(vms_url, headers)
+        #
+        # @since 1.0.0
+        def vms_authorized_headers
+          vms_service.send(:authorized_headers)
+        end
+
+        private
+
+        # Gets or creates Portal service instance
+        #
+        # @return [Conversant::V3::Services::Portal] Portal service instance
+        def portal_service
+          @portal_service ||= Conversant::V3.portal(@customer_id, @type)
+        end
+
+        # Gets or creates CDN service instance
+        #
+        # @return [Conversant::V3::Services::CDN] CDN service instance
+        def cdn_service
+          @cdn_service ||= Conversant::V3.cdn(@customer_id, @type)
+        end
+
+        # Gets or creates LMS service instance
+        #
+        # @return [Conversant::V3::Services::LMS] LMS service instance
+        def lms_service
+          @lms_service ||= Conversant::V3.lms(@customer_id, @type)
+        end
+
+        # Gets or creates VMS service instance
+        #
+        # @return [Conversant::V3::Services::VMS] VMS service instance
+        def vms_service
+          @vms_service ||= Conversant::V3.vms(@customer_id, @type)
+        end
+
+        # Returns the global Conversant configuration
+        #
+        # @return [Conversant::Configuration] Configuration instance
+        def configuration
+          Conversant.configuration
+        end
+
+        # Returns the Redis client from configuration
+        #
+        # @return [Redis] Redis client instance
+        def redis
+          configuration.redis
+        end
+      end
+    end
+  end
+end