crisphive 0.2.0 → 0.3.0

data/lib/crisphive/models/job_request_reassign_fallback.rb

@@ -0,0 +1,287 @@
+=begin
+#Crisphive Developer API
+
+#Public REST API for integrating Crisphive from your own backend. Authenticate every request with a secret API key as a Bearer token (`Authorization: Bearer chsk_live_…`). The key prefix selects the data environment: `chsk_live_…` → production (live), `chsk_test_…` → sandbox (isolated test).  **Key scopes (restricted keys).** A key is either *full-access* (can call every endpoint below) or *restricted* to a set of permission codes chosen at creation — the same codes as the dashboard permission grid (e.g. `customers_view`, `job_create`, `team_manage`). A restricted key calling an endpoint outside its scope gets `403`. The full code list is the permission catalog (`GET /permission/modules` on the dashboard API). Create, scope, and revoke keys from the business dashboard.  Every response is wrapped in the envelope `{ \"error_code\": 0, \"message\": \"Success\", \"data\": <payload> }`.
+
+The version of the OpenAPI document: 1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.11.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Crisphive
+  class JobRequestReassignFallback
+    # How many alternates the engine offered BEFORE in-plan occupancy was applied. 0 = nobody qualified/free at all; >0 = qualified alternates existed but each was taken by another displaced job in this same plan. The coordinator's fix differs between the two, so the count is served rather than folded into the code.
+    attr_accessor :feasible_count
+
+    attr_accessor :job_id
+
+    # Human sentence, window already rendered in the business timezone.
+    attr_accessor :message
+
+    # NO_QUALIFIED_TECH_FREE: the planner found no alternate for this window. JOB_UNREADABLE: the job's row could not be loaded, so no alternate was even considered — transient, worth retrying, unlike the other codes.
+    attr_accessor :reason_code
+
+    attr_accessor :short_code
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'feasible_count' => :'feasible_count',
+        :'job_id' => :'job_id',
+        :'message' => :'message',
+        :'reason_code' => :'reason_code',
+        :'short_code' => :'short_code'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'feasible_count' => :'Integer',
+        :'job_id' => :'String',
+        :'message' => :'String',
+        :'reason_code' => :'String',
+        :'short_code' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Crisphive::JobRequestReassignFallback` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Crisphive::JobRequestReassignFallback`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'feasible_count')
+        self.feasible_count = attributes[:'feasible_count']
+      end
+
+      if attributes.key?(:'job_id')
+        self.job_id = attributes[:'job_id']
+      end
+
+      if attributes.key?(:'message')
+        self.message = attributes[:'message']
+      end
+
+      if attributes.key?(:'reason_code')
+        self.reason_code = attributes[:'reason_code']
+      end
+
+      if attributes.key?(:'short_code')
+        self.short_code = attributes[:'short_code']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      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?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      reason_code_validator = EnumAttributeValidator.new('String', ["NO_QUALIFIED_TECH_FREE", "JOB_UNREADABLE"])
+      return false unless reason_code_validator.valid?(@reason_code)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] reason_code Object to be assigned
+    def reason_code=(reason_code)
+      validator = EnumAttributeValidator.new('String', ["NO_QUALIFIED_TECH_FREE", "JOB_UNREADABLE"])
+      unless validator.valid?(reason_code)
+        fail ArgumentError, "invalid value for \"reason_code\", must be one of #{validator.allowable_values}."
+      end
+      @reason_code = reason_code
+    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 &&
+          feasible_count == o.feasible_count &&
+          job_id == o.job_id &&
+          message == o.message &&
+          reason_code == o.reason_code &&
+          short_code == o.short_code
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [feasible_count, job_id, message, reason_code, short_code].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.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 =~ /\A(true|t|yes|y|1)\z/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
+        # models (e.g. Pet) or oneOf
+        klass = Crisphive.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    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 = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # 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

data/lib/crisphive/models/job_request_skill_summary.rb

@@ -27,7 +27,7 @@ module Crisphive
     # Whether the skill is currently active.
     attr_accessor :is_active
 
-    # Skill display name (resolved to the request locale).
+    # Skill display name (canonical; skill names carry no locale translations, so this is NOT resolved to the request locale).
     attr_accessor :name
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/crisphive/models/job_request_status_summary.rb

@@ -15,7 +15,7 @@ require 'time'
 
 module Crisphive
   class JobRequestStatusSummary
-    # Status display name, resolved to the request locale.
+    # Status display name as authored on the workflow (canonical; NOT resolved to the request locale).
     attr_accessor :display_name
 
     # Workflow status key (the business's workflow defines the set; first is always \"booking\", last always \"completed\").

data/lib/crisphive/models/job_request_time_segments.rb

@@ -27,10 +27,10 @@ module Crisphive
     # IANA timezone of the customer (customer-facing slot times render in this zone).
     attr_accessor :customer_timezone
 
