ruby-jss 1.6.0 → 2.0.0a11

data/lib/{jss/api_object → jamf/api/classic/api_objects}/management_history.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
 
   # Mixin Modules
   #####################################
@@ -57,7 +57,7 @@ module JSS
   # == Raw data versus processed data & event object classes
   #
   # The primary data-retrieval method for management history data is
-  # {JSS::ManagementHistory.management_history}. This method returns the raw
+  # {Jamf::ManagementHistory.management_history}. This method returns the raw
   # JSON data from the API, parsed into a Ruby Hash. If you don't specify a
   # subset, the data returned can be very large.
   #
@@ -68,10 +68,10 @@ module JSS
   # the remaining methods, which only return subsets of the full dataset, will
   # return Arrays of instances of the classes defined in this module.
   #
-  # For example, the {JSS::MobileDevice.audit_history} method returns an Array
-  # of JSS::ManagementHistory::AuditEvent instances,  and the
-  # {JSS::Computer.completed_policies} gives an Array of
-  # JSS::ManagementHistory::PolicyLog objects.
+  # For example, the {Jamf::MobileDevice.audit_history} method returns an Array
+  # of Jamf::ManagementHistory::AuditEvent instances,  and the
+  # {Jamf::Computer.completed_policies} gives an Array of
+  # Jamf::ManagementHistory::PolicyLog objects.
   #
   # These objects are read-only and provide access to their values via both
   # attribute-style methods, and hash-like keys, similar to how OpenStruct
@@ -173,24 +173,26 @@ module JSS
       # NOTE: This returns the raw JSON data from the API, parsed into
       # a ruby Hash. Use the subset-specific methods to retrieve more consistent
       # arrays of ruby-jss objects for each kind of history event, e.g.
-      # JSS::Computer.audits(id) or JSS::MobileDevice.audits(id) to get an array
-      # of JSS::ManagementHistory::AuditEvent objects
+      # Jamf::Computer.audits(id) or Jamf::MobileDevice.audits(id) to get an array
+      # of Jamf::ManagementHistory::AuditEvent objects
       #
       # @param ident [Integer,String] An identifier (id, name, serialnumber,
       #   macadress or udid) of the computer or device for which to retrieve history
       #
       # @param subset[Symbol] the subset to return, rather than full history.
       #
-      # @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,Array] The raw full history or subset requested
       #
-      def management_history(ident, subset = nil, api: JSS.api)
-        id = valid_id ident, api: api
-        raise JSS::NoSuchItemError, "No #{self::RSRC_OBJECT_KEY} matches identifier: #{ident}" unless id
+      def management_history(ident, subset = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
 
-        if self == JSS::Computer
+        id = valid_id ident, cnx: cnx
+        raise Jamf::NoSuchItemError, "No #{self::RSRC_OBJECT_KEY} matches identifier: #{ident}" unless id
+
+        if self == Jamf::Computer
           @hist_subsets ||= HIST_COMPUTER_SUBSETS
           @hist_rsrc ||= HIST_COMPUTER_RSRC
           @hist_key ||= HIST_COMPUTER_KEY
@@ -203,9 +205,9 @@ module JSS
         if subset
           raise "Subset must be one of :#{@hist_subsets.join ', :'}" unless @hist_subsets.include? subset
           subset_rsrc = @hist_rsrc + "/id/#{id}/subset/#{subset}"
-          api.get_rsrc(subset_rsrc)[@hist_key][subset]
+          cnx.c_get(subset_rsrc)[@hist_key][subset]
         else
-          api.get_rsrc(@hist_rsrc + "/id/#{id}")[@hist_key]
+          cnx.c_get(@hist_rsrc + "/id/#{id}")[@hist_key]
         end
       end
       alias history management_history
@@ -214,14 +216,16 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::AuditEvent>] An array of audit events
+      # @return [Array<Jamf::ManagementHistory::AuditEvent>] An array of audit events
       #
