agilix 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0413fee530d80590d22081a3f3dcbb043f9db3743d1f8f29a84f332076fd421
-  data.tar.gz: e43836977de2042b9b8af21bad4418d62298fc94e16049fcad6f4264f87ee84c
+  metadata.gz: 0a82f77811d3cfeb64d923f26b0ea861505f62d304aeac3f50ea1ccd0bdefc14
+  data.tar.gz: bc528e6a6ae236c48856e6a824538638b95ce4ecd15e7d878c4f1b452f0d48b1
 SHA512:
-  metadata.gz: 96fbcf3c60422b1bd344e6ba157bccba2ca81b44ec9a1fbac1f5e326b2d37a70c7f9e42ab7a24dc17bb272ca5d27175e44f01b5b67831d5daeb9e5590d8e4172
-  data.tar.gz: fe2038e729fdb39f5d4b3765245f42a9ed2bffabc192b866e0a21955e77a62dc3b60ad303a0e042d0c662770c67692767faaaddef17a5b26a697e9ed5ba6a77a
+  metadata.gz: 588b495b07ef024a8769457a760461938cb5791068e1e6aa451e61c649250250c811cb58c64546758461ac1e91bea697b7f18e0fd597ad385354c9c3c7974cde
+  data.tar.gz: 267fa0d5a739c92ce0220205dfcb09cc43d3cb9ff8a110e17e581e2624b7a3bd7157d042258bb10f0c36c1fe0944c9354bdeae2196ddd4ea0e001edd50bc79eb

data/.gitignore

@@ -2,7 +2,7 @@
 /.yardoc
 /Gemfile.lock
 /_yardoc/