-    # Offerable days in date order, each with its slot grid. Only slots with at least one feasible technician are offered.
+    # Offerable days in date order, each with its slot grid. Only future slots with at least one feasible technician are offered.
     attr_accessor :days
 
-    # Reserved UI hint; currently always false.
+    # True when the customer's originally chosen dates yield NO offerable slot — either they are already in the past, or no technician is available on them. `days` then holds fresh SUGGESTED days instead: the same time-of-day periods, scanned from the day after their last chosen date (never before today) across at most 7 days, offering the first 3 days that have availability (may be empty when nothing was found — tell the customer no alternative exists within the week). The FE should surface that their chosen dates didn't work out and these are new suggestions.
     attr_accessor :is_suggested
 
     # Job identifier — the human-readable short code when present, else the job UUID.

data/lib/crisphive/models/job_type.rb

@@ -21,10 +21,22 @@ module Crisphive
     # When the job type was created (RFC3339).
     attr_accessor :created_at
 
+    # Default demobilization minutes applied with the default duration. Absent = none.
+    attr_accessor :default_demobilization_minutes
+
+    # Default work duration in minutes used when a quote omits job_duration_minutes. Absent = no default: a quote for this type must send a duration.
+    attr_accessor :default_duration_minutes
+
+    # Default mobilization minutes applied with the default duration. Absent = none.
+    attr_accessor :default_mobilization_minutes
+
     # Job type UUID — the stable identifier used in every job-type endpoint.
     attr_accessor :id
 
-    # True for platform-seeded system rows, which cannot be modified or deleted.
+    # True for the business's DEFAULT job type (the seeded \"General\"): a job booked without a job_type_id gets it, and a job with no job type is quoted from its default bundle. It cannot be deleted or deactivated and its default duration cannot be cleared (it can be changed). Exactly one per business per environment (live and sandbox each have their own).
+    attr_accessor :is_default
+
+    # True for platform-seeded system rows: their name and status cannot be modified and they cannot be deleted; their default quote bundle is editable.
     attr_accessor :is_system
 
     # Job type name, localized server-side to the request locale.
@@ -63,7 +75,11 @@ module Crisphive
       {
         :'business_id' => :'business_id',
         :'created_at' => :'created_at',
+        :'default_demobilization_minutes' => :'default_demobilization_minutes',
+        :'default_duration_minutes' => :'default_duration_minutes',
+        :'default_mobilization_minutes' => :'default_mobilization_minutes',
         :'id' => :'id',
+        :'is_default' => :'is_default',
         :'is_system' => :'is_system',
         :'name' => :'name',
         :'status' => :'status',
@@ -81,7 +97,11 @@ module Crisphive
       {
         :'business_id' => :'String',
         :'created_at' => :'Time',
+        :'default_demobilization_minutes' => :'Integer',
+        :'default_duration_minutes' => :'Integer',
+        :'default_mobilization_minutes' => :'Integer',
         :'id' => :'String',
+        :'is_default' => :'Boolean',
         :'is_system' => :'Boolean',
         :'name' => :'String',
         :'status' => :'String',
@@ -118,10 +138,26 @@ module Crisphive
         self.created_at = attributes[:'created_at']
       end
 
+      if attributes.key?(:'default_demobilization_minutes')
+        self.default_demobilization_minutes = attributes[:'default_demobilization_minutes']
+      end
+
+      if attributes.key?(:'default_duration_minutes')
+        self.default_duration_minutes = attributes[:'default_duration_minutes']
+      end
+
+      if attributes.key?(:'default_mobilization_minutes')
+        self.default_mobilization_minutes = attributes[:'default_mobilization_minutes']
+      end
+
       if attributes.key?(:'id')
         self.id = attributes[:'id']
       end
 
+      if attributes.key?(:'is_default')
+        self.is_default = attributes[:'is_default']
+      end
+
       if attributes.key?(:'is_system')
         self.is_system = attributes[:'is_system']
       end
@@ -173,7 +209,11 @@ module Crisphive
       self.class == o.class &&
           business_id == o.business_id &&
           created_at == o.created_at &&
+          default_demobilization_minutes == o.default_demobilization_minutes &&
+          default_duration_minutes == o.default_duration_minutes &&
+          default_mobilization_minutes == o.default_mobilization_minutes &&
           id == o.id &&
+          is_default == o.is_default &&
           is_system == o.is_system &&
           name == o.name &&
           status == o.status &&
@@ -189,7 +229,7 @@ module Crisphive
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [business_id, created_at, id, is_system, name, status, updated_at].hash
+      [business_id, created_at, default_demobilization_minutes, default_duration_minutes, default_mobilization_minutes, id, is_default, is_system, name, status, updated_at].hash
     end
 
     # Builds the object from hash