rcs 2.0.5 → 2.0.7

data/lib/pinnacle/types/vetting_feedback.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    class VettingFeedback < Internal::Types::Model
+      field :description, -> { String }, optional: false, nullable: false
+      field :display_name, -> { String }, optional: false, nullable: false, api_name: "displayName"
+      field :fields, -> { Internal::Types::Array[String] }, optional: false, nullable: false
+      field :id, -> { String }, optional: false, nullable: false
+    end
+  end
+end

data/lib/pinnacle/types/vetting_history.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    class VettingHistory < Internal::Types::Model
+      field :provider, -> { String }, optional: false, nullable: false
+      field :vetting_class, -> { String }, optional: false, nullable: false, api_name: "vettingClass"
+      field :vetting_date, -> { String }, optional: false, nullable: false, api_name: "vettingDate"
+      field :vetting_score, -> { Integer }, optional: true, nullable: false, api_name: "vettingScore"
+      field :vetting_status, -> { Pinnacle::Types::VettingHistoryVettingStatus }, optional: false, nullable: false, api_name: "vettingStatus"
+    end
+  end
+end

data/lib/pinnacle/types/vetting_history_vetting_status.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    module VettingHistoryVettingStatus
+      extend Pinnacle::Internal::Types::Enum
+
+      ACTIVE = "ACTIVE"
+      FAILED = "FAILED"
+      IN_PROGRESS = "IN_PROGRESS"
+      PENDING = "PENDING"
+    end
+  end
+end

data/lib/pinnacle/types/vetting_results.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    class VettingResults < Internal::Types::Model
+      field :success, -> { Internal::Types::Boolean }, optional: false, nullable: false
+    end
+  end
+end

data/lib/pinnacle/types/webhook_event_enum.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    module WebhookEventEnum
+      extend Pinnacle::Internal::Types::Enum
+
+      MESSAGE_STATUS = "MESSAGE.STATUS"
+      MESSAGE_RECEIVED = "MESSAGE.RECEIVED"
+    end
+  end
+end

data/lib/pinnacle/types/webhook_result.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    # Response containing all webhooks that match the requested identifiers.
+    # Only includes the essential webhook information needed for identification and management.
+    class WebhookResult < Internal::Types::Model
+      field :webhooks, -> { Internal::Types::Array[Pinnacle::Types::Webhooks] }, optional: false, nullable: false
+    end
+  end
+end

data/lib/pinnacle/types/webhooks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    # Webhook configuration that defines where event notifications are sent.
+    class Webhooks < Internal::Types::Model
+      field :endpoint, -> { String }, optional: false, nullable: false
+      field :id, -> { String }, optional: false, nullable: false
+      field :name, -> { String }, optional: false, nullable: false
+    end
+  end
+end

data/lib/pinnacle/types/zod_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Types
+    class ZodError < Internal::Types::Model
+      field :description, -> { String }, optional: false, nullable: false
+      field :errors, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
+    end
+  end
+end

data/lib/pinnacle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  VERSION = "2.0.7"
+end

