purecloud 0.18.0 → 0.25.0

data/lib/purecloud/models/facet_filter_item.rb

@@ -74,7 +74,7 @@ module PureCloud
 
     # Custom attribute writer method checking allowed values (enum).
     def operator=(operator)
-      allowed_values = ["IN", "RANGE", "EQUALS", "NOTEQUALS", "LESSTHAN", "LESSTHANEQUALS", "GREATERTHAN", "GREATERTHANEQUALS"]
+      allowed_values = ["IN", "RANGE", "EQUALS", "NOTEQUALS", "LESSTHAN", "LESSTHANEQUALS", "GREATERTHAN", "GREATERTHANEQUALS", "CONTAINS"]
       if operator && !allowed_values.include?(operator)
         fail "invalid value for 'operator', must be one of #{allowed_values}"
       end

data/lib/purecloud/models/flow_body.rb

@@ -23,7 +23,7 @@ module PureCloud
     def self.swagger_types
       {
         :'format' => :'String',
-        :'body' => :'Hash<String, Line_properties>'
+        :'body' => :'Hash<String, inline_response_200>'
         
       }
     end

data/lib/purecloud/models/flow_body_format.rb

@@ -2,21 +2,17 @@ require 'date'
 
 module PureCloud
   class FlowBodyFormat
-    attr_accessor :name
+    attr_accessor :schema_uri
 
     attr_accessor :description
 
-    attr_accessor :schema_uri
-
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'name' => :'name',
+        :'schema_uri' => :'schemaUri',
         
-        :'description' => :'description',
-        
-        :'schema_uri' => :'schemaUri'
+        :'description' => :'description'
         
       }
     end
@@ -24,9 +20,8 @@ module PureCloud
     # Attribute type mapping.
     def self.swagger_types
       {
-        :'name' => :'String',
-        :'description' => :'String',
-        :'schema_uri' => :'String'
+        :'schema_uri' => :'String',
+        :'description' => :'String'
         
       }
     end
@@ -38,27 +33,22 @@ module PureCloud
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
 
       
-      if attributes[:'name']
-        self.name = attributes[:'name']
+      if attributes[:'schemaUri']
+        self.schema_uri = attributes[:'schemaUri']
       end
       
       if attributes[:'description']
         self.description = attributes[:'description']
       end
       
-      if attributes[:'schemaUri']
-        self.schema_uri = attributes[:'schemaUri']
-      end
-      
     end
 
     # Check equality by comparing each attribute.
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          name == o.name &&
-          description == o.description &&
-          schema_uri == o.schema_uri
+          schema_uri == o.schema_uri &&
+          description == o.description
     end
 
     # @see the `==` method
@@ -68,7 +58,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [name, description, schema_uri].hash
+      [schema_uri, description].hash
     end
 
     # build the object from hash

data/lib/purecloud/models/flow_terminate_request.rb

@@ -1,20 +1,15 @@
 require 'date'
 
 module PureCloud
-  # Passed into a terminate command to customize the termination/cancellation action.
+  # Passed into a terminate command to customize the termination action.
   class FlowTerminateRequest
-    # force the termination of a flow.
-    attr_accessor :force
-
-    # Reason for termination.
+    # Reason code for a termination.
     attr_accessor :reason
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'force' => :'force',
-        
         :'reason' => :'reason'
         
       }
@@ -23,7 +18,6 @@ module PureCloud
     # Attribute type mapping.
     def self.swagger_types
       {
-        :'force' => :'BOOLEAN',
         :'reason' => :'String'
         
       }
@@ -36,12 +30,6 @@ module PureCloud
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
 
       
-      if attributes[:'force']
-        self.force = attributes[:'force']
-      else
-        self.force = false
-      end
-      
       if attributes[:'reason']
         self.reason = attributes[:'reason']
       end
@@ -52,7 +40,6 @@ module PureCloud
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          force == o.force &&
           reason == o.reason
     end
 
@@ -63,7 +50,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [force, reason].hash
+      [reason].hash
     end
 
     # build the object from hash

data/lib/purecloud/models/form.rb

@@ -0,0 +1,148 @@
+require 'date'
+
+module PureCloud
+  class Form
+    attr_accessor :controls
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        
+        :'controls' => :'controls'
+        
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'controls' => :'Array<Control>'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'controls']
+        if (value = attributes[:'controls']).is_a?(Array)
+          self.controls = value
+        end
+      end
+      
+    end
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          controls == o.controls
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [controls].hash
+    end
+
+    # build the object from hash
+    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
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = Object.const_get("PureCloud").const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    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

data/lib/purecloud/models/group.rb

@@ -17,6 +17,8 @@ module PureCloud
 
     attr_accessor :group_state
 
+    attr_accessor :version
+
     # The URI for this object
     attr_accessor :self_uri
 
@@ -38,6 +40,8 @@ module PureCloud
         
         :'group_state' => :'groupState',
         
+        :'version' => :'version',
+        
         :'self_uri' => :'selfUri'
         
       }
@@ -53,6 +57,7 @@ module PureCloud
         :'group_type' => :'String',
         :'group_images' => :'GroupImages',
         :'group_state' => :'String',
+        :'version' => :'Float',
         :'self_uri' => :'String'
         
       }
@@ -93,6 +98,10 @@ module PureCloud
         self.group_state = attributes[:'groupState']
       end
       
+      if attributes[:'version']
+        self.version = attributes[:'version']
+      end
+      
       if attributes[:'selfUri']
         self.self_uri = attributes[:'selfUri']
       end
