user_management_api 0.0.16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8376a6c25481cc0791b5773a8e8f2310bdd0b85e
+  data.tar.gz: e830e75632e58cd72d504a239df747861c884009
+SHA512:
+  metadata.gz: fb713efaa205d81030337fa7eb30c03b7d6df405ed176ae12d9972f6051bde1d43f1825f0847ad6220c9495e2145bfaaba5909cabcbba4ada4abbe0e2351e63b
+  data.tar.gz: 8b5d1ad7823a8d4c4ffabd7b9d160d28338e650a01e3779212c123f39e7ece973f475fe49261a8bead76741fb835d7d33dd14909a2b9c524395d103a65f0c1a1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.idea
+
+Gemfile.lock

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.5

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,90 @@
+User Management API
+===================
+
+Client library for the User Management App API
+
+# Installation
+
+### Add the gem to your Gemfile (note the tag)
+
+```ruby
+gem 'user_management_api', git: 'git@github.umn.edu:mpc/user_management_api.git', tag: 'v0.0.15'
+```
+
+# Configuration
+
+There are four ways to configure the gem, and they can be used interchangeably.
+
+### 1. Application or environment configuration files.
+
+In config/application.rb or config/environments/<ENV>.rb
+```ruby
+config.user_management_api.KEY = VALUE
+```
+
+### 2. Initializer
+
+In config/initializers/mpc_shib_auth.rb
+```ruby
+UserManagementApi::Config.configure do |config|
+  config.KEY = VALUE
+end
+```
+
+### 3. Anywhere else
+
+From anywhere
+```ruby
+UserManagementApi::Config.KEY = VALUE
+```
+
+### 4. Constructor
+
+Any configuration can be overridden by passing values into the constructor:
+```ruby
+UserManagementApi::Client.new('http://someserver.com', '111-TOKEN-0000')
+```
+
+# Configuration Options
+
+#### base_uri
+
+Base URL of the target User Management App.  Should not include any path information.  Ex: `http://localhost:3000`
+
+#### access_token
+
+Access token used in all requests made to the API
+
+# Usage
+
+Provided the base_uri and token have been configured, a client can be created without any constructor parameters: `UserManagementApi::Client.new`
+
+# Client Methods
+
+### Registrations
+
+* `user_registrations(unique_id)`
+* `user_registration(project, unique_id)`
+* `search_registrations(project, criteria = {})`
+* `set_registration_custom_attributes(project, unique_id, attributes)`
+
+### URLs
+
+* `create_account_url(project, return_url = nil)` - Create new user account with project registration
+* `create_registration_url(project, return_url = nil)` - Create new registration for existing, logged in user
+* `edit_registration_url(project, return_url = nil)` - Edit existing registration for logged in user
+* `renew_registration_url(project = nil, return_url = nil)` - Renew all registrations for given user (with brand of optional project)
+* `forgot_password_url`
+* `change_password_url(return_url = nil)`
+
+### Registration Groups
+
+* `owned_registration_groups(project, user_unique_id)`
+* `enrolled_registration_groups(project, user_unique_id)`
+
+### Users
+
+* `users_by_email(emails)`
+* `user(unique_id)`
+* `create_user(user)`
+* `update_user(user)`

data/Rakefile

