purecloud 0.27.0 → 0.28.0

data/lib/purecloud/models/aggregate_metric_data.rb

@@ -0,0 +1,175 @@
+require 'date'
+
+module PureCloud
+  class AggregateMetricData
+    attr_accessor :metric
+
+    attr_accessor :qualifier
+
+    attr_accessor :stats
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        
+        :'metric' => :'metric',
+        
+        :'qualifier' => :'qualifier',
+        
+        :'stats' => :'stats'
+        
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'metric' => :'String',
+        :'qualifier' => :'String',
+        :'stats' => :'StatisticalSummary'
+        
+      }
+    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[:'metric']
+        self.metric = attributes[:'metric']
+      end
+      
+      if attributes[:'qualifier']
+        self.qualifier = attributes[:'qualifier']
+      end
+      
+      if attributes[:'stats']
+        self.stats = attributes[:'stats']
+      end
+      
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    def metric=(metric)
+      allowed_values = ["tSegmentDuration", "oTotalCriticalScore", "oTotalScore", "nEvaluations", "tAbandon", "tIvr", "tAnswered", "tAcd", "tTalk", "tHeld", "tTalkComplete", "tHeldComplete", "tAcw", "tHandle", "tWait", "tAgentRoutingStatus", "tOrganizationPresence", "tSystemPresence", "tUserResponseTime", "tAgentResponseTime", "nOffered", "nOverSla", "nTransferred", "nDialerAttempted", "nDialerConnected", "nDialerAbandoned", "nError", "oServiceTarget", "oServiceLevel", "tActive", "tInactive", "oActiveUsers", "oMemberUsers", "oActiveQueues", "oMemberQueues", "oInteracting", "oWaiting"]
+      if metric && !allowed_values.include?(metric)
+        fail "invalid value for 'metric', must be one of #{allowed_values}"
+      end
+      @metric = metric
+    end
+
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          metric == o.metric &&
+          qualifier == o.qualifier &&
+          stats == o.stats
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [metric, qualifier, stats].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/{session_request.rb → aggregate_query_response.rb}

@@ -1,14 +1,14 @@
 require 'date'
 
 module PureCloud
-  class SessionRequest
-    attr_accessor :minutes_to_live
+  class AggregateQueryResponse
+    attr_accessor :results
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'minutes_to_live' => :'minutesToLive'
+        :'results' => :'results'
         
       }
     end
@@ -16,7 +16,7 @@ module PureCloud
     # Attribute type mapping.
     def self.swagger_types
       {
-        :'minutes_to_live' => :'Integer'
+        :'results' => :'Array<AggregateDataContainer>'
         
       }
     end
@@ -28,8 +28,10 @@ module PureCloud
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
 
       
-      if attributes[:'minutesToLive']
-        self.minutes_to_live = attributes[:'minutesToLive']
+      if attributes[:'results']
+        if (value = attributes[:'results']).is_a?(Array)
+          self.results = value
+        end
       end
       
     end
@@ -38,7 +40,7 @@ module PureCloud
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          minutes_to_live == o.minutes_to_live
+          results == o.results
     end
 
     # @see the `==` method
@@ -48,7 +50,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [minutes_to_live].hash
+      [results].hash
     end
 
     # build the object from hash

data/lib/purecloud/models/{domain_license_entity_listing.rb → aggregation_query.rb}

@@ -1,50 +1,40 @@
 require 'date'
 
 module PureCloud
-  class DomainLicenseEntityListing
-    attr_accessor :page_size
+  class AggregationQuery
+    # Behaves like one clause in a SQL WHERE. Specifies the date and time range of data being queried. Intervals are represented as an ISO-8601 string. For example: YYYY-MM-DDThh:mm:ss/YYYY-MM-DDThh:mm:ss
+    attr_accessor :interval
 
-    attr_accessor :page_number
+    # Granularity aggregates metrics into subpartitions within the time interval specified. The default granularity is the same duration as the interval. Periods are represented as an ISO-8601 string. For example: P1D or P1DT12H
+    attr_accessor :granularity
 
-    attr_accessor :total
+    # Behaves like a SQL GROUPBY. Allows for multiple levels of grouping as a list of dimensions. Partitions resulting aggregate computations into distinct named subgroups rather than across the entire result set as if it were one group.
+    attr_accessor :group_by
 
-    attr_accessor :entities
+    # Behaves like a SQL WHERE clause. This is ANDed with the interval parameter. Expresses boolean logical predicates as well as dimensional filters
+    attr_accessor :filter
 
-    attr_accessor :self_uri
+    # Behaves like a SQL SELECT clause. Enables retrieving only named metrics. If omitted, all metrics that are available will be returned (like SELECT *).
+    attr_accessor :metrics
 
-    attr_accessor :first_uri
-
-    attr_accessor :previous_uri
-
-    attr_accessor :next_uri
-
-    attr_accessor :last_uri
-
-    attr_accessor :page_count
+    # Flattens any multivalued dimensions used in response groups (e.g. ['a','b','c']->'a,b,c')
+    attr_accessor :flatten_multivalued_dimensions
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'page_size' => :'pageSize',
-        
-        :'page_number' => :'pageNumber',
+        :'interval' => :'interval',
         
-        :'total' => :'total',
+        :'granularity' => :'granularity',
         
-        :'entities' => :'entities',
+        :'group_by' => :'groupBy',
         
-        :'self_uri' => :'selfUri',
+        :'filter' => :'filter',
         
-        :'first_uri' => :'firstUri',
+        :'metrics' => :'metrics',
         
