conversant 1.0.16

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class CDN
+        # Domain management service for CDN domains
+        #
+        # Provides comprehensive domain management functionality including:
+        # - Domain listing and filtering
+        # - Domain creation and configuration
+        # - Domain lookup and search
+        # - Storage usage calculations
+        #
+        # @example Basic domain operations
+        #   domains = cdn.domain.all
+        #   domain = cdn.domain.find(123)
+        #   domain = cdn.domain.find_by(name: 'example.com')
+        #
+        #   # Create new domain
+        #   domain_id = cdn.domain.create({
+        #     businessScenarioType: 1,
+        #     name: "cdn.example.com",
+        #     origins: [{ url_prefix: "1.2.3.4" }],
+        #     redirect_http_to_https: true,
+        #     http2_enabled: true
+        #   })
+        #
+        # @since 1.0.1
+        class Domain
+          # @return [CDN] the parent CDN service instance
+          attr_reader :parent
+
+          # Initialize domain service
+          #
+          # @param parent [CDN] the parent CDN service instance
+          def initialize(parent)
+            @parent = parent
+          end
+
+          # Get all domains for the customer
+          #
+          # Retrieves all domains associated with the customer account.
+          # Results are cached in Redis for 10 minutes to improve performance.
+          #
+          # @return [Array<OpenStruct>, Array] array of domain objects with properties like id, name, status, etc.
+          #   Returns empty array on error or if no domains exist.
+          #
+          # @example Get all domains
+          #   domains = cdn.domain.all
+          #   domains.each do |domain|
+          #     puts "#{domain.name} (ID: #{domain.id}) - Status: #{domain.status}"
+          #     puts "  Business Type: #{domain.businessScenarioType}"
+          #     puts "  Current Usage: #{domain.current_disk_usage} bytes"
+          #   end
+          #
+          # @since 1.0.1
+          def all
+            key = "customer.#{@parent.customer_id}.domain.all"
+            domains = redis.get(key)
+
+            if domains.nil?
+              response = @parent.send(:call, 'GET', '/api/delivery_domains?pageSize=-1&pageNumber=-1')
+              return [] if response.nil?
+
+              response = JSON.parse(response)
+              if response&.[]('list')
+                domains = response['list'].to_json
+                redis.set(key, domains, ex: 600)
+              else
+                return []
+              end
+            end
+
+            JSON.parse(domains).map do |item|
+              OpenStruct.new(item.merge(customer_id: @parent.customer_id))
+            end
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            []
+          end
+
+          # Find domain by ID
+          #
+          # @param domain_id [Integer, String] the domain ID to search for
+          #
+          # @return [OpenStruct, nil] domain object if found, nil otherwise
+          #
+          # @example Find domain by ID
+          #   domain = cdn.domain.find(12345)
+          #   if domain
+          #     puts "Found domain: #{domain.name}"
+          #     puts "Status: #{domain.status}"
+          #   else
+          #     puts "Domain not found"
+          #   end
+          #
+          # @since 1.0.1
+          def find(domain_id)
+            all.find { |domain| domain.id == domain_id }
+          end
+
+          # Find domain by attributes
+          #
+          # @param params [Hash] search parameters
+          # @option params [String] :name domain name to search for
+          #
+          # @return [OpenStruct, nil] first domain matching the criteria, nil if not found
+          #
+          # @example Find domain by name
+          #   domain = cdn.domain.find_by(name: 'cdn.example.com')
+          #   if domain
+          #     puts "Found domain with ID: #{domain.id}"
+          #   end
+          #
+          # @since 1.0.1
+          def find_by(params)
+            all.find { |domain| domain.name == params[:name] }
+          end
+
+          # Create a new CDN domain
+          #
+          # Creates a new CDN domain with the specified configuration.
+          # Automatically clears the domain cache upon successful creation.
+          #
+          # @param payload [Hash] domain configuration
+          # @option payload [Integer] :businessScenarioType business scenario (1=CDN, 2=Storage)
+          # @option payload [String] :name domain name (e.g., "cdn.example.com")
+          # @option payload [String] :lfdName load balancer domain name (optional)
+          # @option payload [String] :origin_url origin server URL (optional)
+          # @option payload [String] :origin_proto origin protocol (optional)
+          # @option payload [Boolean] :redirect_http_to_https enable HTTP to HTTPS redirect
+          # @option payload [Boolean] :http2_enabled enable HTTP/2 support
+          # @option payload [Boolean] :streaming_service enable streaming capabilities
+          # @option payload [Boolean] :disabled initial disabled state
+          # @option payload [Boolean] :hwc_enabled enable hardware acceleration
+          # @option payload [Array] :multiCDN multi-CDN configuration
+          # @option payload [Array<Hash>] :origins array of origin servers
+          # @option payload [String] :ftpPassword FTP password (for storage domains)
+          # @option payload [String] :ftpPasswordRepeat FTP password confirmation
+          #
+          # @return [Integer, nil] the new domain ID if successful, nil on error
+          #
+          # @example Create a CDN domain
+          #   domain_id = cdn.domain.create({
+          #     businessScenarioType: 1,
+          #     name: "cdn.example.com",
+          #     origins: [{ url_prefix: "203.0.113.10" }],
+          #     redirect_http_to_https: true,
+          #     http2_enabled: true,
+          #     streaming_service: false,
+          #     disabled: false,
+          #     hwc_enabled: false,
+          #     multiCDN: []
+          #   })
+          #
+          #   if domain_id
+          #     puts "Domain created with ID: #{domain_id}"
+          #   else
+          #     puts "Failed to create domain"
+          #   end
+          #
+          # @example Create a storage domain
+          #   domain_id = cdn.domain.create({
+          #     businessScenarioType: 2,
+          #     name: "storage.example.com",
+          #     ftpPassword: "secure_password",
+          #     ftpPasswordRepeat: "secure_password",
+          #     origins: [{ url_prefix: "203.0.113.20" }]
+          #   })
+          #
+          # @since 1.0.1
+          def create(payload)
+            response = @parent.send(:call, 'POST', '/api/v6/delivery_domain', payload)
+            return nil if response.nil?
+
+            response = JSON.parse(response)
+            return nil unless response.to_i.positive?
+
+            # Clear cache after creation
+            redis.del("customer.#{@parent.customer_id}.domain.all")
+            response
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            nil
+          end
+
+          # Calculate total disk usage for storage domains
+          #
+          # Calculates the total current disk usage across all active storage domains
+          # (businessScenarioType=2, status=1) for the customer.
+          #
+          # @return [Integer] total disk usage in bytes, 0 if no storage domains or on error
+          #
+          # @example Get total storage usage
+          #   total_bytes = cdn.domain.total_current_disk_usage
+          #   total_gb = total_bytes / (1024 ** 3)
+          #   puts "Total storage usage: #{total_gb} GB"
+          #
+          # @since 1.0.1
+          def total_current_disk_usage
+            all.select do |item|
+              item.businessScenarioType == 2 && item.status == 1
+            end.map(&:current_disk_usage).sum
+          rescue StandardError => e
+            logger.error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            0
+          end
+
+          private
+
+          def redis
+            @parent.send(:redis)
+          end
+
+          def logger
+            @parent.send(:logger)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class CDN
+        # Monitoring service for CDN performance tracking
+        #
+        # Provides real-time monitoring data and performance metrics
+        # for CDN infrastructure and service health.
+        #
+        # @example Monitor CDN health
+        #   cdn = Conversant::V3.cdn(12345)
+        #
+        #   spots = cdn.monitoring.spots({
+        #     startTime: "2025-01-01T00:00:00Z",
+        #     endTime: "2025-01-01T01:00:00Z",
+        #     domains: ["example.com"]
+        #   })
+        #
+        #   spots.each do |spot|
+        #     puts "#{spot['location']}: #{spot['status']}"
+        #   end
+        #
+        # @since 1.0.0
+        class Monitoring
+          # @return [CDN] the parent CDN service instance
+          attr_reader :parent
+
+          # Initialize monitoring service
+          #
+          # @param parent [CDN] the parent CDN service instance
+          def initialize(parent)
+            @parent = parent
+          end
+
+          # Get monitoring spot data
+          #
+          # @param payload [Hash] monitoring parameters
+          # @option payload [String] :startTime start time in ISO 8601 format
+          # @option payload [String] :endTime end time in ISO 8601 format
+          # @option payload [Array<String>] :domains array of domains to monitor
+          #
+          # @return [Array] array of monitoring spots data, or empty array on error
+          #
+          # @example Get monitoring data
+          #   spots = cdn.monitoring.spots({
+          #     startTime: "2025-01-01T00:00:00Z",
+          #     endTime: "2025-01-01T01:00:00Z",
+          #     domains: ["example.com"]
+          #   })
+          #   spots.each { |spot| puts "#{spot['location']}: #{spot['status']}" }
+          #
+          # @since 1.0.0
+          def spots(payload)
+            JSON.parse(@parent.send(:call, 'POST', '/api/monitoring', payload))&.[]('spots') || []
+          rescue StandardError => e
+            @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class CDN
+        class Partner
+          # CDN analytics service for partner-level reporting
+          #
+          # Provides partner-level analytics and reporting for CDN services including
+          # bandwidth, volume, traffic usage, storage, and viewer metrics across
+          # multiple customer accounts.
+          #
+          # @example Usage
+          #   cdn = Conversant::V3.cdn(customer_id)
+          #   analytics = cdn.partner.analytics
+          #
+          #   # Get bandwidth metrics
+          #   bandwidth_data = analytics.bandwidth({
+          #     startTime: '2024-01-01T00:00:00Z',
+          #     endTime: '2024-01-31T23:59:59Z',
+          #     interval: 'day'
+          #   })
+          #
+          # @since 1.0.12
+          class Analytics
+            # @return [Conversant::V3::Services::CDN] the parent CDN service instance
+            attr_reader :parent
+
+            # Initialize partner CDN analytics service
+            #
+            # @param parent [Conversant::V3::Services::CDN] the parent CDN service instance
+            def initialize(parent)
+              @parent = parent
+            end
+
+            # Get partner-level bandwidth metrics
+            #
+            # Retrieves aggregated bandwidth usage across all customer accounts
+            # for the partner within the specified time range.
+            #
+            # @param payload [Hash] bandwidth query parameters
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [String] :interval time interval (e.g., "hour", "day", "month")
+            #
+            # @return [Hash] bandwidth data with timestamps and values, or nil on error
+            # @since 1.0.8
+            #
+            # @example Get daily bandwidth for January 2024
+            #   analytics.bandwidth({
+            #     startTime: '2024-01-01T00:00:00Z',
+            #     endTime: '2024-01-31T23:59:59Z',
+            #     interval: 'day'
+            #   })
+            def bandwidth(payload)
+              response = @parent.send(:call, 'POST', '/api/report/bandwidth/partner', payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get partner-level volume metrics
+            #
+            # @param payload [Hash] volume query parameters
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [String] :interval time interval
+            #
+            # @return [Hash] volume data, or nil on error
+            # @since 1.0.8
+            def volume(payload)
+              response = @parent.send(:call, 'POST', '/api/report/volume/partner', payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get partner-level request per second metrics
+            #
+            # @param params [Hash] query parameters
+            #
+            # @return [Hash] RPS data, or nil on error
+            # @since 1.0.8
+            def request_per_second(params)
+              query_string = params.map { |k, v| "#{k}=#{v}" }.join('&')
+              response = @parent.send(:call, 'GET', "/api/rps_chart_data/partner?#{query_string}")
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get domain traffic usage for billing purposes
+            #
+            # @param payload [Hash] usage query parameters
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [Integer] :pageSize number of results per page
+            # @option payload [Integer] :pageNumber page number (0-based)
+            #
+            # @return [Hash] traffic usage data, or nil on error
+            # @since 1.0.8
+            def domain_traffic_usage(payload)
+              response = @parent.send(:call, 'POST', '/api/domain_traffic_usage', payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get partner-level viewer metrics
+            #
+            # @param payload [Hash] viewer query parameters
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [String] :interval time interval
+            #
+            # @return [Hash] viewer data, or nil on error
+            # @since 1.0.8
+            def viewers(payload)
+              response = @parent.send(:call, 'POST', '/api/report/viewers/partner', payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get storage usage for a customer
+            #
+            # Retrieves the disk usage for the current month or specified month.
+            # If no end date is provided in the payload, it defaults to the current date.
+            #
+            # @param payload [Hash, nil] query parameters (optional)
+            # @option payload [String, Date] :end end date to determine year/month (defaults to current date)
+            #
+            # @return [Integer] disk usage in bytes for the specified month, or 0 on error
+            # @since 1.0.8
+            #
+            # @example Get current month's storage usage
+            #   analytics.usages(nil)
+            #   # => 1024000
+            #
+            # @example Get specific month's storage usage
+            #   analytics.usages({ end: '2024-03-15' })
+            #   # => 2048000
+            def usages(payload)
+              payload = payload&.as_json
+              today = (payload&.[]('end') || Date.current).to_date
+
+              # puts @parent.inspect
+
+              response = @parent.send(:call, 'GET', "/api/customers/#{@parent.customer_id}/storage_usages/#{today.year}")
+              JSON.parse(response)&.find do |item|
+                item&.[]('month') == today.month
+              end&.[]('diskUsage') || 0
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              0
+            end
+
+            # Get volume metrics for a specific domain
+            #
+            # @param payload [Hash] volume query parameters
+            # @option payload [String] :domain domain name
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [String] :interval time interval (e.g., "day")
+            # @option payload [Boolean] :fillFixedTime fill missing time slots
+            #
+            # @return [Hash] volume data for domain, or nil on error
+            # @since 1.0.8
+            def domain_volume(payload)
+              response = @parent.send(:call, 'POST', '/api/report/volume', payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get HTTP status codes for specific domains
+            #
+            # Retrieves HTTP status code distribution for specified domains,
+            # useful for monitoring error rates and response codes.
+            #
+            # @param customer_id [String, Integer] customer ID
+            # @param payload [Hash] HTTP codes query parameters
+            # @option payload [Array<String>] :domains array of domain names
+            # @option payload [String] :startTime start time in ISO 8601 format
+            # @option payload [String] :endTime end time in ISO 8601 format
+            # @option payload [String] :interval time interval (e.g., "hour", "day")
+            # @option payload [String] :daHostName specific hostname filter (optional)
+            #
+            # @return [Hash] HTTP codes data grouped by status code, or nil on error
+            # @since 1.0.8
+            #
+            # @example Get HTTP codes for specific domains
+            #   analytics.domain_http_codes(123, {
+            #     domains: ['cdn.example.com', 'static.example.com'],
+            #     startTime: '2024-01-01T00:00:00Z',
+            #     endTime: '2024-01-02T00:00:00Z',
+            #     interval: 'hour'
+            #   })
+            def domain_http_codes(customer_id, payload)
+              response = @parent.send(:call, 'POST', "/api/report/customers/#{customer_id}/http_codes", payload)
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+
+            # Get request per second for specific domain
+            #
+            # @param params [Hash] query parameters
+            #
+            # @return [Hash] RPS data for domain, or nil on error
+            # @since 1.0.8
+            def domain_rps(params)
+              query_string = params.map { |k, v| "#{k}=#{v}" }.join('&')
+              response = @parent.send(:call, 'GET', "/api/rps_chart_data?#{query_string}")
+              JSON.parse(response)
+            rescue StandardError => e
+              @parent.send(:logger).error "#{@parent.send(:identifier)}.METHOD:#{__method__}.EXCEPTION:#{e.message}"
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Conversant
+  module V3
+    module Services
+      class CDN
+        # Partner service for CDN partner-level operations
+        #
+        # Provides access to partner-level analytics for CDN services
+        # that aggregate data across multiple customer accounts.
+        #
+        # @example Access partner analytics
+        #   cdn = Conversant::V3.cdn(12345)
+        #
+        #   # Partner-level CDN analytics
+        #   bandwidth = cdn.partner.analytics.bandwidth({
+        #     startTime: "2025-01-01T00:00:00Z",
+        #     endTime: "2025-01-31T23:59:59Z"
+        #   })
+        #
+        # @since 1.0.12
+        class Partner
+          # @return [CDN] the parent CDN service instance
+          attr_reader :parent
+
+          # Initialize partner service
+          #
+          # @param parent [CDN] the parent CDN service instance
+          def initialize(parent)
+            @parent = parent
+          end
+
+          # Get partner analytics service instance
+          #
+          # Provides partner-level analytics for CDN services including bandwidth,
+          # volume, traffic usage, and viewer metrics across multiple customers.
+          #
+          # @return [Analytics] CDN partner analytics service
+          # @since 1.0.12
+          def analytics
+            @analytics ||= Analytics.new(@parent)
+          end
+
+          # @deprecated Use {Conversant::V3.oss} instead
+          # Get partner OSS analytics service instance (deprecated)
+          #
+          # @return [Conversant::V3::Services::OSS::Partner::Analytics] OSS partner analytics service
+          # @since 1.0.12
+          # @deprecated Use `oss = Conversant::V3.oss(customer_id); oss.partner.analytics` instead of `cdn.partner.oss`
+          def oss
+            @oss ||= Conversant::V3::Services::OSS::Partner::Analytics.new(@parent)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Load nested analytics class after Partner is defined
+require_relative 'partner/analytics'