oci 2.4.7 → 2.5.0

data/lib/oci/{announcements_service/models/notification_followup_details.rb → streaming/models/put_messages_details_entry.rb}

@@ -4,22 +4,23 @@ require 'date'
 
 # rubocop:disable Lint/UnneededCopDisableDirective
 module OCI
-  # Information represents a notification follow-up
-  class AnnouncementsService::Models::NotificationFollowupDetails # rubocop:disable Metrics/LineLength
-    # The follow-up message, a markdown format input
+  # Object that represents a message to emit to a stream.
+  class Streaming::Models::PutMessagesDetailsEntry # rubocop:disable Metrics/LineLength
+    # The key of the message, expressed as a byte array up to 256 bytes in size. Messages with the same key are stored in the same partition.
+    #
     # @return [String]
-    attr_accessor :message
+    attr_accessor :key
 
-    # When the update is made
-    # @return [DateTime]
-    attr_accessor :time_created
+    # **[Required]** The message, expressed as a byte array up to 1 MiB in size.
+    # @return [String]
+    attr_accessor :value
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         # rubocop:disable Style/SymbolLiteral
-        'message': :'message',
-        'time_created': :'timeCreated'
+        'key': :'key',
+        'value': :'value'
         # rubocop:enable Style/SymbolLiteral
       }
     end
@@ -28,8 +29,8 @@ module OCI
     def self.swagger_types
       {
         # rubocop:disable Style/SymbolLiteral
-        'message': :'String',
-        'time_created': :'DateTime'
+        'key': :'String',
+        'value': :'String'
         # rubocop:enable Style/SymbolLiteral
       }
     end
@@ -40,21 +41,17 @@ module OCI
 
     # Initializes the object
     # @param [Hash] attributes Model attributes in the form of hash
-    # @option attributes [String] :message The value to assign to the {#message} property
-    # @option attributes [DateTime] :time_created The value to assign to the {#time_created} property
+    # @option attributes [String] :key The value to assign to the {#key} property
+    # @option attributes [String] :value The value to assign to the {#value} property
     def initialize(attributes = {})
       return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
       attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
 
-      self.message = attributes[:'message'] if attributes[:'message']
-
-      self.time_created = attributes[:'timeCreated'] if attributes[:'timeCreated']
-
-      raise 'You cannot provide both :timeCreated and :time_created' if attributes.key?(:'timeCreated') && attributes.key?(:'time_created')
+      self.key = attributes[:'key'] if attributes[:'key']
 
-      self.time_created = attributes[:'time_created'] if attributes[:'time_created']
+      self.value = attributes[:'value'] if attributes[:'value']
     end
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
     # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
@@ -68,8 +65,8 @@ module OCI
       return true if equal?(other)
 
       self.class == other.class &&
-        message == other.message &&
-        time_created == other.time_created
+        key == other.key &&
+        value == other.value
     end
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/LineLength, Layout/EmptyLines
 
@@ -85,7 +82,7 @@ module OCI
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [message, time_created].hash
+      [key, value].hash
     end
     # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
 

data/lib/oci/streaming/models/put_messages_result.rb

@@ -0,0 +1,165 @@
+# Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+# rubocop:disable Lint/UnneededCopDisableDirective
+module OCI
+  # The response to a {#put_messages put_messages} request. It indicates the number
+  # of failed messages as well as an array of results for successful and failed messages.
+  #
+  class Streaming::Models::PutMessagesResult # rubocop:disable Metrics/LineLength
+    # **[Required]** The number of messages that failed to be added to the stream.
+    # @return [Integer]
+    attr_accessor :failures
+
+    # An array of items representing the result of each message.
+    # The order is guaranteed to be the same as in the `PutMessagesDetails` object.
+    # If a message was successfully appended to the stream, the entry includes the `offset`, `partition`, and `timestamp`.
+    # If a message failed to be appended to the stream, the entry includes the `error` and `errorMessage`.
+    #
+    # @return [Array<OCI::Streaming::Models::PutMessagesResultEntry>]
+    attr_accessor :entries
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'failures': :'failures',
+        'entries': :'entries'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'failures': :'Integer',
+        'entries': :'Array<OCI::Streaming::Models::PutMessagesResultEntry>'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [Integer] :failures The value to assign to the {#failures} property
+    # @option attributes [Array<OCI::Streaming::Models::PutMessagesResultEntry>] :entries The value to assign to the {#entries} property
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.failures = attributes[:'failures'] if attributes[:'failures']
+
+      self.entries = attributes[:'entries'] if attributes[:'entries']
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/LineLength, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        failures == other.failures &&
+        entries == other.entries
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/LineLength, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [failures, entries].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective

data/lib/oci/streaming/models/put_messages_result_entry.rb

@@ -0,0 +1,196 @@
+# Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
+
+require 'date'
+
+# rubocop:disable Lint/UnneededCopDisableDirective
+module OCI
+  # Represents the result of a {#put_messages put_messages} request, whether it was successful or not.
+  # If a message was successfully appended to the stream, the entry includes the `offset`, `partition`, and `timestamp`.
+  # If the message failed to be appended to the stream, the entry includes the `error` and `errorMessage`.
+  #
+  class Streaming::Models::PutMessagesResultEntry # rubocop:disable Metrics/LineLength
+    # The ID of the partition where the message was stored.
+    # @return [String]
+    attr_accessor :partition
+
+    # The offset of the message in the partition.
+    # @return [Integer]
+    attr_accessor :offset
+
+    # The timestamp indicating when the server appended the message to the stream.
+    # @return [DateTime]
+    attr_accessor :timestamp
+
+    # The error code, in case the message was not successfully appended to the stream.
+    # @return [String]
+    attr_accessor :error
+
+    # A human-readable error message associated with the error code.
+    # @return [String]
+    attr_accessor :error_message
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'partition': :'partition',
+        'offset': :'offset',
+        'timestamp': :'timestamp',
+        'error': :'error',
+        'error_message': :'errorMessage'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'partition': :'String',
+        'offset': :'Integer',
+        'timestamp': :'DateTime',
+        'error': :'String',
+        'error_message': :'String'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :partition The value to assign to the {#partition} property
+    # @option attributes [Integer] :offset The value to assign to the {#offset} property
+    # @option attributes [DateTime] :timestamp The value to assign to the {#timestamp} property
+    # @option attributes [String] :error The value to assign to the {#error} property
+    # @option attributes [String] :error_message The value to assign to the {#error_message} property
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.partition = attributes[:'partition'] if attributes[:'partition']
+
+      self.offset = attributes[:'offset'] if attributes[:'offset']
+
+      self.timestamp = attributes[:'timestamp'] if attributes[:'timestamp']
+
+      self.error = attributes[:'error'] if attributes[:'error']
+
+      self.error_message = attributes[:'errorMessage'] if attributes[:'errorMessage']
+
+      raise 'You cannot provide both :errorMessage and :error_message' if attributes.key?(:'errorMessage') && attributes.key?(:'error_message')
+
+      self.error_message = attributes[:'error_message'] if attributes[:'error_message']
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/LineLength, Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/LineLength, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        partition == other.partition &&
+        offset == other.offset &&
+        timestamp == other.timestamp &&
+        error == other.error &&
+        error_message == other.error_message
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/LineLength, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [partition, offset, timestamp, error, error_message].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/LineLength, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective