lex-service_now 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbf260038f432fcd485cb48c125da454b3f796b3165cefe76675b5fea1c1a336
-  data.tar.gz: 1a82c55c3644116943755c214c527173b928a499437cb3b75aa897b25afbf1bf
+  metadata.gz: 7299f2cb64f753600e58b75350804a51164e4ed0b246a0124e9dd691ae813860
+  data.tar.gz: 4cdb63326d0a106814c0f6abb67bf819198e0114d299dbf971a3185ed3b75f8c
 SHA512:
-  metadata.gz: 552a514871309be55f0c41b899724cc833649741bbea34be70695e3b8e3f784f40952dd2afb6244163438b8214808b610cd267f871963cd9d74bd67c7ab0158f
-  data.tar.gz: 8e37565b25abc8382372e77bb2e02acb14ef894b340ee823346671ea9e5beff9256f9af1e32ddb25780bfb3bb2790684164b6805d05125fec8fc55467b52bf65
+  metadata.gz: 619c90c1289c5b046076a55290a5969d51605b5491ad3163a4038de98d99e06294b62774d5a3d24592ec27f0705ab759df3aafca91778be7c6af10f8d0e0d3ea
+  data.tar.gz: 3ee2c4fb6921cf67f71139d9a288d6d056302a0b403f63dcb6b809dfb3667ca00b7689255e5ade8bb188d618a97169338b71673b7c8febb99401ca7e2e493374

