win32-taskscheduler 1.0.10 → 1.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 708456348a54a2c6be8ec93ab9902d108170ad0289ac17c2104b4dbbe43bfd0b
-  data.tar.gz: 3ba2b649ebf7f15bfe0e22b3f60d8462b925a26e0fb8277a4a5017647bf85a18
+  metadata.gz: 5b6d6ad467e4dd3518af4776d1937f9227afbc42bf743c3f3b09480141e08e15
+  data.tar.gz: 2a3a9d694c22b5734e30c50fe50142af6b23e6d467c8e38e33ee48bba3a15952
 SHA512:
-  metadata.gz: b2cf2048d079aaf38b865b8ff391bb09e7926006f743503b4a4322d84cfd7d814c40daf105dac9846109d45e1e43f153702e4e38ace8674cdebb9d46e85fd74a
-  data.tar.gz: 5e5e2c0fb0c1f45e90a19c7b50477958d18416a148a5ce16488121e06e947cdd2c7078a257847b4ff9a5e8b74351e0cc289e5ac7f6ae664261f2eaa044199095
+  metadata.gz: e5ca12f5424d5f790107a1af5ff8838e7931d846cdece3959627c0500a34ff2bcdae1fa749f253a89f4b523065ca27b15f1e629dc11ad586a990854cfbcb2a83
+  data.tar.gz: c423125d42002ae09d4bc1fab148004a325e399cbdeb5bb48fb6210f1f3f5af510a4ecd9f0345fd8ec1e4291905c214d2e8d58eb261cd5b7e791d2b3c59c9c49

data/CHANGELOG.md

