win32-taskscheduler 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b74ccd6aa98c21f9e0a7bdd20c24e09f7e461450
-  data.tar.gz: a0742bc2c56d80f282a1e5cd37fb1b809e0c3e70
+  metadata.gz: '08691b264f7dbe39c37043d65f3765f5949304c3'
+  data.tar.gz: 5247b4be4cf39cefcecb19c795e0dc158bf44ba1
 SHA512:
-  metadata.gz: eaa9bc605ad45fd60797cf46fb9d4083054ead60552c92e10546e4f2e83247cbf0b6c063c9716e7f729271b4b0f7410fc52cdb349e72b281efea287d5252d8fb
-  data.tar.gz: f338910febc7774ce538465684f39e4b6480eb5f5b78d769b56a2c89eb9a02e41d31ead7bba871c1138b09e138c929416dff779d29a2a005b9e3c3f7d589596e
+  metadata.gz: 9394becf37fc16d9fcff57728826f90388c94455f7fd082a5a86ccc87b04d319bf4835266d5119ff508daeed708abee096d49ee07e8ed69ea3e549830d8bf383
+  data.tar.gz: c59df6ee9dc73f263744e0464fdf1031277f66d85601b009995b913fcbb9cdcff10cc6fb41cf78b95ab8d2415b4483716c805b09438a4cd6ae567667355730c0

data/CHANGELOG.md

