kaseyaws 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 780aecac9c46c96b12234d9e8cb5f6a910077a8b
-  data.tar.gz: e4a9e46956778d2e4ee53fc7cf48608b40a1dd4f
+  metadata.gz: 05e73b2d95fd766ef74c52637f295b137eb320a9
+  data.tar.gz: 2988b717660f02eff59882cfca77bce8daf57804
 SHA512:
-  metadata.gz: 1c265dc2bad37597cdc232942e2a6b6f3e967b30c9c6070dd9676cf5f66db206a64fab4028690e166849fdfe18ad1d36fcd6b57cf1f47fac9be57a098834ea44
-  data.tar.gz: 9ce9d480b7cd7e1983b5f16021c0d28bac3645aac7650c616fefd0c9fd8789c009cc8af37a4f80705cff7b6bf45d944772ce21a29708e0f73db313b4efed262b
+  metadata.gz: e51be2546220b7de7261a21bf4c961c6d0bdf6ef9a133146711cd26cb1e7a0a2532db807cf2ea001a93f4b5d72593a0950ed9742f82ad35a270ae80a39e186d7
+  data.tar.gz: e8adae035ee96a14a9478abdf29261f385298beab44fd89ae8eeb7c69af66f58b5a8e799c2c3c34bda7627e7b74a593e90cce8b3cf7973f6ae6b59cb91cb548b

data/README.md

@@ -2,21 +2,23 @@
 
 A simple Ruby Gem that provides a Ruby client for Kaseya's VSA web service.
 
-This is currently a work in progress, as all Kaseya web service operations are not implemented yet.
+This is currently a work in progress, as all Kaseya web service operations are not yet implemented.
 
