Simple Crowd Integration in Ruby

crowd.rb

require 'httparty'
require 'logger'
require 'json'

BASE_PATH = '/crowd/rest/usermanagement/'
API_VERSION = 1

AUTH_PATH = '/authentication'
SESSION_PATH = '/session'
USER_PATH = '/user'
GROUP_PATH = '/group'
SEARCH_PATH = '/search'
DIRECT_PATH = '/direct'

class Crowd
  include HTTParty

  format :json

  headers 'Accept' => 'application/json'
  headers 'Content-Type' => 'application/json'

  def initialize(username, password, base_uri)
    self.class.base_uri base_uri
    self.class.basic_auth username, password
    init_logger
  end

  def init_logger
    @logger = Logger.new(STDOUT)
    @logger.level = Logger::DEBUG
    @logger.formatter = proc { |severity, datetime, progname, msg|
      "#{msg}\n"
    }
  end

  # User resource methods
  def authenticate(username, password)
    query = { :username => username }
    body = { :value => password }

    response = post(auth_path, :query => query, :body => body)

    if response.code == 200
      response['name']
    else
      @logger.info(response)
      nil
    end
  end

  def create_session(username, password)
    body = {
      :username => username, 
      :password => password
    }

    response = post(session_path, :body => body)

    return response.code == 201 ? response['token'] : nil
  end

  def validate_session(token)
    body = {}
    response = post(session_path + "/#{token}", :body => body)

    return response.code == 200 ? response['user']['name'] : nil
  end

  def search_by_email(email)
    query = { 
      "entity-type" => "user", 
      :restriction => "email=#{email}",
    }
    response = get(search_path, :query => query)

    users = response['users'].collect {|user| user['name']}
    return users
  end

  def get_user(username)
    query = { :username => username }
    response = get(user_path, :query => query)

    return response
  end

  # Group resource methods
  def group_members(groupname)
    query = { :groupname => groupname }
    response = get(group_user_direct_path, :query => query)

    users = response['users'].collect {|user| user['name']}

    return users
  end

  private

  def process_opts(opts)
    # Escape query string values
    if opts.has_key?(:query)
      opts[:query].each do |k, v|
        opts[:query][k] = URI.escape(v)
      end
    end

    # Transform request body to JSON
    if opts.has_key?(:body)
      opts[:body] = opts[:body].to_json
    end

    opts
  end

  def get(uri, options)
    options = process_opts(options)
    self.class.get(uri, options)
  end

  def post(uri, options)
    #options[:body] => {} unless options.has_key?(:body)
    options = process_opts(options)
    self.class.post(uri, options)
  end

  def base_path
    BASE_PATH + API_VERSION.to_s
  end

  def search_path
    base_path + SEARCH_PATH
  end

  def user_path
    base_path + USER_PATH
  end

  def auth_path
    base_path + AUTH_PATH
  end

  def session_path
    base_path + SESSION_PATH
  end

  def group_path
    base_path + GROUP_PATH
  end

  def group_user_path
    group_path + USER_PATH
  end

  def group_user_direct_path
    group_user_path + DIRECT_PATH
  end
end