floe-servicenow 0.1.0

data/examples/table.asl

@@ -0,0 +1,138 @@
+{
+  "Comment": "ServiceNow Table API Examples - Demonstrates all CRUD operations",
+  "StartAt": "ListTables",
+  "States": {
+    "ListTables": {
+      "Type": "Task",
+      "Resource": "servicenow://table/list_tables",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "query": "nameSTARTSWITHcmdb",
+        "limit": 5,
+        "fields": "name,label"
+      },
+      "ResultPath": "$.tables",
+      "Next": "QueryRecords"
+    },
+    "QueryRecords": {
+      "Type": "Task",
+      "Resource": "servicenow://table/query_records",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "query": "active=true^priority=1",
+        "limit": 10,
+        "fields": "sys_id,number,short_description,state,priority",
+        "display_value": "true"
+      },
+      "ResultPath": "$.incidents",
+      "Next": "GetRecord"
+    },
+    "GetRecord": {
+      "Type": "Task",
+      "Resource": "servicenow://table/get_record",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "sys_id.$": "$.incidents.result[0].sys_id",
+        "fields": "number,short_description,state,priority,assigned_to",
+        "display_value": "all"
+      },
+      "ResultPath": "$.incident_detail",
+      "Next": "CreateRecord"
+    },
+    "CreateRecord": {
+      "Type": "Task",
+      "Resource": "servicenow://table/create_record",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "data": {
+          "short_description": "Test incident created by workflow",
+          "urgency": "3",
+          "impact": "3",
+          "category": "Software",
+          "subcategory": "Email"
+        },
+        "display_value": "true"
+      },
+      "ResultPath": "$.new_incident",
+      "Next": "PatchRecord"
+    },
+    "PatchRecord": {
+      "Type": "Task",
+      "Resource": "servicenow://table/patch_record",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "sys_id.$": "$.new_incident.result.sys_id",
+        "data": {
+          "state": "2",
+          "work_notes": "Updated by workflow - investigating issue"
+        },
+        "display_value": "true"
+      },
+      "ResultPath": "$.patched_incident",
+      "Next": "UpdateRecord"
+    },
+    "UpdateRecord": {
+      "Type": "Task",
+      "Resource": "servicenow://table/update_record",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "sys_id.$": "$.new_incident.result.sys_id",
+        "data": {
+          "short_description": "Test incident - UPDATED",
+          "urgency": "3",
+          "impact": "3"
+        },
+        "display_value": "true"
+      },
+      "ResultPath": "$.updated_incident",
+      "Next": "DeleteRecord"
+    },
+    "DeleteRecord": {
+      "Type": "Task",
+      "Resource": "servicenow://table/delete_record",
+      "Credentials": {
+        "username.$": "$$.Credentials.username",
+        "password.$": "$$.Credentials.password"
+      },
+      "Parameters": {
+        "instance_id.$": "$.instance_id",
+        "table_name": "incident",
+        "sys_id.$": "$.new_incident.result.sys_id"
+      },
+      "ResultPath": "$.delete_result",
+      "Next": "Success"
+    },
+    "Success": {
+      "Type": "Succeed"
+    }
+  }
+}

data/exe/floe-servicenow

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "floe/cli"
+require "floe/servicenow"
+success = Floe::CLI.new.run(ARGV)
+exit(success ? 0 : 1)

data/lib/floe/service_now.rb

@@ -0,0 +1 @@
+require "floe/servicenow"

