sailpoint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8faa7517c8f7dc3f463e65c8fe1664c2bb114d1e0dea32a5de3c3daf3bf25501
+  data.tar.gz: 754bb1d74249fc947d6e72983270be4c96ff0433b787fc60a41d7ec36834bf92
+SHA512:
+  metadata.gz: dc00288d246b3f26652e2a173f56617b73e3fababe07219f1e1df435e48ba2be5691e0c732d31a5f9ab0382bff28ffbeee399b62f1c31d556a982086c92c4c31
+  data.tar.gz: 7bc723c3372e745dcfd37a895a677e29b99ae7327f0c3c6b2896f5eedb8f7a87f65c5489073ab1da4338c9faf62da88a6251511f48f7d0f1cbac99bec59bb768

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Brandon Hicks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# Sailpoint
+
+This is an unofficial tool for interactiving with Sailpoints [IdentityIQ's](https://www.sailpoint.com/solutions/identityiq/?elqct=Website&elqchannel=OrganicDirect) API interface. This gem assumes your IdenityIQ API is setup to authenticate using [BasicAuth](https://developer.sailpoint.com/SCIM/index.html#authentication) headers. If you require credentials for your SailPoint (IdenitityIQ) interface, I suggest contacting your system administrator before continuing any farther.
+
+**Note:** This gem doesn't include all possible IdentityIQ API requests, primarmly due to last of authorization to access much else. If you happen to have additional access to an IdentitiyIQ API it would be very much appreciated if you contributed any additional API requests.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Gemfile
+gem 'sailpoint'
+```
+
+And then execute:
+
+`bundle install`
+
+## Usage
+
+Before attempting to use the Sailpoint API you'll need to contact your system admin and get a set of API credentials. Every application should have a unique set of credentials, that way if any one application is compromised you don't have to roll the credentials on a number of applications. I would also suggest setting these credentials in your rails encrypted credentials as the following.
+
+```yaml
+sailpoint:
+  username: sample_user
+  password: sample_password
+```
+
+To access these credentials throughout the application you can access them with the following references:
+
+```ruby
+Rails.application.credentials[:sailpoint][:username]
+Rails.application.credentials[:sailpoint][:password]
+```
+
+### Running as a ruby script
+
+If running from `irb` or wanting to call the IdentityIQ API from a ruby script use the following method to access the IdentityIQ API
+
+```ruby
+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')
+```
+
+## 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')
+
+# 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')
+
+# Third method (and my personal favorite to use without assigning the interface)
+Sailpoint::Scim.get_user('sample_user')
+```
+
+### Using this gem with Rails
+
+Lets first start by creating an initializer so you don't have to set the API configuration every time you want to make an API request.
+
+```ruby
+# config/initializers/sailpoint.rb
+if defined?(Sailpoint)
+  Sailpoint::Config.set_credentials('api_username', 'api_password')
+  Sailpoint::Config.host = 'http://example.com/'
+end
+
+# If you're using encrypted credentials
+if defined?(Sailpoint)
+  Sailpoint::Config.set_credentials(Rails.application.credentials[:sailpoint][:username], Rails.application.credentials[:sailpoint][:password])
+  Sailpoint::Config.host = 'http://example.com/'
+end
+```
+
+Now in your controller, models, or wherever required 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
+
+## Interface specific function calls
+
+### SCIM
+
+* `Sailpoint::Scim.accounts` - Returns a massive list of all account entries in the IdeneityIQ sources
+* `Sailpoint::Scim.appliations` - Returnsa list of all Applications and their associated attributes
+* `Sailpoint::Scim.get_user(identity)` - Used to fetch the specified users associated data
+* `Sailpoint::Scim.resource_types` - Fetch all resource types associated with the IdentityIQ API
+* `Sailpoint::Scim.schemas` - Fetch the schemas for all resources types assocaited with the API's returning data
+* `Sailpoint::Scim.service_providers` - Fetch a list of all ServiceProviders associated with the data being served by the API
+* `Sailpoint::Scim.users` - Returns a list of all users from the associated organizations
+* `Sailpoint::Scim.user_resource_types` - Returns a list of data attributes for the ResourceType -> Users
+
+### REST
+
+* `Sailpoint::Rest.authenticate` - Used to verify if the supplied credentials are valid
+* `Sailpoint::Rest.check_roles` - Verify if the user has any policies set within the specified roles
+* `Sailpoint::Rest.get_identity` - Used to fetch the specified user identiy from the REST API interface
+* `Sailpoint::Rest.get_user(identity)` - Used to fetch the specified users associated data
+* `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
+
+## API Documentation
+
+* [IdentityNow](https://api.identitynow.com/)
+* [API Reference (SCIM)](https://developer.sailpoint.com/SCIM/index.html)
+* [Admin Guide](https://myaccess.supervalu.com/identityiq/doc/pdf/7_0_IdentityIQ_Administration_Guide.pdf)
+
+## Contributing
+
+Bug reports and pull requests are welcome on Github at https://github.com/tarellel/sailpoint
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

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

data/bin/setup

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

data/lib/sailpoint.rb

@@ -0,0 +1,61 @@
+require 'sailpoint/version'
+require 'sailpoint/config'
+require 'sailpoint/helpers' # To override defaults and adding global helper functions
+require 'sailpoint/rest'
+require 'sailpoint/scim'
+
+# Sailpoint Module to allow for easily accessing the Sailpoint API
+module Sailpoint
+  # When generating a Standard Exception error
+  class Error < StandardError; 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)
+    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
+
+  # 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
+
+  # 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?
+
+    !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 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?
+  end
+end

data/lib/sailpoint/config.rb

@@ -0,0 +1,101 @@
+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>Sailpoint::Scim.get_user('username')</code>
+      # @return [String] - Returns the entire requesting URL (based on host and interface type)
+      def url(interface = '')
+        return '' if @host.blank? || @interface.blank?
+
+        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

data/lib/sailpoint/helpers.rb

@@ -0,0 +1,88 @@
+# 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
+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?
+  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

@@ -0,0 +1,81 @@
+require 'httparty'
+require 'json'
+
+# Used for creating Sailpoint RESTS requests
+module Sailpoint
+  # Used for created REST API calls to the organizations IdentityIQ source
+  class Rest
+    # 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')
+      JSON.parse(response)
+    end
+
+    # Verify if the user has any policies set within the specified roles
+    # @param identity [String] - The user in which you are requesting data for
+    # @param roles [String, Array] - Roles specified to validate against (either: <code>role</code> or <code>['role1','role2']</code>)
+    # @return [Hash] - Return data associated with there users roles
+    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?
+
+      # 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}&roles=#{roles}"].join('/'),
+                              headers: Sailpoint::Config.auth_header,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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, 'managedIdentities'].join('/'),
+                              headers: Sailpoint::Config.auth_header,
+                              output: 'json')
+      return [] if response.code == '500'
+
+      JSON.parse(response&.body || '{}').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].join('/'),
+                              headers: Sailpoint::Config.auth_header,
+                              output: 'json')
+      raise AuthenticationException, 'Invalid credentials, please try again.' if response.code == 401
+
+      JSON.parse(response&.body || '{}')
+    end
+
+    # Get a users roles within the Organization
+    # @return [Hash] - The users roles associated within the Organization
+    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?
+
+      response = HTTParty.get([Sailpoint::Config.url('rest'), "roles/assignablePermits/?roleMode=assignable&identity=#{identity}"].join('/'),
+                              headers: Sailpoint::Config.auth_header,
+                              output: 'json')
+      response_body = JSON.parse(response&.body || '{}')
+      return response_body['objects'].map { |role| role['name'] } if response['status'].present? && response['status'] == 'success'
+
+      response_body
+    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,
+                   output: 'json')
+    end
+  end
+end

data/lib/sailpoint/scim.rb

@@ -0,0 +1,86 @@
+require 'httparty'
+require 'json'
+
+# Used for creating Sailpoint SCIM requests
+module Sailpoint
+  # Used for created SCIM API calls to the organizations IdentityIQ source
+  class Scim
+    # 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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    end
+
+    # Used to fetch the specified users associated data
+    # @return [Hash] - The users hashed data attributes
+    def self.get_user(identity)
+      puts [Sailpoint::Config.url('scim'), 'v2/Users', identity].join('/')
+      response = HTTParty.get([Sailpoint::Config.url('scim'), 'v2/Users', identity].join('/'),
+                              headers: Sailpoint::Config.auth_header,
+                              output: 'json')
+      # 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'
+
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    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,
+                              output: 'json')
+      JSON.parse(response&.body || '{}')
+    end
+  end
+end

data/lib/sailpoint/version.rb

@@ -0,0 +1,6 @@
+module Sailpoint
+  # The minimum required RUBY_VERSION
+  RUBY_VERSION = '2.5'.freeze
+  # The Sailpoints version
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: sailpoint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brandon Hicks
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+description: 
+email:
+- tarellel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- lib/sailpoint.rb
+- lib/sailpoint/config.rb
+- lib/sailpoint/helpers.rb
+- lib/sailpoint/rest.rb
+- lib/sailpoint/scim.rb
+- lib/sailpoint/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: A Sailpoint API helper
+test_files: []