-        :'previous_uri' => :'previousUri',
-        
-        :'next_uri' => :'nextUri',
-        
-        :'last_uri' => :'lastUri',
-        
-        :'page_count' => :'pageCount'
+        :'flatten_multivalued_dimensions' => :'flattenMultivaluedDimensions'
         
       }
     end
@@ -52,16 +42,12 @@ module PureCloud
     # Attribute type mapping.
     def self.swagger_types
       {
-        :'page_size' => :'Integer',
-        :'page_number' => :'Integer',
-        :'total' => :'Integer',
-        :'entities' => :'Array<DomainLicense>',
-        :'self_uri' => :'String',
-        :'first_uri' => :'String',
-        :'previous_uri' => :'String',
-        :'next_uri' => :'String',
-        :'last_uri' => :'String',
-        :'page_count' => :'Integer'
+        :'interval' => :'DateTime',
+        :'granularity' => :'DateTime',
+        :'group_by' => :'Array<String>',
+        :'filter' => :'AnalyticsQueryFilter',
+        :'metrics' => :'Array<String>',
+        :'flatten_multivalued_dimensions' => :'BOOLEAN'
         
       }
     end
@@ -73,46 +59,34 @@ module PureCloud
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
 
       
-      if attributes[:'pageSize']
-        self.page_size = attributes[:'pageSize']
-      end
-      
-      if attributes[:'pageNumber']
-        self.page_number = attributes[:'pageNumber']
+      if attributes[:'interval']
+        self.interval = attributes[:'interval']
       end
       
-      if attributes[:'total']
-        self.total = attributes[:'total']
+      if attributes[:'granularity']
+        self.granularity = attributes[:'granularity']
       end
       
-      if attributes[:'entities']
-        if (value = attributes[:'entities']).is_a?(Array)
-          self.entities = value
+      if attributes[:'groupBy']
+        if (value = attributes[:'groupBy']).is_a?(Array)
+          self.group_by = value
         end
       end
       
-      if attributes[:'selfUri']
-        self.self_uri = attributes[:'selfUri']
-      end
-      
-      if attributes[:'firstUri']
-        self.first_uri = attributes[:'firstUri']
-      end
-      
-      if attributes[:'previousUri']
-        self.previous_uri = attributes[:'previousUri']
+      if attributes[:'filter']
+        self.filter = attributes[:'filter']
       end
       
-      if attributes[:'nextUri']
-        self.next_uri = attributes[:'nextUri']
-      end
-      
-      if attributes[:'lastUri']
-        self.last_uri = attributes[:'lastUri']
+      if attributes[:'metrics']
+        if (value = attributes[:'metrics']).is_a?(Array)
+          self.metrics = value
+        end
       end
       
-      if attributes[:'pageCount']
-        self.page_count = attributes[:'pageCount']
+      if attributes[:'flattenMultivaluedDimensions']
+        self.flatten_multivalued_dimensions = attributes[:'flattenMultivaluedDimensions']
+      else
+        self.flatten_multivalued_dimensions = false
       end
       
     end
@@ -121,16 +95,12 @@ module PureCloud
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          page_size == o.page_size &&
-          page_number == o.page_number &&
-          total == o.total &&
-          entities == o.entities &&
-          self_uri == o.self_uri &&
-          first_uri == o.first_uri &&
-          previous_uri == o.previous_uri &&
-          next_uri == o.next_uri &&
-          last_uri == o.last_uri &&
-          page_count == o.page_count
+          interval == o.interval &&
+          granularity == o.granularity &&
+          group_by == o.group_by &&
+          filter == o.filter &&
+          metrics == o.metrics &&
+          flatten_multivalued_dimensions == o.flatten_multivalued_dimensions
     end
 
     # @see the `==` method
@@ -140,7 +110,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [page_size, page_number, total, entities, self_uri, first_uri, previous_uri, next_uri, last_uri, page_count].hash
+      [interval, granularity, group_by, filter, metrics, flatten_multivalued_dimensions].hash
     end
 
     # build the object from hash

data/lib/purecloud/models/{tag.rb → aggregation_range.rb}

@@ -1,18 +1,20 @@
 require 'date'
 
 module PureCloud
-  class Tag
-    attr_accessor :label
+  class AggregationRange
+    # Greater than or equal to
+    attr_accessor :gte
 
-    attr_accessor :interaction_flag
+    # Less than
+    attr_accessor :lt
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'label' => :'label',
+        :'gte' => :'gte',
         
-        :'interaction_flag' => :'interactionFlag'
+        :'lt' => :'lt'
         
       }
     end
@@ -20,8 +22,8 @@ module PureCloud
     # Attribute type mapping.
     def self.swagger_types
       {
-        :'label' => :'String',
-        :'interaction_flag' => :'BOOLEAN'
+        :'gte' => :'Float',
+        :'lt' => :'Float'
         
       }
     end
@@ -33,14 +35,12 @@ module PureCloud
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
 
       
-      if attributes[:'label']
-        self.label = attributes[:'label']
+      if attributes[:'gte']
+        self.gte = attributes[:'gte']
       end
       
-      if attributes[:'interactionFlag']
-        self.interaction_flag = attributes[:'interactionFlag']
-      else
-        self.interaction_flag = false
+      if attributes[:'lt']
+        self.lt = attributes[:'lt']
       end
       
     end
@@ -49,8 +49,8 @@ module PureCloud
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          label == o.label &&
-          interaction_flag == o.interaction_flag
+          gte == o.gte &&
+          lt == o.lt
     end
 
     # @see the `==` method
@@ -60,7 +60,7 @@ module PureCloud
 
     # Calculate hash code according to all attributes.
     def hash
-      [label, interaction_flag].hash
+      [gte, lt].hash
     end
 
     # build the object from hash