conversant 1.0.16

data/lib/conversant/v3/services/cdn.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative 'authorization'
+
+module Conversant
+  module V3
+    module Services
+      # CDN service client for Conversant Content Delivery Network
+      #
+      # Provides comprehensive access to CDN functionality including:
+      # - Analytics and reporting (bandwidth, volume, viewers, RPS)
+      # - Domain management and configuration
+      # - SSL certificate management
+      # - Business metrics and monitoring
+      # - Audit logging and compliance
+      #
+      # @example Basic usage
+      #   cdn = Conversant::V3.cdn(customer_id)
+      #
+      #   # Get bandwidth analytics
+      #   bandwidth = cdn.analytics.bandwidths({
+      #     domain: "All",
+      #     startTime: "2025-01-01T00:00:00Z",
+      #     endTime: "2025-01-31T23:59:59Z",
+      #     interval: "hour"
+      #   })
+      #
+      #   # Manage domains
+      #   domains = cdn.domain.all
+      #   new_domain = cdn.domain.create(domain_config)
+      #
+      #   # Business metrics
+      #   traffic = cdn.business.bandwidth(time_range)
+      #
+      # @since 1.0.0
+      class CDN < ::Conversant::V3::Base
+        include Authorization
+
+        # Get analytics service instance
+        #
+        # @return [Analytics] analytics service for CDN metrics and reporting
+        # @since 1.0.0
+        def analytics
+          @analytics ||= Analytics.new(self)
+        end
+
+        # Get monitoring service instance
+        #
+        # @return [Monitoring] monitoring service for real-time CDN performance
+        # @since 1.0.0
+        def monitoring
+          @monitoring ||= Monitoring.new(self)
+        end
+
+        # Get audit service instance
+        #
+        # @return [Audit] audit service for activity logging and compliance
+        # @since 1.0.0
+        def audit
+          @audit ||= Audit.new(self)
+        end
+
+        # Get dashboard service instance
+        #
+        # @return [Dashboard] dashboard service for quick daily metrics
+        # @since 1.0.8
+        def dashboard
+          @dashboard ||= Dashboard.new(self)
+        end
+
+        # Get domain management service instance
+        #
+        # @return [Domain] domain service for CDN domain management
+        # @since 1.0.1
+        def domain
+          @domain ||= Domain.new(self)
+        end
+
+        # Get business metrics service instance
+        #
+        # @return [Business] business service for billing and usage metrics
+        # @since 1.0.1
+        def business
+          @business ||= Business.new(self)
+        end
+
+        # Get certificate management service instance
+        #
+        # @return [Certificate] certificate service for SSL/TLS management
+        # @since 1.0.1
+        def certificate
+          @certificate ||= Certificate.new(self)
+        end
+
+        # Get partner service instance
+        #
+        # Provides access to partner-level analytics and reporting that aggregate
+        # data across multiple customer accounts.
+        #
+        # @return [Partner] partner service for CDN and OSS analytics
+        # @since 1.0.12
+        #
+        # @example Access partner analytics
+        #   cdn = Conversant::V3.cdn(12345)
+        #   bandwidth = cdn.partner.analytics.bandwidth(payload)
+        #   storage = cdn.partner.oss.storage_usage(payload)
+        def partner
+          @partner ||= Partner.new(self)
+        end
+
+        # @deprecated Use {#partner} instead
+        # Get partner analytics service instance (deprecated)
+        #
+        # @return [CDN::Partner::Analytics] partner analytics for CDN reporting
+        # @since 1.0.8
+        # @deprecated Use `cdn.partner.analytics` instead of `cdn.partner_analytics`
+        def partner_analytics
+          @partner_analytics ||= Partner::Analytics.new(self)
+        end
+
+        # @deprecated Use {Conversant::V3.oss} instead
+        # Get partner OSS analytics service instance (deprecated)
+        #
+        # @return [Conversant::V3::Services::OSS::Partner::Analytics] partner analytics for OSS storage reporting
+        # @since 1.0.8
+        # @deprecated Use `oss = Conversant::V3.oss(customer_id); oss.partner.analytics` instead of `cdn.partner_oss`
+        def partner_oss
+          @partner_oss ||= Conversant::V3::Services::OSS::Partner::Analytics.new(self)
+        end
+
+        protected
+
+        def call(method, uri, payload = nil)
+          url = "#{configuration.private_cdn_endpoint}#{uri}"
+
+          headers = authorized_headers
+
+          # Check for SESSION in Cookie header
+          if headers['Cookie'].nil? || !headers['Cookie'].include?('SESSION=')
+            logger.error "#{identifier}.METHOD:call.NO_SESSION"
+            raise AuthenticationError, 'Missing SESSION for CDN'
+          end
+
+          code, response = request(method, url, payload, headers)
+
+          if code >= 400
+            logger.error "#{identifier}.METHOD:call.HTTP_ERROR:#{code}"
+            raise ApiError, "CDN API error: #{code}"
+          end
+
+          response.body
+        end
+
+        private
+
+        def fetch_new_session
+          sessions = authenticate
+          return nil unless sessions && sessions[:session] && sessions[:sso_gw_session2]
+
+          signature_url = "#{configuration.private_cdn_endpoint}/partner-dashboard?customerId=#{customer_id}"
+          logger.debug "#{identifier}.METHOD:authorize.REQUESTING_SESSION"
+
+          response = RestClient.get(
+            signature_url,
+            {
+              authority: URI.parse(configuration.private_cdn_endpoint).hostname,
+              referer: portal_endpoint,
+              user_agent: configuration.default_ua,
+              cookies: {
+                'SESSION': sessions[:session],
+                'SSO_GW_SESSION2': sessions[:sso_gw_session2]
+              },
+              timeout: 30,
+              open_timeout: 30
+            }
+          )
+
+          if response.cookies['SESSION']
+            session_cookie = response.cookies['SESSION']
+            redis.set(session_cache_key, session_cookie, ex: configuration.cache_ttl)
+            logger.debug "#{identifier}.METHOD:authorize.SESSION_OBTAINED"
+            session_cookie
+          else
+            logger.error "#{identifier}.METHOD:authorize.NO_SESSION_IN_RESPONSE"
+            nil
+          end
+        rescue RestClient::Unauthorized, RestClient::Forbidden => e
+          logger.error "#{identifier}.METHOD:authorize.AUTH_ERROR:#{e.message}"
+          nil
+        rescue StandardError => e
+          logger.error "#{identifier}.METHOD:authorize.ERROR:#{e.message}"
+          nil
+        end
+
+        protected
+
+        def service_endpoint
+          configuration.private_cdn_endpoint
+        end
+
+        def session_cookie_name
+          'SESSION'
+        end
+
+        def requires_session?
+          true
+        end
+      end
+    end
+  end
+end
+
+# Load nested service classes after CDN is defined
+require_relative 'cdn/analytics'
+require_relative 'cdn/monitoring'
+require_relative 'cdn/audit'
+require_relative 'cdn/dashboard'
+require_relative 'cdn/domain'
+require_relative 'cdn/business'
+require_relative 'cdn/certificate'
+require_relative 'cdn/partner'

