sailpoint 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 948e79e40e1b960266502c666ca8db069ce15e302374c23012e95112a48b9b36
-  data.tar.gz: 259569e390dd2d392be8e85d3d252ac531dd632dde2b39c4a49a2818eacc99f8
+  metadata.gz: 1220fcec1f06178a2d7a3ad3223c4f8a142c97a1c5c22a1a04cc7d0534fc2969
+  data.tar.gz: 0f4937b7f5a97782a0b2f0a86d7e09f621c196a33576c6149df973aa209ab9fa
 SHA512:
-  metadata.gz: 37b621badd12c2c2028b28614403c105e2ab48557b8918d6ccddef7f19169fd339cfde06fc0eeb0b813da6bb7974cc64458817f07d92c8bae29a97d594401643
-  data.tar.gz: d72001f42801aa0d29f10863619e5fe00e3d12852cee307068e9e3cb169b1935936cdd82843c359d370c7068c7c8a27badb6a280e728e6b18dbe990a6747843e
+  metadata.gz: c16e91fc84ec90643c25af0731eb20762488bd55a8e729e19a557fff8bf0c6186b3daa23773c04b9866a360c7eb0e0de91d480c4ff2029fb56f95e7dc7dd091e
+  data.tar.gz: 8f8e3c65082bf64acc9311621dce1cc1c734a032be70cd86cdcd3705605d4e28d467caa46c54cb7c1b06f23a0bd7fd068ea8350b0ced08156bc9a2a584e5db96

data/README.md

@@ -46,24 +46,23 @@ If running from `irb` or wanting to call the IdentityIQ API from a ruby script u
 require 'sailpoint'
 
 # In order to make any API requests you need to specify the IdentityIQ API Host and set you API credentials
-Sailpoint.set_credentials('foo','bar')
-Sailpoint.set_host = 'https://example.com/';
-Sailpoint.get_user('sample_user')
+Sailpoint.configure do |config|
+  config.username = 'api_username'
+  config.password = 'api_password'
+  config.host = 'https://example.com'
+end
 ```
 
-## Getting Started
-
 By default this will pull users from the REST API
 If you want to pull from the SCIM API there are a number of ways to do this as well
 
 ```ruby
 # First method
-Sailpoint.get_user('sample_user', interface: 'scim')
+Sailpoint.get_user('sample_user')
 
 # Second method
 # Note: When reassigning the API interface future queries will hit the new API endpoint unless specified
-Sailpoint::Config.interface = 'scim'
-Sailpoint.get_user('sample_user')
+Sailpoint::Rest.get_user('sample_user')
 
 # Third method (and my personal favorite to use without assigning the interface)
 Sailpoint::Scim.get_user('sample_user')
@@ -76,53 +75,47 @@ Lets first start by creating an initializer so you don't have to set the API con
 ```ruby
 # config/initializers/sailpoint.rb
 if defined?(Sailpoint)
-  Sailpoint::Config.set_credentials('api_username', 'api_password')
-  Sailpoint::Config.host = 'http://example.com/'
+  Sailpoint.configure do |config|
+    config.username = 'api_username'
+    config.password = 'api_password'
+    config.host = 'https://example.com'
+  end
 end
+```
 
 # If you're using encrypted credentials
+
+```ruby
 if defined?(Sailpoint)
-  Sailpoint::Config.set_credentials(Rails.application.credentials[:sailpoint][:username], Rails.application.credentials[:sailpoint][:password])
-  Sailpoint::Config.host = 'http://example.com/'
+  Sailpoint.configure do |config|
+    config.username = Rails.application.credentials[:sailpoint][:username]
+    config.password = Rails.application.credentials[:sailpoint][:password]
+    config.host = 'https://example.com'
+  end
 end
 ```
 
-Now in your controller, models, or wherever required you should be able to make an API request with the following command
+Now in your controller or models you should be able to make an API request with the following command
 
 ```ruby
 Sailpoint.get_user('sample_user')
 ```
 
-# Misc
-
-```ruby
-Sailpoint::Config.set_credentials('api_username', 'api_password'); Sailpoint::Config.host = 'http://example.com/';
-# Sailpoint::Config.interface = 'rest'
-# Sailpoint::Config.interface = 'scim'
-Sailpoint.get_user('username')
-```
-
 ## General function calls
 