data/lib/pinnacle/webhooks/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Webhooks
+    class Client
+      # @param client [Pinnacle::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieve all webhook that are set up to receive events for specific URLs or phone numbers.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinnacle::Webhooks::Types::GetWebhookParams]
+      # @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 [Pinnacle::Types::WebhookResult]
+      def get(request_options: {}, **params)
+        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
+        body_prop_names = %i[identifiers]
+        body_bag = params.slice(*body_prop_names)
+
+        request = Pinnacle::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "webhooks",
+          body: Pinnacle::Webhooks::Types::GetWebhookParams.new(body_bag).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinnacle::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinnacle::Types::WebhookResult.load(response.body)
+        else
+          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/webhooks/types/get_webhook_params.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Webhooks
+    module Types
+      class GetWebhookParams < Internal::Types::Model
+        field :identifiers, -> { Internal::Types::Array[String] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/pinnacle/wrapper/messages/client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pinnacle
+  module Wrapper
+    module Messages
+      class Client < Pinnacle::Messages::Client
+        # Process incoming webhook request with signature validation.
+        #
+        # @example Process a webhook request
+        #   client = Pinnacle::Client.new(api_key: "your-api-key")
+        #   request = {
+        #     headers: { "PINNACLE-SIGNING-SECRET" => "your-secret" },
+        #     body: '{"type": "MESSAGE.RECEIVED", ...}'
+        #   }
+        #   event = client.messages.process(request)
+        #
+        # @param request [Hash] Request with :headers and :body keys
+        # @param secret [String, nil] Webhook secret (falls back to PINNACLE_SIGNING_SECRET env var)
+        #
+        # @return [Pinnacle::Types::MessageEvent, Pinnacle::Types::UserEvent]
+        # @raise [Pinnacle::Errors::UnauthorizedError] If webhook signature is invalid or missing
+        # @raise [Pinnacle::Errors::ClientError] If request body cannot be parsed
+        def process(request, secret: nil)
+          headers = request[:headers] || request["headers"] || {}
+          body = request[:body] || request["body"]
+
+          header_secret = headers["PINNACLE-SIGNING-SECRET"] ||
+                          headers["pinnacle-signing-secret"] ||
+                          headers["Pinnacle-Signing-Secret"]
+
+          env_secret = secret || ENV.fetch("PINNACLE_SIGNING_SECRET", nil)
+
+          if header_secret.nil?
+            raise Pinnacle::Errors::UnauthorizedError.new(
+              "Failed to get PINNACLE-SIGNING-SECRET header from request",
+              code: 401
+            )
+          end
+
+          if env_secret.nil?
+            raise Pinnacle::Errors::UnauthorizedError.new(
+              "Set PINNACLE_SIGNING_SECRET env var or pass secret argument",
+              code: 401
+            )
+          end
+
+          if header_secret != env_secret
+            raise Pinnacle::Errors::UnauthorizedError.new(
+              "Invalid webhook signature",
+              code: 401
+            )
+          end
+
+          parsed = body.is_a?(String) ? JSON.parse(body) : body
+
+          if parsed["type"] == "USER.TYPING"
+            Pinnacle::Types::UserEvent.coerce(parsed)
+          else
+            Pinnacle::Types::MessageEvent.coerce(parsed)
+          end
+        rescue JSON::ParserError => e
+          raise Pinnacle::Errors::ClientError.new(
+            "Invalid message event format: #{e.message}",
+            code: 400
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/wrapper/tools/client.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pinnacle
+  module Wrapper
+    module Tools
+      class Client < Pinnacle::Tools::Client
+        # @return [Pinnacle::Wrapper::Tools::FileUploader]
+        def file
+          @file ||= Pinnacle::Wrapper::Tools::FileUploader.new(client: @client)
+        end
+      end
+    end
+  end
+end

data/lib/pinnacle/wrapper/tools/file_uploader.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Pinnacle
+  module Wrapper
+    module Tools
+      class FileUploader < Pinnacle::Tools::File::Client
+        SUPPORTED_MIME_TYPES = Set.new(
+          [
+            "audio/mpeg", "audio/mp4", "audio/ogg", "audio/aac",
+            "audio/webm", "audio/wav", "audio/3gpp", "audio/amr",
+            "video/mp4", "video/mpeg", "video/quicktime", "video/webm",
+            "video/3gpp", "video/H264", "video/x-m4v",
+            "image/jpeg", "image/png", "image/gif", "image/bmp",
+            "image/tiff", "image/webp",
+            "application/pdf", "text/csv", "application/rtf",
+            "text/vcard", "text/calendar"
+          ]
+        ).freeze
+
+        MIME_TYPES = {
+          ".mp3" => "audio/mpeg",
+          ".mp4" => "video/mp4",
+          ".ogg" => "audio/ogg",
+          ".aac" => "audio/aac",
+          ".webm" => "video/webm",
+          ".wav" => "audio/wav",
+          ".3gp" => "video/3gpp",
+          ".3gpp" => "video/3gpp",
+          ".amr" => "audio/amr",
+          ".mpeg" => "video/mpeg",
+          ".mpg" => "video/mpeg",
+          ".mov" => "video/quicktime",
+          ".m4v" => "video/x-m4v",
+          ".jpg" => "image/jpeg",
+          ".jpeg" => "image/jpeg",
+          ".png" => "image/png",
+          ".gif" => "image/gif",
+          ".bmp" => "image/bmp",
+          ".tiff" => "image/tiff",
+          ".tif" => "image/tiff",
+          ".webp" => "image/webp",
+          ".pdf" => "application/pdf",
+          ".csv" => "text/csv",
+          ".rtf" => "application/rtf",
+          ".vcf" => "text/vcard",
+          ".vcard" => "text/vcard",
+          ".ics" => "text/calendar"
+        }.freeze
+
+        # Upload a file from local filesystem.
+        #
+        # @example Upload a file
+        #   client = Pinnacle::Client.new(api_key: "your-api-key")
+        #   url = client.tools.file.upload_from_path("/path/to/image.png")
+        #   puts url # => "https://..."
+        #
+        # @example Upload with custom name
+        #   url = client.tools.file.upload_from_path(
+        #     "/path/to/image.png",
+        #     name: "my-custom-name.png"
+        #   )
+        #
+        # @param file_path [String] Path to the file
+        # @param name [String, nil] Override filename
+        # @param options [Hash, nil] Upload options
+        # @param request_options [Hash] Additional request options
+        #
+        # @return [String] Download URL
+        # @raise [Pinnacle::Errors::NotFoundError] If file not found
+        # @raise [Pinnacle::Errors::ClientError] If path is a directory
+        # @raise [Pinnacle::Errors::ServerError] If upload fails
+        def upload_from_path(file_path, name: nil, options: nil, request_options: {})
+          unless ::File.exist?(file_path)
+            raise Pinnacle::Errors::NotFoundError.new(
+              "File not found: #{file_path}",
+              code: 404
+            )
+          end
+
+          if ::File.directory?(file_path)
+            raise Pinnacle::Errors::ClientError.new(
+              "Path is a directory, not a file: #{file_path}",
+              code: 400
+            )
+          end
+
+          size = ::File.size(file_path)
+          file_name = name || ::File.basename(file_path)
+          content_type = get_mime_type(file_path)
+
+          upload_result = upload(
+            content_type: content_type,
+            size: size,
+            name: file_name,
+            options: options,
+            request_options: request_options
+          )
+
+          if upload_result.upload_url
+            uri = URI.parse(upload_result.upload_url)
+            file_content = ::File.binread(file_path)
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == "https"
+
+            request = Net::HTTP::Put.new(uri.request_uri)
+            request["Content-Type"] = content_type
+            request.body = file_content
+
+            response = http.request(request)
+
+            unless response.is_a?(Net::HTTPSuccess)
+              raise Pinnacle::Errors::ServerError.new(
+                "Failed to upload file: #{response.code}",
+                code: response.code.to_i
+              )
+            end
+          end
+
+          upload_result.download_url
+        end
+
+        private
+
+        def get_mime_type(file_path)
+          ext = ::File.extname(file_path).downcase
+          mime_type = MIME_TYPES[ext]
+
+          return "application/octet-stream" unless mime_type
+
+          if SUPPORTED_MIME_TYPES.include?(mime_type)
+            mime_type
+          else
+            base_type = mime_type.split("/").first
+            if %w[audio video image].include?(base_type)
+              warn "MIME type #{mime_type} may not be fully supported. Proceeding anyway."
+              mime_type
+            else
+              "application/octet-stream"
+            end
+          end
+        end
+      end
+    end
+  end
+end