noresponse 8.2.1 → 8.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2de462c63f05c59d55e926053395a45fa2b45c6e10c45aa66f7ade4fc2e0447
-  data.tar.gz: 77ff7a7d0b1b602b1a22b9644746277940a5793f938f27f83571fb7b5660f6c7
+  metadata.gz: 0f9e488e772432bf291e12c927572051286be92d2e7571b8a0d5897d413f1a9f
+  data.tar.gz: 41ce407e0b72b2cb45b757d87ec2f70353cb73f1d563f981865aadd239e3b933
 SHA512:
-  metadata.gz: 3050ce89c6a1388e1f1419752a8cd954a608d02757b22f7d941561d996d3b49dec7a2a4409233e20fa96101ab43d59774b93d9ff9200f29ffaec725ccb29237e
-  data.tar.gz: e8fc417da076ca6bbef8679ca7671392555ed6c89b31dc5ac7164fb2b46af80a46050796101b3b77da5a43ae4e7d1c6cae2e4693bfcb706ea13ce241ad328d9f
+  metadata.gz: 8244940ad0a13006308c976eecd9a5982144d36059373f18101d69c574fca874e1192c16af296d6e15473125fa668c8b02885795d1b4240c3c84e8e3e1cb8461
+  data.tar.gz: b130ae6e02b8d2db706cd843ff6b2ae9552c4d0ec869a3f96431cc76e75247a833adb0f64624f1c3a53ca9b10572cd7146cd4ec8b6f43d25b47eca77be747935

data/lib/no_response/assessments.rb

@@ -1537,6 +1537,299 @@ module NoResponse
       end
     end
 
+    sig {
+      params(
+        request: Models::Shared::AssessmentAggregateRequest,
+        retries: T.nilable(Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::AggregateAssessmentsResponse)
+    }
+    def aggregate(request:, retries: nil, timeout_ms: nil, http_headers: nil)
+      # aggregate - Count assessments by time, decision and reason
+      # Count this environment's assessments created in [from,to) by hour, day or week, grouped by up to two of decision, flow, recommendation, band, reason, lane, country, asn and list_match. Each assessment counts once, by its first answer; late results do not count it again and appear in late_flips. Optional metrics add a score histogram per flow and late account decision changes. from and to start a bucket and cover at most 366 days (31 for hour buckets) inside the retention period. The filters are search's and describe the first answer: send them to search with revision first to list a cell's assessments. Counts hold no identifier, stay when an assessment or account is deleted, and report reasons by code and impact band. No Idempotency-Key.
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/v1/assessments/aggregate"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :request, :json)
+      headers["content-type"] = req_content_type
+      raise StandardError, "request body is required" if data.nil? && form.nil?
+
+      if form && !form.empty?
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, "application/x-www-form-urlencoded")
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+
+      headers["Accept"] = "application/json"
+      headers["user-agent"] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 2.0,
+          initial_interval: 500,
+          max_elapsed_time: 30_000,
+          max_interval: 8000
+        ),
+        retry_connection_errors: true,
+        strategy: "backoff"
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [408, 429, 500, 501, 502, 503, 504, 505]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+      connection = @sdk_configuration.client.dup
+      connection.use(Utils::RetryMiddleware, retry_options)
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: "aggregateAssessments",
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise "no response"
+        end
+      end
+
+      content_type = http_response.headers.fetch("Content-Type", "application/octet-stream")
+      if Utils.match_status_code(http_response.status, ["200"])
+        if Utils.match_content_type(content_type, "application/json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AssessmentAggregate)
+          result = obj
+          response = Models::Operations::AggregateAssessmentsResponse.new(
+            result: result,
+            headers: http_response.headers
+          )
+
+          return response
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["400"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["401"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::AuthenticationError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["403"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PermissionDeniedError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["404"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFoundError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["409"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ConflictError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["429"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RateLimitError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["4XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      elsif Utils.match_status_code(http_response.status, ["5XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      else
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "Unknown status code received"
+        )
+
+      end
+    end
+
     sig {
       params(
         request: Models::Shared::AssessmentSearchRequest,

data/lib/no_response/models/operations/aggregateassessments_response.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class AggregateAssessmentsResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AssessmentAggregate, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AssessmentAggregate).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/aggregateassessments_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::AggregateAssessmentsResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::AggregateAssessmentsResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations.rb

@@ -4,6 +4,7 @@
 module NoResponse
   module Models
     module Operations
+      autoload :AggregateAssessmentsResponse, "no_response/models/operations/aggregateassessments_response.rb"
       autoload :AssociateCredentialRequest, "no_response/models/operations/associatecredential_request.rb"
       autoload :AssociateCredentialResponse, "no_response/models/operations/associatecredential_response.rb"
       autoload :BindProvisionalAccountRequest, "no_response/models/operations/bindprovisionalaccount_request.rb"

data/lib/no_response/models/shared/aggregatebucket.rb

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AggregateBucket
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :start,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("start"), required: true}}
+        )
+        # Assessments first answered whose creation falls in the bucket. With metric count.
+        field(
+          :count,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count")}}
+        )
+        # With metric count and group_by: the bucket's counts of the groups answered, largest group first.
+        field(
+          :groups,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AggregateGroup)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("groups")}}
+        )
+
+        field(
+          :score_histogram,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AggregateScoreCount)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score_histogram")}}
+        )
+
+        field(
+          :late_flips,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::AggregateLateFlip)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("late_flips")}}
+        )
+
+        sig {
+          params(
+            start: ::String,
+            count: T.nilable(::Integer),
+            groups: T.nilable(T::Array[Models::Shared::AggregateGroup]),
+            score_histogram: T.nilable(T::Array[Models::Shared::AggregateScoreCount]),
+            late_flips: T.nilable(T::Array[Models::Shared::AggregateLateFlip])
+          )
+            .void
+        }
+        def initialize(start:, count: nil, groups: nil, score_histogram: nil, late_flips: nil)
+          @start = start
+          @count = count
+          @groups = groups
+          @score_histogram = score_histogram
+          @late_flips = late_flips
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @start == other.start
+          return false unless @count == other.count
+          return false unless @groups == other.groups
+          return false unless @score_histogram == other.score_histogram
+          return false unless @late_flips == other.late_flips
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/aggregatebucket.rbi

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateBucket
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateBucket
+  def start
+  end
+
+  def start=(str_)
+  end
+
+  def count
+  end
+
+  def count=(str_)
+  end
+
+  def groups
+  end
+
+  def groups=(str_)
+  end
+
+  def score_histogram
+  end
+
+  def score_histogram=(str_)
+  end
+
+  def late_flips
+  end
+
+  def late_flips=(str_)
+  end
+end

data/lib/no_response/models/shared/aggregatedimension.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # AggregateDimension - decision, recommendation and band: the first answer's. flow: the assessment's. list_match: the action of the list entry that decided the account when it was first answered. reason: a reason the first answer fired, with its impact band. lane: an evidence lane the first answer listed in incomplete_sources. country and asn: the submitted IP's, from the IP data.
+      class AggregateDimension
+        include ::Crystalline::Enum
+        enums do
+          DECISION = new("decision")
+          FLOW = new("flow")
+          RECOMMENDATION = new("recommendation")
+          BAND = new("band")
+          REASON = new("reason")
+          LANE = new("lane")
+          COUNTRY = new("country")
+          ASN = new("asn")
+          LIST_MATCH = new("list_match")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/aggregatedimension.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AggregateDimension
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AggregateDimension
+end