simplyq 0.8.0rc

data/lib/simplyq/errors.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Simplyq
+  class SimplyqError < StandardError
+    # @return [SimplyqResponse] response object that conveys basic information
+    # about the response that triggered the error
+    attr_accessor :response
+
+    attr_reader :message
+    attr_reader :code
+    attr_reader :error
+    attr_reader :http_status
+    attr_reader :http_headers
+    attr_reader :http_body
+    attr_reader :json_body
+    attr_reader :request_id
+
+    def initialize(message = nil, http_status: nil, http_body: nil,
+                   http_headers: nil, code: nil, error: nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = parse_body
+      @http_headers = http_headers || {}
+      @code = code
+      @request_id = @http_headers["request-id"]
+      @error = error
+    end
+
+    def parse_body
+      return if @http_body.nil?
+
+      @json_body = JSON.parse(@http_body, symbolize_names: true)
+    rescue JSON::ParserError
+      @json_body = nil
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      id_string = @request_id.nil? ? "" : "(Request #{@request_id}) "
+      "#{status_string}#{id_string}#{@message}"
+    end
+  end
+
+  # AuthenticationError is raised when invalid credentials are used to connect
+  # to SimplyQ's servers.
+  class AuthenticationError < SimplyqError
+  end
+
+  # APIConnectionError is raised in the event that the SDK can't connect to
+  # SimplyQ's servers. Reasons vary from a network split to bad TLS certs.
+  class APIConnectionError < SimplyqError
+  end
+
+  # APIError is a general error, that can be raised when other errors are not
+  # appropriate. It can also be used to raise new errors that have been added
+  # to the API but not yet added to the SDK or not in the current version.
+  class APIError < SimplyqError
+  end
+
+  # InvalidRequestError is raised when a request data is found to be invalid.
+  class InvalidRequestError < SimplyqError
+    attr_accessor :param
+    attr_accessor :errors
+
+    def initialize(message, param, http_status: nil, http_body: nil,
+                   http_headers: nil, code: nil, error: nil, errors: [])
+      super(message, http_status: http_status, http_body: http_body,
+                     http_headers: http_headers,
+                     code: code)
+      @param = param
+      @errors = errors
+    end
+  end
+
+  # PaymentRequiredError is raised when your ccount is in bad standing or
+  # exceeded the quota limits on the free plan.
+  # Please go to your account's billing page or reach out to support.
+  class PaymentRequiredError < SimplyqError
+  end
+
+  # RateLimitError is raised when your account is putting too much pressure on
+  # SimplyQ's server. Please back off on request rate, or reach out to support.
+  class RateLimitError < SimplyqError
+  end
+
+  # PermissionError is raised when your account does not have the right
+  # permissions to perform an action.
+  class PermissionError < SimplyqError
+  end
+
+  # SignatureVerificationError is raised when the signature verification for a
+  # webhook fails
+  class SignatureVerificationError < SimplyqError
+  end
+end

data/lib/simplyq/models/application.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Simplyq
+  module Model
+    class Application
+      # Unique identifier for the application
+      attr_accessor :uid
+
+      attr_accessor :name
+
+      attr_accessor :rate_limit
+
+      attr_accessor :created_at
+
+      attr_accessor :updated_at
+
+      attr_accessor :retry_strategy
+
+      def initialize(attributes = {})
+        self.uid = attributes[:uid].to_s if attributes.key?(:uid)
+
+        self.name = attributes[:name] if attributes.key?(:name)
+
+        self.rate_limit = attributes[:rate_limit] if attributes.key?(:rate_limit)
+
+        self.created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self.updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+
+        self.retry_strategy = if attributes.key?(:retry_strategy)
+                                RetryStrategy.from_hash(attributes[:retry_strategy])
+                              else
+                                RetryStrategy.new
+                              end
+      end
+
+      # The model identifier attribute used in list operations
+      #
+      # @return [Symbol]
+      def self.identifier
+        :uid
+      end
+
+      # Serializes the object from a hash
+      #
+      # @param hash [Hash] Hash with the object data
+      # @return [Simplyq::Model::Application]
+      def self.from_hash(hash)
+        return if hash.nil?
+
+        new(hash)
+      end
+
+      # Show invalid properties with the reasons. Usually used together with valid?
+      # @return Array for valid properties with the reasons
+      def validation_errors
+        invalid_properties = []
+        invalid_properties.push('invalid value for "uid", uid cannot be nil.') if @uid.nil?
+
+        if @uid.to_s.length > 255
+          invalid_properties.push('invalid value for "uid", the character length must be smaller than or equal to 255.')
+        end
+
+        if @uid.to_s.empty?
+          invalid_properties.push('invalid value for "uid", the character length must be great than or equal to 1.')
+        end
+
+        pattern = Regexp.new(/^[a-zA-Z0-9\-_.]+$/)
+        invalid_properties.push("invalid value for \"uid\", must conform to the pattern #{pattern}.") if @uid !~ pattern
+
+        invalid_properties.push('invalid value for "name", name cannot be nil.') if @name.nil?
+
+        unless @retry_strategy.valid?
+          invalid_properties.concat(@retry_strategy.validation_errors.map { |x| "retry_strategy.#{x}" })
+        end
+
+        invalid_properties
+      end
+
+      # Check to see if all the properties in the model are valid
+      def valid?
+        validation_errors.empty? && retry_strategy.valid?
+      end
+
+      def [](key)
+        instance_variable_get(:"@#{key}")
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Application)
+
+        uid == other.uid &&
+          name == other.name &&
+          rate_limit == other.rate_limit &&
+          created_at == other.created_at &&
+          updated_at == other.updated_at &&
+          retry_strategy == other.retry_strategy
+      end
+
+      def to_h
+        {
+          uid: uid,
+          name: name,
+          rate_limit: rate_limit,
+          retry_strategy: retry_strategy.to_h,
+          created_at: created_at,
+          updated_at: updated_at
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      class RetryStrategy
+        # The retry strategy type identifies what algorithm will be used
+
+        SUPPORTED_TYPES = [
+          DEFAULT_TYPE = "base_exponential_backoff_with_deadline",
+          "exponential_backoff",
+          "exponential_backoff_with_deadline",
+          "fixed_wait",
+          "fixed_wait_with_deadline"
+        ].freeze
+
+        attr_accessor :type
+
+        attr_accessor :max_retries
+
+        attr_accessor :retry_delay
+
+        attr_accessor :deadline
+
+        def initialize(attributes = {})
+          self.type = DEFAULT_TYPE
+          self.type = attributes[:type] if attributes.key?(:type)
+
+          self.max_retries = attributes[:max_retries] if attributes.key?(:max_retries)
+
+          self.retry_delay = attributes[:retry_delay] if attributes.key?(:retry_delay)
+
+          self.deadline = attributes[:deadline] if attributes.key?(:deadline)
+        end
+
+        def self.from_hash(hash)
+          return if hash.nil?
+
+          new(hash)
+        end
+
+        # Show invalid properties with the reasons. Usually used together with valid?
+        # @return Array for valid properties with the reasons
+        def validation_errors
+          invalid_properties = []
+
+          unless SUPPORTED_TYPES.include?(@type)
+            invalid_properties.push("invalid value for \"type\", must be one of #{SUPPORTED_TYPES.join(", ")}.")
+          end
+
+          invalid_properties
+        end
+
+        # Check to see if all the properties in the model are valid
+        def valid?
+          validation_errors.empty?
+        end
+
+        def [](key)
+          instance_variable_get(:"@#{key}")
+        end
+
+        def ==(other)
+          return false unless other.is_a?(RetryStrategy)
+
+          type == other.type &&
+            max_retries == other.max_retries &&
+            retry_delay == other.retry_delay &&
+            deadline == other.deadline
+        end
+
+        def to_h
+          {
+            type: type,
+            max_retries: max_retries,
+            retry_delay: retry_delay,
+            deadline: deadline
+          }
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/simplyq/models/delivery_attempt.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Simplyq
+  module Model
+    class DeliveryAttempt
+      attr_accessor :id
+
+      attr_accessor :event_id
+
+      attr_accessor :endpoint_id
+
+      # The response of the endpoint when a delivery attempt was made or null if not yet attempted.
+      attr_accessor :response
+
+      # The response code of the endpoint when the event delivery was attempted.
+      attr_accessor :response_status_code
+
+      # The delivery status of the event to the endpoint
+      attr_accessor :status
+
+      # The tigger of the delivery attempt
+      attr_accessor :trigger_type
+
+      # This is the timestamp of when the delivery attempt was made to the endpoint. In case it has not yet been attempted and the status of the delivery attempt is **pending**, then the value of the timestamp will be **null**.
+      attr_accessor :attempted_at
+
+      def initialize(attributes = {})
+        self.id = attributes[:id] if attributes.key?(:id)
+
+        self.event_id = attributes[:event_id] if attributes.key?(:event_id)
+
+        self.endpoint_id = attributes[:endpoint_id] if attributes.key?(:endpoint_id)
+
+        self.response = attributes[:response] if attributes.key?(:response)
+
+        self.response_status_code = attributes[:response_status_code] if attributes.key?(:response_status_code)
+
+        self.status = attributes[:status] if attributes.key?(:status)
+
+        self.trigger_type = attributes[:trigger_type] if attributes.key?(:trigger_type)
+
+        self.attempted_at = attributes[:attempted_at] if attributes.key?(:attempted_at)
+      end
+
+      # The model identifier attribute used in list operations
+      #
+      # @return [Symbol]
+      def self.identifier
+        :id
+      end
+
+      # Serializes the object from a hash
+      #
+      # @param hash [Hash] Hash with the object data
+      # @return [Simplyq::Model::Endpoint]
+      def self.from_hash(hash)
+        return if hash.nil?
+
+        new(hash)
+      end
+
+      # Show invalid properties with the reasons. Usually used together with valid?
+      # @return Array for valid properties with the reasons
+      def validation_errors
+        []
+      end
+
+      # Check if the model is valid
+      # @return true if valid, false otherwise
+      def valid?
+        validation_errors.empty?
+      end
+
+      def [](key)
+        instance_variable_get(:"@#{key}")
+      end
+
+      def ==(other)
+        return false if other.nil?
+
+        self.class == other.class &&
+          id == other.id &&
+          event_id == other.event_id &&
+          endpoint_id == other.endpoint_id &&
+          response == other.response &&
+          response_status_code == other.response_status_code &&
+          status == other.status &&
+          trigger_type == other.trigger_type &&
+          attempted_at == other.attempted_at
+      end
+
+      def to_h
+        {
+          id: id,
+          event_id: event_id,
+          endpoint_id: endpoint_id,
+          response: response,
+          response_status_code: response_status_code,
+          status: status,
+          trigger_type: trigger_type,
+          attempted_at: attempted_at
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/simplyq/models/endpoint.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Simplyq
+  module Model
+    class Endpoint
+      # Unique identifier of the endpoint inside the application.
+      attr_accessor :uid
+
+      attr_accessor :url
+
+      attr_accessor :version
+
+      attr_accessor :description
+
+      attr_accessor :filter_types
+
+      attr_accessor :topics
+
+      attr_accessor :active
+
+      attr_accessor :rate_limit
+
+      attr_accessor :headers
+
+      attr_accessor :secret
+
+      attr_accessor :created_at
+
+      attr_accessor :updated_at
+
+      def initialize(attributes = {})
+        self.uid = attributes[:uid] if attributes.key?(:uid)
+
+        self.url = attributes[:url] if attributes.key?(:url)
+
+        self.version = attributes[:version] if attributes.key?(:version)
+
+        self.description = attributes[:description] if attributes.key?(:description)
+
+        self.filter_types = attributes[:filter_types] if attributes.key?(:filter_types)
+
+        self.topics = attributes[:topics] if attributes.key?(:topics)
+
+        self.active = attributes[:active] if attributes.key?(:active)
+
+        self.rate_limit = attributes[:rate_limit] if attributes.key?(:rate_limit)
+
+        self.headers = if attributes.key?(:headers)
+                         Headers.from_hash(attributes[:headers])
+                       else
+                         Headers.new
+                       end
+
+        self.secret = attributes[:secret] if attributes.key?(:secret)
+
+        self.created_at = attributes[:created_at] if attributes.key?(:created_at)
+
+        self.updated_at = attributes[:updated_at] if attributes.key?(:updated_at)
+      end
+
+      # The model identifier attribute used in list operations
+      #
+      # @return [Symbol]
+      def self.identifier
+        :uid
+      end
+
+      # Serializes the object from a hash
+      #
+      # @param hash [Hash] Hash with the object data
+      # @return [Simplyq::Model::Endpoint]
+      def self.from_hash(hash)
+        return if hash.nil?
+
+        new(hash)
+      end
+
+      # Show invalid properties with the reasons. Usually used together with valid?
+      # @return Array for valid properties with the reasons
+      def validation_errors
+        invalid_properties = []
+        if !@uid.nil? && @uid.to_s.length > 255
+          invalid_properties.push('invalid value for "uid", the character length must be smaller than or equal to 255.')
+        end
+
+        if !@uid.nil? && @uid.to_s.empty?
+          invalid_properties.push('invalid value for "uid", the character length must be great than or equal to 1.')
+        end
+
+        pattern = Regexp.new(/^[a-zA-Z0-9\-_.]+$/)
+        if !@uid.nil? && @uid !~ pattern
+          invalid_properties.push("invalid value for \"uid\", must conform to the pattern #{pattern}.")
+        end
+
+        invalid_properties.push('invalid value for "url", url cannot be nil.') if @url.nil?
+
+        invalid_properties.push('invalid value for "version", version cannot be nil.') if @version.nil?
+
+        if !@topics.nil? && @topics.length > 5
+          invalid_properties.push('invalid value for "topics", number of items must be less than or equal to 5.')
+        end
+
+        if !@topics.nil? && @topics.empty?
+          invalid_properties.push('invalid value for "topics", number of items must be greater than or equal to 1.')
+        end
+
+        if !@rate_limit.nil? && @rate_limit < 1
+          invalid_properties.push('invalid value for "rate_limit", must be greater than or equal to 1.')
+        end
+
+        invalid_properties
+      end
+
+      # Check if the model is valid
+      # @return true if valid, false otherwise
+      def valid?
+        validation_errors.empty?
+      end
+
+      def [](key)
+        instance_variable_get(:"@#{key}")
+      end
+
+      def ==(other)
+        return false if other.nil?
+
+        self.class == other.class &&
+          uid == other.uid &&
+          url == other.url &&
+          version == other.version &&
+          description == other.description &&
+          filter_types == other.filter_types &&
+          topics == other.topics &&
+          active == other.active &&
+          rate_limit == other.rate_limit &&
+          headers == other.headers &&
+          secret == other.secret &&
+          created_at == other.created_at &&
+          updated_at == other.updated_at
+      end
+
+      def to_h
+        {
+          uid: uid,
+          url: url,
+          version: version,
+          description: description,
+          filter_types: filter_types,
+          topics: topics,
+          active: active,
+          rate_limit: rate_limit,
+          headers: headers.to_h,
+          secret: secret,
+          created_at: created_at,
+          updated_at: updated_at
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      class Headers
+        attr_accessor :headers
+
+        attr_accessor :sensitive
+
+        def initialize(attributes = {})
+          self.headers = attributes[:headers] if attributes.key?(:headers)
+
+          self.sensitive = attributes[:sensitive] if attributes.key?(:sensitive)
+        end
+
+        def has_sensitive?
+          !sensitive.nil? && !sensitive.empty?
+        end
+
+        # Serializes the object from a hash
+        #
+        # @param hash [Hash] Hash with the object data
+        # @return [Simplyq::Model::Endpoint::Headers]
+        def self.from_hash(hash)
+          return if hash.nil?
+
+          new(hash)
+        end
+
+        # Show invalid properties with the reasons. Usually used together with valid?
+        #
+        # TODO: Add header object validation
+        #
+        # @return Array for valid properties with the reasons
+        def validation_errors
+          []
+        end
+
+        def valid?
+          validation_errors.empty?
+        end
+
+        def [](key)
+          instance_variable_get(:"@#{key}")
+        end
+
+        def ==(other)
+          return false if other.nil?
+
+          self.class == other.class &&
+            headers == other.headers &&
+            sensitive == other.sensitive
+        end
+
+        def to_h
+          {
+            headers: headers,
+            sensitive: sensitive
+          }
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+      end
+    end
+  end
+end