@@ -128,6 +137,7 @@ module PureCloud
           group_type == o.group_type &&
           group_images == o.group_images &&
           group_state == o.group_state &&
+          version == o.version &&
           self_uri == o.self_uri
     end
 
@@ -138,7 +148,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [id, name, description, member_count, group_type, group_images, group_state, self_uri].hash
+      [id, name, description, member_count, group_type, group_images, group_state, version, self_uri].hash
     end
 
     # build the object from hash

data/lib/purecloud/models/health_check_info.rb

@@ -0,0 +1,268 @@
+require 'date'
+
+module PureCloud
+  class HealthCheckInfo
+    # The globally unique identifier for the object.
+    attr_accessor :id
+
+    attr_accessor :name
+
+    # The URI for this object
+    attr_accessor :self_uri
+
+    attr_accessor :build_time
+
+    attr_accessor :build_version
+
+    attr_accessor :build_jdk
+
+    attr_accessor :built_by
+
+    attr_accessor :implementation_build
+
+    attr_accessor :implementation_version
+
+    attr_accessor :status
+
+    attr_accessor :ping_ms
+
+    # Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
+    attr_accessor :date
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        
+        :'id' => :'id',
+        
+        :'name' => :'name',
+        
+        :'self_uri' => :'selfUri',
+        
+        :'build_time' => :'Build-Time',
+        
+        :'build_version' => :'Build-Version',
+        
+        :'build_jdk' => :'Build-Jdk',
+        
+        :'built_by' => :'Built-By',
+        
+        :'implementation_build' => :'Implementation-Build',
+        
+        :'implementation_version' => :'Implementation-Version',
+        
+        :'status' => :'Status',
+        
+        :'ping_ms' => :'Ping-Ms',
+        
+        :'date' => :'Date'
+        
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'id' => :'String',
+        :'name' => :'String',
+        :'self_uri' => :'String',
+        :'build_time' => :'String',
+        :'build_version' => :'String',
+        :'build_jdk' => :'String',
+        :'built_by' => :'String',
+        :'implementation_build' => :'String',
+        :'implementation_version' => :'String',
+        :'status' => :'String',
+        :'ping_ms' => :'Integer',
+        :'date' => :'DateTime'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+      
+      if attributes[:'name']
+        self.name = attributes[:'name']
+      end
+      
+      if attributes[:'selfUri']
+        self.self_uri = attributes[:'selfUri']
+      end
+      
+      if attributes[:'Build-Time']
+        self.build_time = attributes[:'Build-Time']
+      end
+      
+      if attributes[:'Build-Version']
+        self.build_version = attributes[:'Build-Version']
+      end
+      
+      if attributes[:'Build-Jdk']
+        self.build_jdk = attributes[:'Build-Jdk']
+      end
+      
+      if attributes[:'Built-By']
+        self.built_by = attributes[:'Built-By']
+      end
+      
+      if attributes[:'Implementation-Build']
+        self.implementation_build = attributes[:'Implementation-Build']
+      end
+      
+      if attributes[:'Implementation-Version']
+        self.implementation_version = attributes[:'Implementation-Version']
+      end
+      
+      if attributes[:'Status']
+        self.status = attributes[:'Status']
+      end
+      
+      if attributes[:'Ping-Ms']
+        self.ping_ms = attributes[:'Ping-Ms']
+      end
+      
+      if attributes[:'Date']
+        self.date = attributes[:'Date']
+      end
+      
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    def status=(status)
+      allowed_values = ["OK", "CREATED", "ACCEPTED", "NO_CONTENT", "RESET_CONTENT", "PARTIAL_CONTENT", "MOVED_PERMANENTLY", "FOUND", "SEE_OTHER", "NOT_MODIFIED", "USE_PROXY", "TEMPORARY_REDIRECT", "BAD_REQUEST", "UNAUTHORIZED", "PAYMENT_REQUIRED", "FORBIDDEN", "NOT_FOUND", "METHOD_NOT_ALLOWED", "NOT_ACCEPTABLE", "PROXY_AUTHENTICATION_REQUIRED", "REQUEST_TIMEOUT", "CONFLICT", "GONE", "LENGTH_REQUIRED", "PRECONDITION_FAILED", "REQUEST_ENTITY_TOO_LARGE", "REQUEST_URI_TOO_LONG", "UNSUPPORTED_MEDIA_TYPE", "REQUESTED_RANGE_NOT_SATISFIABLE", "EXPECTATION_FAILED", "INTERNAL_SERVER_ERROR", "NOT_IMPLEMENTED", "BAD_GATEWAY", "SERVICE_UNAVAILABLE", "GATEWAY_TIMEOUT", "HTTP_VERSION_NOT_SUPPORTED"]
+      if status && !allowed_values.include?(status)
+        fail "invalid value for 'status', must be one of #{allowed_values}"
+      end
+      @status = status
+    end
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          name == o.name &&
+          self_uri == o.self_uri &&
+          build_time == o.build_time &&
+          build_version == o.build_version &&
+          build_jdk == o.build_jdk &&
+          built_by == o.built_by &&
+          implementation_build == o.implementation_build &&
+          implementation_version == o.implementation_version &&
+          status == o.status &&
+          ping_ms == o.ping_ms &&
+          date == o.date
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [id, name, self_uri, build_time, build_version, build_jdk, built_by, implementation_build, implementation_version, status, ping_ms, date].hash
+    end
+
+    # build the object from hash
+    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
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = Object.const_get("PureCloud").const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    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