@@ -0,0 +1,114 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'ci/reporter/rake/rspec'
+
+RSpec::Core::RakeTask.new(:spec => 'ci:setup:rspec')
+
+task :test => :spec
+task :default => :spec
+
+task :disable_rubygems do
+  ENV['gem_push'] = 'no'
+end
+
+Rake::Task[:release].enhance [:disable_rubygems]
+
+namespace :spec do
+  # This task reads two env variables: UMA_PORT and UMA_PATH.
+  # UMA_PORT is the port the integration_test version of UMA will listen on
+  # UMA_PATH is the location of the app checkout
+  desc "Starts UMA instance and runs full specs"
+  task :start_server_and_run_all do
+    uma_path = ENV['UMA_PATH'] || File.expand_path('../../user_management_app/', __FILE__)
+    uma_port = ENV['UMA_PORT'] || 3019
+    ENV['UMA_PORT'] = uma_port.to_s
+    pid = nil
+    read_pipe = nil
+    write_pipe = nil
+
+    raise "UMA_PATH [#{uma_path} does not appear to be valid" unless File.exists?("#{uma_path}/bin/rails")
+
+    begin
+      read_pipe, write_pipe = IO.pipe
+
+      # since bundler sets the BUNDLE_GEMFILE env var, we need to clear it so this invocation picks up the right one
+      pid = Process.spawn({"RAILS_ENV" => "integration_test", "BUNDLE_GEMFILE" => nil}, "bundle exec rails server -p #{uma_port}", chdir: uma_path, [:out, :err] => write_pipe)
+      puts "Waiting for server to start..."
+
+      server_output = ''
+      wait_start = Time.now
+      server_started = false
+      server_failed = false
+
+      while !server_started && !server_failed
+        begin
+          buffer = read_pipe.read_nonblock(128)
+          #STDOUT.write(buffer)
+          server_output << buffer
+        rescue IO::WaitReadable
+          IO.select([read_pipe], nil, nil, 2)
+        end
+
+        if (Time.now - wait_start) >= 15
+          server_failed = true
+        end
+
+        begin
+          if Process.waitpid(pid, Process::WNOHANG)
+            server_failed = true
+          end
+        rescue
+          server_failed = true
+        end
+
+        if server_output =~ /WEBrick::HTTPServer#start: pid=\d+ port=\d+/
+          server_started = true
+        end
+      end
+
+      if server_started
+        puts "Server started"
+      else
+        STDERR.puts "Unable to start webserver:"
+        STDERR.puts server_output
+        exit false
+      end
+
+      Rake::Task['spec:all'].invoke
+    ensure
+      begin
+        Process.kill('KILL', pid) if pid
+        write_pipe.close if write_pipe
+        read_pipe.close if read_pipe
+      rescue
+        # do nothing
+      end
+    end
+  end
+
+  desc "integration test the JSON API endpoints"
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    # set the RAILS_ENV such that :integration tagged
+    # specs are run
+    ENV['ENABLE_INTEGRATION'] = 'true'
+
+    # only run those files in the 'integration' directory
+    t.pattern = "./spec/integration{,/*/**}/*_spec.rb"
+  end
+
+  desc 'Run unit and integration tests'
+  task :all do
+    ENV['ENABLE_INTEGRATION'] = 'true'
+    Rake::Task[:spec].invoke
+  end
+end
+
+namespace :test do
+  task :integration => 'spec:integration'
+  task :all => 'spec:all'
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r user_management_api.rb"
+end

data/lib/user_management_api.rb

@@ -0,0 +1,38 @@
+require 'confiture'
+require 'uri'
+require 'faraday'
+require 'multi_json'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/keys'
+
+files = [
+    'version',
+    'errors',
+    'connection_manager',
+    'client_methods/answerbase_session_tokens',
+    'client_methods/users',
+    'client_methods/registrations',
+    'client_methods/registration_groups',
+    'client_methods/urls',
+    'client',
+    'entity',
+    'answerbase_session_token',
+    'paged_collection',
+    'lookup',
+    'user',
+    'registration',
+    'registration_group',
+    'config'
+]
+
+if defined?(::Rails::Railtie)
+  files << 'railtie'
+end
+
+files.each do |f|
+  require File.expand_path("../user_management_api/#{f}", __FILE__)
+end
+
+module UserManagementApi
+
+end

data/lib/user_management_api/answerbase_session_token.rb

@@ -0,0 +1,6 @@
+module UserManagementApi
+  class AnswerbaseSessionToken < Entity
+    attributes :user_unique_id, :session_id, :created_at, :updated_at
+
+  end
+end

data/lib/user_management_api/client.rb

