strongmind-agilix-buzz-client 0.8.3

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/agilix.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "agilix/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "strongmind-agilix-buzz-client"
+  spec.version       = Agilix::VERSION
+  spec.authors       = ["Strongmind"]
+  spec.email         = ["qwertytalk@strongmind.com"]
+
+  spec.summary       = %q{Agilix Buzz API wrapper}
+  spec.description   = %q{Fully implements Agilix Buzz API in Ruby}
+  spec.homepage      = "https://github.com/Strongmind/agilix-buzz-client"
+
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Strongmind/agilix-buzz-client"
+  spec.metadata["changelog_uri"] = "https://github.com/Strongmind/agilix-buzz-client"
+
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "dotenv"
+  spec.add_dependency "httparty"
+  spec.add_dependency "builder"
+  spec.add_dependency "webmock"
+end

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require "dotenv"
+Dotenv.load
+require "bundler/setup"
+require "agilix"
+
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/agilix/buzz/api.rb

@@ -0,0 +1,175 @@
+module Agilix
+  module Buzz
+    class Api
+      include HTTParty
+
+      include Agilix::Buzz::Commands::Authentication
+      include Agilix::Buzz::Commands::Course
+      include Agilix::Buzz::Commands::Domain
+      include Agilix::Buzz::Commands::Enrollment
+      include Agilix::Buzz::Commands::General
+      include Agilix::Buzz::Commands::Library
+      include Agilix::Buzz::Commands::Report
+      include Agilix::Buzz::Commands::Resource
+      include Agilix::Buzz::Commands::Right
+      include Agilix::Buzz::Commands::User
+
+      attr_accessor :username, :password, :domain, :token, :token_expiration, :agilix_url_endpoint
+
+      def initialize(options = {})
+        @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)
+        @agilix_url_endpoint = options.fetch(:agilix_url_endpoint, default_agilix_url_endpoint)
+      end
+
+      def authenticated_get(query = {})
+        check_authentication
+        get query
+      end
+
+      def authenticated_post(query = {})
+        check_authentication unless query.delete(:bypass_authentication_check)
+        post query
+      end
+
+      def authenticated_query_post(query = {})
+        check_authentication unless query.delete(:bypass_authentication_check)
+        query_post query
+      end
+
+      def authenticated_bulk_post(query = {})
+        check_authentication
+        bulk_post query
+      end
+
+      def get(query = {})
+        response = self.class.get(agilix_url_base, query: modify_query(query), timeout: 60, headers: headers)
+      end
+
+      def post(query = {})
+        response = self.class.post(agilix_url_base, body: modify_body(query), timeout: 60, headers: headers)
+      end
+
+      # Not sure if I want to use this yet
+      # api.response_parser response: response, path_to_parse: ['response', 'users', 'user'], collection_name: 'users'
+      # def response_parser(path_to_parse: nil, collection_name: nil, response: )
+      #   if path_to_parse
+      #     result = response.dig(*path_to_parse)
+      #     ostruct = JSON::parse({collection_name => result}.to_json, object_class: OpenStruct)
+      #     ostruct.result_count = result.size
+      #     ostruct.collection_name = collection_name
+      #   else
+      #     ostruct = JSON::parse(response.body, object_class: OpenStruct)
+      #   end
+      #   ostruct.code = response['code']
+      #   ostruct.response = response
+      #   ostruct.request = request
+      #   ostruct
+      # end
+
+      # For when the api is super unconventional & you need to modify both query params & body params in a custom fashion, and upload a file even!
+      def query_post(query = {})
+        url = agilix_url_base
+        query_params = query.delete(:query_params)
+        if query_params
+          url += "?&_token=#{token}" + query_params.map {|k,v| "&#{k}=#{v}" }.join("")
+        end
+        file = query.delete(:file)
+        if file
+          new_headers = headers
+          new_headers["Content-Type"] = "multipart/form-data"
+          response = self.class.post(url, multipart: true, body: {file: file}, timeout: 60, headers: new_headers)
+        else
+          response = self.class.post(url, body: query.to_json, timeout: 60, headers: headers)
+        end
+      end
+
+      def bulk_post(query = {})
+        cmd = query.delete(:cmd)
+        url = agilix_url_base + "?cmd=#{cmd}&_token=#{token}"
+        query_params = query.delete(:query_params)
+        if query_params
+          url += query_params.map {|k,v| "&#{k}=#{v}" }.join("")
+        end
+        response = self.class.post(url, body: modify_bulk_body(query), timeout: 60, headers: headers)
+      end
+
+      def check_authentication
+        if token && token_expiration
+          if token_expiration < Time.now
+            extend_session
+          end
+        else
+          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
+        default_params["_token"] =  token if token
+        default_params
+      end
+
+      def modify_body(body = {})
+        default_params = { request: {}.merge(body) }
+        default_params[:request]["_token"] = token if token
+        default_params.to_json
+      end
+
+      def modify_bulk_body(query = {})
+        root_node = query.delete(:root_node)
+        default_params = { requests: { root_node.to_sym => query[:body] } }
+        default_params.to_json
+      end
+
+      def headers
+        @headers = {
+          "Accept" => "application/json",
+          "Content-Type" => "application/json",
+        }
+      end
+
+      def default_username
+        ENV["AGILIX_BUZZ_USERNAME"]
+      end
+
+      def default_password
+        ENV["AGILIX_BUZZ_PASSWORD"]
+      end
+
+      def default_domain
+        ENV["AGILIX_BUZZ_DEFAULT_DOMAIN"]
+      end
+
+      def default_agilix_url_endpoint
+        ENV.fetch("AGILIX_BUZZ_URL", "https://api.agilixbuzz.com")
+      end
+
+      def agilix_url_base
+        @agilix_url_base ||= "#{agilix_url_endpoint}/cmd"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Authentication
+
+        # 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, :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", bypass_authentication_check: true
+          @token_expiration = set_token_expiration(response.dig("response", "session", "authenticationexpirationminutes"))
+          authenticate! if response.dig("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
+
+        # api.proxy_sso_link userid: 57181
+        def proxy_sso_link(userid: , redirect_url: "home")
+          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')
+          token = response.dig('response', 'user', 'token')
+          # "https://api.leaderinme.net/SSOLogin?domainid=#{response.dig('response', 'user', 'domainid')}&url=/home&token=#{response.dig('response', 'user', 'token')}"
+          if token && userspace
+            "https://#{userspace}.leaderinme.net/login?token=#{token}&url=/#{redirect_url}"
+          end
+        end
+
+        # 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
+end

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

@@ -0,0 +1,91 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Course
+
+        # 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 = {})
+          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
+  end
+end

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

@@ -0,0 +1,85 @@
+module Agilix
+  module Buzz
+    module Commands
+      module Domain
+
+        # api.create_domains [{name: "BuzzTest1", userspace: 'buzz-test-fc-1', parentid: '57025'}]
+        def create_domains(items = [])
+          options = items.map do |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
+
+        # api.delete_domain domainid: '57031'
+        def delete_domain(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "deletedomain", **options
+        end
+
+        # api.get_domain domainid: '57025'
+        def get_domain2(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( select ), options: options )
+          authenticated_get cmd: "getdomain2", **options
+        end
+        alias_method :get_domain, :get_domain2
+
+        # api.get_domain_content domainid: '57025'
+        def get_domain_content(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getdomaincontent", **options
+        end
+
+        # api.get_domain_enrollment_metrics domainid: '57025'
+        def get_domain_enrollment_metrics(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( skipempty ), options: options )
+          authenticated_get cmd: "getdomainenrollmentmetrics", **options
+        end
+
+        # api.get_domain_parent_list domainid: '57025'
+        def get_domain_parent_list(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "getdomainparentlist", **options
+        end
+
+        # api.get_domain_settings domainid: '57025', path: "AgilixBuzzSettings.xml"
+        def get_domain_settings(options = {})
+          options = argument_cleaner(required_params: %i( domainid path ), optional_params: %i( includesource ), options: options )
+          authenticated_get cmd: "getdomainsettings", **options
+        end
+        # Optional can use settings in a POST to set settings attributes if needed.
+
+        # api.get_domain_stats domainid: '57025', options: "users|courses"
+        def get_domain_stats(options = {})
+          # options = 'users|courses|activecourses|sections|enrollments|activeenrollments|activestudents'
+          options = argument_cleaner(required_params: %i( domainid options ), optional_params: %i( includesource ), options: options )
+
+          authenticated_get cmd: "getdomainstats", **options
+        end
+
+        # 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
+
+        # api.restore_domain domainid: '57031'
+        def restore_domain(options = {})
+          options = argument_cleaner(required_params: %i( domainid ), optional_params: %i( ), options: options )
+          authenticated_get cmd: "restoredomain", **options
+        end
+
+        # api.update_domains [{ domainid: "57031", name: "BuzzTestUpdated1", userspace: 'buzz-test-fc-1', parentid: '57025'}]
+        def update_domains(items)
+          options = items.map do |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
+
+      end
+    end
+  end
+end