purecloudplatformclientv2 84.0.0 → 88.0.0

data/lib/purecloudplatformclientv2/models/{scheduling_run_response.rb → bu_schedule_run.rb}

@@ -17,61 +17,63 @@ Terms of Service: https://help.mypurecloud.com/articles/terms-and-conditions/
 require 'date'
 
 module PureCloud
-  # Information containing details of a schedule run
-  class SchedulingRunResponse
-    # ID of the schedule run
-    attr_accessor :run_id
+  class BuScheduleRun
+    # The globally unique identifier for the object.
+    attr_accessor :id
 
-    # The runId from scheduler service.  Useful for debugging schedule errors
+    # The scheduler run ID.  Reference this value for support
     attr_accessor :scheduler_run_id
 
-    # Whether this is the result of a rescheduling request
+    # Whether this is an intraday rescheduling run
     attr_accessor :intraday_rescheduling
 
-    # Status of the schedule run
+    # The state of the generation run
     attr_accessor :state
 
-    # Completion percentage of the schedule run
+    # The number of weeks spanned by the schedule
+    attr_accessor :week_count
+
+    # Percent completion of the schedule run
     attr_accessor :percent_complete
 
-    # The start date of the week for which the scheduling is done in yyyy-MM-dd format
+    # The start date of the target week. Dates are represented as an ISO-8601 string. For example: yyyy-MM-dd
     attr_accessor :target_week
 
-    # ID of the schedule. Does not apply to reschedule, see reschedulingOptions.existingScheduleId
-    attr_accessor :schedule_id
+    # The generated schedule.  Null unless the schedule run is complete
+    attr_accessor :schedule
 
-    # Description of the schedule
+    # The description of the generated schedule
     attr_accessor :schedule_description
 
-    # Start time of the schedule run. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
+    # When the schedule generation run started. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
     attr_accessor :scheduling_start_time
 
-    # User that started the schedule run
+    # The user who started the scheduling run
     attr_accessor :scheduling_started_by
 
-    # User that canceled the schedule run
+    # The user who canceled the scheduling run, if applicable
     attr_accessor :scheduling_canceled_by
 
-    # Time at which the scheduling run was completed. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
+    # When the scheduling run was completed, if applicable. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
     attr_accessor :scheduling_completed_time
 
-    # The selected options for the reschedule request. Will always be null if intradayRescheduling is false
+    # The number of schedule generation messages for this schedule generation run
+    attr_accessor :message_count
+
+    # Rescheduling options for this run.  Null unless intradayRescheduling is true
     attr_accessor :rescheduling_options
 
-    # When the rescheduling result data will expire. Results are kept temporarily as they should be applied as soon as possible after the run finishes.  Will always be null if intradayRescheduling is false. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
+    # When the reschedule result will expire.  Null unless intradayRescheduling is true. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
     attr_accessor :rescheduling_result_expiration
 
-    # Whether the rescheduling run has been marked applied
-    attr_accessor :applied
-
-    # Agents that were not scheduled in the rescheduling operation. Will always be null if intradayRescheduling is false
-    attr_accessor :unscheduled_agents
+    # The URI for this object
+    attr_accessor :self_uri
 
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        :'run_id' => :'runId',
+        :'id' => :'id',
         
         :'scheduler_run_id' => :'schedulerRunId',
         
@@ -79,11 +81,13 @@ module PureCloud
         
         :'state' => :'state',
         
+        :'week_count' => :'weekCount',
+        
         :'percent_complete' => :'percentComplete',
         
         :'target_week' => :'targetWeek',
         
-        :'schedule_id' => :'scheduleId',
+        :'schedule' => :'schedule',
         
         :'schedule_description' => :'scheduleDescription',
         
@@ -95,13 +99,13 @@ module PureCloud
         
         :'scheduling_completed_time' => :'schedulingCompletedTime',
         
+        :'message_count' => :'messageCount',
+        
         :'rescheduling_options' => :'reschedulingOptions',
         
         :'rescheduling_result_expiration' => :'reschedulingResultExpiration',
         
-        :'applied' => :'applied',
-        
-        :'unscheduled_agents' => :'unscheduledAgents'
+        :'self_uri' => :'selfUri'
         
       }
     end
@@ -110,7 +114,7 @@ module PureCloud
     def self.swagger_types
       {
         
-        :'run_id' => :'String',
+        :'id' => :'String',
         
         :'scheduler_run_id' => :'String',
         
@@ -118,11 +122,13 @@ module PureCloud
         
         :'state' => :'String',
         
+        :'week_count' => :'Integer',
+        
         :'percent_complete' => :'Float',
         
-        :'target_week' => :'String',
+        :'target_week' => :'Date',
         
-        :'schedule_id' => :'String',
+        :'schedule' => :'BuScheduleReference',
         
         :'schedule_description' => :'String',
         
@@ -134,13 +140,13 @@ module PureCloud
         
         :'scheduling_completed_time' => :'DateTime',
         
-        :'rescheduling_options' => :'ReschedulingOptionsResponse',
+        :'message_count' => :'Integer',
         
-        :'rescheduling_result_expiration' => :'DateTime',
+        :'rescheduling_options' => :'ReschedulingOptionsRunResponse',
         
-        :'applied' => :'BOOLEAN',
+        :'rescheduling_result_expiration' => :'DateTime',
         
-        :'unscheduled_agents' => :'Array<UnscheduledAgentWarning>'
+        :'self_uri' => :'String'
         
       }
     end
@@ -154,10 +160,10 @@ module PureCloud
       attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
 
       
-      if attributes.has_key?(:'runId')
+      if attributes.has_key?(:'id')
         
         
-        self.run_id = attributes[:'runId']
+        self.id = attributes[:'id']
         
       
       end
@@ -190,6 +196,15 @@ module PureCloud
       end
 
       
+      if attributes.has_key?(:'weekCount')
+        
+        
+        self.week_count = attributes[:'weekCount']
+        
+      
+      end
+
+      
       if attributes.has_key?(:'percentComplete')
         
         
@@ -208,10 +223,10 @@ module PureCloud
       end
 
       
-      if attributes.has_key?(:'scheduleId')
+      if attributes.has_key?(:'schedule')
         
         
-        self.schedule_id = attributes[:'scheduleId']
+        self.schedule = attributes[:'schedule']
         
       
       end
@@ -262,39 +277,37 @@ module PureCloud
       end
 
       
-      if attributes.has_key?(:'reschedulingOptions')
+      if attributes.has_key?(:'messageCount')
         
         
-        self.rescheduling_options = attributes[:'reschedulingOptions']
+        self.message_count = attributes[:'messageCount']
         
       
       end
 
       
-      if attributes.has_key?(:'reschedulingResultExpiration')
+      if attributes.has_key?(:'reschedulingOptions')
         
         
-        self.rescheduling_result_expiration = attributes[:'reschedulingResultExpiration']
+        self.rescheduling_options = attributes[:'reschedulingOptions']
         
       
       end
 
       
-      if attributes.has_key?(:'applied')
+      if attributes.has_key?(:'reschedulingResultExpiration')
         
         
-        self.applied = attributes[:'applied']
+        self.rescheduling_result_expiration = attributes[:'reschedulingResultExpiration']
         
       
       end
 
       
-      if attributes.has_key?(:'unscheduledAgents')
+      if attributes.has_key?(:'selfUri')
         
-        if (value = attributes[:'unscheduledAgents']).is_a?(Array)
-          self.unscheduled_agents = value
-        end
         
+        self.self_uri = attributes[:'selfUri']
         
       
       end
@@ -379,6 +392,10 @@ module PureCloud
       
       
       
+      
+      
+      
+      
       
       
       
@@ -470,6 +487,11 @@ module PureCloud
     
     
     
+    
+    
+    
+    
+    
     
     
     
@@ -481,22 +503,23 @@ module PureCloud
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
-          run_id == o.run_id &&
+          id == o.id &&
           scheduler_run_id == o.scheduler_run_id &&
           intraday_rescheduling == o.intraday_rescheduling &&
           state == o.state &&
+          week_count == o.week_count &&
           percent_complete == o.percent_complete &&
           target_week == o.target_week &&
-          schedule_id == o.schedule_id &&
+          schedule == o.schedule &&
           schedule_description == o.schedule_description &&
           scheduling_start_time == o.scheduling_start_time &&
           scheduling_started_by == o.scheduling_started_by &&
           scheduling_canceled_by == o.scheduling_canceled_by &&
           scheduling_completed_time == o.scheduling_completed_time &&
+          message_count == o.message_count &&
           rescheduling_options == o.rescheduling_options &&
           rescheduling_result_expiration == o.rescheduling_result_expiration &&