@@ -0,0 +1,108 @@
+module UserManagementApi
+  class Client
+    include ClientMethods::AnswerbaseSessionTokens
+    include ClientMethods::Users
+    include ClientMethods::Registrations
+    include ClientMethods::RegistrationGroups
+    include ClientMethods::URLs
+
+    API_VERSION = 'v1'
+
+    attr_reader :conn
+
+    def initialize(uri = nil, token = nil)
+      uri = uri || UserManagementApi::Config.base_uri
+      token = token || UserManagementApi::Config.access_token
+
+      if uri.nil? || token.nil?
+        raise UserManagementApi::ClientConfigurationError, "You must either pass a URI and token or configure UserManagementApi::Config"
+      end
+
+      base_uri = URI(uri)
+
+      unless ['', '/', nil].include? base_uri.path
+        raise UserManagementApi::ClientConfigurationError, "uri should not contain path information"
+      end
+
+      path_prefix = "/api/#{API_VERSION}"
+
+      base_uri.path = path_prefix
+
+      @conn = UserManagementApi::ConnectionManager.get_connection(base_uri.to_s, token)
+      @token = token
+    end
+
+    def base_api_uri
+      conn.url_prefix.to_s
+    end
+
+    def base_uri
+      uri = URI(base_api_uri)
+      uri.path = ''
+      uri.to_s
+    end
+
+    def token
+      @token
+    end
+
+    private
+
+    def get_parsed_response(response)
+      case response.status.to_i
+        when 200
+          parse_body(response.body)
+        when 401
+          raise UserManagementApi::TokenError, "Token [#{self.token}] rejected by Remote Server"
+        when 404
+          nil
+        when 422
+          raise UserManagementApi::UnprocessableEntityError.new(response, parse_body(response.body))
+        when 500...600
+          raise UserManagementApi::ServerError, "Remote Server returned error: [#{response.status}]"
+        else
+          raise UserManagementApi::ServerError, "Remote Server returned unknown HTTP response code: [#{response.status}]"
+      end
+    end
+
+    def parse_body(body)
+      if body && body != ''
+        MultiJson.load(body)
+      else
+        {}
+      end
+    end
+
+    def build_entity(type, response)
+      data = get_parsed_response(response)
+      if data
+        type.new(data)
+      else
+        nil
+      end
+    end
+
+    def build_paged_collection(type, collection_name, response)
+      data = get_parsed_response(response)
+      if data
+        PagedCollection.new(type, collection_name, data)
+      else
+        nil
+      end
+    end
+
+    def build_collection(type, response)
+      data = get_parsed_response(response)
+      if data
+        data.map { |e| type.new(e) }
+      else
+        nil
+      end
+    end
+
+    def encode_entity(entity, entity_name)
+      MultiJson.dump({entity_name.to_sym => entity.as_json})
+    end
+
+  end
+end

data/lib/user_management_api/client_methods/answerbase_session_tokens.rb

@@ -0,0 +1,15 @@
+module UserManagementApi
+  module ClientMethods
+    module AnswerbaseSessionTokens
+
+      def answerbase_session_token(session_id)
+        build_entity(AnswerbaseSessionToken, conn.get("answerbase_session_tokens/#{session_id}"))
+      end
+
+      def create_answerbase_session_token(user_unique_id)
+        res = conn.post("answerbase_session_tokens/#{user_unique_id}")
+        build_entity(AnswerbaseSessionToken, res)
+      end
+    end
+  end
+end

data/lib/user_management_api/client_methods/registration_groups.rb

@@ -0,0 +1,38 @@
+module UserManagementApi
+  module ClientMethods
+    module RegistrationGroups
+
+      def registration_group(unique_id)
+        res = conn.get("registration_groups/#{unique_id}")
+        build_entity(RegistrationGroup, res)
+      end
+
+      def registration_group_enrollees(unique_id)
+        res = conn.get("registration_groups/#{unique_id}/enrollees")
+        build_collection(User, res)
+      end
+
+      def registration_group_remove_enrollee(unique_id, user_unique_id)
+        res = conn.delete("registration_groups/#{unique_id}/enrollees/#{user_unique_id}")
+        data = get_parsed_response(res)
+        !data.nil?
+      end
+
+      def owned_registration_groups(project, user_unique_id)
+        res = conn.get("registration_groups/#{project}/owned/#{user_unique_id}")
+        build_collection(RegistrationGroup, res)
+      end
+
+      def enrolled_registration_groups(project, user_unique_id)
+        res = conn.get("registration_groups/#{project}/enrolled/#{user_unique_id}")
+        build_collection(RegistrationGroup, res)
+      end
+
+      def pending_registration_groups(project)
+        res = conn.get("registration_groups/#{project}/pending")
+        build_collection(RegistrationGroup, res)
+      end
+
+    end
+  end
+end