@@ -4,21 +4,28 @@ Note: this log contains only changes from win32-taskscheduler release 0.4.0 and
 -- it does not contain the changes from prior releases. To view change history
 prior to release 0.4.0, please visit the [source repository](https://github.com/chef/win32-taskscheduler/commits).
 
-<!-- latest_release 1.0.10 -->
-## [win32-taskscheduler-1.0.10](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.10) (2018-07-24)
+<!-- latest_release 1.0.12 -->
+## [win32-taskscheduler-1.0.12](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.12) (2018-10-11)
 
 #### Merged Pull Requests
-- Fix exists? method breaking task full path search [#62](https://github.com/chef/win32-taskscheduler/pull/62) ([Vasu1105](https://github.com/Vasu1105))
+- Fixing user registration at Non English version of windows [#69](https://github.com/chef/win32-taskscheduler/pull/69) ([Nimesh-Msys](https://github.com/Nimesh-Msys))
 <!-- latest_release -->
 
-<!-- release_rollup since=1.0.9 -->
-### Changes since 1.0.9 release
+<!-- release_rollup since=1.0.10 -->
+### Changes since 1.0.10 release
 
 #### Merged Pull Requests
-- Fix exists? method breaking task full path search [#62](https://github.com/chef/win32-taskscheduler/pull/62) ([Vasu1105](https://github.com/Vasu1105)) <!-- 1.0.10 -->
+- Fixing user registration at Non English version of windows [#69](https://github.com/chef/win32-taskscheduler/pull/69) ([Nimesh-Msys](https://github.com/Nimesh-Msys)) <!-- 1.0.12 -->
+- Refactored configure_settings [#67](https://github.com/chef/win32-taskscheduler/pull/67) ([btm](https://github.com/btm)) <!-- 1.0.11 -->
 <!-- release_rollup -->
 
 <!-- latest_stable_release -->
+## [win32-taskscheduler-1.0.10](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.10) (2018-07-24)
+
+#### Merged Pull Requests
+- Fix exists? method breaking task full path search [#62](https://github.com/chef/win32-taskscheduler/pull/62) ([Vasu1105](https://github.com/Vasu1105))
+<!-- latest_stable_release -->
+
 ## [win32-taskscheduler-1.0.9](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.9) (2018-07-23)
 
 #### Merged Pull Requests
@@ -29,7 +36,6 @@ prior to release 0.4.0, please visit the [source repository](https://github.com/
 - [MSYS-827] Add functional test cases  [#58](https://github.com/chef/win32-taskscheduler/pull/58) ([Nimesh-Msys](https://github.com/Nimesh-Msys))
 - Add DisallowStartIfOnBatteries and StopIfGoingOnBatteries task configs [#61](https://github.com/chef/win32-taskscheduler/pull/61) ([dheerajd-msys](https://github.com/dheerajd-msys))
 - Fix priority should return unique value. [#60](https://github.com/chef/win32-taskscheduler/pull/60) ([Vasu1105](https://github.com/Vasu1105))
-<!-- latest_stable_release -->
 
 ## [win32-taskscheduler-1.0.2](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-1.0.2) (2018-06-13)
 - Fix for exists? method returning false for task without full path. [#43](https://github.com/chef/win32-taskscheduler/pull/43)([#Vasu1105](https://github.com/Vasu1105))

data/VERSION

@@ -1 +1 @@
-1.0.10
+1.0.12

data/examples/taskscheduler_example.rb

@@ -6,30 +6,29 @@
 #
 # Modify as you see fit.
 #######################################################################
-require 'win32/taskscheduler'
-require 'fileutils'
-require 'pp'
+require "win32/taskscheduler"
+require "fileutils"
+require "pp"
 include Win32
 
-puts 'VERSION: ' + TaskScheduler::VERSION
+puts "VERSION: " + TaskScheduler::VERSION
 
 ts = TaskScheduler.new
 
 trigger = {
-	"start_year" 	=> 2009,
-	"start_month" 	=> 4,
-	"start_day"   	=> 11,
-	"start_hour"	=> 7,
-	"start_minute"	=> 14,
-	"trigger_type"	=> TaskScheduler::DAILY,
-	"type"			=> { "days_interval" => 1 }
+  start_year: 2009,
+  start_month: 4,
+  start_day: 11,
+  start_hour: 7,
+  start_minute: 14,
+  trigger_type: TaskScheduler::DAILY,
+  type: { "days_interval" => 1 }
 }
 
 unless ts.enum.grep(/foo/).length > 0
-	ts.new_work_item("foo", trigger)
-	ts.application_name = "notepad.exe"
-	ts.save
-	puts "Task Added"
+  ts.new_work_item("foo", trigger)
+  ts.application_name = "notepad.exe"
+  puts "Task Added"
 end
 
 ts.activate("foo")
@@ -39,7 +38,6 @@ ts.working_directory = "C:\\"
 puts "App name: " + ts.application_name
 puts "Creator: " + ts.creator
 puts "Exit code: " + ts.exit_code.to_s
-puts "Flags: " + ts.flags.to_s
 puts "Max run time: " + ts.max_run_time.to_s
 puts "Next run time: " + ts.next_run_time.to_s
 puts "Parameters: " + ts.parameters

data/lib/win32/taskscheduler.rb

@@ -329,36 +329,26 @@ module Win32
     # Sets the +user+ and +password+ for the given task. If the user and
     # password are set properly then true is returned.
     # throws TypeError if password is not provided for other than system users
-    def set_account_information(user, password)
-      raise TypeError unless user.is_a?(String)
-      unless SYSTEM_USERS.include?(user.upcase)
-        raise TypeError unless password.is_a?(String)
-      end
+    def set_account_information(user_id, password)
+      check_credential_requirements(user_id, password)
       check_for_active_task
-
       @password = password
-
-      begin
-        @task = @root.RegisterTaskDefinition(
-          @task.Path,
-          @task.Definition,
-          TASK_CREATE_OR_UPDATE,
-          user,
-          password,
-          password ? TASK_LOGON_PASSWORD : TASK_LOGON_SERVICE_ACCOUNT
-        )
-      rescue WIN32OLERuntimeError => err
-        raise Error, ole_error('RegisterTaskDefinition', err)
-      end
-
+      register_task_definition(@task.Definition, @task.Path, user_id, password)
       true
     end
 
-    # Returns the user associated with the task or nil if no user has yet
-    # been associated with the task.
+    # Returns the user or group associated with the task or nil if no one has been associated with the task yet
+    #
+    # @return [String] user or group associated with the task
     #
     def account_information
-      @task.nil? ? nil : @task.Definition.Principal.UserId
+      if @task.nil?
+        nil
+      elsif !@task.Definition.Principal.UserId.empty?
+        @task.Definition.Principal.UserId
+      else
+        @task.Definition.Principal.GroupId
+      end
     end
 
     # Returns the name of the application associated with the task. If
@@ -391,7 +381,7 @@ module Win32
         action.Path = app if action.Type == 0
       end
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       app
     end
@@ -426,7 +416,7 @@ module Win32
         action.Arguments = param if action.Type == 0
       end
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       param
     end
@@ -459,7 +449,7 @@ module Win32
         action.WorkingDirectory = dir if action.Type == 0
       end
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       dir
     end
@@ -511,7 +501,7 @@ module Win32
       definition = @task.Definition
       definition.Settings.Priority = priority
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       priority
     end
@@ -521,16 +511,12 @@ module Win32
     # job should run.
     #
     def new_work_item(task, trigger, userinfo = { user: nil, password: nil })
-      raise TypeError unless userinfo.is_a?(Hash)
-      raise TypeError unless task.is_a?(String)
-      raise TypeError unless trigger.is_a?(Hash)
+      raise TypeError unless userinfo.is_a?(Hash) && task.is_a?(String) && trigger.is_a?(Hash)
 
-      unless userinfo[:user].nil?
-        raise TypeError unless userinfo[:user].is_a?(String)
-        unless SYSTEM_USERS.include?(userinfo[:user])
-          raise TypeError unless userinfo[:password].is_a?(String)
-        end
-      end
+      # If user ID is not given, consider it as a 'SYSTEM' user
+      userinfo[:user] = SERVICE_ACCOUNT_USERS.first if userinfo[:user].to_s.empty?
+
+      check_credential_requirements(userinfo[:user], userinfo[:password])
 
       taskDefinition = @service.NewTask(0)
       taskDefinition.RegistrationInfo.Description = ''
@@ -621,18 +607,8 @@ module Win32
       act.Path = 'cmd'
 
       @password = userinfo[:password]
-      begin
-        @task = @root.RegisterTaskDefinition(
-          task,
-          taskDefinition,
-          TASK_CREATE_OR_UPDATE,
-          userinfo[:user].nil? || userinfo[:user].empty? ? 'SYSTEM': userinfo[:user],
-          userinfo[:password],
-          userinfo[:password] ? TASK_LOGON_PASSWORD : TASK_LOGON_SERVICE_ACCOUNT
-        )
-      rescue WIN32OLERuntimeError => err
-        raise Error, ole_error('RegisterTaskDefinition', err)
-      end
+
+      register_task_definition(taskDefinition, task, userinfo[:user], userinfo[:password])
 
       @task = @root.GetTask(task)
     end
@@ -677,7 +653,7 @@ module Win32
 
       definition = @task.Definition
       definition.Triggers.Remove(index)
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       index
     end
@@ -860,7 +836,7 @@ module Win32
           end
       end
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       trigger
     end
@@ -947,7 +923,7 @@ module Win32
           trig.Delay = "PT#{trigger[:delay_duration]||0}M"
       end
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       true
     end
@@ -1004,7 +980,7 @@ module Win32
 
       definition = @task.Definition
       definition.RegistrationInfo.Description = comment
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       comment
     end
@@ -1028,7 +1004,7 @@ module Win32
 
       definition = @task.Definition
       definition.RegistrationInfo.Author = creator
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       creator
     end
@@ -1059,18 +1035,6 @@ module Win32
       time
     end
 
-    # Returns idle settings for current active task
-    #
-    def idle_settings
-      check_for_active_task
-      idle_settings = {}
-      idle_settings[:idle_duration] = @task.Definition.Settings.IdleSettings.IdleDuration
-      idle_settings[:stop_on_idle_end] = @task.Definition.Settings.IdleSettings.StopOnIdleEnd
-      idle_settings[:wait_timeout] = @task.Definition.Settings.IdleSettings.WaitTimeout
-      idle_settings[:restart_on_idle] = @task.Definition.Settings.IdleSettings.RestartOnIdle
-      idle_settings
-    end
-
     # Returns the execution time limit for current active task
     #
     def execution_time_limit
@@ -1120,89 +1084,93 @@ module Win32
 
       definition = @task.Definition
       definition.Settings.ExecutionTimeLimit = limit
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       max_run_time
     end
 
-    # Accepts a hash that lets you configure various task definition settings.
-    # The possible options are:
-    #
-    # * allow_demand_start
-    # * allow_hard_terminate
-    # * compatibility
-    # * delete_expired_task_after
-    # * disallowed_start_if_on_batteries
-    # * enabled
-    # * execution_time_limit (or max_run_time)
-    # * hidden
-    # * idle_settings
-    # * network_settings
-    # * priority
-    # * restart_count
-    # * restart_interval
-    # * run_only_if_idle
-    # * run_only_if_network_available
-    # * start_when_available
-    # * stop_if_going_on_batteries
-    # * wake_to_run
-    # * xml_text (or xml)
+    # The Idle settings of a task
     #
-    def configure_settings(hash)
-      raise TypeError unless hash.is_a?(Hash)
-      check_for_active_task
+    # @see https://docs.microsoft.com/en-us/windows/desktop/TaskSchd/idlesettings#properties
+    #
+    IdleSettings = %i[idle_duration restart_on_idle stop_on_idle_end wait_timeout]
+
+    # Configures tasks settings
+    #
+    # @param [Hash] settings_hash The settings to configure a task
+    # @option settings_hash [Boolean] :allow_demand_start The subject
+    # @option settings_hash [Boolean] :allow_hard_terminate
+    # @option settings_hash [Boolean] :disallow_start_if_on_batteries
+    # @option settings_hash [Boolean] :disallow_start_on_remote_app_session
+    # @option settings_hash [Boolean] :enabled
+    # @option settings_hash [Boolean] :hidden
+    # @option settings_hash [Boolean] :run_only_if_idle
+    # @option settings_hash [Boolean] :run_only_if_network_available
+    # @option settings_hash [Boolean] :start_when_available
+    # @option settings_hash [Boolean] :stop_if_going_on_batteries
+    # @option settings_hash [Boolean] :use_unified_scheduling_engine
+    # @option settings_hash [Boolean] :volatile
+    # @option settings_hash [Boolean] :wake_to_run
+    # @option settings_hash [Boolean] :restart_on_idle The Idle Setting
+    # @option settings_hash [Boolean] :stop_on_idle_end The Idle Setting
+    # @option settings_hash [Integer] :compatibility
+    # @option settings_hash [Integer] :multiple_instances
+    # @option settings_hash [Integer] :priority
+    # @option settings_hash [Integer] :restart_count
+    # @option settings_hash [String] :delete_expired_task_after
+    # @option settings_hash [String] :execution_time_limit
+    # @option settings_hash [String] :restart_interval
+    # @option settings_hash [String] :idle_duration The Idle Setting
+    # @option settings_hash [String] :wait_timeout The Idle Setting
+    #
+    # @return [Hash] User input
+    #
+    # @see https://msdn.microsoft.com/en-us/library/windows/desktop/aa383480(v=vs.85).aspx#properties
+    #
+    def configure_settings(settings_hash)
+      raise TypeError, "User input settings are required in hash" unless settings_hash.is_a?(Hash)
 
+      check_for_active_task
       definition = @task.Definition
 
-      allow_demand_start = hash[:allow_demand_start]
-      allow_hard_terminate = hash[:allow_hard_terminate]
-      compatibility = hash[:compatibility]
-      delete_expired_task_after = hash[:delete_expired_task_after]
-      disallow_start_if_on_batteries = hash[:disallow_start_if_on_batteries]
-      enabled = hash[:enabled]
-      execution_time_limit = "PT#{hash[:execution_time_limit] || hash[:max_run_time] || 0}M"
-      hidden = hash[:hidden]
-      idle_duration = "PT#{hash[:idle_duration]||0}M"
-      stop_on_idle_end = hash[:stop_on_idle_end]
-      wait_timeout = "PT#{hash[:wait_timeout]||0}M"
-      restart_on_idle = hash[:restart_on_idle]
-      network_settings = hash[:network_settings]
-      priority = hash[:priority]
-      restart_count = hash[:restart_count]
-      restart_interval = hash[:restart_interval]
-      run_only_if_idle = hash[:run_only_if_idle]
-      run_only_if_network_available = hash[:run_only_if_network_available]
-      start_when_available = hash[:start_when_available]
-      stop_if_going_on_batteries = hash[:stop_if_going_on_batteries]
-      wake_to_run = hash[:wake_to_run]
-      xml_text = hash[:xml_text] || hash[:xml]
+      # Check for invalid setting
+      invalid_settings = settings_hash.keys - valid_settings_options
+      raise TypeError, "Invalid setting passed: #{invalid_settings.join(', ')}" unless invalid_settings.empty?
 
-      definition.Settings.AllowDemandStart = allow_demand_start if allow_demand_start
-      definition.Settings.AllowHardTerminate = allow_hard_terminate if allow_hard_terminate
-      definition.Settings.Compatibility = compatibility if compatibility
-      definition.Settings.DeleteExpiredTaskAfter = delete_expired_task_after if delete_expired_task_after
-      definition.Settings.DisallowStartIfOnBatteries = disallow_start_if_on_batteries if !disallow_start_if_on_batteries.nil?
-      definition.Settings.Enabled = enabled if enabled
-      definition.Settings.ExecutionTimeLimit = execution_time_limit if execution_time_limit
-      definition.Settings.Hidden = hidden if hidden
-      definition.Settings.IdleSettings.IdleDuration = idle_duration if idle_duration
-      definition.Settings.IdleSettings.StopOnIdleEnd = stop_on_idle_end if stop_on_idle_end
-      definition.Settings.IdleSettings.WaitTimeout = wait_timeout if wait_timeout
-      definition.Settings.IdleSettings.RestartOnIdle = restart_on_idle if restart_on_idle
-      definition.Settings.NetworkSettings = network_settings if network_settings
-      definition.Settings.Priority = priority if priority
-      definition.Settings.RestartCount = restart_count if restart_count
-      definition.Settings.RestartInterval = restart_interval if restart_interval
-      definition.Settings.RunOnlyIfIdle = run_only_if_idle if run_only_if_idle
-      definition.Settings.RunOnlyIfNetworkAvailable = run_only_if_network_available if run_only_if_network_available
-      definition.Settings.StartWhenAvailable = start_when_available if start_when_available
-      definition.Settings.StopIfGoingOnBatteries  = stop_if_going_on_batteries if !stop_if_going_on_batteries.nil?
-      definition.Settings.WakeToRun = wake_to_run if wake_to_run
-      definition.Settings.XmlText = xml_text if xml_text
-
-      update_task_definition(definition)
+      # Some modification is required in user input
+      hash = settings_hash.dup
 
-      hash
+      # Conversion of few settings
+      hash[:execution_time_limit] = hash[:max_run_time] unless hash[:max_run_time].nil?
+      %i[execution_time_limit idle_duration restart_interval wait_timeout].each do |setting|
+        hash[setting] = "PT#{hash[setting]}M" unless hash[setting].nil?
+      end
+
+      task_settings = definition.Settings
+
+      # Some Idle setting needs to be configured
+      if IdleSettings.any? { |setting| hash.key?(setting) }
+        idle_settings = task_settings.IdleSettings
+        IdleSettings.each do |setting|
+          unless hash[setting].nil?
+            idle_settings.setproperty(camelize(setting.to_s), hash[setting])
+            # This setting is not required to be configured now
+            hash.delete(setting)
+          end
+        end
+      end
+
+      # XML settings are not to be configured
+      %i[xml_text xml].map { |x| hash.delete(x) }
+
+      hash.each do |setting, value|
+        setting = camelize(setting.to_s)
+        definition.Settings.setproperty(setting, value)
+      end
+
+      register_task_definition(definition)
+
+      settings_hash
     end
 
     # Set registration information options. The possible options are:
@@ -1247,7 +1215,7 @@ module Win32
       definition.RegistrationInfo.Version = version if version
       definition.RegistrationInfo.XmlText = xml_text if xml_text
 
-      update_task_definition(definition)
+      register_task_definition(definition)
 
       hash
     end
@@ -1266,7 +1234,7 @@ module Win32
       definition.Principal.LogonType = principals[:logon_type] if principals[:logon_type].to_s != ""
       definition.Principal.GroupId = principals[:group_id] if principals[:group_id].to_s != ""
       definition.Principal.RunLevel = principals[:run_level] if principals[:run_level].to_s != ""
-      update_task_definition(definition)
+      register_task_definition(definition)
       principals
     end
 
@@ -1314,8 +1282,17 @@ module Win32
       symbolize_keys(settings_hash)
     end
 
+    # Returns the user or group associated with the task. If no one is associated, it returns the default user i.e., 'SYSTEM'
+    #
+    # @param [WIN32OLE] definition
+    #
+    # @return [String] user_id
+    #
     def task_user_id(definition)
-      definition.Principal.UserId
+      user_id = definition.Principal.UserId.to_s
+      user_id = definition.Principal.GroupId.to_s if user_id.empty?
+      user_id = SERVICE_ACCOUNT_USERS.first if user_id.empty?
+      user_id
     end
 
     private
@@ -1325,6 +1302,16 @@ module Win32
       string.gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze).downcase
     end
 
+    # Converts a snake-case string to camel-case format
+    #
+    # @param [String] str
+    #
+    # @return [String] In camel case format
+    #
+    def camelize(str)
+      str.split('_').map(&:capitalize).join
+    end
+
     # Converts all the keys of a hash to underscored-symbol format
     def symbolize_keys(hash)
       hash.each_with_object({}) do |(k, v), h|
@@ -1344,22 +1331,119 @@ module Win32
       }
     end
 
+    # Configurable settings options
+    #
+    # @note Logically, this is summation of
+    #  * Settings
+    #  * IdleSettings - [:idle_settings]
+    #  * :max_run_time, :xml
+    #
+    # @return [Array]
+    #
+    def valid_settings_options
+      %i[allow_demand_start allow_hard_terminate compatibility delete_expired_task_after
+         disallow_start_if_on_batteries disallow_start_on_remote_app_session enabled
+         execution_time_limit hidden idle_duration maintenance_settings max_run_time
+         multiple_instances network_settings priority restart_count restart_interval
+         restart_on_idle run_only_if_idle run_only_if_network_available
+         start_when_available stop_if_going_on_batteries stop_on_idle_end
+         use_unified_scheduling_engine volatile wait_timeout wake_to_run xml xml_text]
+    end
+
     def check_for_active_task
       raise Error, 'No currently active task' if @task.nil?
     end
 
-    def update_task_definition(definition)
-      user = task_user_id(definition) || 'SYSTEM'
+    # Checks if the user belongs to service accounts category
+    #
+    # @return  [Boolean] True or False
+    #
+    def service_account_user?(user)
+      SERVICE_ACCOUNT_USERS.include?(user.to_s.upcase)
+    end
+
+    # Checks if the user belongs to group accounts category
+    #
+    # @return [Boolean] True or False
+    #
+    def group_user?(user)
+      BUILT_IN_GROUPS.include?(user.to_s.upcase)
+    end
+
+    # Checks if the user belongs to system users category
+    #
+    # @return  [Boolean] True or False
+    #
+    def system_user?(user)
+      SYSTEM_USERS.include?(user.to_s.upcase)
+    end
+
+    # Checks whether the given set of user_id and password suits our requirements.
+    #
+    # Raises the error in case of any failures
+    #
+    # Password should be nil for System Users. For other users, it is required.
+    #
+    # @param [String] user_id
+    # @param [String] password
+    #
+    def check_credential_requirements(user_id, password)
+      user_id = user_id.to_s
+      password = password.to_s
+      # Password will be required for non-system users
+      if password.empty?
+        unless system_user?(user_id)
+          raise Error, 'Password is required for non-system users'
+        end
+      else
+        if system_user?(user_id)
+          raise Error, 'Password is not required for system users'
+        end
+      end
+    end
+
+    # Returns the applicable flag as per the given users and groups which is used while
+    # RegisterTaskDefinition
+    #
+    # @param [String] user_id
+    # @param [String] password
+    #
+    # @return [Integer] Logon Types
+    #
+    def logon_type(user_id, password)
+      if service_account_user?(user_id)
+        TASK_LOGON_SERVICE_ACCOUNT
+      elsif group_user?(user_id)
+        TASK_LOGON_GROUP
+      elsif !password.to_s.empty? # Password is present
+        TASK_LOGON_PASSWORD
+      else
+        TASK_LOGON_INTERACTIVE_TOKEN
+      end
+    end
+
+    # Uses RegisterTaskDefinition and creates or updates the task
+    #
+    # @param [WIN32OLE] definition
+    # @param [String] path
+    # @param [String] user_id
+    # @param [String] password
+    #
+    # @return [Integer] Logon Types
+    #
+    def register_task_definition(definition, path = nil, user_id = nil, password = nil)
+      user_id ||= task_user_id(definition)
+      path ||= @task.Path
       @task = @root.RegisterTaskDefinition(
-        @task.Path,
-        definition,
-        TASK_CREATE_OR_UPDATE,
-        user,
-        @password,
-        @password ? TASK_LOGON_PASSWORD : TASK_LOGON_SERVICE_ACCOUNT
+        path, # Path (name) of the task
+        definition, # definition of the task
+        TASK_CREATE_OR_UPDATE, # Equivalent to TASK_CREATE | TASK_UPDATE
+        user_id,
+        password,
+        logon_type(user_id, password)
       )
     rescue WIN32OLERuntimeError => err
-      method_name = caller_locations(1,1)[0].label
+      method_name = caller_locations(1, 1)[0].label
       raise Error, ole_error(method_name, err)
     end
   end

data/lib/win32/taskscheduler/version.rb

@@ -1,6 +1,6 @@
 module Win32
   class TaskScheduler
     # The version of the win32-taskscheduler library
-    VERSION = '1.0.10'.freeze
+    VERSION = '1.0.12'.freeze
   end
 end

data/lib/win32/windows/constants.rb

@@ -1,7 +1,11 @@
+require_relative 'sid'
 module Windows
   module TaskSchedulerConstants
+    SERVICE_ACCOUNT_USERS = SID::SERVICE_ACCOUNT_USERS
 
-    SYSTEM_USERS = ['NT AUTHORITY\SYSTEM', "SYSTEM", 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', "USERS"].freeze
+    BUILT_IN_GROUPS = SID::BUILT_IN_GROUPS
+
+    SYSTEM_USERS = SERVICE_ACCOUNT_USERS + BUILT_IN_GROUPS
 
     # Triggers
 
@@ -192,7 +196,6 @@ module Windows
     # Not in use; currently identical to TASK_LOGON_PASSWORD
     TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD  = 6
 
-
     TASK_MAX_RUN_TIMES = 1440
     TASKS_TO_RETRIEVE  = 5
 
@@ -215,12 +218,12 @@ module Windows
     BELOW_NORMAL_PRIORITY_CLASS = 7 # Or 8
     IDLE_PRIORITY_CLASS         = 9 # Or 10
 
-    CLSCTX_INPROC_SERVER  = 0x1
-    CLSID_CTask =  [0x148BD520,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
-    CLSID_CTaskScheduler =  [0x148BD52A,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
-    IID_ITaskScheduler = [0x148BD527,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
-    IID_ITask = [0x148BD524,0xA2AB,0x11CE,0xB1,0x1F,0x00,0xAA,0x00,0x53,0x05,0x03].pack('LSSC8')
-    IID_IPersistFile = [0x0000010b,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46].pack('LSSC8')
+    CLSCTX_INPROC_SERVER = 0x1
+    CLSID_CTask = [0x148BD520, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03].pack('LSSC8')
+    CLSID_CTaskScheduler = [0x148BD52A, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03].pack('LSSC8')
+    IID_ITaskScheduler = [0x148BD527, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03].pack('LSSC8')
+    IID_ITask = [0x148BD524, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03].pack('LSSC8')
+    IID_IPersistFile = [0x0000010b, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46].pack('LSSC8')
 
     # Days of month
 

data/lib/win32/windows/helper.rb

@@ -8,11 +8,15 @@ module Windows
     FORMAT_MESSAGE_FROM_SYSTEM    = 0x00001000
     FORMAT_MESSAGE_MAX_WIDTH_MASK = 0x000000FF
 
-    ffi_lib :kernel32
+    ffi_lib :kernel32, :advapi32
 
     attach_function :FormatMessage, :FormatMessageA,
     [:ulong, :pointer, :ulong, :ulong, :pointer, :ulong, :pointer], :ulong
 
+    attach_function :ConvertStringSidToSidW, [ :pointer, :pointer ], :bool
+    attach_function :LookupAccountSidW, [ :pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer ], :bool
+    attach_function :LocalFree, [ :pointer ], :pointer
+
     def win_error(function, err=FFI.errno)
       err_msg = ''
       flags = FORMAT_MESSAGE_IGNORE_INSERTS |

data/lib/win32/windows/sid.rb

@@ -0,0 +1,128 @@
+require_relative 'helper'
+
+module FFI
+  class Pointer
+    def read_wstring(num_wchars = nil)
+      if num_wchars.nil?
+        # Find the length of the string
+        length = 0
+        last_char = nil
+        while last_char != "\000\000"
+          length += 1
+          last_char = get_bytes(0, length * 2)[-2..-1]
+        end
+
+        num_wchars = length
+      end
+
+      wide_to_utf8(get_bytes(0, num_wchars * 2))
+    end
+
+    def wide_to_utf8(wstring)
+      # ensure it is actually UTF-16LE
+      # Ruby likes to mark binary data as ASCII-8BIT
+      wstring = wstring.force_encoding('UTF-16LE')
+
+      # encode it all as UTF-8 and remove trailing CRLF and NULL characters
+      wstring.encode('UTF-8').strip
+    end
+  end
+end
+
+class SID
+  extend Windows::TaskSchedulerHelper
+  ERROR_INSUFFICIENT_BUFFER = 122
+
+  def self.LocalSystem
+    from_string_sid('S-1-5-18')
+  end
+
+  def self.NtLocal
+    from_string_sid('S-1-5-19')
+  end
+
+  def self.NtNetwork
+    from_string_sid('S-1-5-20')
+  end
+
+  def self.BuiltinAdministrators
+    from_string_sid('S-1-5-32-544')
+  end
+
+  def self.BuiltinUsers
+    from_string_sid('S-1-5-32-545')
+  end
+
+  def self.Guests
+    from_string_sid('S-1-5-32-546')
+  end
+
+  # Converts a string-format security identifier (SID) into a valid, functional SID
+  # and returns a hash with account_name and account_simple_name
+  # @see https://docs.microsoft.com/en-us/windows/desktop/api/sddl/nf-sddl-convertstringsidtosidw
+  #
+  def self.from_string_sid(string_sid)
+    result = FFI::MemoryPointer.new :pointer
+    unless ConvertStringSidToSidW(utf8_to_wide(string_sid), result)
+      raise FFI::LastError.error
+    end
+    result_pointer = result.read_pointer
+    domain, name, use = account(result_pointer)
+    LocalFree(result_pointer)
+    account_names(domain, name, use)
+  end
+
+  def self.utf8_to_wide(ustring)
+    # ensure it is actually UTF-8
+    # Ruby likes to mark binary data as ASCII-8BIT
+    ustring = (ustring + '').force_encoding('UTF-8')
+
+    # ensure we have the double-null termination Windows Wide likes
+    ustring += "\000\000" if ustring.empty? || ustring[-1].chr != "\000"
+
+    # encode it all as UTF-16LE AKA Windows Wide Character AKA Windows Unicode
+    ustring.encode('UTF-16LE')
+  end
+
+  # Accepts a security identifier (SID) as input.
+  # It retrieves the name of the account for this SID and the name of the
+  # first domain on which this SID is found
+  # @see https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-lookupaccountsidw
+  #
+  def self.account(sid)
+    sid = sid.pointer if sid.respond_to?(:pointer)
+    name_size = FFI::Buffer.new(:long).write_long(0)
+    referenced_domain_name_size = FFI::Buffer.new(:long).write_long(0)
+
+    if LookupAccountSidW(nil, sid, nil, name_size, nil, referenced_domain_name_size, nil)
+      raise 'Expected ERROR_INSUFFICIENT_BUFFER from LookupAccountSid, and got no error!'
+    elsif FFI::LastError.error != ERROR_INSUFFICIENT_BUFFER
+      raise FFI::LastError.error
+    end
+
+    name = FFI::MemoryPointer.new :char, (name_size.read_long * 2)
+    referenced_domain_name = FFI::MemoryPointer.new :char, (referenced_domain_name_size.read_long * 2)
+    use = FFI::Buffer.new(:long).write_long(0)
+    unless LookupAccountSidW(nil, sid, name, name_size, referenced_domain_name, referenced_domain_name_size, use)
+      raise FFI::LastError.error
+    end
+    [referenced_domain_name.read_wstring(referenced_domain_name_size.read_long), name.read_wstring(name_size.read_long), use.read_long]
+  end
+
+  # Formats domain, name and returns a hash with
+  # account_name and account_simple_name
+  #
+  def self.account_names(domain, name, _use)
+    account_name = !domain.to_s.empty? ? "#{domain}\\#{name}" : name
+    account_simple_name = name
+    { account_name: account_name, account_simple_name: account_simple_name }
+  end
+
+  SERVICE_ACCOUNT_USERS = [self.LocalSystem, self.NtLocal, self.NtNetwork].map do |user|
+    [user[:account_simple_name].upcase, user[:account_name].upcase]
+  end.flatten.freeze
+
+  BUILT_IN_GROUPS = [self.BuiltinAdministrators, self.BuiltinUsers, self.Guests].map do |user|
+    [user[:account_simple_name].upcase, user[:account_name].upcase]
+  end.flatten.freeze
+end

data/spec/functional/win32/taskschedular_spec.rb

@@ -53,7 +53,7 @@ RSpec.describe Win32::TaskScheduler, :windows_only do
         expect(no_of_tasks).to eq(0)
       end
 
-      it 'Raises error when path separators(\\\) are absent' do
+      it "Raises error when path separators(\\\) are absent" do
         invalid_path = 'Foo'
         expect { ts.new(@task, @trigger, invalid_path) }.to raise_error(ArgumentError)
         expect(no_of_tasks).to eq(0)
@@ -215,9 +215,9 @@ RSpec.describe Win32::TaskScheduler, :windows_only do
 
     it 'Execute(Start) the Task' do
       @ts.run
-      expect(@ts.status).to eq('running').
-                         or eq('queued').
-                         or eq('ready') # It takes time to load sometimes
+      expect(@ts.status).to eq('running')
+        .or eq('queued')
+        .or eq('ready') # It takes time to load sometimes
     end
 
     it 'Raises an error if task does not exists' do
@@ -518,20 +518,48 @@ RSpec.describe Win32::TaskScheduler, :windows_only do
 
   describe '#account_information' do
     before { create_task }
-    it 'System users may not require any password' do
-      user = 'SYSTEM'
-      password = nil
-      expect(@ts.set_account_information(user, password)). to be_truthy
-      expect(@ts.account_information).to eq(user)
+    context 'Service Account Users' do
+      let(:service_user) { 'LOCAL SERVICE' }
+      let(:password) { nil }
+      it 'Does not require any password' do
+        expect(@ts.set_account_information(service_user, password)). to be_truthy
+        expect(@ts.account_information.upcase).to eq(service_user)
+      end
+      it 'passing account_name will display account_simple_name' do
+        user = 'NT AUTHORITY\LOCAL SERVICE'
+        expect(@ts.set_account_information(user, password)). to be_truthy
+        expect(@ts.account_information.upcase).to eq(service_user)
+      end
+      it 'Raises an error if password is given' do
+        password = 'XYZ'
+        expect { @ts.set_account_information(service_user, password) }. to raise_error(tasksch_err)
+      end
     end
-
-    it 'User will require a password' do
-      user = ENV['user']
-      password = nil
-      expect { @ts.set_account_information(user, password) }. to raise_error(TypeError)
-      expect(@ts.account_information).to include(user)
+    context 'Built in Groups' do
+      let(:group_user) { 'USERS' }
+      let(:password) { nil }
+      it 'Does not require any password' do
+        expect(@ts.set_account_information(group_user, password)). to be_truthy
+        expect(@ts.account_information.upcase).to eq(group_user)
+      end
+      it 'passing account_name will display account_simple_name' do
+        user = 'BUILTIN\USERS'
+        expect(@ts.set_account_information(user, password)). to be_truthy
+        expect(@ts.account_information.upcase).to eq(group_user)
+      end
+      it 'Raises an error if password is given' do
+        password = 'XYZ'
+        expect { @ts.set_account_information(group_user, password) }. to raise_error(tasksch_err)
+      end
+    end
+    context 'Non-system users' do
+      it 'Require a password' do
+        user = ENV['user']
+        password = nil
+        expect { @ts.set_account_information(user, password) }. to raise_error(tasksch_err)
+        expect(@ts.account_information).to include(user)
+      end
     end
-
     it 'Raises an error if task does not exists' do
       @ts.instance_variable_set(:@task, nil)
       user = 'User'
@@ -640,31 +668,57 @@ RSpec.describe Win32::TaskScheduler, :windows_only do
     before { create_task }
     before { stub_user }
 
+    it 'Require a hash' do
+      expect { @ts.configure_settings('XYZ') }. to raise_error(TypeError)
+      expect(@ts.configure_settings({})).to eq({})
+    end
+
+    it 'Raises an error if invalid setting is passed' do
+      expect { @ts.configure_settings(invalid: true) }. to raise_error(TypeError)
+    end
+
+    it 'Sets settings of the task and returns a hash' do
+      settings = { allow_demand_start: false,
+                   disallow_start_if_on_batteries: false,
+                   enabled: false,
+                   stop_if_going_on_batteries: false }
+
+      expect(@ts.configure_settings(settings)).to eq(settings)
+      expect(@ts.settings).to include(settings)
+    end
+
     it 'Sets idle settings of the task' do
-      skip 'Functionality is not working'
-      # Seems like it accepts time in minutes; but returns the result in ISO8601 format
-      settings = { idle_duration: 'PT11M',
-                   wait_timeout: 'PT2H',
+      # It accepts time in minutes
+      # and returns the result in ISO8601 format
+      settings = { idle_duration: 11,
+                   wait_timeout: 10,
                    stop_on_idle_end: true,
                    restart_on_idle: false }
-      @ts.configure_settings(settings)
-      expect(@ts.idle_settings).to eq(settings)
-    end
 
-    it 'Sets network settings of the task' do
-      skip 'Functionality is not working'
-      settings = { network_settings: { name: 'NET1' } }
+      result_settings = { idle_duration: 'PT11M',
+                          wait_timeout: 'PT10M',
+                          stop_on_idle_end: true,
+                          restart_on_idle: false }
+
       @ts.configure_settings(settings)
-      expect(@ts.network_settings).to eq(settings)
+      expect(@ts.idle_settings).to eq(result_settings)
     end
 
-    it 'Configures the settings of the task' do
-      skip 'Functionality is not working properly'
-      settings = @ts.settings
-      settings[:allow_demand_start] = false
-      settings[:execution_time_limit] = 'PT70H'
-      @ts.configure_settings(settings)
-      expect(@ts.settings).to eq(settings)
+    it 'Set settings and idle settings of the task' do
+      settings = {
+        allow_demand_start: false,
+        disallow_start_if_on_batteries: false,
+        stop_if_going_on_batteries: false
+      }
+
+      idle_settings = {
+        stop_on_idle_end: true,
+        restart_on_idle: false
+      }
+
+      @ts.configure_settings(settings.merge(idle_settings))
+      expect(@ts.settings).to include(settings)
+      expect(@ts.idle_settings).to include(idle_settings)
     end
 
     it 'Raises an error if task does not exists' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: win32-taskscheduler
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.12
 platform: ruby
 authors:
 - Park Heesob
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-24 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -120,6 +120,7 @@ files:
 - lib/win32/taskscheduler/version.rb
 - lib/win32/windows/constants.rb
 - lib/win32/windows/helper.rb
+- lib/win32/windows/sid.rb
 - lib/win32/windows/time_calc_helper.rb
 - spec/functional/win32/taskschedular_spec.rb
 - spec/functional/win32/windows/time_calc_helper_spec.rb