-      def audit_history(ident, api: JSS.api)
-        hist = management_history(ident, :audits, api: api)
-        hist.map! { |aud| JSS::ManagementHistory::AuditEvent.new aud }
+      def audit_history(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        hist = management_history(ident, :audits, cnx: cnx)
+        hist.map! { |aud| Jamf::ManagementHistory::AuditEvent.new aud }
       end
       alias audits audit_history
 
@@ -229,14 +233,16 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::UserLocationChange>] An array of UserLocation change events
+      # @return [Array<Jamf::ManagementHistory::UserLocationChange>] An array of UserLocation change events
       #
-      def user_location_history(ident, api: JSS.api)
-        hist = management_history(ident, :user_location, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::UserLocationChange.new evt }
+      def user_location_history(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        hist = management_history(ident, :user_location, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::UserLocationChange.new evt }
       end
 
       # The history of mdm commands for a target
@@ -245,16 +251,18 @@ module JSS
       #
       # @param status [Symbol] Return only the :completed, :pending, or :failed commands
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MDMCommand>] An array of MDMCommands
+      # @return [Array<Jamf::ManagementHistory::MdmCommand>] An array of MdmCommands
       #
-      def mdm_command_history(ident, status = nil, api: JSS.api)
-        subset = self == JSS::Computer ? :commands : :management_commands
-        hist = management_history(ident, subset, api: api)
+      def mdm_command_history(ident, status = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        subset = self == Jamf::Computer ? :commands : :management_commands
+        hist = management_history(ident, subset, cnx: cnx)
         if status
-          raise JSS::InvalidDataError, 'status must be one of :completed, :pending, or :failed' unless HIST_MDM_STATUSES.include? status
+          raise Jamf::InvalidDataError, 'status must be one of :completed, :pending, or :failed' unless HIST_MDM_STATUSES.include? status
           statuses_to_do = [status]
         else
           statuses_to_do = HIST_MDM_STATUSES
@@ -271,7 +279,7 @@ module JSS
             # but we always set the :status
             cmd[:status] = a_status
 
-            JSS::ManagementHistory::MDMCommand.new cmd
+            Jamf::ManagementHistory::MdmCommand.new cmd
           end # map do |cmd|
         end # statuses_to_do.each do |a_status|
         result
@@ -283,13 +291,15 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MDMCommand>] An array of completed MDMCommands
+      # @return [Array<Jamf::ManagementHistory::MdmCommand>] An array of completed MdmCommands
       #
-      def completed_mdm_commands(ident, api: JSS.api)
-        mdm_command_history(ident, :completed, api: api)
+      def completed_mdm_commands(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        mdm_command_history(ident, :completed, cnx: cnx)
       end # completed_mdm_commands
       alias completed_commands completed_mdm_commands
 
@@ -297,13 +307,15 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MDMCommand>] An array of pending MDMCommands
+      # @return [Array<Jamf::ManagementHistory::MdmCommand>] An array of pending MdmCommands
       #
-      def pending_mdm_commands(ident, api: JSS.api)
-        mdm_command_history(ident, :pending, api: api)
+      def pending_mdm_commands(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        mdm_command_history(ident, :pending, cnx: cnx)
       end # completed_mdm_commands
       alias pending_commands pending_mdm_commands
 
@@ -311,13 +323,15 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MDMCommand>] An array of failed MDMCommands
+      # @return [Array<Jamf::ManagementHistory::MdmCommand>] An array of failed MdmCommands
       #
-      def failed_mdm_commands(ident, api: JSS.api)
-        mdm_command_history(ident, :failed, api: api)
+      def failed_mdm_commands(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        mdm_command_history(ident, :failed, cnx: cnx)
       end # completed_mdm_commands
       alias failed_commands failed_mdm_commands
 
@@ -330,14 +344,16 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Time, nil] An array of completed MDMCommands
+      # @return [Time, nil] An array of completed MdmCommands
       #