-/coverage/
+coverage/*
 /doc/
 /pkg/
 /spec/reports/
@@ -19,3 +19,4 @@ mkmf.log
 .env
 .ruby-version
 .ruby-gemset
+

data/README.md

@@ -49,7 +49,13 @@ Otherwise, you can pass `:username`, `:password`, and `:domain` into the initial
 ```
 api = Agilix::Buzz::Api.new username: 'my-username', password: 'my-password', domain: 'my-domain'
 ```
+The authentication API gives you back a token that can be used within a 15 minute window. This library will manage the need to fetch a new token or `extend_session` by setting the token & token expiration in the initialized api object.
 
+### Passing arguments
+
+All APIs have defined required arguments and optional arguments, and an argument cleaner will prevent the calls from being made if conditions are not met. Additionally it will strip out any unsupported api params that are not defined in the required or optional fields.
+
+Below are instructions for basic invocation of the api methods. For additional information about each API method, please consult the Agilix documentation, linked in each method's name.
 
 ### Domains
 
@@ -62,6 +68,7 @@ api.create_domains [{name: "BuzzTest1", userspace: 'buzz-test-fc-1', parentid: '
 api.delete_domain domainid: '57027'
 ```
 #### [GetDomain2](https://api.agilixbuzz.com/docs/#!/Command/GetDomain2)
+This is aliased to `get_domain`
 ```
 api.get_domain domainid: '57025'
 ```
@@ -98,26 +105,100 @@ api.restore_domain domainid: '57027'
 api.update_domains [{ domainid: "57027", name: "BuzzTestUpdated1", userspace: 'buzz-test-fc-1', parentid: '57025'}]
 ```
 
-## Reports
+### Reports
 
-- [ ] [GetReportInfo](https://api.agilixbuzz.com/docs/#!/Command/GetReportInfo)
-- [ ] [GetReportList](https://api.agilixbuzz.com/docs/#!/Command/GetReportList)
-- [ ] [GetRunnableReportList](https://api.agilixbuzz.com/docs/#!/Command/GetRunnableReportList)
-- [ ] [RunReport](https://api.agilixbuzz.com/docs/#!/Command/RunReport)
+`get_runnable_report_list` and `run_report` are probably the only ones you would use.
+
+#### [GetReportInfo](https://api.agilixbuzz.com/docs/#!/Command/GetReportInfo)
+```
+api.get_report_info reportid: 127
+```
+#### [GetReportList](https://api.agilixbuzz.com/docs/#!/Command/GetReportList)
+```
+api.get_report_list domainid: 1
+```
+#### [GetRunnableReportList](https://api.agilixbuzz.com/docs/#!/Command/GetRunnableReportList)
+```
+api.get_runnable_report_list domainid: 57025
+```
+#### [RunReport](https://api.agilixbuzz.com/docs/#!/Command/RunReport)
+```
+api.run_report reportid: 127, entityid: 57025, format: 'json'
+```
 
 ## Users
 
-- [ ] [CreateUsers2](https://api.agilixbuzz.com/docs/#!/Command/CreateUsers2)
-- [ ] [DeleteUsers](https://api.agilixbuzz.com/docs/#!/Command/DeleteUsers)
-- [ ] [GetActiveUserCount](https://api.agilixbuzz.com/docs/#!/Command/GetActiveUserCount)
-- [ ] [GetDomainActivity](https://api.agilixbuzz.com/docs/#!/Command/GetDomainActivity)
-- [ ] [GetProfilePicture](https://api.agilixbuzz.com/docs/#!/Command/GetProfilePicture)
-- [ ] [GetUser2](https://api.agilixbuzz.com/docs/#!/Command/GetUser2)
-- [ ] [GetUserActivity](https://api.agilixbuzz.com/docs/#!/Command/GetUserActivity)
-- [ ] [GetUserActivityStream](https://api.agilixbuzz.com/docs/#!/Command/GetUserActivityStream)
-- [ ] [ListUsers](https://api.agilixbuzz.com/docs/#!/Command/ListUsers)
-- [ ] [RestoreUser](https://api.agilixbuzz.com/docs/#!/Command/RestoreUser)
-- [ ] [UpdateUsers](https://api.agilixbuzz.com/docs/#!/Command/UpdateUsers)
+#### [CreateUsers2](https://api.agilixbuzz.com/docs/#!/Command/CreateUsers2)
+This is aliased to `create_users`
+```
+api.create_users( [{
+  domainid: '57025',
+  username: "BuzzUserTest1",
+  email: 'buzzusertest1@agilix.com',
+  password: 'testpassword1234',
+  firstname: 'Buzz',
+  lastname: "Man",
+  passwordquestion: "Who's your best friend?",
+  passwordanswer: "Me"
+  }] )
+```
+
+#### [DeleteUsers](https://api.agilixbuzz.com/docs/#!/Command/DeleteUsers)
+```
+api.delete_users [userid: '57181']
+```
+
+#### [GetActiveUserCount](https://api.agilixbuzz.com/docs/#!/Command/GetActiveUserCount)
+```
+api.get_active_user_count domainid: '57025'
+api.get_active_user_count domainid: '5', includedescendantdomains: true, bymonth:true, startdate: '2018-01-01', enddate: '2019-03-01'
+```
+
+#### [GetDomainActivity](https://api.agilixbuzz.com/docs/#!/Command/GetDomainActivity)
+```
+api.get_domain_activity domainid: '57025'
+```
+
+#### [GetProfilePicture](https://api.agilixbuzz.com/docs/#!/Command/GetProfilePicture)
+Returns base 64 encoded picture
+```
+api.get_profile_picture entityid: 57026
+```
+The api will return 404 not found if they don't have one, unless you supply it with a default profile pic, then it will return that
+```
+api.get_profile_picture entityid: 57025, default: "https://www.gravatar.com/avatar/00000000000000000000000000000000?d=mm"
+```
+
+#### [GetUser2](https://api.agilixbuzz.com/docs/#!/Command/GetUser2)
+This is aliased to `get_user`
+```
+api.get_user userid: 57026
+```
+
+#### [GetUserActivity](https://api.agilixbuzz.com/docs/#!/Command/GetUserActivity)
+```
+api.get_user_activity userid: 57026
+```
+
+#### [GetUserActivityStream](https://api.agilixbuzz.com/docs/#!/Command/GetUserActivityStream)
+```
+api.get_user_activity_stream userid: 57026
+```
+
+#### [ListUsers](https://api.agilixbuzz.com/docs/#!/Command/ListUsers)
+```
+api.list_users domainid: 57025
+```
+
+#### [RestoreUser](https://api.agilixbuzz.com/docs/#!/Command/RestoreUser)
+```
+api.restore_user userid: 57026
+```
+
+#### [UpdateUsers](https://api.agilixbuzz.com/docs/#!/Command/UpdateUsers)
+```
+api.update_users  [{ userid: '57026', username: "BuzzUserTestUpdated1", email: 'buzzusertest1@agilix.com',firstname: 'Buzz', lastname: "ManUpdated"}]
+```
 
 ---
 
@@ -125,35 +206,171 @@ api.update_domains [{ domainid: "57027", name: "BuzzTestUpdated1", userspace: 'b
 
 ## Authentication
 
-- [ ] [ExtendSession](https://api.agilixbuzz.com/docs/#!/Command/ExtendSession)
-- [ ] [GetKey](https://api.agilixbuzz.com/docs/#!/Command/GetKey)
-- [ ] [ForcePasswordChange](https://api.agilixbuzz.com/docs/#!/Command/ForcePasswordChange)
-- [ ] [GetPasswordLoginAttemptHistory](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordLoginAttemptHistory)
-- [ ] [GetPasswordPolicy](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordPolicy)
-- [ ] [GetPasswordQuestion](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordQuestion)
-- [ ] [Login2](https://api.agilixbuzz.com/docs/#!/Command/Login2)
-- [ ] [Logout](https://api.agilixbuzz.com/docs/#!/Command/Logout)
-- [ ] [Proxy](https://api.agilixbuzz.com/docs/#!/Command/Proxy)
-- [ ] [PutKey](https://api.agilixbuzz.com/docs/#!/Command/PutKey)
-- [ ] [ResetLockout](https://api.agilixbuzz.com/docs/#!/Command/ResetLockout)
-- [ ] [ResetPassword](https://api.agilixbuzz.com/docs/#!/Command/ResetPassword)
-- [ ] [Unproxy](https://api.agilixbuzz.com/docs/#!/Command/Unproxy)
-- [ ] [UpdatePassword](https://api.agilixbuzz.com/docs/#!/Command/UpdatePassword)
-- [ ] [UpdatePasswordQuestionAnswer](https://api.agilixbuzz.com/docs/#!/Command/UpdatePasswordQuestionAnswer)
+#### [Login2](https://api.agilixbuzz.com/docs/#!/Command/Login2)
+This is handled automatically by instantiation of a base Agilix::Buzz::Api instance. It wouldn't need to be called manually unless using for other users or making calls on their behalf
+```
+api.login username: 'my-username', password: 'my-password', domain: 'my-domain'
+```
+
+#### [Logout](https://api.agilixbuzz.com/docs/#!/Command/Logout)
+Clears your login session
+```
+api.logout
+```
+
+#### [ExtendSession](https://api.agilixbuzz.com/docs/#!/Command/ExtendSession)
+This is handled automatically by instantiation of a base Agilix::Buzz::Api instance and on subsequent calls to the api through the check_authentication method
+```
+api.extend_session
+```
+
+#### [ForcePasswordChange](https://api.agilixbuzz.com/docs/#!/Command/ForcePasswordChange)
+```
+api.force_password_change userid: 57181
+```
+
+#### [GetPasswordLoginAttemptHistory](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordLoginAttemptHistory)
+```
+api.get_password_login_attempt_history userid: 57181
+api.get_password_login_attempt_history userid: 57181, earliestrecordtoreturn: '2018-01-01'
+```
+
+#### [GetPasswordPolicy](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordPolicy)
+For current domain
+```
+api.get_password_policy
+```
+for a specific domain
+```
+api.get_password_policy domainid: 57031
+```
+
+#### [GetPasswordQuestion](https://api.agilixbuzz.com/docs/#!/Command/GetPasswordQuestion)
+```
+api.get_password_question username: "auto-tests/BuzzUserUp1"
+```
+
+#### [UpdatePasswordQuestionAnswer](https://api.agilixbuzz.com/docs/#!/Command/UpdatePasswordQuestionAnswer)
+ISSUE: This works with a GET call
+```
+api.update_password_question_answer userid: 57181, passwordquestion: "Where is your favorite vacation place?", passwordanswer: "Hawaii"
+
+```
+
+#### [Proxy](https://api.agilixbuzz.com/docs/#!/Command/Proxy)
+```
+  api.proxy userid: 57181
+```
+In addition to these, we've created a proxy api method that will setup an api client for the proxied connection:
+
+#### Proxy Api
+```
+proxy_api = api.proxy_api userid: 57181
+```
+
+This will allow you to make requests as the proxied user, like you would the main api user. It's required to demonstrate how unproxy works below
+
+#### [Unproxy](https://api.agilixbuzz.com/docs/#!/Command/Unproxy)
+First setup a proxy_api
+```
+proxy_api = api.proxy_api userid: 57181
+```
+Then you can unproxy out of it to logout as the proxied user
+```
+proxy_api.unproxy userid: 57181
+```
+
+#### [ResetLockout](https://api.agilixbuzz.com/docs/#!/Command/ResetLockout)
+```
+api.reset_lockout userid: 57181
+```
+#### [ResetPassword](https://api.agilixbuzz.com/docs/#!/Command/ResetPassword)
+```
+api.reset_password username:'auto-tests/BuzzUserUp1'
+```
+
+#### [UpdatePassword](https://api.agilixbuzz.com/docs/#!/Command/UpdatePassword)
+```
+api.update_password userid: 57181, password: "IChanged123"
+```
+
+#### [PutKey](https://api.agilixbuzz.com/docs/#!/Command/PutKey)
+ISSUE: This should be a POST method as it's storing data
+```
+api.put_key entityid: 57031, name: 'secret_key_1', value: "Super Secret"
+```
+
+#### [GetKey](https://api.agilixbuzz.com/docs/#!/Command/GetKey)
+```
+api.get_key entityid: 57031, name: 'secret_key_1'
+```
+
+#### [ComputeHMAC](https://api.agilixbuzz.com/docs/#!/Command/ComputeHMAC)
+This requires a key to exist with the given keyname, see `put_key`. **not sure what its used for yet**
+```
+api.compute_hmac domainid: 57025, keyname: "secret_key_1", message:"my-secret-1"
+```
 
 ## Courses
 
-- [ ] [CopyCourses](https://api.agilixbuzz.com/docs/#!/Command/CopyCourses)
-- [ ] [CreateCourses](https://api.agilixbuzz.com/docs/#!/Command/CreateCourses)
-- [ ] [CreateDemoCourse](https://api.agilixbuzz.com/docs/#!/Command/CreateDemoCourse)
-- [ ] [DeactivateCourse](https://api.agilixbuzz.com/docs/#!/Command/DeactivateCourse)
-- [ ] [DeleteCourses](https://api.agilixbuzz.com/docs/#!/Command/DeleteCourses)
-- [ ] [GetCourse2](https://api.agilixbuzz.com/docs/#!/Command/GetCourse2)
-- [ ] [GetCourseHistory](https://api.agilixbuzz.com/docs/#!/Command/GetCourseHistory)
-- [ ] [ListCourses](https://api.agilixbuzz.com/docs/#!/Command/ListCourses)
-- [ ] [MergeCourses](https://api.agilixbuzz.com/docs/#!/Command/MergeCourses)
-- [ ] [RestoreCourse](https://api.agilixbuzz.com/docs/#!/Command/RestoreCourse)
-- [ ] [UpdateCourses](https://api.agilixbuzz.com/docs/#!/Command/UpdateCourses)
+#### [CopyCourses](https://api.agilixbuzz.com/docs/#!/Command/CopyCourses)
+```
+api.copy_courses [{courseid: 60982, domainid: 57025}]
+```
+
+#### [CreateCourses](https://api.agilixbuzz.com/docs/#!/Command/CreateCourses)
+```
+api.create_courses title: "Starter Course", domainid: 57025
+```
+
+#### [CreateDemoCourse](https://api.agilixbuzz.com/docs/#!/Command/CreateDemoCourse)
+ISSUE: documentation on request format is inconsistent, not sure if it is bulk
+```
+api.create_demo_course courseid: 60982, domainid: 57025, title: "Demo Course",
+```
+
+#### [DeactivateCourse](https://api.agilixbuzz.com/docs/#!/Command/DeactivateCourse)
+ISSUE: get request should be delete, put, patch
+```
+api.deactivate_course
+```
+
+#### [DeleteCourses](https://api.agilixbuzz.com/docs/#!/Command/DeleteCourses)
+ISSUE: Why so different than deactivate course
+```
+api.delete_courses [{courseid: 60994}]
+```
+
+#### [GetCourse2](https://api.agilixbuzz.com/docs/#!/Command/GetCourse2)
+```
+api.get_course2 courseid: 60994
+```
+
+#### [GetCourseHistory](https://api.agilixbuzz.com/docs/#!/Command/GetCourseHistory)
+```
+api.get_course_history courseid: 60994
+```
+
+#### [ListCourses](https://api.agilixbuzz.com/docs/#!/Command/ListCourses)
+```
+api.list_courses domainid: 5
+```
+
+#### [MergeCourses](https://api.agilixbuzz.com/docs/#!/Command/MergeCourses)
+```
+api.merge_courses courseid: 60994
+```
+
+#### [RestoreCourse](https://api.agilixbuzz.com/docs/#!/Command/RestoreCourse)
+```
+api.restore_course courseid: 60994
+```
+
+#### [UpdateCourses](https://api.agilixbuzz.com/docs/#!/Command/UpdateCourses)
+```
+api.update_courses [{courseid: 60994, title: "Updated Course"}]
+```
+
 
 ## Enrollments
 

data/lib/agilix.rb

@@ -7,13 +7,21 @@ require "agilix/buzz/commands/authentication"
 require "agilix/buzz/commands/course"
 require "agilix/buzz/commands/domain"
 require "agilix/buzz/commands/general"
+require "agilix/buzz/commands/report"
+require "agilix/buzz/commands/user"
 
 require "agilix/buzz/api"
 require "agilix/version"
 
 
-module AgilixX
+
+module Agilix
   module Buzz
+    class Api::AuthenticationError < StandardError
+      def initialize(msg="Could not Authenticate")
+        super
+      end
+    end
     # Your code goes here...
   end
 end

data/lib/agilix/buzz/api.rb

@@ -9,6 +9,8 @@ module Agilix
       include Agilix::Buzz::Commands::Course
       include Agilix::Buzz::Commands::Domain
       include Agilix::Buzz::Commands::General
+      include Agilix::Buzz::Commands::Report
+      include Agilix::Buzz::Commands::User
 
       attr_accessor :username, :password, :domain, :token, :token_expiration
 
@@ -16,6 +18,8 @@ module Agilix
         @username = options.fetch(:username, default_username)
         @password = options.fetch(:password, default_password)
         @domain = options.fetch(:domain, default_domain)
+        @token = options.dig(:token)
+        @token_expiration = options.dig(:token_expiration)
       end
 
       def authenticated_get(query = {})
@@ -24,7 +28,7 @@ module Agilix
       end
 
       def authenticated_post(query = {})
-        check_authentication
+        check_authentication unless query.delete(:bypass_authentication_check)
         post query
       end
 
@@ -34,43 +38,46 @@ module Agilix
       end
 
       def get(query = {})
-        response = self.class.get(URL_BASE, query: modify_query(query), timeout: 30, headers: headers)
+        response = self.class.get(URL_BASE, query: modify_query(query), timeout: 60, headers: headers)
       end
 
       def post(query = {})
-        response = self.class.post(URL_BASE, body: modify_body(query), timeout: 30, headers: headers)
+        response = self.class.post(URL_BASE, body: modify_body(query), timeout: 60, headers: headers)
       end
 
       def bulk_post(query = {})
         cmd = query.delete(:cmd)
         url = URL_BASE + "?cmd=#{cmd}&_token=#{token}"
-        response = self.class.post(url, body: modify_bulk_body(query), timeout: 30, headers: headers)
+        response = self.class.post(url, body: modify_bulk_body(query), timeout: 60, headers: headers)
       end
 
-      private
-
       def check_authentication
         if token && token_expiration
           if token_expiration < Time.now
             extend_session
           end
         else
-          response = login username: @username, password: @password, domain: @domain
-          @token = response.dig("response", "user", "token")
-          @token_expiration = Time.now + (response.dig("response", "user", "authenticationexpirationminutes").to_i * 60 ) if @token
+          authenticate!
         end
       end
 
+      private
+
+      def authenticate!
+        response = login username: @username, password: @password, domain: @domain
+        raise AuthenticationError.new(response.dig("response", "message")) if response.dig("response", "code") == "InvalidCredentials"
+        @token = response.dig("response", "user", "token")
+        @token_expiration = Time.now + (response.dig("response", "user", "authenticationexpirationminutes").to_i * 60 ) if @token
+        response
+      end
+
       def argument_cleaner(required_params: , optional_params: , options: )
         missing_required = required_params - options.map {|k,v| k.to_sym }
         raise ArgumentError.new("Missing Required Arguments: #{missing_required.join(', ')}") if missing_required.any?
-
         all_params = (required_params + optional_params).flatten
         return options.select {|k,v| all_params.include?(k.to_sym)}
       end
 
-
-
       def modify_query(query = {})
         default_params = {}
         default_params.merge! query

data/lib/agilix/buzz/commands/authentication.rb

@@ -3,17 +3,149 @@ module Agilix
     module Commands
       module Authentication
 
-        def login_2(username: , password: , domain: )
+        # This is handled automatically by instantiation of a base Agilix::Buzz::Api instance. It wouldn't need to be called manually unless using for other users or making calls on their behalf
+        # api.login username: 'my-username', password: 'my-password', domain: 'my-domain'
+        def login2(username: , password: , domain: )
           post cmd: "login2", username: "#{domain}/#{username}", password: password
         end
-        alias_method :login, :login_2
+        alias_method :login, :login2
 
+        # api.logout
+        def logout
+          response = authenticated_get cmd: "logout"
+          @token = nil
+          @token_expiration = nil
+          response
+        end
+
+        # This is handled automatically by instantiation of a base Agilix::Buzz::Api instance and on subsequent calls to the api through the check_authentication method
+        # api.extend_session
         def extend_session
-          response = authenticated_post cmd: "extendsession"
-          @token_expiration = Time.now + (response.dig("response", "session", "authenticationexpirationminutes").to_i * 60 )
+          response = authenticated_post cmd: "extendsession", bypass_authentication_check: true
+          @token_expiration = set_token_expiration(response.dig("response", "session", "authenticationexpirationminutes"))
+          authenticate! if response['code'] == 'NoAuthentication'
           response
         end
 
+        # api.force_password_change userid: 57181
+        def force_password_change(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( ), options: options )
+          authenticated_post cmd: "forcepasswordchange", **options
+        end
+
+        # api.get_password_login_attempt_history userid: 57181
+        # api.get_password_login_attempt_history userid: 57181, earliestrecordtoreturn: '2018-01-01'
+        def get_password_login_attempt_history(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( earliestrecordtoreturn ), options: options )
+          authenticated_get cmd: "getpasswordloginattempthistory", **options
+        end
+
+        # api.get_password_policy
+        # api.get_password_policy domainid: 57031
+        def get_password_policy(options = {})
+          options = argument_cleaner(required_params: %i(  ), optional_params: %i( domainid bypasscache ), options: options )
+          authenticated_get cmd: "getpasswordpolicy", **options
+        end
+
+        # api.get_password_question username: "auto-tests/BuzzUserUp1"
+        def get_password_question(options = {})
+          options = argument_cleaner(required_params: %i( username ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getpasswordquestion", **options
+        end
+
+        # ISSUE: This works with a GET call
+        # api.update_password_question_answer userid: 57181, passwordquestion: "Where is your favorite vacation place?", passwordanswer: "Hawaii"
+        def update_password_question_answer(options = {})
+          options = argument_cleaner(required_params: %i( userid passwordquestion passwordanswer ), optional_params: %i( oldpassword ), options: options )
+          authenticated_post cmd: "updatepasswordquestionanswer", **options
+        end
+
+        # api.proxy userid: 57181
+        def proxy(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( noazt ), options: options )
+          options[:noazt] ||= true
+          authenticated_post cmd: "proxy", **options
+        end
+
+        # proxy_api = api.proxy_api userid: 57181
+        # proxy_api.unproxy userid: 57181
+        def unproxy(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( noazt ), options: options )
+          authenticated_post cmd: "unproxy", **options
+        end
+
+
+        # proxy_api = api.proxy_api userid: 57181
+        def proxy_api(userid: )
+          response = proxy userid: userid
+          self.class.new username: response.dig('response', 'user', 'username'), token: response.dig('response', 'user', 'token'), domain: response.dig('response', 'user', 'userspace'), token_expiration: set_token_expiration(response.dig('response', 'user', 'authenticationexpirationminutes'))
+        end
+
+
+        # :skip_test_coverage:
+        # api.proxy_sso_link userid: 57181
+        def proxy_sso_link(userid: )
+          response = proxy userid: userid
+          sso =  {
+             "customization": {
+                "authentication": {
+                   "provider": {
+                      "server": "https://www.google.com"
+                   }
+                }
+             }
+          }
+          self.update_domains [ {domainid: response.dig('response', 'user', 'domainid'), data: sso}]
+          # userspace = response.dig('response', 'user', 'userspace')
+          "https://api.leaderinme.net/SSOLogin?domainid=#{response.dig('response', 'user', 'domainid')}&url=/home&token=#{response.dig('response', 'user', 'token')}"
+        end
+        # :skip_test_coverage:
+
+        # api.reset_lockout userid: 57181
+        def reset_lockout(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( ), options: options )
+          authenticated_post cmd: "resetlockout", **options
+        end
+
+        #
+        def reset_password(options = {})
+          options = argument_cleaner(required_params: %i( username ), optional_params: %i( answer ), options: options )
+          authenticated_get cmd: "resetpassword", **options
+        end
+
+       # api.update_password userid: 57181, password: "IChanged123"
+        def update_password(options = {})
+          options = argument_cleaner(required_params: %i( userid password ), optional_params: %i( token oldpassword ), options: options )
+          authenticated_get cmd: "updatepassword", **options
+        end
+
+        # ISSUE: This should be a POST method as it's storing data
+        # api.put_key entityid: 57031, name: 'secret_key_1', value: "Super Secret"
+        def put_key(options = {})
+          options = argument_cleaner(required_params: %i( entityid name value ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "putkey", **options
+        end
+
+        # api.get_key entityid: 57031, name: 'secret_key_1'
+        def get_key(options = {})
+          options = argument_cleaner(required_params: %i( entityid name ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getkey", **options
+        end
+
+        # This requires a key to exist with the given keyname, see putkey
+        # not sure what its used for yet
+        # api.compute_hmac
+        def compute_hmac(options = {})
+          options = argument_cleaner(required_params: %i( domainid keyname message ), optional_params: %i( algorithm format ), options: options )
+          options[:message] = "$VAR_USERID#{options[:message]}$VAR_SECRETTime$VAR_TIME"
+          authenticated_get cmd: "computeHMAC", **options
+        end
+
+        private
+        def set_token_expiration(minutes)
+          Time.now + (minutes.to_i * 60 )
+        end
+
       end
     end
   end

data/lib/agilix/buzz/commands/course.rb

@@ -3,13 +3,87 @@ module Agilix
     module Commands
       module Course
 
-        # api = Agilix::Buzz::Api::new
-        # api.list_courses
+        # api.copy_courses [{courseid: 60982, domainid: 57025}]
+        def copy_courses(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( courseid domainid ), optional_params: %i( action depth reference status roleid title type startdate enddate days term indexrule ), options: item )
+          end
+          authenticated_bulk_post cmd: "copycourses", root_node: "course", body: options
+        end
+
+        # api.create_courses title: "Starter Course", domainid: 57025
+        def create_courses(items = [])
+          options = items.map do |item|
+            item[:schema] ||= 3 # should default to 3, 2 is old news
+            argument_cleaner(required_params: %i( title domainid schema ), optional_params: %i(reference status roleid type startdate enddate days term indexrule data ), options: item )
+          end
+          authenticated_bulk_post cmd: "createcourses", root_node: "course", body: options
+        end
+
+        # ISSUE: documentation on request format is inconsistent, not sure if it is bulk post or normal post format. in one place rood node is request, in other its course
+        # api.create_demo_course courseid: 60982, domainid: 57025, title: "Demo Course", daysoffset: 60
+        def create_demo_course(options = {})
+          options = argument_cleaner(required_params: %i( courseid domainid ), optional_params: %i( schema reference title daysoffset usermap ), options: options )
+          authenticated_post cmd: "createdemocourse", **options
+        end
+
+        # ISSUE: get request should be delete, put, patch
+        # api.deactivate_course
+        def deactivate_course(options = {})
+          options = argument_cleaner(required_params: %i( courseid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "deactivatecourse", **options
+        end
+
+        # ISSUE: Why so different than deactivate course
+        # api.delete_courses [{courseid: 60994}]
+        def delete_courses(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( courseid ), optional_params: %i(), options: item )
+          end
+          authenticated_bulk_post cmd: "deletecourses", root_node: "course", body: options
+        end
+
+        # api.get_course2 courseid: 60994
+        def get_course2(options = {})
+          options = argument_cleaner(required_params: %i( courseid ), optional_params: %i( select version ), options: options )
+          authenticated_get cmd: "getcourse2", **options
+        end
+        alias_method :get_course, :get_course2
+
+        # api.get_course_history courseid: 60994
+        def get_course_history(options = {})
+          options = argument_cleaner(required_params: %i( courseid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getcoursehistory", **options
+        end
+
         # api.list_courses domainid: 5
         def list_courses(options = {})
-          authenticated_get cmd: "listcourses", domainid: options.fetch(:domainid, 0)
+          options[:domainid] ||= 0
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( includedescendantdomains limit show select text query subtype subscriptionmode subscriptiondomainid ), options: options )
+          authenticated_get cmd: "listcourses", **options
         end
 
+        # api.merge_courses courseid: 60994
+        def merge_courses(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( courseid  ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "mergecourses", root_node: "course", body: options
+        end
+
+        # api.restore_course courseid: 60994
+        def restore_course(options = {})
+          options = argument_cleaner(required_params: %i( courseid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "restorecourse", **options
+        end
+
+        # api.update_courses [{courseid: 60994, title: "Updated Course"}]
+        def update_courses(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( courseid  ), optional_params: %i( domainid title reference type baseid startdate enddate days term indexrule schema data ), options: item )
+          end
+          authenticated_bulk_post cmd: "updatecourses", root_node: "course", body: options
+        end
 
       end
     end

data/lib/agilix/buzz/commands/domain.rb

@@ -3,11 +3,10 @@ module Agilix
     module Commands
       module Domain
 
-        # api = Agilix::Buzz::Api::new
         # api.create_domains [{name: "BuzzTest1", userspace: 'buzz-test-fc-1', parentid: '57025'}]
         def create_domains(items = [])
           options = items.map do |item|
-            options = argument_cleaner(required_params: %i( name userspace parentid ), optional_params: %i( reference flags data ), options: item )
+            argument_cleaner(required_params: %i( name userspace parentid ), optional_params: %i( reference flags data ), options: item )
           end
           authenticated_bulk_post cmd: "createdomains", root_node: 'domain', body: options
         end
@@ -61,6 +60,7 @@ module Agilix
         # api.list_domains domainid: '0' # all domains for user
         # api.list_domains domainid: '57025'
         def list_domains(options = {})
+          options[:domainid] ||= 0
           options = argument_cleaner(required_params: %i( domainid  ), optional_params: %i( includedescendantdomains limit show select text query ), options: options )
           authenticated_get cmd: "listdomains", **options
         end
@@ -74,7 +74,7 @@ module Agilix
         # api.update_domains [{ domainid: "57031", name: "BuzzTestUpdated1", userspace: 'buzz-test-fc-1', parentid: '57025'}]
         def update_domains(items)
           options = items.map do |item|
-            options = argument_cleaner(required_params: %i( domainid  ), optional_params: %i( name userspace parentid reference flags data ), options: item )
+            argument_cleaner(required_params: %i( domainid  ), optional_params: %i( name userspace parentid reference flags data ), options: item )
           end
           authenticated_bulk_post cmd: "updatedomains", root_node: 'domain', body: options
         end

data/lib/agilix/buzz/commands/report.rb

@@ -0,0 +1,37 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Report
+
+        # Use this one to find reports you can run
+        # api.get_runnable_report_list domainid: 57025
+        def get_runnable_report_list(options = {})
+          options = argument_cleaner(required_params: %i( ), optional_params: %i( entityid domainid ), options: options )
+          authenticated_get cmd: "getrunnablereportlist", **options
+        end
+
+        # Use this one to run a report
+        # api.run_report reportid: 127, entityid: 57025
+        def run_report(options = {})
+          options = argument_cleaner(required_params: %i( reportid entityid ), optional_params: %i( format content_disposition nodata AsOf), options: options )
+          authenticated_get cmd: "runreport", **options
+        end
+
+        # slightly more info than get_runnable_report_list
+        # api.get_report_info reportid: 123
+        def get_report_info(options = {})
+          options = argument_cleaner(required_params: %i( reportid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getreportinfo", **options
+        end
+
+        # This call seems worthless, and we don't seem to have rights
+        # api.get_report_list domainid: 1
+        def get_report_list(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getreportlist", **options
+        end
+
+      end
+    end
+  end
+end

data/lib/agilix/buzz/commands/user.rb

@@ -0,0 +1,85 @@
+module Agilix
+  module Buzz
+    module Commands
+      module User
+
+        # api.create_users [{ domainid: '57025', username: "BuzzUserTest1", email: 'buzzusertest1@agilix.com', password: 'testpassword1234', firstname: 'Buzz', lastname: "Man", passwordquestion: "Who's your best friend?", passwordanswer: "Me"}]
+        def create_users2(items = [])
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( domainid username email password firstname lastname   ), optional_params: %i( passwordquestion passwordanswer reference flags rights roleid data ), options: item )
+          end
+          authenticated_bulk_post cmd: "createusers2", root_node: 'user', body: options
+        end
+        alias_method :create_users, :create_users2
+
+        # api.delete_users [userid: '57181']
+        def delete_users(items = {})
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( userid ), optional_params: %i( ), options: item )
+          end
+          authenticated_bulk_post cmd: "deleteusers", root_node: 'user', body: options
+        end
+
+        # api.get_active_user_count domainid: '57025'
+        # api.get_active_user_count domainid: '5', includedescendantdomains: true, bymonth:true, startdate: '2018-01-01', enddate: '2019-03-01'
+        def get_active_user_count(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i(includedescendantdomains persona startdate enddate byday bymonth byyear ), options: options)
+          authenticated_get cmd: "getactiveusercount", **options
+        end
+
+        # api.get_domain_activity domainid: '57025'
+        def get_domain_activity(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( startdate enddate maxusers select ), options: options)
+          authenticated_get cmd: "getdomainactivity", **options
+        end
+
+        # api.get_profile_picture entityid: 57026
+        #  api.get_profile_picture entityid: 57025, default: "https://www.gravatar.com/avatar/00000000000000000000000000000000?d=mm"
+        def get_profile_picture(options = {})
+          options = argument_cleaner(required_params: %i( entityid ), optional_params: %i( default ), options: options)
+          authenticated_get cmd: "getprofilepicture", **options
+        end
+
+        # api.get_user2 userid: 57026
+        def get_user2(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( select ), options: options)
+          authenticated_get cmd: "getuser2", **options
+        end
+        alias_method :get_user, :get_user2
+
+        # api.get_user_activity userid: 57026
+        def get_user_activity(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( startdate enddate ), options: options)
+          authenticated_get cmd: "getuseractivity", **options
+        end
+
+        # api.get_user_activity_stream userid: 57026
+        def get_user_activity_stream(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( enrollmentid startkey limit types ), options: options)
+          authenticated_get cmd: "getuseractivitystream", **options
+        end
+
+        # api.list_users domainid: 57025
+        def list_users(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( includedescendantdomains limit show select text query ), options: options)
+          authenticated_get cmd: "listusers", **options
+        end
+
+        # api.restore_user userid: 57026
+        def restore_user(options = {})
+          options = argument_cleaner(required_params: %i( userid ), optional_params: %i( ), options: options)
+          authenticated_get cmd: "restoreuser", **options
+        end
+
+        # api.update_users  [{ userid: '57026', username: "BuzzUserTestUpdated1", email: 'buzzusertest1@agilix.com',firstname: 'Buzz', lastname: "ManUpdated"}]
+        def update_users(items)
+          options = items.map do |item|
+            argument_cleaner(required_params: %i( userid ), optional_params: %i( domainid username firstname lastname email reference flags data ), options: item)
+          end
+          authenticated_bulk_post cmd: "updateusers", root_node: 'user', body: options
+        end
+
+      end
+    end
+  end
+end

data/lib/agilix/version.rb

@@ -1,3 +1,3 @@
 module Agilix
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agilix
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ben Eggett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-11 00:00:00.000000000 Z
+date: 2019-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -189,6 +189,8 @@ files:
 - lib/agilix/buzz/commands/course.rb
 - lib/agilix/buzz/commands/domain.rb
 - lib/agilix/buzz/commands/general.rb
+- lib/agilix/buzz/commands/report.rb
+- lib/agilix/buzz/commands/user.rb
 - lib/agilix/version.rb
 homepage: https://github.com/beneggett/agilix
 licenses: