schematichq 1.4.0

data/lib/schematic/events/client.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    class Client
+      # @param client [Schematic::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # @param request_options [Hash]
+      # @param params [Schematic::Events::Types::CreateEventBatchRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Events::Types::CreateEventBatchResponse]
+      def create_event_batch(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "event-batch",
+          body: Schematic::Events::Types::CreateEventBatchRequestBody.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::CreateEventBatchResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :q
+      # @option params [String, nil] :event_subtypes
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Events::Types::GetEventSummariesResponse]
+      def get_event_summaries(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[q event_subtypes limit offset]
+        query_params = {}
+        query_params["q"] = params[:q] if params.key?(:q)
+        query_params["event_subtypes"] = params[:event_subtypes] if params.key?(:event_subtypes)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+        params.except(*query_param_names)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "event-types",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::GetEventSummariesResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String, nil] :company_id
+      # @option params [String, nil] :event_subtype
+      # @option params [Schematic::Types::EventType, nil] :event_types
+      # @option params [String, nil] :flag_id
+      # @option params [String, nil] :user_id
+      # @option params [Integer, nil] :limit
+      # @option params [Integer, nil] :offset
+      #
+      # @return [Schematic::Events::Types::ListEventsResponse]
+      def list_events(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[company_id event_subtype event_types flag_id user_id limit offset]
+        query_params = {}
+        query_params["company_id"] = params[:company_id] if params.key?(:company_id)
+        query_params["event_subtype"] = params[:event_subtype] if params.key?(:event_subtype)
+        query_params["event_types"] = params[:event_types] if params.key?(:event_types)
+        query_params["flag_id"] = params[:flag_id] if params.key?(:flag_id)
+        query_params["user_id"] = params[:user_id] if params.key?(:user_id)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["offset"] = params[:offset] if params.key?(:offset)
+        params.except(*query_param_names)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "events",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::ListEventsResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Schematic::Types::CreateEventRequestBody]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Events::Types::CreateEventResponse]
+      def create_event(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "events",
+          body: Schematic::Types::CreateEventRequestBody.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::CreateEventResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :event_id
+      #
+      # @return [Schematic::Events::Types::GetEventResponse]
+      def get_event(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "events/#{URI.encode_uri_component(params[:event_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::GetEventResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Schematic::Events::Types::GetSegmentIntegrationStatusResponse]
+      def get_segment_integration_status(request_options: {}, **params)
+        Schematic::Internal::Types::Utils.normalize_keys(params)
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "segment-integration",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Schematic::Events::Types::GetSegmentIntegrationStatusResponse.load(response.body)
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/schematic/events/types/create_event_batch_request_body.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class CreateEventBatchRequestBody < Internal::Types::Model
+        field :events, -> { Internal::Types::Array[Schematic::Types::CreateEventRequestBody] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/create_event_batch_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class CreateEventBatchResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::RawEventBatchResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/create_event_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class CreateEventResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::RawEventResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/get_event_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class GetEventResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::EventDetailResponseData }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/get_event_summaries_params.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      # Input parameters
+      class GetEventSummariesParams < Internal::Types::Model
+        field :event_subtypes, -> { Internal::Types::Array[String] }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+        field :q, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/get_event_summaries_request.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class GetEventSummariesRequest < Internal::Types::Model
+        field :q, -> { String }, optional: true, nullable: false
+        field :event_subtypes, -> { String }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/get_event_summaries_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class GetEventSummariesResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Schematic::Types::EventSummaryResponseData] }, optional: false, nullable: false
+        field :params, -> { Schematic::Events::Types::GetEventSummariesParams }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/get_segment_integration_status_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class GetSegmentIntegrationStatusResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::SegmentStatusResp }, optional: false, nullable: false
+        field :params, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/list_events_params.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      # Input parameters
+      class ListEventsParams < Internal::Types::Model
+        field :company_id, -> { String }, optional: true, nullable: false
+        field :event_subtype, -> { String }, optional: true, nullable: false
+        field :event_types, -> { Internal::Types::Array[Schematic::Types::EventType] }, optional: true, nullable: false
+        field :flag_id, -> { String }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+        field :user_id, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/list_events_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class ListEventsRequest < Internal::Types::Model
+        field :company_id, -> { String }, optional: true, nullable: false
+        field :event_subtype, -> { String }, optional: true, nullable: false
+        field :event_types, -> { Schematic::Types::EventType }, optional: true, nullable: false
+        field :flag_id, -> { String }, optional: true, nullable: false
+        field :user_id, -> { String }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+        field :offset, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/events/types/list_events_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Events
+    module Types
+      class ListEventsResponse < Internal::Types::Model
+        field :data, -> { Internal::Types::Array[Schematic::Types::EventDetailResponseData] }, optional: false, nullable: false
+        field :params, -> { Schematic::Events::Types::ListEventsParams }, optional: false, nullable: false
+      end
+    end
+  end
+end