-      def last_mdm_contact(ident, api: JSS.api)
-        epochs = completed_mdm_commands(ident, api: api).map { |cmd| cmd.completed_epoch }
-        epochs += failed_mdm_commands(ident, api: api).map { |cmd| cmd.failed_epoch }
+      def last_mdm_contact(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        epochs = completed_mdm_commands(ident, cnx: cnx).map { |cmd| cmd.completed_epoch }
+        epochs += failed_mdm_commands(ident, cnx: cnx).map { |cmd| cmd.failed_epoch }
         epoch = epochs.max
         epoch ? JSS.epoch_to_time(epoch) : nil
       end
@@ -349,17 +365,19 @@ module JSS
       #
       # @param status [Symbol] Return only the :installed, :pending, or :failed apps
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MacAppStoreApp>] An array of MacAppStoreApp
+      # @return [Array<Jamf::ManagementHistory::MacAppStoreApp>] An array of MacAppStoreApp
       #
-      def mac_app_store_app_history(ident, status = nil, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have mac app store apps' unless self == JSS::Computer
+      def mac_app_store_app_history(ident, status = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have mac app store apps' unless self == Jamf::Computer
 
-        hist = management_history(ident, :mac_app_store_applications, api: api)
+        hist = management_history(ident, :mac_app_store_applications, cnx: cnx)
         if status
-          raise JSS::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
+          raise Jamf::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
           statuses_to_do = [status]
         else
           statuses_to_do = HIST_APP_STATUSES
@@ -371,7 +389,7 @@ module JSS
           result += hist[a_status].map! do |app|
             # set the :status
             app[:status] = a_status
-            JSS::ManagementHistory::MacAppStoreApp.new app
+            Jamf::ManagementHistory::MacAppStoreApp.new app
           end # map do |cmd|
         end # statuses_to_do.each do |a_status|
 
@@ -384,17 +402,19 @@ module JSS
       #
       # @param status [Symbol] Return only the :installed, :pending, or :failed apps
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::MobileDeviceApp>] An array of MobileDeviceApp
+      # @return [Array<Jamf::ManagementHistory::MobileDeviceApp>] An array of MobileDeviceApp
       #
-      def mobile_device_app_history(ident, status = nil, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only mobile devices have mobile device apps' unless self == JSS::MobileDevice
+      def mobile_device_app_history(ident, status = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only mobile devices have mobile device apps' unless self == Jamf::MobileDevice
 
-        hist = management_history(ident, :applications, api: api)
+        hist = management_history(ident, :applications, cnx: cnx)
         if status
-          raise JSS::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
+          raise Jamf::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
           statuses_to_do = [status]
         else
           statuses_to_do = HIST_APP_STATUSES
@@ -427,7 +447,7 @@ module JSS
           result += apps.map! do |app|
             # set the :status in the hash
             app[:status] = a_status
-            JSS::ManagementHistory::MobileDeviceApp.new app
+            Jamf::ManagementHistory::MobileDeviceApp.new app
           end # map do |cmd|
         end # statuses_to_do.each do |a_status|
 
@@ -440,16 +460,18 @@ module JSS
       #
       # @param status [Symbol] Return only the :installed, :pending, or :failed apps
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
       # @return [Array] An array of MacAppStoreApp or MobileDeviceApp
       #
-      def app_store_app_history(ident, status = nil, api: JSS.api)
-        if self == JSS::MobileDevice
-          mobile_device_app_history(ident, status, api: api)
+      def app_store_app_history(ident, status = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        if self == Jamf::MobileDevice
+          mobile_device_app_history(ident, status, cnx: cnx)
         else
-          mac_app_store_app_history(ident, status, api: api)
+          mac_app_store_app_history(ident, status, cnx: cnx)
         end
       end
       alias managed_app_history app_store_app_history
@@ -458,8 +480,10 @@ module JSS
       #
       # @see #app_store_app_history
       #
-      def installed_app_store_apps(ident, api: JSS.api)
-        app_store_app_history(ident, :installed, api: api)
+      def installed_app_store_apps(ident,api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        app_store_app_history(ident, :installed, cnx: cnx)
       end
       alias installed_managed_apps installed_app_store_apps
 
@@ -467,8 +491,10 @@ module JSS
       #
       # @see #app_store_app_history
       #
-      def pending_app_store_apps(ident, api: JSS.api)
-        app_store_app_history(ident, :pending, api: api)
+      def pending_app_store_apps(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        app_store_app_history(ident, :pending, cnx: cnx)
       end
       alias pending_managed_apps pending_app_store_apps
 
@@ -476,8 +502,10 @@ module JSS
       #
       # @see #app_store_app_history
       #
-      def failed_app_store_apps(ident, api: JSS.api)
-        app_store_app_history(ident, :failed, api: api)
+      def failed_app_store_apps(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        app_store_app_history(ident, :failed, cnx: cnx)
       end
       alias failed_managed_apps failed_app_store_apps
 
@@ -485,45 +513,51 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::CasperImagingLog>] An array of CasperImagingLog events
+      # @return [Array<Jamf::ManagementHistory::CasperImagingLog>] An array of CasperImagingLog events
       #
-      def casper_imaging_logs(ident, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have casper imaging logs' unless self == JSS::Computer
-        hist = management_history(ident, :casper_imaging_logs, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::CasperImagingLog.new evt }
+      def casper_imaging_logs(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have casper imaging logs' unless self == Jamf::Computer
+        hist = management_history(ident, :casper_imaging_logs, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::CasperImagingLog.new evt }
       end
 
       # The history of Casper Remote events for a computer
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::CasperRemoteLog>] An array of CasperRemoteLog events
+      # @return [Array<Jamf::ManagementHistory::CasperRemoteLog>] An array of CasperRemoteLog events
       #
-      def casper_remote_logs(ident, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have casper remote logs' unless self == JSS::Computer
-        hist = management_history(ident, :casper_remote_logs, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::CasperRemoteLog.new evt }
+      def casper_remote_logs(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have casper remote logs' unless self == Jamf::Computer
+        hist = management_history(ident, :casper_remote_logs, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::CasperRemoteLog.new evt }
       end
 
       # The history of usage events for a computer
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::ComputerUsageLog>] An array of ComputerUsageLog events
+      # @return [Array<Jamf::ManagementHistory::ComputerUsageLog>] An array of ComputerUsageLog events
       #
-      def computer_usage_logs(ident, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have usage logs' unless self == JSS::Computer
-        hist = management_history(ident, :computer_usage_logs, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::ComputerUsageLog.new evt }
+      def computer_usage_logs(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have usage logs' unless self == Jamf::Computer
+        hist = management_history(ident, :computer_usage_logs, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::ComputerUsageLog.new evt }
       end
       alias usage_logs computer_usage_logs
 
@@ -531,44 +565,52 @@ module JSS
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::ScreenSharingLog>] An array of ScreenSharingLog events
+      # @return [Array<Jamf::ManagementHistory::ScreenSharingLog>] An array of ScreenSharingLog events
       #
-      def screen_sharing_logs(ident, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have screen sharing logs' unless self == JSS::Computer
-        hist = management_history(ident, :screen_sharing_logs, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::ScreenSharingLog.new evt }
+      def screen_sharing_logs(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have screen sharing logs' unless self == Jamf::Computer
+        hist = management_history(ident, :screen_sharing_logs, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::ScreenSharingLog.new evt }
       end
 
       # The history of policy execution for a computer
       #
       # @param ident [Type] The identifier for the object - id, name, sn, udid, etc.
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::PolicyLog>] An array of PolicyLog events
+      # @return [Array<Jamf::ManagementHistory::PolicyLog>] An array of PolicyLog events
       #
-      def policy_logs(ident, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only computers have policy logs' unless self == JSS::Computer
-        hist = management_history(ident, :policy_logs, api: api)
-        hist.map! { |evt| JSS::ManagementHistory::PolicyLog.new evt }
+      def policy_logs(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only computers have policy logs' unless self == Jamf::Computer
+        hist = management_history(ident, :policy_logs, cnx: cnx)
+        hist.map! { |evt| Jamf::ManagementHistory::PolicyLog.new evt }
       end
 
       # The array from .policy_logs, limited to status = :completed
       # @see ManagementHistory::ClassMethods.policy_logs
       #
-      def completed_policies(ident, api: JSS.api)
-        policy_logs(ident, api: api).select { |pl| pl.status == :completed }
+      def completed_policies(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        policy_logs(ident, cnx: cnx).select { |pl| pl.status == :completed }
       end
 
       # The array from .policy_logs, limited to status = :failed
       # @see ManagementHistory::ClassMethods.policy_logs
       #
-      def failed_policies(ident, api: JSS.api)
-        policy_logs(ident, api: api).select { |pl| pl.status == :failed }
+      def failed_policies(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        policy_logs(ident, cnx: cnx).select { |pl| pl.status == :failed }
       end
 
       # The history of ebooks for a mobile device
@@ -577,17 +619,19 @@ module JSS
       #
       # @param status [Symbol] Return only the :installed, :pending, or :failed apps
       #
-      # @param api [JSS::APIConnection] The API connection to use for the query
+      # @param cnx [Jamf::Connection] The API connection to use for the query
       #   defaults to the currently active connection
       #
-      # @return [Array<JSS::ManagementHistory::EBook>] An array of EBook
+      # @return [Array<Jamf::ManagementHistory::Ebook>] An array of Ebook
       #
-      def ebook_history(ident, status = nil, api: JSS.api)
-        raise JSS::UnsupportedError, 'Only mobile devices have ebooks' unless self == JSS::MobileDevice
+      def ebook_history(ident, status = nil, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        raise Jamf::UnsupportedError, 'Only mobile devices have ebooks' unless self == Jamf::MobileDevice
 
-        hist = management_history(ident, :ebooks, api: api)
+        hist = management_history(ident, :ebooks, cnx: cnx)
         if status
-          raise JSS::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
+          raise Jamf::InvalidDataError, 'status must be one of :installed, :pending, or :failed' unless HIST_APP_STATUSES.include? status
           statuses_to_do = [status]
         else
           statuses_to_do = HIST_APP_STATUSES
@@ -620,7 +664,7 @@ module JSS
           result += books.map! do |book|
             # set the :status in the hash
             book[:status] = a_status
-            JSS::ManagementHistory::EBook.new book
+            Jamf::ManagementHistory::Ebook.new book
           end # map do |books|
         end # statuses_to_do.each do |a_status|
 
@@ -632,8 +676,10 @@ module JSS
       #
       # @see #ebook_history
       #
-      def installed_ebooks(ident, api: JSS.api)
-        ebook_history(ident, :installed, api: api)
+      def installed_ebooks(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        ebook_history(ident, :installed, cnx: cnx)
       end
       alias installed_managed_ebooks installed_ebooks
 
@@ -641,8 +687,10 @@ module JSS
       #
       # @see #ebook_history
       #
-      def pending_ebooks(ident, api: JSS.api)
-        ebook_history(ident, :pending, api: api)
+      def pending_ebooks(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        ebook_history(ident, :pending, cnx: cnx)
       end
       alias pending_managed_ebooks pending_ebooks
 
@@ -650,21 +698,23 @@ module JSS
       #
       # @see #ebook_history
       #
-      def failed_ebooks(ident, api: JSS.api)
-        ebook_history(ident, :failed, api: api)
+      def failed_ebooks(ident, api: nil, cnx: Jamf.cnx)
+        cnx = api if api
+
+        ebook_history(ident, :failed, cnx: cnx)
       end
       alias failed_managed_ebooks failed_ebooks
 
     end # module ClassMethods
 
     # Extend ourself when included
-    # @see {JSS::ManagementHistory::ClassMethods}
+    # @see {Jamf::ManagementHistory::ClassMethods}
     #
     # See https://codereview.stackexchange.com/questions/23637/mixin-both-instance-and-class-methods-in-ruby
     # for discussion of this technique for mixing in both
     # Class and Instance methods when including a module.
     def self.included(klass)
-      klass.extend JSS::ManagementHistory::ClassMethods
+      klass.extend Jamf::ManagementHistory::ClassMethods
     end
 
     # Mixin Instance Methods
@@ -675,233 +725,220 @@ module JSS
 
     # The raw management history data for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def management_history(subset = nil)
-      self.class.management_history(@id, subset, api: @api)
+      self.class.management_history(@id, subset, cnx: @cnx)
     end
     alias history management_history
 
     # The audit_history for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def audit_history
-      self.class.audit_history(@id, api: @api)
+      self.class.audit_history(@id, cnx: @cnx)
     end
     alias audits audit_history
 
     # The user_location_history for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def user_location_history
-      self.class.user_location_history(@id, api: @api)
+      self.class.user_location_history(@id, cnx: @cnx)
     end
 
     # The mdm_command_history for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def mdm_command_history(status = nil)
-      self.class.mdm_command_history(@id, status, api: @api)
+      self.class.mdm_command_history(@id, status, cnx: @cnx)
     end
     alias commands mdm_command_history
     alias management_command_history mdm_command_history
 
     # The completed_mdm_commands for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def completed_mdm_commands
-      self.class.completed_mdm_commands(@id, api: @api)
+      self.class.completed_mdm_commands(@id, cnx: @cnx)
     end # completed_mdm_commands
     alias completed_commands completed_mdm_commands
 
     # The time of the last completed mdm command for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def last_mdm_contact
-      self.class.last_mdm_contact(@id, api: @api)
+      self.class.last_mdm_contact(@id, cnx: @cnx)
     end # completed_mdm_commands
 
     # The pending_mdm_commands for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def pending_mdm_commands
-      self.class.pending_mdm_commands(@id, api: @api)
+      self.class.pending_mdm_commands(@id, cnx: @cnx)
     end # completed_mdm_commands
     alias pending_commands pending_mdm_commands
 
     # The failed_mdm_commands for this object
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def failed_mdm_commands
-      self.class.failed_mdm_commands(@id, api: @api)
+      self.class.failed_mdm_commands(@id, cnx: @cnx)
     end # completed_mdm_commands
     alias failed_commands failed_mdm_commands
 
     # The mac_app_store_app_history for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def mac_app_store_app_history(status = nil)
-      self.class.mac_app_store_app_history(@id, status, api: @api)
+      self.class.mac_app_store_app_history(@id, status, cnx: @cnx)
     end
 
     # The mobile_device_app_history for this mobile device
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def mobile_device_app_history(status = nil)
-      self.class.mobile_device_app_history(@id, status, api: @api)
+      self.class.mobile_device_app_history(@id, status, cnx: @cnx)
     end
 
     # Wrapper for app store history for both computers and mobile devices
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def app_store_app_history(status = nil)
-      self.class.app_store_app_history(@id, status, api: @api)
+      self.class.app_store_app_history(@id, status, cnx: @cnx)
     end
     alias managed_app_history app_store_app_history
 
     # shortcut for app_store_app_history where status = :installed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def installed_app_store_apps
-      self.class.installed_app_store_apps(@id, api: @api)
+      self.class.installed_app_store_apps(@id, cnx: @cnx)
     end
     alias installed_managed_apps installed_app_store_apps
 
     # shortcut for app_store_app_history where status = :pending
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def pending_app_store_apps
-      self.class.pending_app_store_apps(@id, api: @api)
+      self.class.pending_app_store_apps(@id, cnx: @cnx)
     end
     alias pending_managed_apps pending_app_store_apps
 
     # shortcut for app_store_app_history where status = :failed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def failed_app_store_apps
-      self.class.failed_app_store_apps(@id, api: @api)
+      self.class.failed_app_store_apps(@id, cnx: @cnx)
     end
     alias failed_managed_apps failed_app_store_apps
 
     # The casper_imaging_logs for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def casper_imaging_logs
-      self.class.casper_imaging_logs(@id, api: @api)
+      self.class.casper_imaging_logs(@id, cnx: @cnx)
     end
 
     # The casper_remote_logs for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def casper_remote_logs
-      self.class.casper_remote_logs(@id, api: @api)
+      self.class.casper_remote_logs(@id, cnx: @cnx)
     end
 
     # The computer_usage_logs for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def computer_usage_logs
-      self.class.computer_usage_logs(@id, api: @api)
+      self.class.computer_usage_logs(@id, cnx: @cnx)
     end
     alias usage_logs computer_usage_logs
 
     # The screen_sharing_logs for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def screen_sharing_logs
-      self.class.screen_sharing_logs(@id, api: @api)
+      self.class.screen_sharing_logs(@id, cnx: @cnx)
     end
 
     # The policy_logs for this computer
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def policy_logs
-      self.class.policy_logs(@id, api: @api)
+      self.class.policy_logs(@id, cnx: @cnx)
     end
 
     # The array from .policy_logs, limited to status = :completed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def completed_policies
-      self.class.completed_policies(@id, api: @api)
+      self.class.completed_policies(@id, cnx: @cnx)
     end
 
     # The array from .policy_logs, limited to status = :failed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def failed_policies
-      self.class.failed_policies(@id, api: @api)
+      self.class.failed_policies(@id, cnx: @cnx)
     end
 
     # The ebook_history for this mobile device
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def ebook_history(status = nil)
-      self.class.ebook_history(@id, status, api: @api)
+      self.class.ebook_history(@id, status, cnx: @cnx)
     end
     alias managed_ebook_history ebook_history
 
     # shortcut for ebook_history where status = :installed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def installed_ebooks
-      self.class.installed_ebooks(@id, api: @api)
+      self.class.installed_ebooks(@id, cnx: @cnx)
     end
     alias installed_managed_ebooks installed_ebooks
 
     # shortcut for ebook_history where status = :pending
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def pending_ebooks
-      self.class.pending_ebooks(@id, api: @api)
+      self.class.pending_ebooks(@id, cnx: @cnx)
     end
     alias pending_managed_ebooks pending_ebooks
 
     # shortcut for ebook_history where status = :failed
     #
-    # @see the matching method in  {JSS::ManagementHistory::ClassMethods}
+    # @see the matching method in  {Jamf::ManagementHistory::ClassMethods}
     #
     def failed_ebooks
-      self.class.failed_ebooks(@id, api: @api)
+      self.class.failed_ebooks(@id, cnx: @cnx)
     end
     alias failed_managed_ebooks failed_ebooks
 
   end # module ManagementHistory
 
-end # module JSS
-
-require 'jss/api_object/management_history/hashlike'
-require 'jss/api_object/management_history/audit_event'
-require 'jss/api_object/management_history/casper_imaging_log'
-require 'jss/api_object/management_history/casper_remote_log'
-require 'jss/api_object/management_history/computer_usage_log'
-require 'jss/api_object/management_history/ebook'
-require 'jss/api_object/management_history/mac_app_store_app'
-require 'jss/api_object/management_history/mdm_command'
-require 'jss/api_object/management_history/mobile_device_app'
-require 'jss/api_object/management_history/policy_log'
-require 'jss/api_object/management_history/screen_sharing_log'
-require 'jss/api_object/management_history/user_location_change'
+end # module Jamf