-## Installation
-
-Add this line to your application's Gemfile:
+[The offical documentation for the Kaseya VSA web service](http://tinyurl.com/kaseyavsaws)
 
-    gem 'kaseyaws'
+## Installation
 
-And then execute:
+KaseyaWS is available at [Rubygems](http://rubygems.org/gems/kaseyaws) and can be installed as follows.
 
-    $ bundle
+```
+$ gem install kaseyaws
+```
 
-Or install it yourself as:
+or add it to your Gemfile:
 
-    $ gem install kaseyaws
+```
+gem 'kaseyaws', '~> 0.0.3'
+```
 
 ## Usage
 

data/kaseyaws.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.version       = KaseyaWS::VERSION
   s.authors       = "Phillip Henslee"
   s.email         = "phenslee@towerdigital.us"
-  s.description   = "A Ruby Gem for Kaseya's VSA web services"
+  s.description   = "A Ruby Gem for Kaseya's VSA web service"
   s.summary       = "A simple client for the Kaseya VSA web service"
   s.homepage      = "https://github.com/towerdigital/kaseyaws"
   s.license       = "MIT"

data/lib/kaseyaws/client.rb

@@ -14,6 +14,8 @@ require "savon"
 
 module KaseyaWS
 
+  # The client class is just a wrapper for the Kaseya VSA WSDL. All methods return a Hash object
+
   class Client
     HASH_ALGORITHM = "SHA-256"
     attr_accessor :client
@@ -36,31 +38,31 @@ module KaseyaWS
     def add_mach_group_to_scope(group_name,scope_name)
 
       response = self.client.call(:add_mach_group_to_scope, message: {req:[{
-                                                                        group_name: group_name,
-                                                                        scope_name: scope_name,
-                                                                        browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                             group_name: group_name,
+                                                                             scope_name: scope_name,
+                                                                             browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:add_mach_group_to_scope_response][:add_mach_group_to_scope_result]
     end
 
     def add_org_to_scope(company_id,scope_id)
 
       response = self.client.call(:add_org_to_scope, message: {req:[{
-                                                                 company_i_d: company_id,
-                                                                 scope_i_d: scope_id,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                      company_i_d: company_id,
+                                                                      scope_i_d: scope_id,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:add_org_to_scope_response][:add_org_to_scope_result]
     end
 
     def add_user_to_role(username,role_id)
 
       response = self.client.call(:add_user_to_role, message: {req:[{
-                                                                 user_name: user_name,
-                                                                 role_i_d: role_id,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                      user_name: user_name,
+                                                                      role_i_d: role_id,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:add_user_to_role_response][:add_user_to_role_result]
     end
 
@@ -68,7 +70,6 @@ module KaseyaWS
 
       random_number = KaseyaWS::Security.secure_random
       covered_password = KaseyaWS::Security.compute_covered_password(username,password, random_number, HASH_ALGORITHM)
-      browser_ip = @client_ip
 
       self.client = Savon::Client.new(@savon_options)
 
@@ -76,7 +77,7 @@ module KaseyaWS
                                                                   user_name: username,
                                                                   covered_password: covered_password,
                                                                   random_number: random_number,
-                                                                  browser_ip: browser_ip,
+                                                                  browser_i_p: @client_ip,
                                   hashing_algorithm: HASH_ALGORITHM}]}
                                   )
       @sessionid = response.body[:authenticate_response][:authenticate_result][:session_id]
@@ -85,53 +86,111 @@ module KaseyaWS
     def close_alarm (monitor_alarm_id, notes)
 
       response = self.client.call(:close_alarm, message: {req:[{
-                                                            monitor_alarm_i_d: monitor_alarm_id,
-                                                            notes: notes,
-                                                            browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                 monitor_alarm_i_d: monitor_alarm_id,
+                                                                 notes: notes,
+                                                                 browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:close_alarm_response][:close_alarm_result]
     end
 
     def create_machine_group (group_name,org_name,parent_name)
 
       response = self.client.call(:create_machine_group, message: {req:[{
-                                                            group_name: group_name,
-                                                            org_name: org_name,
-                                                            parent_name: parent_name,
-                                                            browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                          group_name: group_name,
+                                                                          org_name: org_name,
+                                                                          parent_name: parent_name,
+                                                                          browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:create_machine_group_response][:create_machine_group_result]
     end
 
     def create_role (role_name,role_type,parent_role_name)
 
       response = self.client.call(:create_role, message: {req:[{
-                                                            role_name: role_name,
-                                                            role_type: role_type,
-                                                            parent_role_name: parent_role_name,
-                                                            browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                 role_name: role_name,
+                                                                 role_type: role_type,
+                                                                 parent_role_name: parent_role_name,
+                                                                 browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:create_role_response][:create_role_result]
     end
 
     def delete_admin (user_name)
 
       response = self.client.call(:delete_admin, message: {req:[{
-                                                            user_name: user_name,
-                                                            browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                  user_name: user_name,
+                                                                  browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:delete_admin_response][:delete_admin_result]
     end
 
+
+    def delete_agent (agent_guid, uninstall_agent_first)
+
+      response = self.client.call(:delete_agent, message: {req:[{
+                                                                  agent_guid: agent_guid,
+                                                                  uninstall_agent_first: uninstall_agent_first,
+                                                                  browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
+      response.body[:delete_agent_response][:delete_agent_result]
+    end
+
+    def delete_agent_install_package (package_id)
+
+      response = self.client.call(:delete_agent_install_package, message: {req:[{
+                                                                                  package_id: package_id,
+                                                                                  browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
+      response.body[:delete_agent_install_package_response][:delete_agent_install_package_result]
+    end
+
+    def delete_machine_group (group_name)
+
+      response = self.client.call(:delete_machine_group, message: {req:[{
+                                                                          group_name: group_name,
+                                                                          browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
+      response.body[:delete_machine_group_response][:delete_machine_group_result]
+    end
+
+    def echo (input)
+
+      response = self.client.call(:echo, message: { input: input })
+                                                                          
+      response.body[:echo_response][:echo_result]
+    end
+
+    def echo_mt (payload)
+
+      response = self.client.call(:echo_mt, message: {req:[{
+                                                               payload: payload,
+                                  session_i_d: @sessionid}]}
+                                  )
+      response.body[:echo_mt_response][:echo_mt_result]
+    end
+
     def get_alarm (monitor_alarm_id)
 
       response = self.client.call(:get_alarm, message: {req:[{
                                                                monitor_alarm_i_d: monitor_alarm_id,
-                                                               browser_ip: @client_ip,
+                                                               browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
+      response.body[:get_alarm_response][:get_alarm_result]
+    end
+
+    def get_alarm (monitor_alarm_id)
+
+      response = self.client.call(:get_alarm, message: {req:[{
+                                                               monitor_alarm_i_d: monitor_alarm_id,
+                                                               browser_i_p: @client_ip,
                                   session_i_d: @sessionid}]}
                                   )
       response.body[:get_alarm_response][:get_alarm_result]
@@ -141,7 +200,7 @@ module KaseyaWS
 
       response = self.client.call(:get_alarm_list, message: {req:[{
                                                                     return_all_records: get_all_records,
-                                                                    browser_ip: @client_ip,
+                                                                    browser_i_p: @client_ip,
                                   session_i_d: @sessionid}]}
                                   )
       response.body[:get_alarm_list_response][:get_alarm_list_result]
@@ -150,32 +209,32 @@ module KaseyaWS
     def get_machine(machine_group_id)
 
       response = self.client.call(:get_machine, message: {req:[{
-                                                            machine___group_i_d: machine_group_id,
-                                                            browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                 machine___group_i_d: machine_group_id,
+                                                                 browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:get_machine_response][:get_machine_result]
     end
 
     def get_machine_group_list
 
       response = self.client.call(:get_machine_group_list, message: {req:[{
-                                                                       browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                            browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:get_machine_group_list_response][:get_machine_group_list_result]
     end
 
     def get_machine_list(machine_group,machine_collection)
 
       response = self.client.call(:get_machine_list, message: {req:[{
-                                                                 machine_group: machine_group,
-                                                                 machine_collection: machine_collection,
-                                                                 browser_ip: @client_ip,
-                             session_i_d: @sessionid}]}
-                             )
+                                                                      machine_group: machine_group,
+                                                                      machine_collection: machine_collection,
+                                                                      browser_i_p: @client_ip,
+                                  session_i_d: @sessionid}]}
+                                  )
       response.body[:get_machine_list_response][:get_machine_list_result]
     end
 
   end
-end
+end

data/lib/kaseyaws/security.rb

@@ -18,16 +18,14 @@ require 'json'
 module KaseyaWS
   class Security
 
-    # Utility method to return the client's IP address
-    # Most but not all Kaseya VSA SOAP request require <BrowserIP>
+    # Utility method to return the client's IP address, most but not all Kaseya VSA SOAP request require it.
 
     def self.client_ip
       r =  Net::HTTP.get( 'jsonip.com','/' )
       r = JSON::parse(r)['ip']
     end
 
-    # Create a secure random number, returns a eight digit string
-    # Used to compute the second hash for the double hash sequence
+    # Returns an eight digit secure random number, used to compute the second hash for the double hash sequence.
     
     def self.secure_random
       i = SecureRandom.random_bytes
@@ -36,7 +34,7 @@ module KaseyaWS
       i = i[1..8]
     end
 
-    # Computes the double hashed covered password to authenticate with the VSA
+    # Computes the double hashed covered password to authenticate with the VSA server.
     
     def self.compute_covered_password(username, password, rnd_number, hashing_algorithm)
       if hashing_algorithm == "SHA-1"

data/lib/kaseyaws/version.rb

@@ -2,7 +2,7 @@ module KaseyaWS
   VERSION_NUMBERS = [
     VERSION_MAJOR = 0,
     VERSION_MINOR = 0,
-    VERSION_BUILD = 3,
+    VERSION_BUILD = 4,
   ]
   VERSION = VERSION_NUMBERS.join(".")
 end

data/lib/kaseyaws.rb

@@ -12,6 +12,4 @@
 
 require "kaseyaws/version"
 require "kaseyaws/security"
-require "kaseyaws/client"
-
-
+require "kaseyaws/client"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kaseyaws
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Phillip Henslee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-28 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: savon
@@ -66,7 +66,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A Ruby Gem for Kaseya's VSA web services
+description: A Ruby Gem for Kaseya's VSA web service
 email: phenslee@towerdigital.us
 executables: []
 extensions: []