-Listed below are the majority of the functions used throughout the library and their intended purpose.
-
 * `Sailpoint.get_user(identity)` - Search the API resources for the specified user identity
-* `Sailpoint.set_credentials(username, password)` - Assign the credentials for accessing the IdentityIQ API
-* `Sailpoint.set_host(host)` - Assign the IdentityIQ API base URL
 
 ## Configuration
 
-* `Sailpoint::Config.auth_header` - Returns the BasicAuth Header for creating and API request
-* `Sailpoint::Config.credentials` - A hash containing the API credentials when setting API requests headers
-* `Sailpoint::Config.hashed_credentials` - A Base64 encoded string for the API request
-* `Sailpoint::Config.host` - Returns the API base host
-* `Sailpoint::Config.interface` - Returns the specified API interface (REST || SCIM)
-* `Sailpoint::Config.interface_path` - Returns the API path dependant on the interface
-* `Sailpoint::Config.password` - Returns the API password specified
-* `Sailpoint::Config.set_credentials(username, password)` - Used for assigning credentials for accessing the IndentityIQ API
-* `Sailpoint::Config.trimmed_host` - Returns the API base host with all trailing whitespace and slashs trimmed
-* `Sailpoint::Config.url` - Returns the full API URL based on the `host+interface`
-* `Sailpoint::Config.username` - If set, it returns the username credentials for API
+* `Sailpoint.config.auth_header` - Returns the BasicAuth Header for creating and API request (if the username/password have been set)
+* `Sailpoint.config.credentials` - A hash containing the API credentials when setting API requests headers
+* `Sailpoint.config.hashed_credentials` - A Base64 encoded string for the API request
+* `Sailpoint.config.host` - Returns the API base host
+* `Sailpoint.config.interface` - Returns the specified API interface (REST || SCIM)
+* `Sailpoint.config.interface_path` - Returns the API path dependant on the interface
+* `Sailpoint.config.password` - Returns the API password specified
+* `Sailpoint.config.url` - Returns the full API URL based on the `host+interface`
+* `Sailpoint.config.username` - If set, it returns the username credentials for API
 
 ## Interface specific function calls
 
@@ -146,6 +139,11 @@ Listed below are the majority of the functions used throughout the library and t
 * `Sailpoint::Rest.permitted_roles(identity)` - Get a users roles within the Organization
 * `Sailpoint::Rest.ping` - Used to verify your credentials are valid and IdentityIQ reource is properly responding
 