-          applied == o.applied &&
-          unscheduled_agents == o.unscheduled_agents
+          self_uri == o.self_uri
     end
 
     # @see the `==` method
@@ -508,7 +531,7 @@ module PureCloud
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [run_id, scheduler_run_id, intraday_rescheduling, state, percent_complete, target_week, schedule_id, schedule_description, scheduling_start_time, scheduling_started_by, scheduling_canceled_by, scheduling_completed_time, rescheduling_options, rescheduling_result_expiration, applied, unscheduled_agents].hash
+      [id, scheduler_run_id, intraday_rescheduling, state, week_count, percent_complete, target_week, schedule, schedule_description, scheduling_start_time, scheduling_started_by, scheduling_canceled_by, scheduling_completed_time, message_count, rescheduling_options, rescheduling_result_expiration, self_uri].hash
     end
 
     # build the object from hash

data/lib/purecloudplatformclientv2/models/{time_off_request_entity_list.rb → bu_schedule_run_listing.rb}

@@ -17,7 +17,7 @@ Terms of Service: https://help.mypurecloud.com/articles/terms-and-conditions/
 require 'date'
 
 module PureCloud
-  class TimeOffRequestEntityList
+  class BuScheduleRunListing
     attr_accessor :entities
 
     # Attribute mapping from ruby-style variable name to JSON key.
@@ -33,7 +33,7 @@ module PureCloud
     def self.swagger_types
       {
         
-        :'entities' => :'Array<TimeOffRequestResponse>'
+        :'entities' => :'Array<BuScheduleRun>'
         
       }
     end

data/lib/purecloudplatformclientv2/models/{wfm_service_level.rb → bu_service_level.rb}

@@ -18,7 +18,7 @@ require 'date'
 
 module PureCloud
   # Service goal service level configuration
-  class WfmServiceLevel
+  class BuServiceLevel
     # Whether to include service level targets in the associated configuration
     attr_accessor :include
 

data/lib/purecloudplatformclientv2/models/bu_short_term_forecast.rb