@@ -0,0 +1,122 @@
+## [v0.4.0](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.4.0) (5-Apr-2018)
+- Updated code to create task without trigger. [#25](https://github.com/chef/win32-taskscheduler/pull/25) ([#Vasu1105](https://github.com/Vasu1105))
+- Fix for execution time limit and weeks of month. [#23](https://github.com/chef/win32-taskscheduler/pull/23) ([#Vasu1105](https://github.com/Vasu1105))
+- Added methods to get and set principal information of the task. [#22](https://github.com/chef/win32-taskscheduler/pull/22) ([#Nimesh-Msys](https://github.com/Nimesh-Msys))
+- Added methods to retrieve settings(all/Idle/Network) of current task. [#21](https://github.com/chef/win32-taskscheduler/pull/21) ([#Nimesh-Msys](https://github.com/Nimesh-Msys))
+- Refactored constants, moved predefined MSDN constns to another file. [#20](https://github.com/chef/win32-taskscheduler/pull/20) ([#Nimesh-Msys](https://github.com/Nimesh-Msys))
+- Added code to handle on idle trigger and on idle settings. [#19](https://github.com/chef/win32-taskscheduler/pull/19) ([#Vasu1105](https://github.com/Vasu1105))
+- Fix for trigger at_logon and at_system_start. [#18](https://github.com/chef/win32-taskscheduler/pull/18) ([#Nimesh-Msys](https://github.com/Nimesh-Msys))
+- Added get_task and enabled? method. [#17](https://github.com/chef/win32-taskscheduler/pull/17) ([#Vasu1105](https://github.com/Vasu1105))
+- Fix for undefined method 'weeks' error while updating week_of_month[#16](https://github.com/chef/win32-taskscheduler/pull/16) ([#Vasu1105](https://github.com/Vasu1105))
+- Fix for handling days of month for trigger_type MONTHLYDATE. [#15](https://github.com/chef/win32-taskscheduler/pull/15)([#Vasu1105](https://github.com/Vasu1105))
+- Fix for setting system user for scheduled task. [#14](https://github.com/chef/win32-taskscheduler/pull/14) ([#Vasu1105](https://github.com/Vasu1105))
+- Fix for Wrong value is set for end_day, end_year, end_month it should be EndBoundary and not StartBoundary. [#13](https://github.com/chef/win32-taskscheduler/pull/13)([#Vasu1105](https://github.com/Vasu1105))
+
+## [v0.3.2](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.3.2) (18-Mar-2017)
+- Use the block form for FFI::MemoryPointer in the error message helper
+  function. Thanks go to Ethan Brown for the suggestion.
+- Fixed a potential bug in the helper module, which was also renamed to
+  help prevent any name collisions.
+- Added the win32-taskscheduler.rb file for convenience.
+- Added the configure_settings method.
+- Added the configure_registration_info method.
+- Added the description and description= aliases for comments.
+- Added the author and author= aliases for creator.
+- Some internal cleanup, moving common code to private methods.
+- Rakefile now assumes Rubygems 2.0 or later for tasks.
+- Gemspec cleanup, updated home page, removed old rubyforge_project reference.
+- This gem is now signed.
+
+## [v0.3.1](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.3.1) (6-Jul-2014)
+- Added FFI as a dependency. Thanks go to Maxime Lapointe for the spot.
+- Some updates to the win_error helper method. Thanks go to Ethan J. Brown
+  for the suggestions.
+
+## [v0.3.0](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.3.0) (15-Jan-2014)
+- Rewritten to use Win32OLE instead of using wrapping the C API. Benefits
+  include working on Windows Vista or later, and working with JRuby.
+- Modified the constructor to accept 3rd and 4th arguments. These indicate
+  which folder to use, and whether or not to create it if it doesn't exist.
+- The TaskScheduler#save method is now no longer necessary. It is retained
+  for backwards compatibility, but will raise a deprecation warning. In this
+  version simply calling TaskScheduler#activate will implement the task.
+- Added support for the AT_SYSTEMSTART, AT_LOGON and ON_IDLE trigger types.
+- Now requires the structured_warnings gem.
+- Removed the doc directory and separate documentation file. Everything is
+  inlined now. There's still an example under the "examples" directory, too.
+- Added test-unit, rake, and win32-security as development dependencies.
+  These are needed for testing only.
+
+## [v0.2.2](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.2.2)(29-Feb-2012)
+- Moved some include statements inside the TaskScheduler class to avoid
+  polluting Object. Thanks go to Josh Cooper for the spot and patch.
+- Minor formatting tweaks to silence 1.9 warnings.
+
+## [v0.2.1](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.2.1) (8-Oct-2011)
+- Fixed a bug that would not allow task to run as SYSTEM. Thanks go to
+  Josh cooper for the spot and patch.
+- Fixed a bug in new_work_item that would cause it to crash if you tried
+  to create a work item that already existed. An error is now raised instead.
+  Thanks go to Pete Higgins for the spot.
+- The set_trigger and trigger= methods now internally transform and validate
+  the trigger hash in the same manner as new_work_item. Thanks again go to
+  Pete Higgins.
+- Cleaned up the repo. The C source files have been removed from the main
+  repository (and this gem). They are in a separate branch on github for
+  anyone who misses them.
+- Refactored the Rakefile, removing tasks related to the old C source files,
+  and added tasks for cleaning, building and installing a gem.
+- Updated the README file, eliminating references to anything that was only
+  related to the older C version.
+
+## [v0.2.0](https://github.com/chef/win32-taskscheduler/tree/win32-taskscheduler-0.2.0)(19-Jun-2009)
+- Rewritten in pure Ruby!
+- The TaskScheduler::ONCE constant is now a valid trigger type. Thanks go to
+  Uri Iurgel for the spot and patch.
+- Added the TaskScheduler#exists? method.
+- Added the TaskScheduler#tasks alias for the TaskScheduler#enum method.
+- The TaskScheduler#new_work_item method now accepts symbols as well as
+  strings for hash keys, and ignores case. Also, the keys are now validated.
+- Renamed the example file and test file.
+- Added the 'example' Rake task.
+- Fixed some code in the README synopsis that was incorrect.
+
+## [v0.1.0](11-May-2008)
+- The TaskScheduler#save instance method now accepts an optional file name.
+- Most of the TaskScheduler setter methods now return the value specified
+  instead of true.
+- Removed the RUN_ONLY_IF_DOCKED and RUN_IF_CONNECTED_TO_INTERNET constants.
+  The MSDN docs say that they are unused.
+- Added more documentation. Much more rdoc friendly now.
+- Added many more tests.
+- Better type handling for bad arguments.
+- Added a Rakefile with tasks for building, installation and testing.
+- Added a gemspec.
+- Inlined the rdoc documentation.
+- Internal project reorganization and code cleanup.
+
+## [v0.0.3](1-Mar-2005)
+- Bug fix for the bitFieldToHumanDays() internal function.
+- Moved the 'examples' directory to the toplevel directory.
+- Made the CHANGES and README files rdoc friendly.
+- Minor updates to taskscheduler.h.
+
+## [v0.0.2](04-Aug-2004)
+- Now uses the newer allocation framework and replaced all instances of the
+  deprecated STR2CSTR() function with StringValuePtr().  This means that, as
+  of this release, Ruby 1.8.0 or later is required.
+- Modified the constructor to accept arguments.  This is just some sugar for
+  creating a new task item in one call instead of two.
+- The argument to trigger= now must be a hash.  The same goes for the 'type'
+  sub-hash.
+- Added the add_trigger() method.  Actually, the C code for this method was
+  already in place, I simply forgot to create a corresponding Ruby method
+  for it.
+- Removed the create_trigger() method.  This was really nothing more than an
+  alias for trigger=().  I got confused somehow.
+- Test suite modified and many more tests added.
+- Documentation updates, including docs for a couple of methods that I had
+  accidentally omitted previously.
+
+## [v0.0.1](24-Apr-2004)
+- Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README

@@ -58,10 +58,11 @@
 
   Please submit any bug reports to the project page at:
 
-  http://github.com/djberg96/win32-taskscheduler
+  http://github.com/chef/win32-taskscheduler
 
 = Copyright
   (C) 2003-2017 Daniel J. Berger
+  (C) 2018 Chef Software, Inc.
   All Rights Reserved
 
 = License

data/RELEASE_NOTES.md

@@ -0,0 +1,36 @@
+<!---
+This file is reset every time a new release is done. The contents of this file are for the currently unreleased version.
+
+Example Note:
+
+## Example Heading
+Details about the thing that changed that needs to get included in the Release Notes in markdown.
+-->
+
+# win32-taskscheduler 0.4.0 release notes:
+In this release we have fixed some issues and added following methods.
+
+`get_task`
+Returns current active task with given name.
+
+`configure_principals`
+Sets the principals for current active task. The principal is hash with following possible options.
+Expected principal hash: { id: STRING, display_name: STRING, user_id: STRING, logon_type: INTEGER, group_id: STRING, run_level: INTEGER }
+
+'principals'
+Returns a hash containing all the principal information of the current task.
+
+`execution_time_limit`
+Returns execution time limit for current active task.
+
+`settings`
+Returns a hash containing all settings of the current task.
+
+`idle_settings`
+Returns a hash of idle settings of the current task.
+
+`network_settings`
+Returns a hash of network settings of the current task.
+
+'enabled?'
+Returns true if current task is enabled

data/Rakefile

@@ -9,7 +9,6 @@ namespace 'gem' do
   task :create => [:clean] do
     require 'rubygems/package'
     spec = eval(IO.read('win32-taskscheduler.gemspec'))
-    spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
     Gem::Package.build(spec, true)
   end
 

data/certs/djberg96_pub.pem

@@ -1,21 +1,21 @@
------BEGIN CERTIFICATE-----
-MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhkamJl
-cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
-MB4XDTE2MTIxMjAwMTQ1M1oXDTE3MTIxMjAwMTQ1M1owPzERMA8GA1UEAwwIZGpi
-ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
-bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMVtTm/wETO8yKVKRPBO
-VgPRvE94iEfKryOb/tQrmhGhchG2ALqdw/r54cGJvLaXeItrYJ6N8pSE/FSnN5jM
-xugUhHBprPl+AsQ4E+IBy0dKwyU8XjFoVYzWvT1wnqwQdSazdgFCfQqb51QCgUIT
-PGGakKlyzCb3Mbq30is8+QlRrqXt/JbpkUZbQwUqCdAulMT4oyPBk/L+48pbVX0s
-4yj7YaVAqfGByAMTPXEmUS388lX+0xq8+GGir2Fuh0TpNW0ggr9BxprwqL0Mg4Oo
-YhM5L1y8Plolo8mOTN3+K8I3afZ0lD0BtwniVb6g+Ut/4aBjKy2+GyFwwNOu0gSj
-desCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFJfg
-HmQ0uDU3Z9A9hB1lQMjr5VZSMB0GA1UdEQQWMBSBEmRqYmVyZzk2QGdtYWlsLmNv
-bTAdBgNVHRIEFjAUgRJkamJlcmc5NkBnbWFpbC5jb20wDQYJKoZIhvcNAQEFBQAD
-ggEBACjRCHRP944MHIQJNCglZbDnZowybV2HxmG1uhnvRwrOjBA7CXemc+QSAL7K
-7eXC4FdojVEJrnU7ZxuCmfQU+fvkEQKOnah1osG1874aPiDlwtjHclpeqcDgTUI7
-A7CF+OXK8x7ksFx205ruhPHKaPYtwVG/W/J+y7Wx8yl9rvwUgRBL5cVzTBiEz+AB
-NRT7yoHXXfFXjuQWN1eHunSbNds2ZTGQd64yBCujb17Xdl+F9tu4klkTga3gxP3P
-y3zoX1VttxnIZBojRM/s2A7c2aubMH2SVbXMR3ccVkB9XbYKl1OvCe7q85xEHit2
-Kbpico5nnyHqf7YSPmvZe8bCU94=
------END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE2MTIxMjAwMTQ1M1oXDTE3MTIxMjAwMTQ1M1owPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMVtTm/wETO8yKVKRPBO
+VgPRvE94iEfKryOb/tQrmhGhchG2ALqdw/r54cGJvLaXeItrYJ6N8pSE/FSnN5jM
+xugUhHBprPl+AsQ4E+IBy0dKwyU8XjFoVYzWvT1wnqwQdSazdgFCfQqb51QCgUIT
+PGGakKlyzCb3Mbq30is8+QlRrqXt/JbpkUZbQwUqCdAulMT4oyPBk/L+48pbVX0s
+4yj7YaVAqfGByAMTPXEmUS388lX+0xq8+GGir2Fuh0TpNW0ggr9BxprwqL0Mg4Oo
+YhM5L1y8Plolo8mOTN3+K8I3afZ0lD0BtwniVb6g+Ut/4aBjKy2+GyFwwNOu0gSj
+desCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFJfg
+HmQ0uDU3Z9A9hB1lQMjr5VZSMB0GA1UdEQQWMBSBEmRqYmVyZzk2QGdtYWlsLmNv
+bTAdBgNVHRIEFjAUgRJkamJlcmc5NkBnbWFpbC5jb20wDQYJKoZIhvcNAQEFBQAD
+ggEBACjRCHRP944MHIQJNCglZbDnZowybV2HxmG1uhnvRwrOjBA7CXemc+QSAL7K
+7eXC4FdojVEJrnU7ZxuCmfQU+fvkEQKOnah1osG1874aPiDlwtjHclpeqcDgTUI7
+A7CF+OXK8x7ksFx205ruhPHKaPYtwVG/W/J+y7Wx8yl9rvwUgRBL5cVzTBiEz+AB
+NRT7yoHXXfFXjuQWN1eHunSbNds2ZTGQd64yBCujb17Xdl+F9tu4klkTga3gxP3P
+y3zoX1VttxnIZBojRM/s2A7c2aubMH2SVbXMR3ccVkB9XbYKl1OvCe7q85xEHit2
+Kbpico5nnyHqf7YSPmvZe8bCU94=
+-----END CERTIFICATE-----

data/lib/win32/taskscheduler.rb

@@ -1,4 +1,6 @@
 require_relative 'windows/helper'
+require_relative 'windows/time_calc_helper'
+require_relative 'windows/constants'
 require 'win32ole'
 require 'socket'
 require 'time'
@@ -10,215 +12,111 @@ module Win32
   # The TaskScheduler class encapsulates a Windows scheduled task
   class TaskScheduler
     include Windows::TaskSchedulerHelper
+    include Windows::TimeCalcHelper
+    include Windows::TaskSchedulerConstants
 
     # The version of the win32-taskscheduler library
-    VERSION = '0.3.2'.freeze
+    VERSION = '0.4.0'.freeze
 
     # The Error class is typically raised if any TaskScheduler methods fail.
     class Error < StandardError; end
 
-    # Triggers
-
-    # Trigger is set to run the task a single tim
-    TASK_TIME_TRIGGER_ONCE = 0
-
-    # Trigger is set to run the task on a daily interval
-    TASK_TIME_TRIGGER_DAILY = 1
-
-    # Trigger is set to run the task on specific days of a specific week & month
-    TASK_TIME_TRIGGER_WEEKLY = 2
-
-    # Trigger is set to run the task on specific day(s) of the month
-    TASK_TIME_TRIGGER_MONTHLYDATE = 3
-
-    # Trigger is set to run the task on specific day(s) of the month
-    TASK_TIME_TRIGGER_MONTHLYDOW = 4
-
-    # Trigger is set to run the task if the system remains idle for the amount
-    # of time specified by the idle wait time of the task
-    TASK_EVENT_TRIGGER_ON_IDLE = 5
-
-    # Trigger is set to run the task at system startup
-    TASK_EVENT_TRIGGER_AT_SYSTEMSTART = 6
-
-    # Trigger is set to run the task when a user logs on
-    TASK_EVENT_TRIGGER_AT_LOGON = 7
-
-    # Daily Tasks
-
-    # The task will run on Sunday
-    TASK_SUNDAY = 0x1
-
-    # The task will run on Monday
-    TASK_MONDAY = 0x2
-
-    # The task will run on Tuesday
-    TASK_TUESDAY = 0x4
-
-    # The task will run on Wednesday
-    TASK_WEDNESDAY = 0x8
-
-    # The task will run on Thursday
-    TASK_THURSDAY = 0x10
-
-    # The task will run on Friday
-    TASK_FRIDAY = 0x20
-
-    # The task will run on Saturday
-    TASK_SATURDAY = 0x40
-
-    # Weekly tasks
-
-    # The task will run between the 1st and 7th day of the month
-    TASK_FIRST_WEEK = 1
-
-    # The task will run between the 8th and 14th day of the month
-    TASK_SECOND_WEEK = 2
-
-    # The task will run between the 15th and 21st day of the month
-    TASK_THIRD_WEEK = 3
-
-    # The task will run between the 22nd and 28th day of the month
-    TASK_FOURTH_WEEK = 4
-
-    # The task will run the last seven days of the month
-    TASK_LAST_WEEK = 5
-
-    # Monthly tasks
-
-    # The task will run in January
-    TASK_JANUARY = 0x1
-
-    # The task will run in February
-    TASK_FEBRUARY = 0x2
-
-    # The task will run in March
-    TASK_MARCH = 0x4
-
-    # The task will run in April
-    TASK_APRIL = 0x8
-
-    # The task will run in May
-    TASK_MAY = 0x10
-
-    # The task will run in June
-    TASK_JUNE = 0x20
-
-    # The task will run in July
-    TASK_JULY = 0x40
-
-    # The task will run in August
-    TASK_AUGUST = 0x80
-
-    # The task will run in September
-    TASK_SEPTEMBER = 0x100
-
-    # The task will run in October
-    TASK_OCTOBER = 0x200
-
-    # The task will run in November
-    TASK_NOVEMBER = 0x400
-
-    # The task will run in December
-    TASK_DECEMBER = 0x800
-
-    # Flags
-
-    # Used when converting AT service jobs into work items
-    TASK_FLAG_INTERACTIVE = 0x1
-
-    # The work item will be deleted when there are no more scheduled run times
-    TASK_FLAG_DELETE_WHEN_DONE = 0x2
-
-    # The work item is disabled. Useful for temporarily disabling a task
-    TASK_FLAG_DISABLED = 0x4
-
-    # The work item begins only if the computer is not in use at the scheduled
-    # start time
-    TASK_FLAG_START_ONLY_IF_IDLE = 0x10
-
-    # The work item terminates if the computer makes an idle to non-idle
-    # transition while the work item is running
-    TASK_FLAG_KILL_ON_IDLE_END = 0x20
-
-    # The work item does not start if the computer is running on battery power
-    TASK_FLAG_DONT_START_IF_ON_BATTERIES = 0x40
-
-    # The work item ends, and the associated application quits, if the computer
-    # switches to battery power
-    TASK_FLAG_KILL_IF_GOING_ON_BATTERIES = 0x80
-
-    # The work item starts only if the computer is in a docking station
-    TASK_FLAG_RUN_ONLY_IF_DOCKED = 0x100
-
-    # The work item created will be hidden
-    TASK_FLAG_HIDDEN = 0x200
-
-    # The work item runs only if there is a valid internet connection
-    TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET = 0x400
-
-    # The work item starts again if the computer makes a non-idle to idle
-    # transition
-    TASK_FLAG_RESTART_ON_IDLE_RESUME = 0x800
-
-    # The work item causes the system to be resumed, or awakened, if the
-    # system is running on batter power
-    TASK_FLAG_SYSTEM_REQUIRED = 0x1000
-
-    # The work item runs only if a specified account is logged on interactively
-    TASK_FLAG_RUN_ONLY_IF_LOGGED_ON = 0x2000
-
-    # Triggers
-
-    # The task will stop at some point in time
-    TASK_TRIGGER_FLAG_HAS_END_DATE = 0x1
-
-    # The task can be stopped at the end of the repetition period
-    TASK_TRIGGER_FLAG_KILL_AT_DURATION_END = 0x2
-
-    # The task trigger is disabled
-    TASK_TRIGGER_FLAG_DISABLED = 0x4
-
-    # :stopdoc:
+    # Shorthand constants
 
-    TASK_MAX_RUN_TIMES = 1440
-    TASKS_TO_RETRIEVE  = 5
+    IDLE = IDLE_PRIORITY_CLASS
+    NORMAL = NORMAL_PRIORITY_CLASS
+    HIGH = HIGH_PRIORITY_CLASS
+    REALTIME = REALTIME_PRIORITY_CLASS
+    BELOW_NORMAL = BELOW_NORMAL_PRIORITY_CLASS
+    ABOVE_NORMAL = ABOVE_NORMAL_PRIORITY_CLASS
 
-    # Task creation
+    ONCE = TASK_TIME_TRIGGER_ONCE
+    DAILY = TASK_TIME_TRIGGER_DAILY
+    WEEKLY = TASK_TIME_TRIGGER_WEEKLY
+    MONTHLYDATE = TASK_TIME_TRIGGER_MONTHLYDATE
+    MONTHLYDOW = TASK_TIME_TRIGGER_MONTHLYDOW
 
-    TASK_VALIDATE_ONLY = 0x1
-    TASK_CREATE = 0x2
-    TASK_UPDATE = 0x4
-    TASK_CREATE_OR_UPDATE = 0x6
-    TASK_DISABLE = 0x8
-    TASK_DONT_ADD_PRINCIPAL_ACE = 0x10
-    TASK_IGNORE_REGISTRATION_TRIGGERS = 0x20
+    ON_IDLE = TASK_EVENT_TRIGGER_ON_IDLE
+    AT_SYSTEMSTART = TASK_EVENT_TRIGGER_AT_SYSTEMSTART
+    AT_LOGON = TASK_EVENT_TRIGGER_AT_LOGON
+    FIRST_WEEK = TASK_FIRST_WEEK
+    SECOND_WEEK = TASK_SECOND_WEEK
+    THIRD_WEEK = TASK_THIRD_WEEK
+    FOURTH_WEEK = TASK_FOURTH_WEEK
+    LAST_WEEK = TASK_LAST_WEEK
+    SUNDAY = TASK_SUNDAY
+    MONDAY = TASK_MONDAY
+    TUESDAY = TASK_TUESDAY
+    WEDNESDAY = TASK_WEDNESDAY
+    THURSDAY = TASK_THURSDAY
+    FRIDAY = TASK_FRIDAY
+    SATURDAY = TASK_SATURDAY
+    JANUARY = TASK_JANUARY
+    FEBRUARY = TASK_FEBRUARY
+    MARCH = TASK_MARCH
+    APRIL = TASK_APRIL
+    MAY = TASK_MAY
+    JUNE = TASK_JUNE
+    JULY = TASK_JULY
+    AUGUST = TASK_AUGUST
+    SEPTEMBER = TASK_SEPTEMBER
+    OCTOBER = TASK_OCTOBER
+    NOVEMBER = TASK_NOVEMBER
+    DECEMBER = TASK_DECEMBER
 
-    # Task logon types
+    INTERACTIVE = TASK_FLAG_INTERACTIVE
+    DELETE_WHEN_DONE = TASK_FLAG_DELETE_WHEN_DONE
+    DISABLED = TASK_FLAG_DISABLED
+    START_ONLY_IF_IDLE = TASK_FLAG_START_ONLY_IF_IDLE
+    KILL_ON_IDLE_END = TASK_FLAG_KILL_ON_IDLE_END
+    DONT_START_IF_ON_BATTERIES = TASK_FLAG_DONT_START_IF_ON_BATTERIES
+    KILL_IF_GOING_ON_BATTERIES = TASK_FLAG_KILL_IF_GOING_ON_BATTERIES
+    RUN_ONLY_IF_DOCKED = TASK_FLAG_RUN_ONLY_IF_DOCKED
+    HIDDEN = TASK_FLAG_HIDDEN
+    RUN_IF_CONNECTED_TO_INTERNET = TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET
+    RESTART_ON_IDLE_RESUME = TASK_FLAG_RESTART_ON_IDLE_RESUME
+    SYSTEM_REQUIRED = TASK_FLAG_SYSTEM_REQUIRED
+    RUN_ONLY_IF_LOGGED_ON = TASK_FLAG_RUN_ONLY_IF_LOGGED_ON
 
-    TASK_LOGON_NONE = 0
-    TASK_LOGON_PASSWORD = 1
-    TASK_LOGON_S4U = 2
-    TASK_LOGON_INTERACTIVE_TOKEN = 3
-    TASK_LOGON_GROUP = 4
-    TASK_LOGON_SERVICE_ACCOUNT = 5
-    TASK_LOGON_INTERACTIVE_TOKEN_OR_PASSWORD = 6
+    FLAG_HAS_END_DATE = TASK_TRIGGER_FLAG_HAS_END_DATE
+    FLAG_KILL_AT_DURATION_END = TASK_TRIGGER_FLAG_KILL_AT_DURATION_END
+    FLAG_DISABLED = TASK_TRIGGER_FLAG_DISABLED
 
-    # Priority classes
+    MAX_RUN_TIMES = TASK_MAX_RUN_TIMES
 
-    REALTIME_PRIORITY_CLASS     = 0
-    HIGH_PRIORITY_CLASS         = 1
-    ABOVE_NORMAL_PRIORITY_CLASS = 2 # Or 3
-    NORMAL_PRIORITY_CLASS       = 4 # Or 5, 6
-    BELOW_NORMAL_PRIORITY_CLASS = 7 # Or 8
-    IDLE_PRIORITY_CLASS         = 9 # Or 10
+    FIRST = TASK_FIRST
+    SECOND = TASK_SECOND
+    THIRD = TASK_THIRD
+    FOURTH = TASK_FOURTH
+    FIFTH = TASK_FIFTH
+    SIXTH = TASK_SIXTH
+    SEVENTH = TASK_SEVENTH
+    EIGHTH = TASK_EIGHTH
+    NINETH = TASK_NINETH
+    TENTH = TASK_TENTH
+    ELEVENTH = TASK_ELEVENTH
+    TWELFTH = TASK_TWELFTH
+    THIRTEENTH = TASK_THIRTEENTH
+    FOURTEENTH = TASK_FOURTEENTH
+    FIFTEENTH = TASK_FIFTEENTH
+    SIXTEENTH = TASK_SIXTEENTH
+    SEVENTEENTH = TASK_SEVENTEENTH
+    EIGHTEENTH = TASK_EIGHTEENTH
+    NINETEENTH = TASK_NINETEENTH
+    TWENTIETH = TASK_TWENTIETH
+    TWENTY_FIRST = TASK_TWENTY_FIRST
+    TWENTY_SECOND = TASK_TWENTY_SECOND
+    TWENTY_THIRD = TASK_TWENTY_THIRD
+    TWENTY_FOURTH = TASK_TWENTY_FOURTH
+    TWENTY_FIFTH = TASK_TWENTY_FIFTH
+    TWENTY_SIXTH = TASK_TWENTY_SIXTH
+    TWENTY_SEVENTH = TASK_TWENTY_SEVENTH
+    TWENTY_EIGHTH = TASK_TWENTY_EIGHTH
+    TWENTY_NINTH = TASK_TWENTY_NINTH
+    THIRTYETH = TASK_THIRTYETH
+    THIRTY_FIRST = TASK_THIRTY_FIRST
+    LAST = TASK_LAST
 
-    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')
 
     # :startdoc:
 
@@ -298,6 +196,19 @@ module Win32
       enum.include?(task)
     end
 
+    # Return the sepcified task if exist
+    #
+    def get_task(task)
+      raise TypeError unless task.is_a?(String)
+
+      begin
+        registeredTask = @root.GetTask(task)
+        @task = registeredTask
+      rescue WIN32OLERuntimeError => err
+        raise Error, ole_error('activate', err)
+      end
+    end
+
     # Activate the specified task.
     #
     def activate(task)
@@ -388,10 +299,12 @@ 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)
-      raise TypeError unless password.is_a?(String)
+      unless SYSTEM_USERS.include?(user.upcase)
+        raise TypeError unless password.is_a?(String)
+      end
       check_for_active_task
 
       @password = password
@@ -582,8 +495,6 @@ module Win32
       raise TypeError unless task.is_a?(String)
       raise TypeError unless trigger.is_a?(Hash)
 
-      validate_trigger(trigger)
-
       taskDefinition = @service.NewTask(0)
       taskDefinition.RegistrationInfo.Description = ''
       taskDefinition.RegistrationInfo.Author = ''
@@ -591,95 +502,85 @@ module Win32
       taskDefinition.Settings.Enabled  = true
       taskDefinition.Settings.Hidden = false
 
-      case trigger[:trigger_type]
-        when TASK_TIME_TRIGGER_ONCE
-          type = 1
-        when TASK_TIME_TRIGGER_DAILY
-          type = 2
-        when TASK_TIME_TRIGGER_WEEKLY
-          type = 3
-        when TASK_TIME_TRIGGER_MONTHLYDATE
-          type = 4
-        when TASK_TIME_TRIGGER_MONTHLYDOW
-          type = 5
-        when TASK_EVENT_TRIGGER_ON_IDLE
-          type = 6
-        when TASK_EVENT_TRIGGER_AT_SYSTEMSTART
-          type = 8
-        when TASK_EVENT_TRIGGER_AT_LOGON
-          type = 9
-        else
-          raise ArgumentError, 'Unknown trigger type'
-      end
+      unless trigger.empty?
+        raise ArgumentError, 'Unknown trigger type' unless valid_trigger_option(trigger[:trigger_type])
+        validate_trigger(trigger)
 
-      startTime = "%04d-%02d-%02dT%02d:%02d:00" % [
-        trigger[:start_year], trigger[:start_month], trigger[:start_day],
-        trigger[:start_hour], trigger[:start_minute]
-      ]
-
-      # Set defaults
-      trigger[:end_year]  ||= 0
-      trigger[:end_month] ||= 0
-      trigger[:end_day]   ||= 0
+        startTime = "%04d-%02d-%02dT%02d:%02d:00" % [
+          trigger[:start_year], trigger[:start_month], trigger[:start_day],
+          trigger[:start_hour], trigger[:start_minute]
+        ]
 
-      endTime = "%04d-%02d-%02dT00:00:00" % [
-        trigger[:end_year], trigger[:end_month], trigger[:end_day]
-      ]
+        # Set defaults
+        trigger[:end_year]  ||= 0
+        trigger[:end_month] ||= 0
+        trigger[:end_day]   ||= 0
 
-      trig = taskDefinition.Triggers.Create(type)
-      trig.Id = "RegistrationTriggerId#{taskDefinition.Triggers.Count}"
-      trig.StartBoundary = startTime
-      trig.EndBoundary = endTime if endTime != '0000-00-00T00:00:00'
-      trig.Enabled = true
+        endTime = "%04d-%02d-%02dT00:00:00" % [
+          trigger[:end_year], trigger[:end_month], trigger[:end_day]
+        ]
 
-      repetitionPattern = trig.Repetition
+        trig = taskDefinition.Triggers.Create(trigger[:trigger_type].to_i)
+        trig.Id = "RegistrationTriggerId#{taskDefinition.Triggers.Count}"
+        trig.StartBoundary = startTime
+        trig.EndBoundary = endTime if endTime != '0000-00-00T00:00:00'
+        trig.Enabled = true
 
-      if trigger[:minutes_duration].to_i > 0
-        repetitionPattern.Duration = "PT#{trigger[:minutes_duration]||0}M"
-      end
+        repetitionPattern = trig.Repetition
 
-      if trigger[:minutes_interval].to_i > 0
-        repetitionPattern.Interval = "PT#{trigger[:minutes_interval]||0}M"
-      end
+        if trigger[:minutes_duration].to_i > 0
+          repetitionPattern.Duration = "PT#{trigger[:minutes_duration]||0}M"
+        end
 
-      tmp = trigger[:type]
-      tmp = nil unless tmp.is_a?(Hash)
+        if trigger[:minutes_interval].to_i > 0
+          repetitionPattern.Interval = "PT#{trigger[:minutes_interval]||0}M"
+        end
 
-      case trigger[:trigger_type]
-        when TASK_TIME_TRIGGER_DAILY
-          trig.DaysInterval = tmp[:days_interval] if tmp && tmp[:days_interval]
-          if trigger[:random_minutes_interval].to_i > 0
-            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]}M"
-          end
-        when TASK_TIME_TRIGGER_WEEKLY
-          trig.DaysOfWeek = tmp[:days_of_week] if tmp && tmp[:days_of_week]
-          trig.WeeksInterval = tmp[:weeks_interval] if tmp && tmp[:weeks_interval]
-          if trigger[:random_minutes_interval].to_i > 0
-            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
-          end
-        when TASK_TIME_TRIGGER_MONTHLYDATE
-          trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
-          trig.DaysOfMonth = tmp[:days] if tmp && tmp[:days]
-          if trigger[:random_minutes_interval].to_i > 0
-            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
-          end
-        when TASK_TIME_TRIGGER_MONTHLYDOW
-          trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
-          trig.DaysOfWeek = tmp[:days_of_week] if tmp && tmp[:days_of_week]
-          trig.WeeksOfMonth = tmp[:weeks] if tmp && tmp[:weeks]
-          if trigger[:random_minutes_interval].to_i>0
-            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
-          end
-        when TASK_TIME_TRIGGER_ONCE
-          if trigger[:random_minutes_interval].to_i > 0
-            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
-          end
+        tmp = trigger[:type]
+        tmp = nil unless tmp.is_a?(Hash)
+
+        case trigger[:trigger_type]
+          when TASK_TIME_TRIGGER_DAILY
+            trig.DaysInterval = tmp[:days_interval] if tmp && tmp[:days_interval]
+            if trigger[:random_minutes_interval].to_i > 0
+              trig.RandomDelay = "PT#{trigger[:random_minutes_interval]}M"
+            end
+          when TASK_TIME_TRIGGER_WEEKLY
+            trig.DaysOfWeek = tmp[:days_of_week] if tmp && tmp[:days_of_week]
+            trig.WeeksInterval = tmp[:weeks_interval] if tmp && tmp[:weeks_interval]
+            if trigger[:random_minutes_interval].to_i > 0
+              trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
+            end
+          when TASK_TIME_TRIGGER_MONTHLYDATE
+            trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
+            trig.DaysOfMonth = tmp[:days] if tmp && tmp[:days]
+            if trigger[:random_minutes_interval].to_i > 0
+              trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
+            end
+            trig.RunOnLastDayOfMonth = trigger[:run_on_last_day_of_month] if trigger[:run_on_last_day_of_month]
+          when TASK_TIME_TRIGGER_MONTHLYDOW
+            trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
+            trig.DaysOfWeek = tmp[:days_of_week] if tmp && tmp[:days_of_week]
+            trig.WeeksOfMonth = tmp[:weeks_of_month] if tmp && tmp[:weeks_of_month]
+            if trigger[:random_minutes_interval].to_i>0
+              trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
+            end
+            trig.RunOnLastWeekOfMonth = trigger[:run_on_last_week_of_month] if trigger[:run_on_last_week_of_month]
+          when TASK_TIME_TRIGGER_ONCE
+            if trigger[:random_minutes_interval].to_i > 0
+              trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
+            end
+          when TASK_EVENT_TRIGGER_AT_SYSTEMSTART
+            trig.Delay = "PT#{trigger[:delay_duration]||0}M"
+          when TASK_EVENT_TRIGGER_AT_LOGON
+            trig.UserId = trigger[:user_id] if trigger[:user_id]
+            trig.Delay = "PT#{trigger[:delay_duration]||0}M"
+        end
       end
 
       act = taskDefinition.Actions.Create(0)
       act.Path = 'cmd'
 
-
       begin
         @task = @root.RegisterTaskDefinition(
           task,
@@ -756,59 +657,60 @@ module Win32
       end
 
       trigger = {}
-      trigger[:start_year], trigger[:start_month],
-      trigger[:start_day],  trigger[:start_hour],
-      trigger[:start_minute] = trig.StartBoundary.scan(/(\d+)-(\d+)-(\d+)T(\d+):(\d+)/).first
-
-      trigger[:end_year], trigger[:end_month],
-      trigger[:end_day] = trig.StartBoundary.scan(/(\d+)-(\d+)-(\d+)T/).first
-
-      if trig.Repetition.Duration != ""
-        trigger[:minutes_duration] = trig.Repetition.Duration.scan(/(\d+)M/)[0][0].to_i
-      end
-
-      if trig.Repetition.Interval != ""
-        trigger[:minutes_interval] = trig.Repetition.Interval.scan(/(\d+)M/)[0][0].to_i
-      end
-
-      if trig.RandomDelay != ""
-        trigger[:random_minutes_interval] = trig.RandomDelay.scan(/(\d+)M/)[0][0].to_i
-      end
 
       case trig.Type
-        when 2
-          trigger[:trigger_type] = TASK_TIME_TRIGGER_DAILY
+        when TASK_TIME_TRIGGER_DAILY
           tmp = {}
           tmp[:days_interval] = trig.DaysInterval
           trigger[:type] = tmp
-        when 3
-          trigger[:trigger_type] = TASK_TIME_TRIGGER_WEEKLY
+          trigger[:random_minutes_interval] = time_in_minutes(trig.RandomDelay)
+        when TASK_TIME_TRIGGER_WEEKLY
           tmp = {}
           tmp[:weeks_interval] = trig.WeeksInterval
           tmp[:days_of_week] = trig.DaysOfWeek
           trigger[:type] = tmp
-        when 4
-          trigger[:trigger_type] = TASK_TIME_TRIGGER_MONTHLYDATE
+          trigger[:random_minutes_interval] = time_in_minutes(trig.RandomDelay)
+        when TASK_TIME_TRIGGER_MONTHLYDATE
           tmp = {}
           tmp[:months] = trig.MonthsOfYear
           tmp[:days] = trig.DaysOfMonth
           trigger[:type] = tmp
-        when 5
-          trigger[:trigger_type] = TASK_TIME_TRIGGER_MONTHLYDOW
+          trigger[:random_minutes_interval] = time_in_minutes(trig.RandomDelay)
+          trigger[:run_on_last_day_of_month] = trig.RunOnLastDayOfMonth
+        when TASK_TIME_TRIGGER_MONTHLYDOW
           tmp = {}
           tmp[:months] = trig.MonthsOfYear
           tmp[:days_of_week] = trig.DaysOfWeek
-          tmp[:weeks] = trig.weeks
+          tmp[:weeks_of_month] = trig.WeeksOfMonth
           trigger[:type] = tmp
-        when 1
-          trigger[:trigger_type] = TASK_TIME_TRIGGER_ONCE
+          trigger[:random_minutes_interval] = time_in_minutes(trig.RandomDelay)
+          trigger[:run_on_last_week_of_month] = trig.RunOnLastWeekOfMonth
+        when TASK_TIME_TRIGGER_ONCE
           tmp = {}
           tmp[:once] = nil
           trigger[:type] = tmp
+          trigger[:random_minutes_interval] = time_in_minutes(trig.RandomDelay)
+        when TASK_EVENT_TRIGGER_AT_SYSTEMSTART
+          trigger[:delay_duration] = time_in_minutes(trig.Delay)
+        when TASK_EVENT_TRIGGER_AT_LOGON
+          trigger[:user_id] = trig.UserId if trig.UserId.to_s != ""
+          trigger[:delay_duration] = time_in_minutes(trig.Delay)
+        when TASK_EVENT_TRIGGER_ON_IDLE
+          trigger[:execution_time_limit] = time_in_minutes(trig.ExecutionTimeLimit)
         else
           raise Error, 'Unknown trigger type'
       end
 
+      trigger[:start_year], trigger[:start_month], trigger[:start_day],
+      trigger[:start_hour], trigger[:start_minute] = trig.StartBoundary.scan(/(\d+)-(\d+)-(\d+)T(\d+):(\d+)/).first
+
+      trigger[:end_year], trigger[:end_month],
+      trigger[:end_day] = trig.EndBoundary.scan(/(\d+)-(\d+)-(\d+)T/).first
+
+      trigger[:minutes_duration] = time_in_minutes(trig.Repetition.Duration)
+      trigger[:minutes_interval] = time_in_minutes(trig.Repetition.Interval)
+      trigger[:trigger_type] = trig.Type
+
       trigger
     end
 
@@ -838,6 +740,8 @@ module Win32
     #
     def trigger=(trigger)
       raise TypeError unless trigger.is_a?(Hash)
+      raise ArgumentError, 'Unknown trigger type' unless valid_trigger_option(trigger[:trigger_type])
+
       check_for_active_task
 
       validate_trigger(trigger)
@@ -845,27 +749,6 @@ module Win32
       definition = @task.Definition
       definition.Triggers.Clear()
 
-      case trigger[:trigger_type]
-        when TASK_TIME_TRIGGER_ONCE
-          type = 1
-        when TASK_TIME_TRIGGER_DAILY
-          type = 2
-        when TASK_TIME_TRIGGER_WEEKLY
-          type = 3
-        when TASK_TIME_TRIGGER_MONTHLYDATE
-          type = 4
-        when TASK_TIME_TRIGGER_MONTHLYDOW
-          type = 5
-        when TASK_EVENT_TRIGGER_ON_IDLE
-          type = 6
-        when TASK_EVENT_TRIGGER_AT_SYSTEM_START
-          type = 8
-        when TASK_EVENT_TRIGGER_AT_LOGON
-          type = 9
-        else
-          raise Error, 'Unknown trigger type'
-      end
-
       startTime = "%04d-%02d-%02dT%02d:%02d:00" % [
         trigger[:start_year], trigger[:start_month],
         trigger[:start_day], trigger[:start_hour], trigger[:start_minute]
@@ -875,7 +758,7 @@ module Win32
         trigger[:end_year], trigger[:end_month], trigger[:end_day]
       ]
 
-      trig = definition.Triggers.Create(type)
+      trig = definition.Triggers.Create( trigger[:trigger_type].to_i )
       trig.Id = "RegistrationTriggerId#{definition.Triggers.Count}"
       trig.StartBoundary = startTime
       trig.EndBoundary = endTime if endTime != '0000-00-00T00:00:00'
@@ -912,17 +795,29 @@ module Win32
           if trigger[:random_minutes_interval].to_i > 0
             trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+          trig.RunOnLastDayOfMonth = trigger[:run_on_last_day_of_month] if trigger[:run_on_last_day_of_month]
         when TASK_TIME_TRIGGER_MONTHLYDOW
           trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
           trig.DaysOfWeek = tmp[:days_of_week] if tmp && tmp[:days_of_week]
-          trig.WeeksOfMonth = tmp[:weeks] if tmp && tmp[:weeks]
+          trig.WeeksOfMonth = tmp[:weeks_of_month] if tmp && tmp[:weeks_of_month]
           if trigger[:random_minutes_interval].to_i > 0
             trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+          trig.RunOnLastWeekOfMonth = trigger[:run_on_last_week_of_month] if trigger[:run_on_last_week_of_month]
         when TASK_TIME_TRIGGER_ONCE
           if trigger[:random_minutes_interval].to_i > 0
             trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+        when TASK_EVENT_TRIGGER_AT_SYSTEMSTART
+          trig.Delay = "PT#{trigger[:delay_duration]||0}M"
+        when TASK_EVENT_TRIGGER_AT_LOGON
+          trig.UserId = trigger[:user_id] if trigger[:user_id]
+          trig.Delay = "PT#{trigger[:delay_duration]||0}M"
+        when TASK_EVENT_TRIGGER_ON_IDLE
+          # for setting execution time limit Ref : https://msdn.microsoft.com/en-us/library/windows/desktop/aa380724(v=vs.85).aspx
+          if trigger[:execution_time_limit].to_i > 0
+            trig.ExecutionTimeLimit = "PT#{trigger[:execution_time_limit]||0}M"
+          end
       end
 
       update_task_definition(definition)
@@ -935,23 +830,11 @@ module Win32
     def add_trigger(index, trigger)
       raise TypeError unless index.is_a?(Numeric)
       raise TypeError unless trigger.is_a?(Hash)
+      raise ArgumentError, 'Unknown trigger type' unless valid_trigger_option(trigger[:trigger_type])
+
       check_for_active_task
 
       definition = @task.Definition
-      case trigger[:trigger_type]
-        when TASK_TIME_TRIGGER_DAILY
-          type = 2
-        when TASK_TIME_TRIGGER_WEEKLY
-          type = 3
-        when TASK_TIME_TRIGGER_MONTHLYDATE
-          type = 4
-        when TASK_TIME_TRIGGER_MONTHLYDOW
-          type = 5
-        when TASK_TIME_TRIGGER_ONCE
-          type = 1
-        else
-          raise Error, 'Unknown trigger type'
-      end
 
       startTime = "%04d-%02d-%02dT%02d:%02d:00" % [
         trigger[:start_year], trigger[:start_month], trigger[:start_day],
@@ -967,7 +850,7 @@ module Win32
         trigger[:end_year], trigger[:end_month], trigger[:end_day]
       ]
 
-      trig = definition.Triggers.Create(type)
+      trig = definition.Triggers.Create( trigger[:trigger_type].to_i )
       trig.Id = "RegistrationTriggerId#{definition.Triggers.Count}"
       trig.StartBoundary = startTime
       trig.EndBoundary = endTime if endTime != '0000-00-00T00:00:00'
@@ -1002,19 +885,26 @@ module Win32
           trig.MonthsOfYear = tmp[:months] if tmp && tmp[:months]
           trig.DaysOfMonth = tmp[:days] if tmp && tmp[:days]
           if trigger[:random_minutes_interval].to_i > 0
-          trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
+            trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+          trig.RunOnLastDayOfMonth = trigger[:run_on_last_day_of_month] if trigger[:run_on_last_day_of_month]
         when TASK_TIME_TRIGGER_MONTHLYDOW
           trig.MonthsOfYear  = tmp[:months] if tmp && tmp[:months]
           trig.DaysOfWeek  = tmp[:days_of_week] if tmp && tmp[:days_of_week]
-          trig.WeeksOfMonth  = tmp[:weeks] if tmp && tmp[:weeks]
+          trig.WeeksOfMonth  = tmp[:weeks_of_month] if tmp && tmp[:weeks_of_month]
           if trigger[:random_minutes_interval].to_i > 0
           trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+          trig.RunOnLastWeekOfMonth = trigger[:run_on_last_week_of_month] if trigger[:run_on_last_week_of_month]
         when TASK_TIME_TRIGGER_ONCE
           if trigger[:random_minutes_interval].to_i > 0
           trig.RandomDelay = "PT#{trigger[:random_minutes_interval]||0}M"
           end
+        when TASK_EVENT_TRIGGER_AT_SYSTEMSTART
+          trig.Delay = "PT#{trigger[:delay_duration]||0}M"
+        when TASK_EVENT_TRIGGER_AT_LOGON
+          trig.UserId = trigger[:user_id] if trigger[:user_id]
+          trig.Delay = "PT#{trigger[:delay_duration]||0}M"
       end
 
       update_task_definition(definition)
@@ -1033,6 +923,8 @@ module Win32
           status = 'ready'
         when 4
           status = 'running'
+        when 2
+          status = 'queued'
         when 1
           status = 'not scheduled'
         else
@@ -1042,6 +934,12 @@ module Win32
       status
     end
 
+    # Returns true if current task is enabled
+    def enabled?
+      check_for_active_task
+      @task.enabled
+    end
+
     # Returns the exit code from the last scheduled run.
     #
     def exit_code
@@ -1121,6 +1019,25 @@ 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
+      check_for_active_task
+      @task.Definition.Settings.ExecutionTimeLimit
+    end
+
     # Returns the maximum length of time, in milliseconds, that the task
     # will run before terminating.
     #
@@ -1203,9 +1120,12 @@ module Win32
       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 = hash[:execution_time_limit] || hash[:max_run_time]
+      execution_time_limit = "PT#{hash[:execution_time_limit] || hash[:max_run_time] || 0}M"
       hidden = hash[:hidden]
-      idle_settings = hash[:idle_settings]
+      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]
@@ -1225,7 +1145,10 @@ module Win32
       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 = idle_settings if idle_settings
+      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
@@ -1289,71 +1212,88 @@ module Win32
       hash
     end
 
-    # Shorthand constants
-
-    IDLE = IDLE_PRIORITY_CLASS
-    NORMAL = NORMAL_PRIORITY_CLASS
-    HIGH = HIGH_PRIORITY_CLASS
-    REALTIME = REALTIME_PRIORITY_CLASS
-    BELOW_NORMAL = BELOW_NORMAL_PRIORITY_CLASS
-    ABOVE_NORMAL = ABOVE_NORMAL_PRIORITY_CLASS
+    # Sets the principals for current active task. The principal is hash with following possible options.
+    # Expected principal hash: { id: STRING, display_name: STRING, user_id: STRING,
+    # logon_type: INTEGER, group_id: STRING, run_level: INTEGER }
+    #
+    def configure_principals(principals)
+      raise TypeError unless principals.is_a?(Hash)
+      check_for_active_task
+      definition = @task.Definition
+      definition.Principal.Id = principals[:id] if principals[:id].to_s != ""
+      definition.Principal.DisplayName = principals[:display_name] if principals[:display_name].to_s != ""
+      definition.Principal.UserId = principals[:user_id] if principals[:user_id].to_s != ""
+      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)
+      principals
+    end
 
-    ONCE = TASK_TIME_TRIGGER_ONCE
-    DAILY = TASK_TIME_TRIGGER_DAILY
-    WEEKLY = TASK_TIME_TRIGGER_WEEKLY
-    MONTHLYDATE = TASK_TIME_TRIGGER_MONTHLYDATE
-    MONTHLYDOW = TASK_TIME_TRIGGER_MONTHLYDOW
+    # Returns a hash containing all the principal information of the current task
+    def principals
+      check_for_active_task
+      principals_hash = {}
+      @task.Definition.Principal.ole_get_methods.each do |principal|
+        principals_hash[principal.name] = @task.Definition.Principal._getproperty(principal.dispid, [], [])
+      end
+      symbolize_keys(principals_hash)
+    end
 
-    ON_IDLE = TASK_EVENT_TRIGGER_ON_IDLE
-    AT_SYSTEMSTART = TASK_EVENT_TRIGGER_AT_SYSTEMSTART
-    AT_LOGON = TASK_EVENT_TRIGGER_AT_LOGON
-    FIRST_WEEK = TASK_FIRST_WEEK
-    SECOND_WEEK = TASK_SECOND_WEEK
-    THIRD_WEEK = TASK_THIRD_WEEK
-    FOURTH_WEEK = TASK_FOURTH_WEEK
-    LAST_WEEK = TASK_LAST_WEEK
-    SUNDAY = TASK_SUNDAY
-    MONDAY = TASK_MONDAY
-    TUESDAY = TASK_TUESDAY
-    WEDNESDAY = TASK_WEDNESDAY
-    THURSDAY = TASK_THURSDAY
-    FRIDAY = TASK_FRIDAY
-    SATURDAY = TASK_SATURDAY
-    JANUARY = TASK_JANUARY
-    FEBRUARY = TASK_FEBRUARY
-    MARCH = TASK_MARCH
-    APRIL = TASK_APRIL
-    MAY = TASK_MAY
-    JUNE = TASK_JUNE
-    JULY = TASK_JULY
-    AUGUST = TASK_AUGUST
-    SEPTEMBER = TASK_SEPTEMBER
-    OCTOBER = TASK_OCTOBER
-    NOVEMBER = TASK_NOVEMBER
-    DECEMBER = TASK_DECEMBER
+    # Returns a hash containing all settings of the current task
+    def settings
+      check_for_active_task
+      settings_hash = {}
+      @task.Definition.Settings.ole_get_methods.each do |setting|
+        next if setting.name == "XmlText" # not needed
+        settings_hash[setting.name] = @task.Definition.Settings._getproperty(setting.dispid, [], [])
+      end
 
-    INTERACTIVE = TASK_FLAG_INTERACTIVE
-    DELETE_WHEN_DONE = TASK_FLAG_DELETE_WHEN_DONE
-    DISABLED = TASK_FLAG_DISABLED
-    START_ONLY_IF_IDLE = TASK_FLAG_START_ONLY_IF_IDLE
-    KILL_ON_IDLE_END = TASK_FLAG_KILL_ON_IDLE_END
-    DONT_START_IF_ON_BATTERIES = TASK_FLAG_DONT_START_IF_ON_BATTERIES
-    KILL_IF_GOING_ON_BATTERIES = TASK_FLAG_KILL_IF_GOING_ON_BATTERIES
-    RUN_ONLY_IF_DOCKED = TASK_FLAG_RUN_ONLY_IF_DOCKED
-    HIDDEN = TASK_FLAG_HIDDEN
-    RUN_IF_CONNECTED_TO_INTERNET = TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET
-    RESTART_ON_IDLE_RESUME = TASK_FLAG_RESTART_ON_IDLE_RESUME
-    SYSTEM_REQUIRED = TASK_FLAG_SYSTEM_REQUIRED
-    RUN_ONLY_IF_LOGGED_ON = TASK_FLAG_RUN_ONLY_IF_LOGGED_ON
+      settings_hash["IdleSettings"] = idle_settings
+      settings_hash["NetworkSettings"] = network_settings
+      symbolize_keys(settings_hash)
+    end
 
-    FLAG_HAS_END_DATE = TASK_TRIGGER_FLAG_HAS_END_DATE
-    FLAG_KILL_AT_DURATION_END = TASK_TRIGGER_FLAG_KILL_AT_DURATION_END
-    FLAG_DISABLED = TASK_TRIGGER_FLAG_DISABLED
+    # Returns a hash of idle settings of the current task
+    def idle_settings
+      check_for_active_task
+      settings_hash = {}
+      @task.Definition.Settings.IdleSettings.ole_get_methods.each do |setting|
+        settings_hash[setting.name] = @task.Definition.Settings.IdleSettings._getproperty(setting.dispid, [], [])
+      end
+      symbolize_keys(settings_hash)
+    end
 
-    MAX_RUN_TIMES = TASK_MAX_RUN_TIMES
+    # Returns a hash of network settings of the current task
+    def network_settings
+      check_for_active_task
+      settings_hash = {}
+      @task.Definition.Settings.NetworkSettings.ole_get_methods.each do |setting|
+        settings_hash[setting.name] = @task.Definition.Settings.NetworkSettings._getproperty(setting.dispid, [], [])
+      end
+      symbolize_keys(settings_hash)
+    end
 
     private
 
+    # Returns a camle-case string to its underscore format
+    def underscore(string)
+      string.gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze).downcase
+    end
+
+    # Converts all the keys of a hash to underscored-symbol format
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(k, v), h|
+        h[underscore(k.to_s).to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
+      end
+    end
+
+    def valid_trigger_option(trigger_type)
+      [ TASK_TIME_TRIGGER_ONCE, TASK_TIME_TRIGGER_DAILY, TASK_TIME_TRIGGER_WEEKLY,
+        TASK_TIME_TRIGGER_MONTHLYDATE, TASK_TIME_TRIGGER_MONTHLYDOW, TASK_EVENT_TRIGGER_ON_IDLE,
+        TASK_EVENT_TRIGGER_AT_SYSTEMSTART, TASK_EVENT_TRIGGER_AT_LOGON ].include?(trigger_type.to_i)
+    end
+
     def validate_trigger(hash)
       [:start_year, :start_month, :start_day].each{ |key|
         raise ArgumentError, "#{key} must be set" unless hash[key]
@@ -1380,4 +1320,5 @@ module Win32
       raise Error, ole_error(method_name, err)
     end
   end
+  # :stopdoc:
 end