data/lib/floe/servicenow/cmdb.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Floe
+  module ServiceNow
+    class Cmdb < Floe::ServiceNow::Methods
+      # Get a Configuration Item (CI) by sys_id
+      def self.get_ci(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_get_ci_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        table = params["table"] || "cmdb_ci"
+        sys_id = params["sys_id"]
+
+        http_params = build_http_params(
+          "GET",
+          "/api/now/table/#{table}/#{sys_id}",
+          params,
+          secrets
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Query Configuration Items with optional filters
+      def self.query_cis(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_query_cis_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        instance_id = params["instance_id"]
+        table       = params["table"] || "cmdb_ci"
+        username    = secrets["username"]
+        password    = secrets["password"]
+
+        require "base64"
+        authorization = "Basic #{::Base64.urlsafe_encode64("#{username}:#{password}")}"
+
+        headers = {
+          "Authorization" => authorization,
+          "Content-Type"  => "application/json",
+          "Accept"        => "application/json"
+        }
+
+        query_params = {}
+        query_params["sysparm_query"]  = params["query"]  if params["query"]
+        query_params["sysparm_limit"]  = params["limit"]  if params["limit"]
+        query_params["sysparm_offset"] = params["offset"] if params["offset"]
+        query_params["sysparm_fields"] = params["fields"] if params["fields"]
+
+        http_params = {
+          "Method"          => params["method"],
+          "Url"             => "https://#{instance_id}.service-now.com/api/now/table/#{table}",
+          "Options"         => {"Encoding" => "JSON"},
+          "Headers"         => headers,
+          "QueryParameters" => query_params
+        }
+
+        begin
+          http_request(http_params, {}, {})
+        rescue => err
+          ServiceNow.error!({}, :cause => err.to_s)
+        end
+      end
+
+      # Create a new Configuration Item
+      def self.create_ci(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_create_ci_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        table = params["table"] || "cmdb_ci"
+
+        http_params = build_http_params(
+          "POST",
+          "/api/now/table/#{table}",
+          params,
+          secrets,
+          :body => params.except("instance_id", "table")
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Update an existing Configuration Item
+      def self.update_ci(params, secrets, _context)
+        error = verify_credentials(secrets)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        error = verify_update_ci_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        table = params["table"] || "cmdb_ci"
+        sys_id = params["sys_id"]
+
+        http_params = build_http_params(
+          "PATCH",
+          "/api/now/table/#{table}/#{sys_id}",
+          params,
+          secrets,
+          :body => params.except("sys_id", "instance_id", "table")
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Delete a Configuration Item
+      def self.delete_ci(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_delete_ci_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        table = params["table"] || "cmdb_ci"
+        sys_id = params["sys_id"]
+
+        http_params = build_http_params(
+          "DELETE",
+          "/api/now/table/#{table}/#{sys_id}",
+          params,
+          secrets
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Get CI relationships
+      def self.get_ci_relationships(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_get_ci_relationships_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        sys_id = params["sys_id"]
+
+        # Get CI instance
+        query_params = {
+          "sysparm_display_value"          => "true",
+          "sysparm_exclude_reference_link" => "true"
+        }
+
+        http_params = build_http_params(
+          "GET",
+          "/api/now/cmdb/instance/cmdb_ci/#{sys_id}",
+          params,
+          secrets,
+          :query => query_params
+        )
+
+        ci_response = http_request(http_params, {}, {})
+        return ci_response unless ci_response["success"]
+
+        # Get relationships
+        rel_query_params = {
+          "sysparm_query"         => "parent=#{sys_id}^ORchild=#{sys_id}",
+          "sysparm_display_value" => "true"
+        }
+
+        rel_http_params = build_http_params(
+          "GET",
+          "/api/now/table/cmdb_rel_ci",
+          params,
+          secrets,
+          :query => rel_query_params
+        )
+
+        rel_response = http_request(rel_http_params, {}, {})
+        return rel_response unless rel_response["success"]
+
+        # Merge results
+        ci_data = ci_response["output"]["result"]
+        rel_data = rel_response["output"]["result"]
+        output = ci_data.merge("relationships" => rel_data)
+
+        ServiceNow.success!({}, :output => output)
+      end
+
+      # Create a CI relationship
+      def self.create_ci_relationship(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_create_ci_relationship_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        body = {
+          "parent"              => params["parent_sys_id"],
+          "child"               => params["child_sys_id"],
+          "type"                => params["relationship_type"],
+          "connection_strength" => params["connection_strength"] || "1"
+        }
+
+        http_params = build_http_params(
+          "POST",
+          "/api/now/table/cmdb_rel_ci",
+          params,
+          secrets,
+          :body => body
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Get CI classes (types)
+      def self.get_ci_classes(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_instance_id(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        query_params = {
+          "sysparm_query"  => "nameSTARTSWITHcmdb_ci",
+          "sysparm_fields" => "name,label,super_class"
+        }
+        query_params["sysparm_limit"] = params["limit"] if params["limit"]
+
+        http_params = build_http_params(
+          "GET",
+          "/api/now/table/sys_db_object",
+          params,
+          secrets,
+          :query => query_params
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Verify parameters for get_ci
+      private_class_method def self.verify_get_ci_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id"      if params["sys_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for query_cis
+      private_class_method def self.verify_query_cis_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for create_ci
+      private_class_method def self.verify_create_ci_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for update_ci
+      private_class_method def self.verify_update_ci_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id"      if params["sys_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for delete_ci
+      private_class_method def self.verify_delete_ci_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id"      if params["sys_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for get_ci_relationships
+      private_class_method def self.verify_get_ci_relationships_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id"      if params["sys_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for create_ci_relationship
+      private_class_method def self.verify_create_ci_relationship_params(params)
+        return "Missing Parameter: instance_id"       if params["instance_id"].nil?
+        return "Missing Parameter: parent_sys_id"     if params["parent_sys_id"].nil?
+        return "Missing Parameter: child_sys_id"      if params["child_sys_id"].nil?
+        return "Missing Parameter: relationship_type" if params["relationship_type"].nil?
+
+        nil
+      end
+    end
+  end
+end

data/lib/floe/servicenow/incident.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Floe
+  module ServiceNow
+    class Incident < Floe::ServiceNow::Methods
+      # Create a new incident in ServiceNow
+      def self.create_incident(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_create_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        http_params = build_http_params(
+          "POST",
+          "/api/now/table/incident",
+          params,
+          secrets,
+          :body => params.except("instance_id")
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Get an incident by sys_id
+      def self.get_incident(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_get_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        sys_id = params["sys_id"]
+
+        http_params = build_http_params(
+          "GET",
+          "/api/now/table/incident/#{sys_id}",
+          params,
+          secrets
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Update an existing incident
+      def self.update_incident(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_update_params(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        sys_id = params["sys_id"]
+
+        http_params = build_http_params(
+          "PATCH",
+          "/api/now/table/incident/#{sys_id}",
+          params,
+          secrets,
+          :body => params.except("sys_id", "instance_id")
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      def self.resolve_incident(params, secrets, context)
+        params['attributes'] ||= {}
+        params['attributes']['state'] = '6' # state enum 6 is resolved
+        params['attributes']['resolution_code'] = params.delete('close_code') if params['close_code']
+        params['attributes']['resolution_notes'] = params.delete('close_notes') if params['close_notes']
+
+        update_incident(params, secrets, context)
+      end
+
+      def self.close_incident(params, secrets, context)
+        params['attributes'] ||= {}
+        params['attributes']['state'] = '7' # state enum 7 is closed
+        params['attributes']['resolution_code'] = params.delete('close_code') if params['close_code']
+        params['attributes']['resolution_notes'] = params.delete('close_notes') if params['close_notes']
+
+        update_incident(params, secrets, context)
+      end
+
+      # Query incidents with optional filters
+      def self.query_incidents(params, secrets, _context)
+        error   = verify_credentials(secrets)
+        error ||= verify_instance_id(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        query_params = {}
+        query_params["sysparm_query"] = params["query"] if params["query"]
+        query_params["sysparm_limit"] = params["limit"] if params["limit"]
+        query_params["sysparm_offset"] = params["offset"] if params["offset"]
+        query_params["sysparm_fields"] = params["fields"] if params["fields"]
+
+        http_params = build_http_params(
+          "GET",
+          "/api/now/table/incident",
+          params,
+          secrets,
+          :query => query_params
+        )
+
+        http_request(http_params, {}, {})
+      end
+
+      # Verify parameters for create_incident
+      private_class_method def self.verify_create_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: short_description" if params["short_description"].nil?
+
+        nil
+      end
+
+      # Verify parameters for get_incident
+      private_class_method def self.verify_get_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id" if params["sys_id"].nil?
+
+        nil
+      end
+
+      # Verify parameters for update_incident
+      private_class_method def self.verify_update_params(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+        return "Missing Parameter: sys_id" if params["sys_id"].nil?
+
+        nil
+      end
+    end
+  end
+end

data/lib/floe/servicenow/methods.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Floe
+  module ServiceNow
+    class Methods < Floe::BuiltinRunner::Methods
+      private_class_method def self.verify_credentials(secrets)
+        return "Missing Credentials" if secrets.nil?
+
+        # Allow either username/password OR access_token
+        has_basic_auth = secrets["username"] && secrets["password"]
+        has_oauth = secrets["access_token"]
+
+        return "Missing Credentials: Provide either (username and password) or access_token" unless has_basic_auth || has_oauth
+
+        nil
+      end
+
+      private_class_method def self.verify_instance_id(params)
+        return "Missing Parameter: instance_id" if params["instance_id"].nil?
+
+        nil
+      end
+
+      private_class_method def self.verify_required_param(params, param_name)
+        return "Missing Parameter: #{param_name}" if params[param_name].nil?
+
+        nil
+      end
+
+      private_class_method def self.build_http_params(method, path, params, secrets, options = {})
+        instance_id = params["instance_id"]
+
+        # Build authorization header - support both Basic Auth and OAuth
+        if secrets["access_token"]
+          authorization = "Bearer #{secrets["access_token"]}"
+        elsif secrets["username"] && secrets["password"]
+          require "base64"
+          authorization = "Basic #{::Base64.urlsafe_encode64("#{secrets["username"]}:#{secrets["password"]}")}"
+        end
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Accept"       => "application/json"
+        }
+        headers["Authorization"] = authorization if authorization
+
+        http_params = {
+          "Method"  => method,
+          "Url"     => "https://#{instance_id}.service-now.com#{path}",
+          "Options" => {"Encoding" => "JSON"},
+          "Headers" => headers
+        }
+
+        http_params["QueryParameters"] = options[:query] if options[:query]
+        http_params["Body"] = options[:body] if options[:body]
+
+        http_params
+      end
+
+      # Wrapper around http() that returns only the Body wrapped in success response
+      private_class_method def self.http_request(http_params, secrets, context)
+        response = http(http_params, secrets, context)
+
+        # If there's an error at the top level, return it as-is
+        return response if response.key?("success") && !response["success"]
+
+        # Extract the Body and wrap in success response
+        body = response.dig("output", "Body") || response
+        ServiceNow.success!({}, :output => body)
+      end
+    end
+  end
+end

data/lib/floe/servicenow/oauth.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Floe
+  module ServiceNow
+    class OAuth < Floe::ServiceNow::Methods
+      def self.token(params, secrets, context)
+        error = verify_instance_id(params)
+        return ServiceNow.error!({}, :cause => error) if error
+
+        instance_id = params["instance_id"]
+
+        headers = {
+          "ContentType" => "application/x-www-form-urlencoded",
+          "Accept"      => "application/json"
+        }
+
+        body_params = {}
+        body_params["grant_type"]    = params["grant_type"]     if params["grant_type"]
+        body_params["client_id"]     = params["client_id"]      if params["client_id"]
+        body_params["scope"]         = params["scope"]          if params["scope"]
+        body_params["username"]      = secrets["username"]      if secrets["username"]
+        body_params["password"]      = secrets["password"]      if secrets["password"]
+        body_params["client_secret"] = secrets["client_secret"] if secrets["client_secret"]
+        body_params["refresh_token"] = secrets["refresh_token"] if secrets["refresh_token"]
+
+        http_params = {
+          "Method"  => "POST",
+          "Headers" => headers,
+          "Url"     => "https://#{instance_id}.service-now.com/oauth_token.do",
+          "Body"    => body_params
+        }
+
+        http_request(http_params, secrets, context)
+      end
+    end
+  end
+end