data/lib/conversant/v3/services/lms/dashboard.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class LMS
+        class Dashboard
+          attr_reader :parent
+
+          def initialize(parent)
+            @parent = parent
+          end
+
+          def live
+            payload = { _: (Time.now.to_f * 1000).to_i }
+            response = @parent.send(:call, 'GET', "/v4/live/duration?#{payload.to_query}")
+            return nil if response.nil?
+
+            JSON.parse(response)
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          def vod
+            payload = { _: (Time.now.to_f * 1000).to_i }
+            response = @parent.send(:call, 'GET', "/v4/live/duration?#{payload.to_query}")
+            return nil if response.nil?
+
+            JSON.parse(response)
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          def dvr
+            payload = { _: (Time.now.to_f * 1000).to_i }
+            response = @parent.send(:call, 'GET', "/v4/dvr/duration?#{payload.to_query}")
+            return nil if response.nil?
+
+            JSON.parse(response)
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          def recent_jobs
+            response = @parent.send(:call, 'GET', '/dashboard/dashboard')
+            return [] if response.nil?
+
+            # Parse HTML response to extract job data
+            require 'nokogiri' if defined?(Nokogiri)
+            return [] unless defined?(Nokogiri)
+
+            doc = Nokogiri::HTML.parse(response)
+            table = doc.at('table')
+            return [] if table.nil?
+
+            jobs = table.search('tr').map do |row|
+              cells = row.search('td')
+              next [] if cells.length.zero?
+
+              app_name, stream_name, type, created, started, recording, status = cells
+
+              {
+                app_name: app_name&.text&.strip,
+                stream_name: stream_name&.text&.strip,
+                type: type&.text&.strip,
+                created: parse_timestamp(created&.text),
+                started: parse_timestamp(started&.text),
+                recording: recording&.text&.strip,
+                status: status&.text&.strip
+              }
+            end.flatten.compact
+
+            jobs
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            []
+          end
+
+          private
+
+          def parse_timestamp(timestamp_text)
+            return nil unless timestamp_text
+
+            Time.at(timestamp_text.to_i / 1000)
+          rescue StandardError
+            nil
+          end
+
+          def logger
+            @parent.send(:logger)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conversant/v3/services/lms/domain.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class LMS
+        class Domain
+          attr_reader :parent
+
+          def initialize(parent)
+            @parent = parent
+          end
+
+          def all(params = {})
+            default_payload = {
+              sEcho: 1,
+              iColumns: 1,
+              sColumns: nil,
+              iDisplayStart: 0,
+              iDisplayLength: 20,
+              mDataProp_0: 'domain',
+              mDataProp_1: 'app',
+              mDataProp_2: 'stream',
+              mDataProp_3: 'created',
+              mDataProp_4: 'id',
+              iSortingCols: 0,
+              bSortable_0: 'false',
+              bSortable_1: 'false',
+              bSortable_2: 'false',
+              bSortable_3: 'false',
+              bSortable_4: 'false',
+              page_number: 1,
+              page_size: 20,
+              sort_field: nil,
+              sort_type: nil,
+              _: (Time.now.to_f * 1000).to_i
+            }
+
+            merged_payload = default_payload.merge(params)
+            response = @parent.send(:call, 'GET', "/live/domain?#{merged_payload.to_query}")
+            return nil if response.nil?
+
+            response = JSON.parse(response)
+            return nil unless response&.[]('list')
+
+            {
+              current_page_number: response['current_page_number'],
+              has_next: response['has_next'],
+              has_pre: response['has_pre'],
+              total_count: response['total_count'],
+              total_page_number: response['total_page_number'],
+              data: response['list']
+            }
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          def show(domain_id)
+            response = @parent.send(:call, 'GET', "/live/domain/#{domain_id}")
+            return nil if response.nil?
+
+            JSON.parse(response)
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          def create(payload)
+            response = @parent.send(:call, 'POST', '/live/domain', payload)
+            return false if response.nil?
+
+            JSON.parse(response)&.[]('status') == 'ok'
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            false
+          end
+
+          def update(payload)
+            response = @parent.send(:call, 'PUT', '/live/domain', payload)
+            return false if response.nil?
+
+            JSON.parse(response)&.[]('status') == 'ok'
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            false
+          end
+
+          def delete(domain_id)
+            response = @parent.send(:call, 'DELETE', "/live/domain/#{domain_id}")
+            return false if response.nil?
+
+            JSON.parse(response)&.[]('status') == 'ok'
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            false
+          end
+
+          private
+
+          def logger
+            @parent.send(:logger)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conversant/v3/services/lms/job.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class LMS
+        # Job management service for live streaming operations
+        #
+        # Provides comprehensive job management functionality for live streaming including:
+        # - Job listing and filtering
+        # - Job status tracking
+        # - Stream profile information
+        # - Manifest URL generation
+        #
+        # @example Query streaming jobs
+        #   lms = Conversant::V3.lms(12345)
+        #
+        #   # Get all streaming jobs
+        #   jobs = lms.job.where(status: 'streaming')
+        #
+        #   jobs.each do |job|
+        #     puts "Job #{job[:id]}: #{job[:name]} - #{job[:status]}"
+        #     puts "  Manifest: #{job[:manifest]}"
+        #     puts "  Profiles: #{job[:profiles].length}"
+        #   end
+        #
+        # @since 1.0.0
+        class Job
+          # @return [LMS] the parent LMS service instance
+          attr_reader :parent
+
+          # Initialize job service
+          #
+          # @param parent [LMS] the parent LMS service instance
+          def initialize(parent)
+            @parent = parent
+          end
+
+          # Query streaming jobs with filters
+          #
+          # Retrieves a list of streaming jobs matching the specified filters.
+          # Returns detailed information about each job including status, profiles,
+          # and manifest URLs.
+          #
+          # @param params [Hash] query parameters
+          # @option params [String] :status job status filter ('streaming', 'ready', 'interrupted')
+          # @option params [Integer] :limit maximum number of results
+          # @option params [Integer] :offset pagination offset
+          #
+          # @return [Array<Hash>, nil] array of job hashes with details, or nil on error
+          #   Each hash contains:
+          #   - :entity [Integer] OSP entity ID
+          #   - :id [Integer] job ID
+          #   - :app [String] application name
+          #   - :name [String] stream name
+          #   - :status [String] job status ('ready', 'streaming', 'interrupted')
+          #   - :created_at [DateTime] job creation timestamp
+          #   - :started_at [DateTime] job start timestamp
+          #   - :ended_at [DateTime] job end timestamp
+          #   - :client [String] client IP address
+          #   - :encoder [String] encoder IP address
+          #   - :server [String] execution server
+          #   - :manifest [String] manifest URL
+          #   - :profiles [Array<Hash>] array of stream profiles
+          #   - :transcoding [Boolean] transcoding enabled
+          #   - :gpu [Boolean] GPU acceleration enabled
+          #
+          # @example Get streaming jobs
+          #   jobs = lms.job.where(status: 'streaming', limit: 50)
+          #   jobs.each do |job|
+          #     puts "#{job[:name]} (#{job[:status]}) - #{job[:manifest]}"
+          #   end
+          #
+          # @example Get all jobs
+          #   all_jobs = lms.job.where
+          #
+          # @since 1.0.0
+          def where(**params)
+            response = JSON.parse(@parent.send(:call, 'GET', "/v4/streams?#{params.to_query}"))
+            return nil unless response
+
+            items = response['list'] || response[:list] || []
+
+            items.map do |item|
+              status = item['status']&.to_i || item[:status]&.to_i
+              inbound = item['stream_rtmp_inbound'] || item[:stream_rtmp_inbound]
+
+              profiles = (item['stream_rtmp_outbounds'] || item[:stream_rtmp_outbounds])&.map do |stream|
+                {
+                  preset: stream['preset_name'] || stream[:preset_name],
+                  type: stream['type'] || stream[:type],
+                  profile: build_profile_url(inbound, item, stream)
+                }
+              end
+
+              {
+                entity: item['osp_id'] || item[:osp_id],
+                id: item['id'] || item[:id],
+                app: item['app'] || item[:app],
+                name: item['stream'] || item[:stream],
+                status: parse_status(status),
+                created_at: parse_timestamp(item['created'] || item[:created]),
+                started_at: parse_timestamp(item['started'] || item[:started]),
+                ended_at: parse_timestamp(item['ended'] || item[:ended]),
+                client: inbound && (inbound['client_ip'] || inbound[:client_ip]),
+                encoder: extract_encoder(item),
+                server: item['exec_ta'] || item[:exec_ta],
+                manifest: build_manifest_url(inbound, item, profiles),
+                profiles: profiles || [],
+                transcoding: item['transcoding'] || item[:transcoding],
+                gpu: (item['gpu'] || item[:gpu]) == 'gpu'
+              }
+            end
+          rescue StandardError => e
+            @parent.send(:logger).error "LMS::Job.where error: #{e.message}"
+            nil
+          end
+
+          private
+
+          # Parse numeric status code to string
+          #
+          # @param status [Integer] numeric status code
+          # @return [String, Integer] status string or original code if unknown
+          def parse_status(status)
+            case status
+            when 1 then 'ready'
+            when 2 then 'streaming'
+            when 12 then 'interrupted'
+            else status
+            end
+          end
+
+          # Parse Unix timestamp (milliseconds) to DateTime
+          #
+          # @param timestamp [Integer] Unix timestamp in milliseconds
+          # @return [DateTime, nil] parsed DateTime or nil if invalid
+          def parse_timestamp(timestamp)
+            return nil unless timestamp
+
+            Time.at(timestamp.to_i / 1000).to_datetime
+          rescue StandardError
+            nil
+          end
+
+          # Extract encoder IP from stream metadata
+          #
+          # @param item [Hash] job item hash
+          # @return [String] encoder IP address or '-' if not found
+          def extract_encoder(item)
+            metadata = item['stream_metadata'] || item[:stream_metadata]
+            metadata && (metadata['source_ip'] || metadata[:source_ip]) || '-'
+          end
+
+          # Get file extension for stream type
+          #
+          # @param type [String] stream type ('hls', 'dash')
+          # @return [String] file extension with dot
+          def stream_extension(type)
+            case type
+            when 'hls' then '.m3u8'
+            when 'dash' then '.mpd'
+            else ''
+            end
+          end
+
+          # Build profile URL for a stream
+          #
+          # @param inbound [Hash] inbound stream configuration
+          # @param item [Hash] job item hash
+          # @param stream [Hash] stream profile configuration
+          # @return [String, nil] profile URL or nil if inbound is missing
+          def build_profile_url(inbound, item, stream)
+            return nil unless inbound
+
+            domain = inbound['domain'] || inbound[:domain]
+            app = item['app'] || item[:app]
+            stream_name = item['stream'] || item[:stream]
+            preset = stream['preset_name'] || stream[:preset_name]
+            type = stream['type'] || stream[:type]
+
+            "http://#{domain}/#{app}/#{stream_name}-#{preset}#{stream_extension(type)}"
+          end
+
+          # Build manifest URL for a job
+          #
+          # @param inbound [Hash] inbound stream configuration
+          # @param item [Hash] job item hash
+          # @param profiles [Array<Hash>] array of stream profiles
+          # @return [String, nil] manifest URL or nil if inbound is missing
+          def build_manifest_url(inbound, item, profiles)
+            return nil unless inbound
+
+            domain = inbound['domain'] || inbound[:domain]
+            app = item['app'] || item[:app]
+            manifest_name = item['manifest_name'] || item[:manifest_name]
+
+            ext = if profiles&.first
+                    type = profiles.first[:type]
+                    stream_extension(type)
+                  else
+                    ''
+                  end
+
+            "http://#{domain}/#{app}/#{manifest_name}#{ext}"
+          end
+        end
+      end
+    end
+  end
+end