ruby-jss 1.6.4 → 2.0.0a10

data/lib/{jss/api_object → jamf/api/classic/api_objects}/computer.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -24,7 +24,7 @@
 ###
 
 ###
-module JSS
+module Jamf
 
   # This class represents a Computer in the JSS.
   #
@@ -63,7 +63,7 @@ module JSS
   #
   # === MDM Commands
   #
-  # See the {JSS::MDM} mixin module for Class and Instance methods for
+  # See the {Jamf::MDM} mixin module for Class and Instance methods for
   # sending MDM commands to computers.
   #
   # To send MDM commands without fetching Computer instances, use the class
@@ -86,7 +86,7 @@ module JSS
   #
   # Computer Management History and logs can now be retrieved both from a
   # Computer instance, and directly via class methods without fetching an
-  # instance. This is handled by the mixed-in {JSS::ManagementHistory} module,
+  # instance. This is handled by the mixed-in {Jamf::ManagementHistory} module,
   # Q.V. for details.
   #
   # === Appication Usage History
@@ -145,21 +145,21 @@ module JSS
   # @see Matchable
   # @see FileUpload
   #
-  class Computer < JSS::APIObject
+  class Computer < Jamf::APIObject
 
     # MixIns
     #####################################
-    include JSS::Creatable
-    include JSS::Updatable
-    include JSS::Locatable
-    include JSS::Purchasable
-    include JSS::Uploadable
-    include JSS::Extendable
-    include JSS::Sitable
-    include JSS::MDM
-    include JSS::ManagementHistory
-
-    extend JSS::Matchable
+    include Jamf::Creatable
+    include Jamf::Updatable
+    include Jamf::Locatable
+    include Jamf::Purchasable
+    include Jamf::Uploadable
+    include Jamf::Extendable
+    include Jamf::Sitable
+    include Jamf::MDM
+    include Jamf::ManagementHistory
+
+    extend Jamf::Matchable
 
     # Class Constants
     #####################################
@@ -183,7 +183,7 @@ module JSS
     # these keys,  as well as :id and :name, can be used to look up objects
     # of this class in the JSS
     #