@@ -0,0 +1,584 @@
+=begin
+PureCloud Platform API
+
+With the PureCloud Platform API, you can control all aspects of your PureCloud environment. With the APIs you can access the system configuration, manage conversations and more.
+
+OpenAPI spec version: v2
+Contact: DeveloperEvangelists@genesys.com
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+
+License: UNLICENSED
+https://help.mypurecloud.com/articles/terms-and-conditions/
+
+Terms of Service: https://help.mypurecloud.com/articles/terms-and-conditions/
+
+=end
+
+require 'date'
+
+module PureCloud
+  class BuShortTermForecast
+    # The globally unique identifier for the object.
+    attr_accessor :id
+
+    # The start week date of this forecast in yyyy-MM-dd.  Must fall on the start day of week for the associated business unit. Dates are represented as an ISO-8601 string. For example: yyyy-MM-dd
+    attr_accessor :week_date
+
+    # The number of weeks this forecast covers
+    attr_accessor :week_count
+
+    # The method by which this forecast was created
+    attr_accessor :creation_method
+
+    # The description of this forecast
+    attr_accessor :description
+
+    # Whether this forecast contains modifications on legacy metrics
+    attr_accessor :legacy
+
+    # Metadata for this forecast
+    attr_accessor :metadata
+
+    # The reference start date for interval-based data for this forecast. Date time is represented as an ISO-8601 string. For example: yyyy-MM-ddTHH:mm:ss.SSSZ
+    attr_accessor :reference_start_date
+
+    # The source day pointers for this forecast
+    attr_accessor :source_days
+
+    # Any manual modifications applied to this forecast
+    attr_accessor :modifications
+
+    # Generation result metadata
+    attr_accessor :generation_results
+
+    # The time zone for this forecast
+    attr_accessor :time_zone
+
+    # The version of the planning groups that was used for this forecast
+    attr_accessor :planning_groups_version
+
+    # A snapshot of the planning groups used for this forecast as of the version number indicated
+    attr_accessor :planning_groups
+
+    # The URI for this object
+    attr_accessor :self_uri
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        
+        :'id' => :'id',
+        
+        :'week_date' => :'weekDate',
+        
+        :'week_count' => :'weekCount',
+        
+        :'creation_method' => :'creationMethod',
+        
+        :'description' => :'description',
+        
+        :'legacy' => :'legacy',
+        
+        :'metadata' => :'metadata',
+        
+        :'reference_start_date' => :'referenceStartDate',
+        
+        :'source_days' => :'sourceDays',
+        
+        :'modifications' => :'modifications',
+        
+        :'generation_results' => :'generationResults',
+        
+        :'time_zone' => :'timeZone',
+        
+        :'planning_groups_version' => :'planningGroupsVersion',
+        
+        :'planning_groups' => :'planningGroups',
+        
+        :'self_uri' => :'selfUri'
+        
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        
+        :'id' => :'String',
+        
+        :'week_date' => :'Date',
+        
+        :'week_count' => :'Integer',
+        
+        :'creation_method' => :'String',
+        
+        :'description' => :'String',
+        
+        :'legacy' => :'BOOLEAN',
+        
+        :'metadata' => :'WfmVersionedEntityMetadata',
+        
+        :'reference_start_date' => :'DateTime',
+        
+        :'source_days' => :'Array<ForecastSourceDayPointer>',
+        
+        :'modifications' => :'Array<BuForecastModification>',
+        
+        :'generation_results' => :'BuForecastGenerationResult',
+        
+        :'time_zone' => :'String',
+        
+        :'planning_groups_version' => :'Integer',
+        
+        :'planning_groups' => :'ForecastPlanningGroupsResponse',
+        
+        :'self_uri' => :'String'
+        
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    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}
+
+      
+      if attributes.has_key?(:'id')
+        
+        
+        self.id = attributes[:'id']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'weekDate')
+        
+        
+        self.week_date = attributes[:'weekDate']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'weekCount')
+        
+        
+        self.week_count = attributes[:'weekCount']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'creationMethod')
+        
+        
+        self.creation_method = attributes[:'creationMethod']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'description')
+        
+        
+        self.description = attributes[:'description']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'legacy')
+        
+        
+        self.legacy = attributes[:'legacy']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'metadata')
+        
+        
+        self.metadata = attributes[:'metadata']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'referenceStartDate')
+        
+        
+        self.reference_start_date = attributes[:'referenceStartDate']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'sourceDays')
+        
+        if (value = attributes[:'sourceDays']).is_a?(Array)
+          self.source_days = value
+        end
+        
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'modifications')
+        
+        if (value = attributes[:'modifications']).is_a?(Array)
+          self.modifications = value
+        end
+        
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'generationResults')
+        
+        
+        self.generation_results = attributes[:'generationResults']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'timeZone')
+        
+        
+        self.time_zone = attributes[:'timeZone']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'planningGroupsVersion')
+        
+        
+        self.planning_groups_version = attributes[:'planningGroupsVersion']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'planningGroups')
+        
+        
+        self.planning_groups = attributes[:'planningGroups']
+        
+      
+      end
+
+      
+      if attributes.has_key?(:'selfUri')
+        
+        
+        self.self_uri = attributes[:'selfUri']
+        
+      
+      end
+
+      
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properies with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      
+      
+      return invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      allowed_values = ["Import", "ImportedHistoricalWeightedAverage", "HistoricalWeightedAverage", "Advanced"]
+      if @creation_method && !allowed_values.include?(@creation_method)
+        return false
+      end
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+    end
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] creation_method Object to be assigned
+    def creation_method=(creation_method)
+      allowed_values = ["Import", "ImportedHistoricalWeightedAverage", "HistoricalWeightedAverage", "Advanced"]
+      if creation_method && !allowed_values.include?(creation_method)
+        fail ArgumentError, "invalid value for 'creation_method', must be one of #{allowed_values}."
+      end
+      @creation_method = creation_method
+    end
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          week_date == o.week_date &&
+          week_count == o.week_count &&
+          creation_method == o.creation_method &&
+          description == o.description &&
+          legacy == o.legacy &&
+          metadata == o.metadata &&
+          reference_start_date == o.reference_start_date &&
+          source_days == o.source_days &&
+          modifications == o.modifications &&
+          generation_results == o.generation_results &&
+          time_zone == o.time_zone &&
+          planning_groups_version == o.planning_groups_version &&
+          planning_groups == o.planning_groups &&
+          self_uri == o.self_uri
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [id, week_date, week_count, creation_method, description, legacy, metadata, reference_start_date, source_days, modifications, generation_results, time_zone, planning_groups_version, planning_groups, self_uri].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.to_s =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      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