data/lib/legion/extensions/service_now/access_control/runners/access_control.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module AccessControl
+        module Runners
+          module AccessControl
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_acls(sysparm_limit: 100, sysparm_offset: 0,
+                          sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/sys_security_acl', params)
+              { acls: resp.body['result'] }
+            end
+
+            def get_acl(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sys_security_acl/#{sys_id}")
+              { acl: resp.body['result'] }
+            end
+
+            def create_acl(name:, type:, operation:, active: true,
+                           script: nil, condition: nil, **)
+              body = { name: name, type: type, operation: operation, active: active }
+              body[:script]    = script if script
+              body[:condition] = condition if condition
+              resp = connection(**).post('/api/now/table/sys_security_acl', body)
+              { acl: resp.body['result'] }
+            end
+
+            def update_acl(sys_id:, active: nil, script: nil, condition: nil, **)
+              body = {}
+              body[:active]    = active unless active.nil?
+              body[:script]    = script if script
+              body[:condition] = condition if condition
+              resp = connection(**).patch("/api/now/table/sys_security_acl/#{sys_id}", body)
+              { acl: resp.body['result'] }
+            end
+
+            def delete_acl(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/sys_security_acl/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/calendar/runners/calendar.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Calendar
+        module Runners
+          module Calendar
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_schedules(sysparm_limit: 100, sysparm_offset: 0,
+                               sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/cmn_schedule', params)
+              { schedules: resp.body['result'] }
+            end
+
+            def get_schedule(sys_id:, **)
+              resp = connection(**).get("/api/now/table/cmn_schedule/#{sys_id}")
+              { schedule: resp.body['result'] }
+            end
+
+            def create_schedule(name:, type: 'include', time_zone: nil, **)
+              body = { name: name, type: type }
+              body[:time_zone] = time_zone if time_zone
+              resp = connection(**).post('/api/now/table/cmn_schedule', body)
+              { schedule: resp.body['result'] }
+            end
+
+            def update_schedule(sys_id:, name: nil, time_zone: nil, **)
+              body = {}
+              body[:name]      = name if name
+              body[:time_zone] = time_zone if time_zone
+              resp = connection(**).patch("/api/now/table/cmn_schedule/#{sys_id}", body)
+              { schedule: resp.body['result'] }
+            end
+
+            def delete_schedule(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/cmn_schedule/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            def list_schedule_entries(schedule_sys_id:, sysparm_limit: 100, **)
+              params = {
+                sysparm_query: "schedule=#{schedule_sys_id}",
+                sysparm_limit: sysparm_limit
+              }
+              resp = connection(**).get('/api/now/table/cmn_schedule_span', params)
+              { entries: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/catalog_task/runners/catalog_task.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module CatalogTask
+        module Runners
+          module CatalogTask
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_catalog_tasks(sysparm_limit: 100, sysparm_offset: 0,
+                                   sysparm_query: nil, request_item: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              if request_item
+                params[:sysparm_query] = "request_item=#{request_item}"
+              elsif sysparm_query
+                params[:sysparm_query] = sysparm_query
+              end
+              resp = connection(**).get('/api/now/table/sc_task', params)
+              { catalog_tasks: resp.body['result'] }
+            end
+
+            def get_catalog_task(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sc_task/#{sys_id}")
+              { catalog_task: resp.body['result'] }
+            end
+
+            def update_catalog_task(sys_id:, state: nil, assigned_to: nil,
+                                    work_notes: nil, **)
+              body = {}
+              body[:state]       = state if state
+              body[:assigned_to] = assigned_to if assigned_to
+              body[:work_notes]  = work_notes if work_notes
+              resp = connection(**).patch("/api/now/table/sc_task/#{sys_id}", body)
+              { catalog_task: resp.body['result'] }
+            end
+
+            def close_catalog_task(sys_id:, close_notes:, **)
+              body = { state: '3', close_notes: close_notes }
+              resp = connection(**).patch("/api/now/table/sc_task/#{sys_id}", body)
+              { catalog_task: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/change/runners/change.rb

@@ -65,18 +65,18 @@ module Legion
               { deleted: resp.status == 204, id: id }
             end
 
-            def list_tasks(id:, **)
+            def list_change_tasks(id:, **)
               resp = connection(**).get("/api/sn_chg_rest/change/#{id}/task")
               { tasks: resp.body['result'] }
             end
 
-            def create_task(id:, short_description:, **)
+            def create_change_task(id:, short_description:, **)
               body = { short_description: short_description }
               resp = connection(**).post("/api/sn_chg_rest/change/#{id}/task", body)
               { task: resp.body['result'] }
             end
 
-            def update_task(id:, task_id:, short_description: nil, state: nil, assigned_to: nil, **)
+            def update_change_task(id:, task_id:, short_description: nil, state: nil, assigned_to: nil, **)
               body = {}
               body[:short_description] = short_description if short_description
               body[:state]             = state if state
@@ -85,7 +85,7 @@ module Legion
               { task: resp.body['result'] }
             end
 
-            def delete_task(id:, task_id:, **)
+            def delete_change_task(id:, task_id:, **)
               resp = connection(**).delete("/api/sn_chg_rest/change/#{id}/task/#{task_id}")
               { deleted: resp.status == 204, task_id: task_id }
             end

data/lib/legion/extensions/service_now/ci_relationship/runners/ci_relationship.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module CiRelationship
+        module Runners
+          module CiRelationship
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_relationship_types(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/now/table/cmdb_rel_type', params)
+              { relationship_types: resp.body['result'] }
+            end
+
+            def get_relationship_type(sys_id:, **)
+              resp = connection(**).get("/api/now/table/cmdb_rel_type/#{sys_id}")
+              { relationship_type: resp.body['result'] }
+            end
+
+            def list_ci_relationships(sysparm_limit: 100, sysparm_offset: 0,
+                                      parent: nil, child: nil, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              query_parts = []
+              query_parts << "parent=#{parent}" if parent
+              query_parts << "child=#{child}" if child
+              query_parts << sysparm_query if sysparm_query
+              params[:sysparm_query] = query_parts.join('^') unless query_parts.empty?
+              resp = connection(**).get('/api/now/table/cmdb_rel_ci', params)
+              { relationships: resp.body['result'] }
+            end
+
+            def create_ci_relationship(parent:, child:, type:, **)
+              body = { parent: parent, child: child, type: type }
+              resp = connection(**).post('/api/now/table/cmdb_rel_ci', body)
+              { relationship: resp.body['result'] }
+            end
+
+            def delete_ci_relationship(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/cmdb_rel_ci/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/client.rb

@@ -5,6 +5,8 @@ module Legion
     module ServiceNow
       class Client
         include Helpers::Client
+        include Helpers::Pagination
+        include Helpers::Retry
         include Change::Runners::Change
         include Cmdb::Instance::Runners::Instance
         include Cmdb::Meta::Runners::Meta
@@ -51,6 +53,22 @@ module Legion
         include MidServer::Runners::MidServer
         include CatalogVariable::Runners::CatalogVariable
         include Workflow::Runners::Workflow
+        include Vendor::Runners::Vendor
+        include CiRelationship::Runners::CiRelationship
+        include ScriptAction::Runners::ScriptAction
+        include UiPolicy::Runners::UiPolicy
+        include UiAction::Runners::UiAction
+        include AccessControl::Runners::AccessControl
+        include CatalogTask::Runners::CatalogTask
+        include KnowledgeBase::Runners::KnowledgeBase
+        include Tag::Runners::Tag
+        include Metric::Runners::Metric
+        include Currency::Runners::Currency
+        include Calendar::Runners::Calendar
+        include KnowledgeFeedback::Runners::KnowledgeFeedback
+        include License::Runners::License
+        include DeprecationLog::Runners::DeprecationLog
+        include CmdbHealth::Runners::CmdbHealth
 
         attr_reader :opts
 

data/lib/legion/extensions/service_now/cmdb_health/runners/cmdb_health.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module CmdbHealth
+        module Runners
+          module CmdbHealth
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_health_rules(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/now/table/sa_m2m_suggested_relationship', params)
+              { health_rules: resp.body['result'] }
+            end
+
+            def get_cmdb_health_dashboard(**)
+              resp = connection(**).get('/api/now/cmdb/health_dashboard')
+              { dashboard: resp.body['result'] }
+            end
+
+            def list_duplicate_cis(class_name:, sysparm_limit: 100, **)
+              params = {
+                sysparm_query: "sys_class_name=#{class_name}",
+                sysparm_limit: sysparm_limit
+              }
+              resp = connection(**).get('/api/now/table/cmdb_duplicate', params)
+              { duplicates: resp.body['result'] }
+            end
+
+            def list_stale_cis(class_name:, days_since_discovery: 30, **)
+              cutoff = (::Time.now - (days_since_discovery * 86_400)).strftime('%Y-%m-%d %H:%M:%S')
+              params = {
+                sysparm_query: "sys_class_name=#{class_name}^last_discovered<#{cutoff}",
+                sysparm_limit: 100
+              }
+              resp = connection(**).get('/api/now/table/cmdb_ci', params)
+              { stale_cis: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/currency/runners/currency.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Currency
+        module Runners
+          module Currency
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_currencies(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/now/table/fx_currency', params)
+              { currencies: resp.body['result'] }
+            end
+
+            def get_currency(sys_id:, **)
+              resp = connection(**).get("/api/now/table/fx_currency/#{sys_id}")
+              { currency: resp.body['result'] }
+            end
+
+            def list_exchange_rates(from_currency: nil, to_currency: nil,
+                                    sysparm_limit: 100, **)
+              params = { sysparm_limit: sysparm_limit }
+              query_parts = []
+              query_parts << "from_cur=#{from_currency}" if from_currency
+              query_parts << "to_cur=#{to_currency}" if to_currency
+              params[:sysparm_query] = query_parts.join('^') unless query_parts.empty?
+              resp = connection(**).get('/api/now/table/fx_rate', params)
+              { exchange_rates: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/deprecation_log/runners/deprecation_log.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module DeprecationLog
+        module Runners
+          module DeprecationLog
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_upgrade_logs(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/now/table/sys_upgrade_history', params)
+              { upgrade_logs: resp.body['result'] }
+            end
+
+            def get_upgrade_log(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sys_upgrade_history/#{sys_id}")
+              { upgrade_log: resp.body['result'] }
+            end
+
+            def list_upgrade_skips(sysparm_limit: 100, **)
+              params = { sysparm_limit: sysparm_limit }
+              resp = connection(**).get('/api/now/table/sys_upgrade_skip', params)
+              { upgrade_skips: resp.body['result'] }
+            end
+
+            def list_deprecation_entries(sysparm_limit: 100, sysparm_offset: 0,
+                                         sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/sys_deprecation_log', params)
+              { deprecation_entries: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Errors
+        class ServiceNowError < StandardError
+          attr_reader :status, :detail
+
+          def initialize(message, status: nil, detail: nil)
+            super(message)
+            @status = status
+            @detail = detail
+          end
+        end
+
+        class AuthenticationError < ServiceNowError; end
+        class AuthorizationError < ServiceNowError; end
+        class NotFoundError < ServiceNowError; end
+        class UnprocessableError < ServiceNowError; end
+        class RateLimitError < ServiceNowError; end
+        class ServerError < ServiceNowError; end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/helpers/client.rb

@@ -38,6 +38,38 @@ module Legion
               resp.body['access_token']
             end
           end
+
+          def handle_response(resp)
+            case resp.status
+            when 200, 201, 202, 204
+              resp
+            when 401
+              raise Errors::AuthenticationError.new(error_message(resp), status: 401, detail: resp.body)
+            when 403
+              raise Errors::AuthorizationError.new(error_message(resp), status: 403, detail: resp.body)
+            when 404
+              raise Errors::NotFoundError.new(error_message(resp), status: 404, detail: resp.body)
+            when 422
+              raise Errors::UnprocessableError.new(error_message(resp), status: 422, detail: resp.body)
+            when 429
+              raise Errors::RateLimitError.new(error_message(resp), status: 429, detail: resp.body)
+            when 500..599
+              raise Errors::ServerError.new(error_message(resp), status: resp.status, detail: resp.body)
+            else
+              raise Errors::ServiceNowError.new(error_message(resp), status: resp.status, detail: resp.body)
+            end
+          end
+
+          private
+
+          def error_message(resp)
+            body = resp.body
+            return "ServiceNow error (#{resp.status})" unless body.is_a?(Hash)
+
+            msg = body.dig('error', 'message') || body.dig('error', 'detail') ||
+                  body['error'] || body['message'] || "ServiceNow error (#{resp.status})"
+            msg.to_s
+          end
         end
       end
     end

data/lib/legion/extensions/service_now/helpers/pagination.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Helpers
+        module Pagination
+          def paginate(method_name, **opts)
+            results = []
+            offset = 0
+            limit = opts.fetch(:sysparm_limit, 100)
+
+            loop do
+              response = public_send(method_name, **opts, sysparm_limit: limit, sysparm_offset: offset)
+              key = response.keys.first
+              batch = response[key]
+              break if batch.nil? || batch.empty?
+
+              results.concat(batch)
+              break if batch.size < limit
+
+              offset += limit
+            end
+
+            results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/helpers/retry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Helpers
+        module Retry
+          MAX_RETRIES = 3
+          BASE_DELAY  = 1.0
+
+          def with_retry(max_retries: MAX_RETRIES)
+            attempts = 0
+            begin
+              attempts += 1
+              yield
+            rescue Errors::RateLimitError => e
+              raise e if attempts >= max_retries
+
+              sleep(BASE_DELAY * (2**(attempts - 1)))
+              retry
+            rescue Errors::ServerError => e
+              raise e if attempts >= max_retries
+
+              sleep(BASE_DELAY)
+              retry
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/knowledge_base/runners/knowledge_base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module KnowledgeBase
+        module Runners
+          module KnowledgeBase
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_knowledge_bases(sysparm_limit: 100, sysparm_offset: 0,
+                                     sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/kb_knowledge_base', params)
+              { knowledge_bases: resp.body['result'] }
+            end
+
+            def get_knowledge_base(sys_id:, **)
+              resp = connection(**).get("/api/now/table/kb_knowledge_base/#{sys_id}")
+              { knowledge_base: resp.body['result'] }
+            end
+
+            def create_knowledge_base(title:, description: nil, owner: nil,
+                                      active: true, **)
+              body = { title: title, active: active }
+              body[:description] = description if description
+              body[:owner]       = owner if owner
+              resp = connection(**).post('/api/now/table/kb_knowledge_base', body)
+              { knowledge_base: resp.body['result'] }
+            end
+
+            def update_knowledge_base(sys_id:, title: nil, description: nil,
+                                      active: nil, **)
+              body = {}
+              body[:title]       = title if title
+              body[:description] = description if description
+              body[:active]      = active unless active.nil?
+              resp = connection(**).patch("/api/now/table/kb_knowledge_base/#{sys_id}", body)
+              { knowledge_base: resp.body['result'] }
+            end
+
+            def delete_knowledge_base(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/kb_knowledge_base/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            def list_kb_categories(knowledge_base_sys_id:, sysparm_limit: 100, **)
+              params = {
+                sysparm_query: "kb_knowledge_base=#{knowledge_base_sys_id}",
+                sysparm_limit: sysparm_limit
+              }
+              resp = connection(**).get('/api/now/table/kb_category', params)
+              { categories: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/knowledge_feedback/runners/knowledge_feedback.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module KnowledgeFeedback
+        module Runners
+          module KnowledgeFeedback
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_knowledge_feedback(sysparm_limit: 100, sysparm_offset: 0,
+                                        article: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = "article=#{article}" if article
+              resp = connection(**).get('/api/now/table/kb_feedback', params)
+              { feedback: resp.body['result'] }
+            end
+
+            def get_knowledge_feedback(sys_id:, **)
+              resp = connection(**).get("/api/now/table/kb_feedback/#{sys_id}")
+              { feedback: resp.body['result'] }
+            end
+
+            def create_knowledge_feedback(article:, rating:, comments: nil, **)
+              body = { article: article, rating: rating }
+              body[:comments] = comments if comments
+              resp = connection(**).post('/api/now/table/kb_feedback', body)
+              { feedback: resp.body['result'] }
+            end
+
+            def list_knowledge_views(article: nil, sysparm_limit: 100, **)
+              params = { sysparm_limit: sysparm_limit }
+              params[:sysparm_query] = "article=#{article}" if article
+              resp = connection(**).get('/api/now/table/kb_view', params)
+              { views: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/license/runners/license.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module License
+        module Runners
+          module License
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_licenses(sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              resp = connection(**).get('/api/now/table/license_agreement', params)
+              { licenses: resp.body['result'] }
+            end
+
+            def get_license(sys_id:, **)
+              resp = connection(**).get("/api/now/table/license_agreement/#{sys_id}")
+              { license: resp.body['result'] }
+            end
+
+            def list_license_allocations(license_sys_id: nil, sysparm_limit: 100, **)
+              params = { sysparm_limit: sysparm_limit }
+              params[:sysparm_query] = "license_agreement=#{license_sys_id}" if license_sys_id
+              resp = connection(**).get('/api/now/table/license_allocation', params)
+              { allocations: resp.body['result'] }
+            end
+
+            def list_installed_software(sysparm_limit: 100, sysparm_offset: 0,
+                                        sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/cmdb_sam_sw_install', params)
+              { installations: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/metric/runners/metric.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Metric
+        module Runners
+          module Metric
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_metric_definitions(sysparm_limit: 100, sysparm_offset: 0,
+                                        sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/metric_definition', params)
+              { metric_definitions: resp.body['result'] }
+            end
+
+            def get_metric_definition(sys_id:, **)
+              resp = connection(**).get("/api/now/table/metric_definition/#{sys_id}")
+              { metric_definition: resp.body['result'] }
+            end
+
+            def list_metric_instances(metric_sys_id: nil, table: nil,
+                                      sysparm_limit: 100, sysparm_offset: 0, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              query_parts = []
+              query_parts << "metric_definition=#{metric_sys_id}" if metric_sys_id
+              query_parts << "table=#{table}" if table
+              params[:sysparm_query] = query_parts.join('^') unless query_parts.empty?
+              resp = connection(**).get('/api/now/table/metric_instance', params)
+              { metric_instances: resp.body['result'] }
+            end
+
+            def get_metric_instance(sys_id:, **)
+              resp = connection(**).get("/api/now/table/metric_instance/#{sys_id}")
+              { metric_instance: resp.body['result'] }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/script_action/runners/script_action.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module ScriptAction
+        module Runners
+          module ScriptAction
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_script_actions(sysparm_limit: 100, sysparm_offset: 0,
+                                    sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/sysevent_script_action', params)
+              { script_actions: resp.body['result'] }
+            end
+
+            def get_script_action(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sysevent_script_action/#{sys_id}")
+              { script_action: resp.body['result'] }
+            end
+
+            def create_script_action(name:, event_name:, script:, active: true, **)
+              body = { name: name, event_name: event_name, script: script, active: active }
+              resp = connection(**).post('/api/now/table/sysevent_script_action', body)
+              { script_action: resp.body['result'] }
+            end
+
+            def update_script_action(sys_id:, script: nil, active: nil, **)
+              body = {}
+              body[:script] = script if script
+              body[:active] = active unless active.nil?
+              resp = connection(**).patch("/api/now/table/sysevent_script_action/#{sys_id}", body)
+              { script_action: resp.body['result'] }
+            end
+
+            def delete_script_action(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/sysevent_script_action/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/table/runners/table.rb

@@ -30,12 +30,14 @@ module Legion
             end
 
             def table_create(table_name:, **fields)
-              resp = connection(**fields).post("/api/now/table/#{table_name}", fields)
+              body = fields.except(:url, :client_id, :client_secret, :token, :username, :password)
+              resp = connection(**fields).post("/api/now/table/#{table_name}", body)
               { record: resp.body['result'] }
             end
 
             def table_update(table_name:, sys_id:, **fields)
-              resp = connection(**fields).patch("/api/now/table/#{table_name}/#{sys_id}", fields)
+              body = fields.except(:url, :client_id, :client_secret, :token, :username, :password, :sys_id)
+              resp = connection(**fields).patch("/api/now/table/#{table_name}/#{sys_id}", body)
               { record: resp.body['result'] }
             end
 

data/lib/legion/extensions/service_now/tag/runners/tag.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Tag
+        module Runners
+          module Tag
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_tags(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/label', params)
+              { tags: resp.body['result'] }
+            end
+
+            def get_tag(sys_id:, **)
+              resp = connection(**).get("/api/now/table/label/#{sys_id}")
+              { tag: resp.body['result'] }
+            end
+
+            def create_tag(name:, color: nil, **)
+              body = { name: name }
+              body[:color] = color if color
+              resp = connection(**).post('/api/now/table/label', body)
+              { tag: resp.body['result'] }
+            end
+
+            def delete_tag(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/label/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            def list_tagged_records(tag_sys_id:, table_name: nil, sysparm_limit: 100, **)
+              query = "label=#{tag_sys_id}"
+              query += "^table=#{table_name}" if table_name
+              params = { sysparm_query: query, sysparm_limit: sysparm_limit }
+              resp = connection(**).get('/api/now/table/label_entry', params)
+              { tagged_records: resp.body['result'] }
+            end
+
+            def add_tag_to_record(tag_sys_id:, table_name:, record_sys_id:, **)
+              body = { label: tag_sys_id, table: table_name, id_display: record_sys_id }
+              resp = connection(**).post('/api/now/table/label_entry', body)
+              { tag_entry: resp.body['result'] }
+            end
+
+            def remove_tag_from_record(tag_entry_sys_id:, **)
+              resp = connection(**).delete("/api/now/table/label_entry/#{tag_entry_sys_id}")
+              { deleted: resp.status == 204, sys_id: tag_entry_sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/ui_action/runners/ui_action.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module UiAction
+        module Runners
+          module UiAction
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_ui_actions(sysparm_limit: 100, sysparm_offset: 0,
+                                sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/sys_ui_action', params)
+              { ui_actions: resp.body['result'] }
+            end
+
+            def get_ui_action(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sys_ui_action/#{sys_id}")
+              { ui_action: resp.body['result'] }
+            end
+
+            def create_ui_action(name:, table:, script:, action_type: 'button',
+                                 active: true, **)
+              body = { name: name, table: table, script: script,
+                       action_type: action_type, active: active }
+              resp = connection(**).post('/api/now/table/sys_ui_action', body)
+              { ui_action: resp.body['result'] }
+            end
+
+            def update_ui_action(sys_id:, script: nil, active: nil, name: nil, **)
+              body = {}
+              body[:script] = script if script
+              body[:active] = active unless active.nil?
+              body[:name]   = name if name
+              resp = connection(**).patch("/api/now/table/sys_ui_action/#{sys_id}", body)
+              { ui_action: resp.body['result'] }
+            end
+
+            def delete_ui_action(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/sys_ui_action/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/ui_policy/runners/ui_policy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module UiPolicy
+        module Runners
+          module UiPolicy
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_ui_policies(sysparm_limit: 100, sysparm_offset: 0,
+                                 sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/sys_ui_policy', params)
+              { ui_policies: resp.body['result'] }
+            end
+
+            def get_ui_policy(sys_id:, **)
+              resp = connection(**).get("/api/now/table/sys_ui_policy/#{sys_id}")
+              { ui_policy: resp.body['result'] }
+            end
+
+            def create_ui_policy(table:, short_description:, script: nil, active: true, **)
+              body = { table: table, short_description: short_description, active: active }
+              body[:script] = script if script
+              resp = connection(**).post('/api/now/table/sys_ui_policy', body)
+              { ui_policy: resp.body['result'] }
+            end
+
+            def update_ui_policy(sys_id:, active: nil, script: nil, **)
+              body = {}
+              body[:active] = active unless active.nil?
+              body[:script] = script if script
+              resp = connection(**).patch("/api/now/table/sys_ui_policy/#{sys_id}", body)
+              { ui_policy: resp.body['result'] }
+            end
+
+            def delete_ui_policy(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/sys_ui_policy/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/vendor/runners/vendor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module ServiceNow
+      module Vendor
+        module Runners
+          module Vendor
+            include Legion::Extensions::ServiceNow::Helpers::Client
+
+            def list_vendors(sysparm_limit: 100, sysparm_offset: 0, sysparm_query: nil, **)
+              params = { sysparm_limit: sysparm_limit, sysparm_offset: sysparm_offset }
+              params[:sysparm_query] = sysparm_query if sysparm_query
+              resp = connection(**).get('/api/now/table/core_company',
+                                        params.merge(sysparm_query: build_vendor_query(sysparm_query)))
+              { vendors: resp.body['result'] }
+            end
+
+            def get_vendor(sys_id:, **)
+              resp = connection(**).get("/api/now/table/core_company/#{sys_id}")
+              { vendor: resp.body['result'] }
+            end
+
+            def create_vendor(name:, phone: nil, website: nil, vendor_type: nil, **)
+              body = { name: name, vendor: true }
+              body[:phone]       = phone if phone
+              body[:website]     = website if website
+              body[:vendor_type] = vendor_type if vendor_type
+              resp = connection(**).post('/api/now/table/core_company', body)
+              { vendor: resp.body['result'] }
+            end
+
+            def update_vendor(sys_id:, name: nil, phone: nil, website: nil, **)
+              body = {}
+              body[:name]    = name if name
+              body[:phone]   = phone if phone
+              body[:website] = website if website
+              resp = connection(**).patch("/api/now/table/core_company/#{sys_id}", body)
+              { vendor: resp.body['result'] }
+            end
+
+            def delete_vendor(sys_id:, **)
+              resp = connection(**).delete("/api/now/table/core_company/#{sys_id}")
+              { deleted: resp.status == 204, sys_id: sys_id }
+            end
+
+            private
+
+            def build_vendor_query(extra_query)
+              base = 'vendor=true'
+              extra_query ? "#{base}^#{extra_query}" : base
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/service_now/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module ServiceNow
-      VERSION = '0.2.0'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/legion/extensions/service_now.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/service_now/version'
+require 'legion/extensions/service_now/errors'
 require 'legion/extensions/service_now/helpers/client'
+require 'legion/extensions/service_now/helpers/pagination'
+require 'legion/extensions/service_now/helpers/retry'
 
 require 'legion/extensions/service_now/change/runners/change'
 require 'legion/extensions/service_now/cmdb/instance/runners/instance'
@@ -49,6 +52,22 @@ require 'legion/extensions/service_now/discovery/runners/discovery'
 require 'legion/extensions/service_now/mid_server/runners/mid_server'
 require 'legion/extensions/service_now/catalog_variable/runners/catalog_variable'
 require 'legion/extensions/service_now/workflow/runners/workflow'
+require 'legion/extensions/service_now/vendor/runners/vendor'
+require 'legion/extensions/service_now/ci_relationship/runners/ci_relationship'
+require 'legion/extensions/service_now/script_action/runners/script_action'
+require 'legion/extensions/service_now/ui_policy/runners/ui_policy'
+require 'legion/extensions/service_now/ui_action/runners/ui_action'
+require 'legion/extensions/service_now/access_control/runners/access_control'
+require 'legion/extensions/service_now/catalog_task/runners/catalog_task'
+require 'legion/extensions/service_now/knowledge_base/runners/knowledge_base'
+require 'legion/extensions/service_now/tag/runners/tag'
+require 'legion/extensions/service_now/metric/runners/metric'
+require 'legion/extensions/service_now/currency/runners/currency'
+require 'legion/extensions/service_now/calendar/runners/calendar'
+require 'legion/extensions/service_now/knowledge_feedback/runners/knowledge_feedback'
+require 'legion/extensions/service_now/license/runners/license'
+require 'legion/extensions/service_now/deprecation_log/runners/deprecation_log'
+require 'legion/extensions/service_now/cmdb_health/runners/cmdb_health'
 
 require 'legion/extensions/service_now/client'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-service_now
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
@@ -157,6 +157,7 @@ files:
 - Rakefile
 - lex-service_now.gemspec
 - lib/legion/extensions/service_now.rb
+- lib/legion/extensions/service_now/access_control/runners/access_control.rb
 - lib/legion/extensions/service_now/account/runners/account.rb
 - lib/legion/extensions/service_now/aggregate/runners/aggregate.rb
 - lib/legion/extensions/service_now/approval/runners/approval.rb
@@ -164,25 +165,38 @@ files:
 - lib/legion/extensions/service_now/attachment/runners/attachment.rb
 - lib/legion/extensions/service_now/audit/runners/audit.rb
 - lib/legion/extensions/service_now/business_rule/runners/business_rule.rb
+- lib/legion/extensions/service_now/calendar/runners/calendar.rb
+- lib/legion/extensions/service_now/catalog_task/runners/catalog_task.rb
 - lib/legion/extensions/service_now/catalog_variable/runners/catalog_variable.rb
 - lib/legion/extensions/service_now/change/runners/change.rb
+- lib/legion/extensions/service_now/ci_relationship/runners/ci_relationship.rb
 - lib/legion/extensions/service_now/client.rb
 - lib/legion/extensions/service_now/cmdb/instance/runners/instance.rb
 - lib/legion/extensions/service_now/cmdb/meta/runners/meta.rb
+- lib/legion/extensions/service_now/cmdb_health/runners/cmdb_health.rb
 - lib/legion/extensions/service_now/company/runners/company.rb
 - lib/legion/extensions/service_now/contract/runners/contract.rb
 - lib/legion/extensions/service_now/cost_center/runners/cost_center.rb
+- lib/legion/extensions/service_now/currency/runners/currency.rb
 - lib/legion/extensions/service_now/department/runners/department.rb
+- lib/legion/extensions/service_now/deprecation_log/runners/deprecation_log.rb
 - lib/legion/extensions/service_now/discovery/runners/discovery.rb
 - lib/legion/extensions/service_now/email_log/runners/email_log.rb
+- lib/legion/extensions/service_now/errors.rb
 - lib/legion/extensions/service_now/event/runners/event.rb
 - lib/legion/extensions/service_now/flow/runners/flow.rb
 - lib/legion/extensions/service_now/helpers/client.rb
+- lib/legion/extensions/service_now/helpers/pagination.rb
+- lib/legion/extensions/service_now/helpers/retry.rb
 - lib/legion/extensions/service_now/hr_case/runners/hr_case.rb
 - lib/legion/extensions/service_now/import_set/runners/import_set.rb
 - lib/legion/extensions/service_now/incident/runners/incident.rb
 - lib/legion/extensions/service_now/knowledge/runners/knowledge.rb
+- lib/legion/extensions/service_now/knowledge_base/runners/knowledge_base.rb
+- lib/legion/extensions/service_now/knowledge_feedback/runners/knowledge_feedback.rb
+- lib/legion/extensions/service_now/license/runners/license.rb
 - lib/legion/extensions/service_now/location/runners/location.rb
+- lib/legion/extensions/service_now/metric/runners/metric.rb
 - lib/legion/extensions/service_now/mid_server/runners/mid_server.rb
 - lib/legion/extensions/service_now/notification/runners/notification.rb
 - lib/legion/extensions/service_now/on_call/runners/on_call.rb
@@ -192,6 +206,7 @@ files:
 - lib/legion/extensions/service_now/release/runners/release.rb
 - lib/legion/extensions/service_now/request/runners/request.rb
 - lib/legion/extensions/service_now/scheduled_job/runners/scheduled_job.rb
+- lib/legion/extensions/service_now/script_action/runners/script_action.rb
 - lib/legion/extensions/service_now/script_include/runners/script_include.rb
 - lib/legion/extensions/service_now/security_incident/runners/security_incident.rb
 - lib/legion/extensions/service_now/service_catalog/runners/service_catalog.rb
@@ -209,10 +224,14 @@ files:
 - lib/legion/extensions/service_now/survey/runners/survey.rb
 - lib/legion/extensions/service_now/system_property/runners/system_property.rb
 - lib/legion/extensions/service_now/table/runners/table.rb
+- lib/legion/extensions/service_now/tag/runners/tag.rb
 - lib/legion/extensions/service_now/task/runners/task.rb
+- lib/legion/extensions/service_now/ui_action/runners/ui_action.rb
+- lib/legion/extensions/service_now/ui_policy/runners/ui_policy.rb
 - lib/legion/extensions/service_now/update_set/runners/update_set.rb
 - lib/legion/extensions/service_now/user/runners/user.rb
 - lib/legion/extensions/service_now/user_group/runners/user_group.rb
+- lib/legion/extensions/service_now/vendor/runners/vendor.rb
 - lib/legion/extensions/service_now/version.rb
 - lib/legion/extensions/service_now/work_order/runners/work_order.rb
 - lib/legion/extensions/service_now/workflow/runners/workflow.rb