-    # the wierd alises mac_addresse and macaddresse
+    # the weird alises mac_addresse and macaddresse
     # are for proper pluralization of 'mac_address' and such
     OTHER_LOOKUP_KEYS = {
       udid: {
@@ -210,10 +210,10 @@ module JSS
     NON_UNIQUE_NAMES = true
 
     # This class lets us seach for computers
-    SEARCH_CLASS = JSS::AdvancedComputerSearch
+    SEARCH_CLASS = Jamf::AdvancedComputerSearch
 
     # This is the class for relevant Extension Attributes
-    EXT_ATTRIB_CLASS = JSS::ComputerExtensionAttribute
+    EXT_ATTRIB_CLASS = Jamf::ComputerExtensionAttribute
 
     # Boot partitions are noted with the string "(Boot Partition)" at the end
     BOOT_FLAG = ' (Boot Partition)'.freeze
@@ -230,9 +230,6 @@ module JSS
     # The date format for retrieving usage data
     APPLICATION_USAGE_DATE_FMT = '%Y-%m-%d'.freeze
 
-    # The classes that can be used with the date format
-    APPLICATION_USAGE_DATE_CLASSES = [Time, DateTime, Date].freeze
-
     # The top-level hash key of the raw app usage data
     APPLICATION_USAGE_KEY = :computer_application_usage
 
@@ -268,6 +265,8 @@ module JSS
     # The top-level hash key for the inventory collection settings
     INV_COLLECTION_KEY = :computer_inventory_collection
 
+    COMPUTER_APPLICATIONS_RSRC = 'computerapplications/application'.freeze
+
     # the object type for this object in
     # the object history table.
     # See {APIObject#add_object_history_entry}
@@ -280,28 +279,30 @@ module JSS
     # Currently this is read-only in ruby-jss, even tho the API
     # allows updating.
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Hash] the Computer Checkin Settings from the
     #   currently connected JSS.
     #
-    def self.checkin_settings(api: JSS.api)
-      api.get_rsrc(CHECKIN_RSRC)[CHECKIN_KEY]
+    def self.checkin_settings(api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+      cnx.c_get(CHECKIN_RSRC)[CHECKIN_KEY]
     end
 
     # Display the current Computer Inventory Collection settings in the JSS.
     # Currently this is read-only in ruby-jss, even tho the API
     # allows updating.
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Hash] the Computer Inventpry Collection Settings from the
     #   currently connected JSS.
     #
-    def self.inventory_collection_settings(api: JSS.api)
-      api.get_rsrc(INV_COLLECTION_RSRC)[INV_COLLECTION_KEY]
+    def self.inventory_collection_settings(api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+      cnx.c_get(INV_COLLECTION_RSRC)[INV_COLLECTION_KEY]
     end
 
     # A larger set of info about the computers in the JSS.
@@ -313,93 +314,102 @@ module JSS
     # :managed, :building, :department, :username, and :report_date
     #
     # Because this requires a different, unusual, resource path, we're completely re-defining
-    # {APIObject.all} for JSS::Computer.  Hopefully some day the original /computers/
+    # {APIObject.all} for Jamf::Computer.  Hopefully some day the original /computers/
     # resource will be updated to return this data.
     #
     # @param refresh[Boolean] should the data be re-queried from the API?
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx[Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Array<Hash{:name=>String, :id=> Integer}>]
     #
-    def self.all(refresh = false, api: JSS.api)
-      cache = api.object_list_cache
+    def self.all(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      cache = cnx.c_object_list_cache
       cache_key = self::RSRC_LIST_KEY
       cache[cache_key] = nil if refresh
       return cache[cache_key] if cache[cache_key]
 
-      cache[cache_key] = api.get_rsrc(self::LIST_RSRC)[cache_key]
+      cache[cache_key] = cnx.c_get(self::LIST_RSRC)[cache_key]
     end
 
-    # # @return [Array<String>] all computer serial numbers in the jss
-    # def self.all_serial_numbers(refresh = false, api: JSS.api)
-    #   all(refresh, api: api).map { |i| i[:serial_number] }
-    # end
-    #
-    # # @return [Array<String>] all computer mac_addresses in the jss
-    # def self.all_mac_addresses(refresh = false, api: JSS.api)
-    #   all(refresh, api: api).map { |i| i[:mac_address] }
-    # end
-    #
-    # # @return [Array<String>] all computer udids in the jss
-    # def self.all_udids(refresh = false, api: JSS.api)
-    #   all(refresh, api: api).map { |i| i[:udid] }
-    # end
-
     # @return [Array<Hash>] all managed computers in the jss
-    def self.all_managed(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:managed] }
+    def self.all_managed(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:managed] }
     end
 
     # @return [Array<Hash>] all unmanaged computers in the jss
-    def self.all_unmanaged(refresh = false, api: JSS.api)
-      all(refresh, api: api).reject { |d| d[:managed] }
+    def self.all_unmanaged(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).reject { |d| d[:managed] }
     end
 
     # @return [Array<Hash>] all laptop computers in the jss
-    def self.all_laptops(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /book/i }
+    def self.all_laptops(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /book/i }
     end
 
     # @return [Array<Hash>] all macbooks in the jss
-    def self.all_macbooks(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^macbook\d/i }
+    def self.all_macbooks(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^macbook\d/i }
     end
 
     # @return [Array<Hash>] all macbookpros in the jss
-    def self.all_macbookpros(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^macbookpro\d/i  }
+    def self.all_macbookpros(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^macbookpro\d/i  }
     end
 
     # @return [Array<Hash>] all macbookairs in the jss
-    def self.all_macbookairs(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^macbookair\d/i  }
+    def self.all_macbookairs(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^macbookair\d/i  }
     end
 
     # @return [Array<Hash>] all xserves in the jss
-    def self.all_xserves(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /serve/i }
+    def self.all_xserves(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /serve/i }
     end
 
     # @return [Array<Hash>] all desktop macs in the jss
-    def self.all_desktops(refresh = false, api: JSS.api)
-      all(refresh, api: api).reject { |d| d[:model] =~ /serve|book/i }
+    def self.all_desktops(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).reject { |d| d[:model] =~ /serve|book/i }
     end
 
     # @return [Array<Hash>] all imacs in the jss
-    def self.all_imacs(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^imac/i }
+    def self.all_imacs(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^imac/i }
     end
 
     # @return [Array<Hash>] all mac minis in the jss
-    def self.all_minis(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^macmini/i }
+    def self.all_minis(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^macmini/i }
     end
 
     # @return [Array<Hash>] all macpros in the jss
-    def self.all_macpros(refresh = false, api: JSS.api)
-      all(refresh, api: api).select { |d| d[:model] =~ /^macpro/i }
+    def self.all_macpros(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      all(refresh, cnx: cnx).select { |d| d[:model] =~ /^macpro/i }
     end
 
     # Retrieve Application Usage data for a computer by id, without
@@ -412,8 +422,8 @@ module JSS
     #
     # @param end_date [String,Date,DateTime,Time] Defaults to start_date
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Hash{Date=>Array<Hash>}] A Hash with keys (Date instances) for
     #   each day in the range.
@@ -428,24 +438,105 @@ module JSS
     #     :foreground => Integer, the minutes it was in the foreground
     #     :open => Integer, the minutes it was running.
     #
-    def self.application_usage(ident, start_date, end_date = nil, api: JSS.api)
-      id = valid_id ident, api: api
+    def self.application_usage(ident, start_date, end_date = nil, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      id = valid_id ident, cnx: cnx
       raise "No computer matches identifier: #{ident}" unless id
+
       end_date ||= start_date
-      start_date = Time.parse start_date if start_date.is_a? String
-      end_date = Time.parse end_date if end_date.is_a? String
-      raise JSS::InvalidDataError, 'Invalid Start or End Date' unless ([start_date.class, end_date.class] - APPLICATION_USAGE_DATE_CLASSES).empty?
+      start_date = Jamf.parse_time start_date
+      end_date = Jamf.parse_time end_date
+
       start_date = start_date.strftime APPLICATION_USAGE_DATE_FMT
       end_date = end_date.strftime APPLICATION_USAGE_DATE_FMT
-      data = api.get_rsrc(APPLICATION_USAGE_RSRC + "/id/#{id}/#{start_date}_#{end_date}")
+
+      data = cnx.c_get(APPLICATION_USAGE_RSRC + "/id/#{id}/#{start_date}_#{end_date}")
+
       parsed_data = {}
+
       data[APPLICATION_USAGE_KEY].each do |day_hash|
         date = Date.parse day_hash[:date]
         parsed_data[date] = day_hash[:apps]
       end
+
       parsed_data
     end # app usage
 
+    # Query the JSS for computers with some app installed. An app name is required
+    # as the first parameter.
+    #
+    # If no other parameters are given, returns a Hash, one key per version of the
+    # app. For each version there is an array of Hashes, one Hash for each
+    # computer with that version. The sub hashes contain keys for the computer's
+    # identifiers, i.e. :name, :id, :udid, :serial_number, :mac_address.
+    #
+    # If one or more inventory fields are provided in the 'fields' parameter,
+    # each computer's hash also has keys and values for those fields if they
+    # exist in the JSS. These fields are those available in the display options
+    # for Advanced Computer Searches (including extention attribute names) and
+    # their names are case-sensitive, so 'Username', not 'username'
+    #
+    # If a specific version is provided in the 'version' parameter, only computers
+    # containing that version of the app are returned as an Array of Hashes.
+    #
+    # If the ids_only parameter is truthy, an Array of JSS id numbers for
+    # computers with this app is returned. In this case the 'fields' parameter
+    # is ignored, however the 'version' parameters is still valid and will
+    # restrict the list to those computer ids with that version installed.
+    #
+    # This method implements the 'computerapplications' API endpoint.
+    #
+    # NOTE: To see all the apps installed on a specific computer, fetch the
+    # Jamf::Computer instance and call its {Jamf::Computer#apps} method.
+    #
+    # @param appname [String] The name of the app to look for, e.g. 'Transmogrifier.app'
+    #
+    # @param fields [String,Array<String>] Additional 'inventory fields' to return
+    #    with each computer's data
+    #
+    # @param version [String] Limit search to a specific version of the app
+    #
+    # @param ids_only [Boolean] Just return an array of the id's of computers
+    #  found with this query. Defaults to false
+    #
+    # @param cnx [Jamf::Connection] The API connection to use for the query.
+    #   default: Jamf.cnx
+    #
+    # @return [Array<Integer>] When ids_only == true, the ids of computers with
+    #   the app installed (possibly limited to version)
+    #
+    # @return [Array<Hash>] When version is provided, An Array of Hashes, one
+    #   for each computer, with keys for identifiers plus any requested fields.
+    #
+    # @return [Hash{String => Array<Hash>}] When no version is provided, a Hash
+    #   with keys for each version, pointing to an array of Hashes, one for
+    #   each computer with that version. Each computer's Hash has keys for
+    #   identifiers plus any requested fields.
+    #
+    #
+    def self.application_installs(appname, fields: [], version: nil, ids_only: false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      fields = [fields] unless fields.is_a? Array
+
+      rsrc = "#{COMPUTER_APPLICATIONS_RSRC}/#{CGI.escape appname.to_s}"
+      rsrc << "/version/#{CGI.escape version.to_s}" if version
+      rsrc << "/inventory/#{CGI.escape fields.join(',')}" unless ids_only || fields.empty?
+
+      result = cnx.c_get(rsrc)[:computer_applications]
+
+      return result[:unique_computers].map { |c| c[:id] } if ids_only
+
+      if version.nil?
+        hash_by_version = {}
+        result[:versions].each { |v| hash_by_version[v[:number]] = v[:computers] }
+        return hash_by_version
+      end
+
+      result[:versions].first[:computers]
+    end # self.application_installs
+
     # The 'computer management' data for a given computer by id,
     # looked up on the fly.
     #
@@ -468,8 +559,8 @@ module JSS
     # @param only[Symbol] When fetching a subset, only return one value
     #   per item in the array. meaningless without a subset.
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Hash] Without a subset:, a hash of all subsets, each of which is
     #   an Array
@@ -477,33 +568,41 @@ module JSS
     # @return [Array] With a subset:, an array of items in that subset, possibly
     #   limited to just certain values with only:
     #
-    def self.management_data(ident, subset: nil, only: nil, api: JSS.api)
-      id = valid_id ident, api: api
+    def self.management_data(ident, subset: nil, only: nil, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      id = valid_id ident, cnx: cnx
       raise "No computer matches identifier: #{ident}" unless id
       if subset
-        management_data_subset id, subset: subset, only: only, api: api
+        management_data_subset id, subset: subset, only: only, cnx: cnx
       else
-        full_management_data id, api: api
+        full_management_data id, cnx: cnx
       end
     end
 
     # The full set of management data for a given computer.
     # This private method is called by self.management_data, q.v.
     #
-    def self.full_management_data(id, api: JSS.api)
+    def self.full_management_data(id, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
       mgmt_rsrc = MGMT_DATA_RSRC + "/id/#{id}"
-      api.get_rsrc(mgmt_rsrc)[MGMT_DATA_KEY]
+      cnx.c_get(mgmt_rsrc)[MGMT_DATA_KEY]
     end
     private_class_method :full_management_data
 
     # A subset of management data for a given computer.
     # This private method is called by self.management_data, q.v.
     #
-    def self.management_data_subset(id, subset: nil, only: nil, api: JSS.api)
+    def self.management_data_subset(id, subset: nil, only: nil, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
       raise "Subset must be one of :#{MGMT_DATA_SUBSETS.join ', :'}" unless MGMT_DATA_SUBSETS.include? subset
+
       subset_rsrc = MGMT_DATA_RSRC + "/id/#{id}/subset/#{subset}"
-      subset_data = api.get_rsrc(subset_rsrc)[MGMT_DATA_KEY]
+      subset_data = cnx.c_get(subset_rsrc)[MGMT_DATA_KEY]
       return subset_data[subset] unless only
+
       subset_data[subset].map { |d| d[only] }
     end
     private_class_method :management_data_subset
@@ -776,8 +875,8 @@ module JSS
     #   alt_mac_address:, barcode_1:, barcode_2:
     #
     #
-    def initialize(args = {})
-      super args
+    def initialize(**args)
+      super
       if @in_jss
 
         # mutable stuff
@@ -946,21 +1045,21 @@ module JSS
 
     # Get application usage data for this computer
     # for a given date range.
-    # See {JSS::Computer.application_usage} for details
+    # See {Jamf::Computer.application_usage} for details
     #
     def application_usage(start_date, end_date = nil)
-      JSS::Computer.application_usage @id, start_date, end_date, api: @api
+      Jamf::Computer.application_usage @id, start_date, end_date, cnx: @cnx
     end # app usage
 
     # The 'computer management' data for this computer
     #
     # NOTE: the data isn't cached locally, and the API is queried every time
     #
-    # @see {JSS::Computer.management_data} for details
+    # @see {Jamf::Computer.management_data} for details
     #
     def management_data(subset: nil, only: nil)
-      raise JSS::NoSuchItemError, 'Computer not yet saved in the JSS' unless @in_jss
-      JSS::Computer.management_data @id, subset: subset, only: only, api: @api
+      raise Jamf::NoSuchItemError, 'Computer not yet saved in the JSS' unless @in_jss
+      Jamf::Computer.management_data @id, subset: subset, only: only, cnx: @cnx
     end
 
     # A shortcut for 'management_data subset: :smart_groups'
@@ -1038,7 +1137,7 @@ module JSS
     # The same as
     #   #set_management_to nil, nil
     # followed by
-    #   JSS::Computer.send_mdm_command @id, :unmanage_device
+    #   Jamf::Computer.send_mdm_command @id, :unmanage_device
     # which currently isn't working
     #
     # @return [void]
@@ -1058,15 +1157,14 @@ module JSS
     end
 
     # flush the logs for this computer in a given policy
-    # @see JSS::Policy.flush_logs
+    # @see Jamf::Policy.flush_logs
     #
     def flush_policy_logs(policy, older_than: 0, period: :days)
-      JSS::Policy.flush_logs(
+      Jamf::Policy.flush_logs(
         policy,
         older_than: older_than,
         period: period,
-        computers: [@id],
-        api: @api
+        computers: [@id], cnx: @cnx
       )
     end
 
@@ -1088,31 +1186,31 @@ module JSS
 
     def ip_address=(new_val)
       return nil if @ip_address == new_val
-      @ip_address = new_val.empty? ? new_val : JSS::Validate.ip_address(new_val)
+      @ip_address = new_val.empty? ? new_val : Jamf::Validate.ip_address(new_val)
       @need_to_update = true
     end
 
     def mac_address=(new_val)
       return nil if new_val == @mac_address
-      @mac_address =  new_val.empty? ? new_val : JSS::Validate.mac_address(new_val)
+      @mac_address =  new_val.empty? ? new_val : Jamf::Validate.mac_address(new_val)
       @need_to_update = true
     end
 
     def alt_mac_address=(new_val)
       return nil if new_val == @alt_mac_address
-      @alt_mac_address = new_val.empty? ? new_val : JSS::Validate.mac_address(new_val)
+      @alt_mac_address = new_val.empty? ? new_val : Jamf::Validate.mac_address(new_val)
       @need_to_update = true
     end
 
     def serial_number=(new_val)
       return nil if new_val == @serial_number
-      @serial_number =  new_val.empty? ? new_val : JSS::Validate.doesnt_already_exist(JSS::Computer, :serial_number, new_val, api: api)
+      @serial_number =  new_val.empty? ? new_val : Jamf::Validate.doesnt_already_exist(Jamf::Computer, :serial_number, new_val, cnx: cnx)
       @need_to_update = true
     end
 
     def udid=(new_val)
       return nil if new_val == @udid
-      @udid = new_val.empty? ? new_val : JSS::Validate.doesnt_already_exist(JSS::Computer, :udid, new_val, api: api)
+      @udid = new_val.empty? ? new_val : Jamf::Validate.doesnt_already_exist(Jamf::Computer, :udid, new_val, cnx: cnx)
       @need_to_update = true
     end
 
@@ -1171,6 +1269,9 @@ module JSS
       @software = nil
     end # delete
 
+
+
+
     # aliases
     alias alt_macaddress alt_mac_address
     alias bar_code_1 barcode1
@@ -1202,7 +1303,7 @@ module JSS
     # In particular, any data gatherd by a Recon cannot be changed
     #
     def rest_xml
-      doc = REXML::Document.new APIConnection::XML_HEADER
+      doc = REXML::Document.new Jamf::Connection::XML_HEADER
       computer = doc.add_element self.class::RSRC_OBJECT_KEY.to_s
 
       general = computer.add_element('general')
@@ -1235,5 +1336,3 @@ module JSS
   end # class Computer
 
 end # module
-
-require 'jss/api_object/computer/application_installs'