+```shell
+# Rebuilding the gem to test in a required IRB term
+gem uninstall sailpoint; rm -rf sailpoint-0.1.0.gem; gem build; gem install sailpoint
+```
+
 ## API Documentation
 
 * [IdentityNow](https://api.identitynow.com/)

data/lib/sailpoint.rb

@@ -1,61 +1,71 @@
+# frozen_string_literal: true
+
 require 'sailpoint/version'
-require 'sailpoint/config'
-require 'sailpoint/helpers' # To override defaults and adding global helper functions
+require 'sailpoint/core_ext/blank'
+require 'sailpoint/core_ext/escape_str'
 require 'sailpoint/rest'
 require 'sailpoint/scim'
 
-# Sailpoint Module to allow for easily accessing the Sailpoint API
 module Sailpoint
+  require 'sailpoint/helpers' # To override defaults and adding global helper functions
+  require 'sailpoint/configuration'
+
   # When generating a Standard Exception error
   class Error < StandardError; end
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
 
-  # If a valid username and URL have been supplied a lookup requests will be send to determine if the user exists in the specified interface
-  # @param username [String] - the username that we are going to valid exists in the IdentityIQ listing
-  # @return [Hash] - If a user is found, it will return all the that identities attributes
-  def self.get_user(username, interface: nil)
-    raise ArgumentError, 'An invalid user lookup was specified.' if username.to_s.blank?
-    raise ArgumentError, 'Please specify a valid HOST/Interface before attemping a lookup.' unless valid_url?
-    raise ArgumentError, 'Valid credentials are required before attempting an API request.' unless valid_credentials?
-    raise ArgumentError, 'Invalid method type' unless valid_interface_type?(interface) || valid_interface_type?(Sailpoint::Config.interface)
-
-    if interface.nil?
-      Object.const_get("Sailpoint::#{Sailpoint::Config.interface.capitalize}").get_user(username)
-    elsif valid_interface_type?(interface)
-      Object.const_get("Sailpoint::#{interface.capitalize}").get_user(username)
+    # Used to memorize and create a Mutex to keep config in sync across running threads
+    #
+    # @return [Mutex]
+    def mutex
+      @mutex ||= Mutex.new
     end
-  end
 
-  # Assign the credentials for accessing the IdentityIQ API
-  # @param username [String] - The Sailpoint username required for accessing the API
-  # @param password [String] - The Sailpoint password required for accessing the API
-  def self.set_credentials(username, password)
-    Sailpoint::Config.set_credentials(username, password) unless username.nil? && password.nil?
-  end
+    # If a valid username and URL have been supplied a lookup requests will be send to determine if the user exists in the specified interface
+    # @param username [String] - the username that we are going to valid exists in the IdentityIQ listing
+    # @return [Hash] - If a user is found, it will return all the that identities attributes
+    def get_user(username = '')
+      raise ArgumentError, 'An invalid user lookup was specified.' if username.blank?
+      raise ArgumentError, 'Please specify a valid HOST/Interface before attemping a lookup.' unless valid_url?
+      raise ArgumentError, 'Valid credentials are required before attempting an API request.' unless valid_credentials?
+      raise ArgumentError, 'Invalid interface type' unless valid_interface_type?(config.interface)
 
-  # Assign the IdentityIQ API base URL
-  # @param host [String] - The base URL in which the API calls will be built upon
-  def self.set_host(host)
-    Sailpoint::Config.host = host unless host.blank?
-  end
+      if config.interface.blank?
+        Sailpoint::Scim.get_user(username)
+      else
+        Object.const_get("Sailpoint::#{config.interface&.capitalize}").get_user(username)
+      end
+    end
 
-  # Used to verify if any credentails were supplied for the API request
-  # @return [Boolean] if credentials were supplied or not
-  def self.valid_credentials?
-    return false if Sailpoint::Config.username.blank? && Sailpoint::Config.password.blank?
+    # Used to verify if any credentails were supplied for the API request
+    # @return [Boolean] if credentials were supplied or not
+    def valid_credentials?
+      return false if Sailpoint.config.username.blank? && Sailpoint.config.password.blank?
 
-    !Sailpoint::Config.hashed_credentials.blank?
-  end
+      !Sailpoint.config.hashed_credentials.blank?
+    end
 
-  # Used to verify if the specifed interface type is valid for the Sailpoint API
-  # @param interface [String] - A specified API interface endpoint, that can either be `Rest` or `Scim`
-  # @return [Boolean] - Returns weither the specifed interface is a a valid type allowed by the API.
-  def self.valid_interface_type?(interface)
-    %w[rest scim].include?(interface)
-  end
+    # Used to verify if the specifed interface type is valid for the Sailpoint API
+    # @param interface [String] - A specified API interface endpoint, that can either be `Rest` or `Scim`
+    # @return [Boolean] - Returns weither the specifed interface is a a valid type allowed by the API.
+    def valid_interface_type?(interface = nil)
+      return false if interface.blank?
+
+      Sailpoint::Configuration::ALLOWED_INTERFACES.include?(interface)
+    end
 
-  # Used to verify if the URL string is blank or a URL was supplied
-  # @return [Boolean] - if a url for the API endpoint was supplied or not
-  def self.valid_url?
-    !Sailpoint::Config.url.blank?
+    # Used to verify if the URL string is blank or a URL was supplied
+    # @return [Boolean] - if a url for the API endpoint was supplied or not
+    def valid_url?
+      !Sailpoint.config.url.blank?
+    end
+
+    def configure
+      self.config ||= config
+      yield(config)
+    end
   end
 end

data/lib/sailpoint/configuration.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'sailpoint/helpers'
+
+# Used for setting you Sailpoint API configuration and credentials
+module Sailpoint
+  # Used for setting API configuration before creating API Requests
+  # Configuration can include: <code>username, password, interface, host, url</code>
+  class Configuration
+    ALLOWED_INTERFACES = %w[rest scim].freeze
+
+    attr_accessor :password, :username
+
+    # Variables used for storing values for host= and interface=
+    attr_accessor :host_val, :interface_val
+
+    def initialize
+      reload_config
+    end
+
+    def host=(val = nil)
+      self.host_val = trim_host(val)
+    end
+
+    def host
+      host_val
+    end
+
+    def interface=(val = nil)
+      val = val&.to_s&.strip unless val.blank?
+      self.interface_val = begin
+        if val.blank? || !ALLOWED_INTERFACES.include?(val)
+          'scim'
+        else
+          val
+        end
+      end
+    end
+
+    def interface
+      interface_val
+    end
+
+    # SailPoints auth requires a Base64 string of (username:password)
+    # This is how most BasicAuth authentication methods work
+    # @return [String] - It will either return an empty string or a Base64.encoded hash for the the API credentials (BasicAuth requires Base64)
+    def hashed_credentials
+      return '' if username.blank? && password.blank?
+
+      Base64.encode64("#{username}:#{password}").strip
+    end
+
+    # Used for fetching the API interface_path based on the API interface specification
+    # @return [String] - Returns the API's interface path, based on interface type
+    def interface_path
+      return 'scim' if interface.blank? || !ALLOWED_INTERFACES.include?(interface)
+
+      interface
+    end
+
+    # Used for fetching the requesting users entire URL (Host+Interface)
+    # @return [String] - Returns the entire requesting URL (based on host and interface type)
+    def url
+      return '' if host.blank? || interface.blank?
+
+      full_host(interface)
+    end
+
+    def full_host(interface = '')
+      (interface.blank? ? [host, 'identityiq', interface_path].join('/') : [host, 'identityiq', interface].join('/'))
+    end
+
+    # Used for fetching the API credentials when setting API requests headers
+    # @return [String] - Return a hash of the current API credentils (for validation purposes)
+    def credentials
+      { username: username, password: password }.freeze
+    end
+
+    # Used for generating the API BasicAuth Header when creating an API request
+    # @return [String] - Return the API Authorization header for the making API requests
+    def auth_header
+      return {}.freeze if username.blank? && password.blank?
+
+      { 'Authorization' => "Basic #{hashed_credentials}" }.freeze
+    end
+
+    private
+
+    def reload_config
+      ::Sailpoint.mutex.synchronize do
+        self.interface ||= 'scim'
+        self.host ||= nil
+        self.password ||= nil
+        self.username ||= nil
+      end
+    end
+
+    # Remove trailing forward slashes from the end of the Host, that way hosts and interfaces can be properly joined
+    # => I also did this because you'd get the same results if something supplied `http://example.com` or `https://example.com/`
+    # @return [String] - Returns a cleaned up and trimmed host with trailing slashs removed
+    def trim_host(str = nil)
+      return nil if str.blank?
+
+      str&.strip&.downcase&.gsub(%r{/?++$}, '')
+    end
+  end
+end

data/lib/sailpoint/core_ext/blank.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+unless defined?(Object.blank?)
+  class Object
+    def blank?
+      respond_to?(:empty?) ? !!empty? : !self
+    end
+
+    def present?
+      !blank?
+    end
+  end
+
+  # Used to override and give String the blank? validation similar to Rails
+  class String
+    # Used to determine if the object is nil or empty ('')
+    # @return [Boolean]
+    def blank?
+      strip&.empty? || strip&.length&.zero?
+    end
+  end
+
+  # Similar to Rails imlemneation https://github.com/rails/rails/blob/66cabeda2c46c582d19738e1318be8d59584cc5b/activesupport/lib/active_support/core_ext/object/blank.rb#L56
+  class NilClass
+    # Used to determine if the object is blank? || empty?
+    # *Note:* If a nil value is specified it *should* always be blank? || empty?
+    # @return [Boolean]
+    def blank?
+      true
+    end
+  end
+
+  # Used to override and give Number the blank? validation similar to Rails
+  class Numeric
+    # Used to determine if the object is blank? || empty?
+    #
+    # *Note:* If a object is declared a Numerica valye, it shouldn't ever be blank
+    # @return [Boolean]
+    def blank?
+      false
+    end
+  end
+
+  # Used to override and give Array the blank? validation similar to Rails
+  class Array
+    # Used to determine if the object is blank? || empty?
+    # @return [Boolean]
+    alias blank? empty?
+  end
+
+  # Used to override and give Hash the blank? validation similar to Rails
+  class Hash
+    alias blank? empty?
+  end
+end

data/lib/sailpoint/core_ext/escape_str.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+class Object
+  # In case anything other than a string is called with escape_str
+  # @return [String]
+  def escape_str
+    ''
+  end
+end
+
+class String
+  # Escape any special characters to make them URL safe
+  # @return [String]
+  def escape_str
+    CGI.escape(strip)
+  end
+end
+
+class NilClass
+  # If the identity value was never decalred
+  # @return [String]
+  def escape_str
+    ''
+  end
+end

data/lib/sailpoint/helpers.rb

@@ -1,92 +1,28 @@
-# Used to override and give String the blank? validation similar to Rails
-class String
-  # Used to determine if the object is nil or empty ('')
-  # @return [true, false]
-  def blank?
-    self.nil? || self.strip.empty? || self.strip.length.zero?
-  end
-
-  # Used to determine if the object is not nil
-  # @return [true, false]
-  def present?
-    !self.nil?
-  end
-
-  def escape_str
-    CGI.escape(self)
-  end
-end
-
-# Used to printout a [Red] message to STDOUT in case you want to print a message without causing an Exception.
-# @param msg [String] - The excpetion message that should be printed out
-def print_exception(msg = '')
-  puts "\e[31m#{msg}\e[0m"
-end
-
-# Similar to Rails imlemneation https://github.com/rails/rails/blob/66cabeda2c46c582d19738e1318be8d59584cc5b/activesupport/lib/active_support/core_ext/object/blank.rb#L56
-class NilClass
-  # Used to determine if the object is blank? || empty?
-  # *Note:* If a nil value is specified it *should* always be blank? || empty?
-  # @return [true, false]
-  def blank?
-    true
-  end
-
-  # Used to determine if the object is not nil
-  # @return [true, false]
-  def present?
-    !blank?
+# frozen_string_literal: true
+
+module Sailpoint
+  class Helpers
+    # Used to printout a [Red] message to STDOUT in case you want to print a message without causing an Exception.
+    # @param msg [String] - The excpetion message that should be printed out
+    def self.print_exception(msg = '')
+      puts "\e[31m#{msg}\e[0m"
+    end
+
+    # Used to generate an Exception error hen invalid credentails have been supplied
+    class AuthenticationException < StandardError
+      attr_reader :data
+
+      # Used to generate an ExceptionError message when Authenication has failed
+      # @param data [String] - The message in which you wish to send to STDOUT for the exception error
+      def initialize(data = 'An API Authentication error has occured.')
+        super
+        @data = data
+      end
+
+      # Specify the attribute in which to push to STDOUT when generating a Ruby ExceptionError
+      def message
+        @data
+      end
+    end
   end
 end
-
-# Used to override and give Number the blank? validation similar to Rails
-class Numeric
-  # Used to determine if the object is blank? || empty?
-  #
-  # *Note:* If a object is declared a Numerica valye, it shouldn't ever be blank
-  # @return [true, false]
-  def blank?
-    false
-  end
-
-  # Used to determine if the object is not nil
-  # @return [true, false]
-  def present?
-    !blank?
-  end
-end
-
-# Used to override and give Array the blank? validation similar to Rails
-class Array
-  # Used to determine if the object is blank? || empty?
-  # @return [true, false]
-  alias_method :blank?, :empty?
-end
-
-# Used to override and give Hash the blank? validation similar to Rails
-class Hash
-  alias_method :blank?, :empty?
-
-  # Used to determine if the object is not nil
-  # @return [true, false]
-  def present?
-    !blank?
-  end
-end
-
-# Used to generate an Exception error hen invalid credentails have been supplied
-class AuthenticationException < StandardError
-  attr_reader :data
-
-  # Used to generate an ExceptionError message when Authenication has failed
-  # @param data [String] - The message in which you wish to send to STDOUT for the exception error
-  def initialize(data = 'An API Authentication error has occured.')
-    super
-    @data = data
-  end
-
-  # Specify the attribute in which to push to STDOUT when generating a Ruby ExceptionError
-  def message
-    @data
-  end
-end

data/lib/sailpoint/rest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'httparty'
 require 'json'
 
@@ -5,12 +7,16 @@ require 'json'
 module Sailpoint
   # Used for created REST API calls to the organizations IdentityIQ source
   class Rest
+    EMPTY_RESPONSE = '{}'
+    EMPTY_HASH = {}.freeze
+
     # Used to verify if the supplied credentials are valid
     # @return [Hash] - The responses body as a JSON hash
     def self.authenticate
-      response = HTTParty.get([Sailpoint::Config.url('rest'), 'authentication'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
-                              output: 'json')
+      set_rest_interface
+      response = HTTParty.get([Sailpoint.config.url, 'authentication'].join('/'),
+                              headers: Sailpoint.config.auth_header,
+                              output: 'json', timeout: 10)
       JSON.parse(response)
     end
 
@@ -21,61 +27,76 @@ module Sailpoint
     def self.check_roles(identity, roles)
       # Values for both attributes are required in order to create the request
       # And verify the user exists before attempting to create the request (this prevents IdentityIQ from making a long last query looking for a non-existant user)
-      return {} if identity.blank? || roles.blank? || get_user(identity).empty?
+      return EMPTY_HASH if identity.blank? || roles.blank? || get_user(identity).empty?
 
+      set_rest_interface
       # the roles attribute should either be 'Contractor,Assistant' or ['Contractor', 'Assistant']
       roles = roles.join(',') if roles.is_a?(Array)
-      response = HTTParty.get([Sailpoint::Config.url('rest'), "policies/checkRolePolicies?identity=#{identity.escape_str}&roles=#{roles}"].join('/'),
-                              headers: Sailpoint::Config.auth_header,
-                              output: 'json')
-      JSON.parse(response&.body || '{}')
+      response = HTTParty.get([Sailpoint.config.url, "policies/checkRolePolicies?identity=#{identity&.escape_str}&roles=#{roles}"].join('/'),
+                              headers: Sailpoint.config.auth_header,
+                              output: 'json', timeout: 10)
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Used to fetch the specified user identiy from the REST API interface
     # @param identity [String] - The user in which you are requesting data for
     # @return [Hash] - If no user if found an empty hash will be returned. If a a user is found, their parsed JSON will be returned as a result
     def self.get_identity(identity)
-      response = HTTParty.get([Sailpoint::Config.url('rest'), 'identities', identity.escape_str, 'managedIdentities'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_rest_interface
+      response = HTTParty.get([Sailpoint.config.url, 'identities', identity&.escape_str, 'managedIdentities'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      return [] if response.code == '500'
+      return [].freeze if response.code == '500'
 
-      JSON.parse(response&.body || '{}').first
+      JSON.parse(response&.body || EMPTY_RESPONSE).first
     end
 
     # Used to fetch the specified users associated data
     # @param identity [String] - The user in which you are requesting data for
     # @return [Hash] - If no user if found an empty hash will be returned. If a a user is found, their parsed JSON will be returned as a result
     def self.get_user(identity)
-      response = HTTParty.get([Sailpoint::Config.url('rest'), 'identities', identity.escape_str].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_rest_interface
+      response = HTTParty.get([Sailpoint.config.url, 'identities', identity&.escape_str].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      raise AuthenticationException, 'Invalid credentials, please try again.' if response.code == 401
+      raise Sailpoint::Helpers::AuthenticationException, 'Invalid credentials, please try again.' if response.code == 401
 
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Get a users roles within the Organization
     # @return [Hash] - The users roles associated within the Organization
-    def self.permitted_roles(identity)
+    def self.permitted_roles(identity = '')
       # Before requesting a users roles we need to verify if the identiy matches a valid user first
-      return {} if identity.blank? || get_user(identity).empty?
+      return EMPTY_HASH if identity.blank? || get_user(identity).blank?
 
-      response = HTTParty.get([Sailpoint::Config.url('rest'), "roles/assignablePermits/?roleMode=assignable&identity=#{identity.escape_str}"].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_rest_interface
+      response = HTTParty.get([Sailpoint.config.url, "roles/assignablePermits/?roleMode=assignable&identity=#{identity&.escape_str}"].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      response_body = JSON.parse(response&.body || '{}')
+      response_body = JSON.parse(response&.body || EMPTY_RESPONSE)
       return response_body['objects'].map { |role| role['name'] } if response['status'].present? && response['status'] == 'success'
 
       response_body
+    rescue
+      EMPTY_HASH
     end
 
     # Used to verify your credentials are valid and IdentityIQ reource is properly responding
     # @return [Hash] - The head and body of the response
     def self.ping
-      HTTParty.get([Sailpoint::Config.url('rest'), 'ping'].join('/'),
-                   headers: Sailpoint::Config.auth_header,
+      set_rest_interface
+      HTTParty.get([Sailpoint.config.url, 'ping'].join('/'),
+                   headers: Sailpoint.config.auth_header,
                    output: 'json', timeout: 10)
+    rescue
+      false
     end
+
+    def self.set_rest_interface
+      Sailpoint.config.interface = 'rest'
+    end
+
+    private_class_method :set_rest_interface
   end
 end

data/lib/sailpoint/scim.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'httparty'
 require 'json'
 
@@ -5,81 +7,97 @@ require 'json'
 module Sailpoint
   # Used for created SCIM API calls to the organizations IdentityIQ source
   class Scim
+    EMPTY_RESPONSE = '{}'
+
     # Returns a massive list of all account entries in the IdeneityIQ sources
     # @return [Hash] - A hashed list of all IdenityIQ accounts [Service and User accounts]
     def self.accounts
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Accounts'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/Accounts'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Used to fetch a list of all Applications and their associated attributes
     # @return [Hash] - A hash of all avaialble applications and their associated MetaData attributes
     def self.applications
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Applications'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/Applications'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Used to fetch the specified users associated data
     # @return [Hash] - The users hashed data attributes
     def self.get_user(identity)
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Users', identity.escape_str].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/Users', identity].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
       # NOTE: If invalid credentials are supplied or the user could not be found response bodies contain a status code.
       # => But if a a user if found, a status code isn't returned, but all of their data attributes are returned instead.
-      raise AuthenticationException, 'Invalid credentials, please try again.' if response.body['status'] && response.body['status'] == '401'
-      return [] if response.body && response.body['status'] && response.body['status'] == '404'
+      raise Sailpoint::Helpers::AuthenticationException, 'Invalid credentials, please try again.' if response.body['status'] && response.body['status'] == '401'
+      return [].freeze if response.body && response.body['status'] && response.body['status'] == '404'
 
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Fetch all resource types associated with the IdentityIQ API
     # @return [Hash] - A hash of all resources types [Users, Applications, Accounts, Roles, etc.]
     def self.resource_types
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/ResourceTypes'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/ResourceTypes'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Fetch the schemas for all resources types assocaited with the API's returning data
     # @return [Hash] - A hash of all all ResourceType Schemas
     def self.schemas
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Schemas'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/Schemas'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Fetch a list of all ServiceProviders associated with the data being served by the API
     # @return [Hash] - A hashed list of SailPoint service providers associated with the IdentityIQ Instance
     def self.service_providers
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/ServiceProviderConfig'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/ServiceProviderConfig'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Returns a list of all users from the associated organizations
     # @return [Hash] - All users entries from the organizations sources
     def self.users
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Users'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/Users'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
 
     # Returns a list of data attributes for the ResourceType -> Users
     # @return [Hash] - A hash to describe the user schema attributes
     def self.user_resource_types
-      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/ResourceTypes/User'].join('/'),
-                              headers: Sailpoint::Config.auth_header,
+      set_scim_interface
+      response = HTTParty.get([Sailpoint.config.url, 'v2/ResourceTypes/User'].join('/'),
+                              headers: Sailpoint.config.auth_header,
                               output: 'json', timeout: 10)
-      JSON.parse(response&.body || '{}')
+      JSON.parse(response&.body || EMPTY_RESPONSE)
     end
+
+    def self.set_scim_interface
+      Sailpoint.config.interface = 'scim'
+    end
+
+    private_class_method :set_scim_interface
   end
 end

data/lib/sailpoint/version.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Sailpoint
   # The minimum required RUBY_VERSION
-  RUBY_VERSION = '2.5'.freeze
-  # The Sailpoints version
-  VERSION = '0.0.3'.freeze
+  RUBY_VERSION = '2.5'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sailpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Brandon Hicks
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-10-16 00:00:00.000000000 Z
+date: 2021-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: '0.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.0
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -50,29 +50,29 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.8.0
-description: 
+        version: '3.9'
+description: An helper for making API requests to a Sailpoint/IdentityIQ APIendpoint
 email:
 - tarellel@gmail.com
 executables: []
@@ -86,16 +86,21 @@ files:
 - bin/console
 - bin/setup
 - lib/sailpoint.rb
-- lib/sailpoint/config.rb
+- lib/sailpoint/configuration.rb
+- lib/sailpoint/core_ext/blank.rb
+- lib/sailpoint/core_ext/escape_str.rb
 - lib/sailpoint/helpers.rb
 - lib/sailpoint/rest.rb
 - lib/sailpoint/scim.rb
 - lib/sailpoint/version.rb
-homepage: 
+homepage: https://github.com/tarellel/sailpoint
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/tarellel/sailpoint/issues
+  changelog_uri: https://github.com/tarellel/sailpoint/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/tarellel/sailpoint
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,8 +115,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A Sailpoint API helper
 test_files: []

data/lib/sailpoint/config.rb

@@ -1,105 +0,0 @@
-require 'base64'
-require 'sailpoint/helpers'
-
-# Used for setting you Sailpoint API configuration and credentials
-module Sailpoint
-  # Used for setting API configuration before creating API Requests
-  # Configuration can include: <code>username, password, interface, host, url</code>
-  class Config
-    attr_accessor :username, :password, :interface, :url
-
-    @username = nil
-    @password = nil
-    @interface = 'rest' # By default lets resort to using the Rest interface
-    @host = nil         # Where the SailPoint server is hosted
-
-    class << self
-      attr_writer :username, :password, :interface, :host, :url
-
-      # Used to set the API requests BasicAuth credentails
-      # @param username [String] - Username for the API request
-      # @param password [String] - Password for the API request
-      def set_credentials(username, password)
-        @username = username unless username.nil?
-        @password = password unless password.nil?
-      end
-
-      # Used for setting if the interface type is Rest || SCIM
-      # @return [String] - Returns either the specified interface (Default: <code>rest</code>)
-      def interface
-        (@interface ||= 'rest')
-      end
-
-      # Used for fetching the API interface_path based on the API interface specification
-      # @return [String] - Returns the API's interface path, based on interface type
-      def interface_path
-        (@interface == 'scim' ? 'scim' : 'rest')
-      end
-
-      # Used to fetch the host for the API request
-      # @return [String] - If a valid host was specified, it will returned a trimmed string with trailing whitespaces and slashes removed
-      def host
-        return '' if @host.blank?
-
-        trimmed_host
-      end
-
-      # Used for fetching the requesting users entire URL (Host+Interface)
-      # @param interface [String] - used for when the user is specicically calling an API such as <code>Unmh::Sailpoint::Scim.get_user('brhicks')</code>
-      # @return [String] - Returns the entire requesting URL (based on host and interface type)
-      def url(interface = '')
-        return '' if @host.blank? || @interface.blank?
-
-        full_host(interface)
-      end
-
-      def full_host(interface = '')
-        interface.blank? ? [trimmed_host, 'identityiq', interface_path].join('/') : [trimmed_host, 'identityiq', interface].join('/')
-      end
-
-      # Used for fetching credentails username (if it has been set)
-      # @return [String] - The credentails username
-      def username
-        @username || ''
-      end
-
-      # Used for fetching the requesting users credentials password (if it has been set)
-      # @return [String] - The password for the API credentials
-      def password
-        @password || ''
-      end
-
-      # Used for fetching the API credentials when setting API requests headers
-      # @return [String] - Return a hash of the current API credentils (for validation purposes)
-      def credentials
-        { username: @username, password: @password }
-      end
-
-      # Remove trailing forward slashes from the end of the Host, that way hosts and interfaces can be properly joined
-      # => I also did this because you'd get the same results if something supplied `http://example.com` or `https://example.com/`
-      # @return [String] - Returns a cleaned up and trimmed host with trailing slashs removed
-      def trimmed_host
-        return '' if @host.blank?
-
-        @host.strip.gsub!(%r{\/?++$}, '')
-      end
-
-      # SailPoints auth requires a Base64 string of (username:password)
-      # This is how most BasicAuth authentication methods work
-      # @return [String] - It will either return an empty string or a Base64.encoded hash for the the API credentials (BasicAuth requires Base64)
-      def hashed_credentials
-        return '' if @username.blank? && @password.blank?
-
-        Base64.encode64("#{@username}:#{@password}").strip
-      end
-
-      # Used for generating the API BasicAuth Header when creating an API request
-      # @return [String] - Return the API Authorization header for the making API requests
-      def auth_header
-        return '' if @username.blank? && @password.blank?
-
-        { 'Authorization' => "Basic #{Sailpoint::Config.hashed_credentials}" }
-      end
-    end
-  end
-end