user_management_api 0.0.16

data/lib/user_management_api/client_methods/registrations.rb

@@ -0,0 +1,54 @@
+module UserManagementApi
+  module ClientMethods
+    module Registrations
+
+      # Returns all registrations owned by the given user
+      def user_registrations(unique_id)
+        res = conn.get("registrations/#{unique_id}")
+        build_collection(Registration, res)
+      end
+
+      # Returns the registration given by the user and project
+      def user_registration(project, unique_id)
+        res = conn.get("registrations/#{project}/#{unique_id}")
+        build_entity(Registration, res)
+      end
+
+      # returns a list of registrations for the given project
+      # registrations may be filtered by setting criteria keys as follows:
+      # any of the following keys will filter data:
+      # valid
+      # first_name
+      # last_name
+      # unique_id
+      # email
+      #
+      # The following keys will reflect the order and paging of the returned data:
+      # sort_column: name of the column to sort by.  May be one of last_name, first_name, or email
+      # sort_direction: asc or desc
+      # page: page number to return
+      # per: number of users per page (defaults to 25)
+      #
+      # The returned object will be a PagedCollection instance
+      def search_registrations(project, criteria = {})
+        query = {}
+        criteria = criteria.stringify_keys
+
+        %w(first_name last_name unique_id email sort_column sort_direction page per valid).each do |prop|
+          query[prop] = criteria[prop] if criteria[prop]
+        end
+
+        res = conn.get("registrations/#{project}", query)
+
+        build_paged_collection(Registration, 'registrations', res)
+      end
+
+      # Sets the given attributes as custom attributes on the given registration.
+      # Performs a merge on any existing attributes.  Any keys with nil or empty values will be deleted.
+      def set_registration_custom_attributes(project, unique_id, attributes)
+        res = conn.patch("registrations/#{project}/#{unique_id}/custom_attributes", MultiJson.dump(custom_attributes: attributes))
+        build_entity(Registration, res)
+      end
+    end
+  end
+end

data/lib/user_management_api/client_methods/urls.rb

@@ -0,0 +1,65 @@
+module UserManagementApi
+  module ClientMethods
+    module URLs
+
+      def create_account_url(project, return_url = nil, parameters = {})
+        build_url("/#{project}/user/new", {return_url: return_url}.merge(parameters))
+      end
+
+      def create_registration_url(project, return_url = nil, parameters = {})
+        build_url("/#{project}/registration/new", {return_url: return_url}.merge(parameters))
+      end
+
+      def edit_registration_url(project, return_url = nil)
+        build_url("/#{project}/registration/edit", return_url: return_url)
+      end
+
+      def renew_registration_url(project = nil, return_url = nil)
+        project_path = project ? "/#{project}" : ''
+        build_url("#{project_path}/registration/renew", return_url: return_url)
+      end
+
+      def forgot_password_url
+        build_url("/user/forgot_password/")
+      end
+
+      def change_password_url(return_url = nil)
+        build_url("/user/change_password/", return_url: return_url)
+      end
+
+      def create_class_group_url(project, return_url = nil)
+        build_url("/#{project}/registration_groups/new", return_url: return_url)
+      end
+
+      def join_class_group_url(project = nil, return_url = nil)
+        project_path = project ? "/#{project}" : ''
+        build_url("#{project_path}/registration_groups/select", return_url: return_url)
+      end
+
+      def admin_url
+        build_url('/admin')
+      end
+
+      def admin_pending_registration_url(project)
+        build_url("/admin/registrations/pending/#{project}")
+      end
+
+      def admin_pending_registration_groups_url(project)
+        build_url("/admin/registration_groups/pending/#{project}")
+      end
+
+      private
+
+      def build_url(path, params = {})
+        uri = URI(base_uri)
+        uri.path = path
+
+        p = params.delete_if {|_, v| v.nil? }
+        uri.query = p.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&') unless p.empty?
+
+        uri.to_s
+      end
+
+    end
+  end
+end

data/lib/user_management_api/client_methods/users.rb

@@ -0,0 +1,24 @@
+module UserManagementApi
+  module ClientMethods
+    module Users
+
+      def users_by_email(emails)
+        build_collection(User, conn.get('users/by_email', email: emails))
+      end
+
+      def user(unique_id)
+        build_entity(User, conn.get("users/#{unique_id}"))
+      end
+
+      def create_user(user)
+        res = conn.post("users", encode_entity(user, :user))
+        build_entity(User, res)
+      end
+
+      def update_user(user)
+        res = conn.put("users/#{user.unique_id}", encode_entity(user, :user))
+        build_entity(User, res)
+      end
+    end
+  end
+end

data/lib/user_management_api/config.rb

@@ -0,0 +1,13 @@
+module UserManagementApi
+  class Config
+    include Confiture::Configuration
+
+    confiture_allowed_keys(:base_uri, :access_token)
+
+    confiture_defaults({
+                           base_uri: nil,
+                           access_token: nil
+                       })
+
+  end
+end

data/lib/user_management_api/connection_manager.rb

@@ -0,0 +1,17 @@
+module UserManagementApi
+  class ConnectionManager
+    class << self
+
+      # Disable creating instances
+      private :new
+
+      def get_connection(uri, access_token)
+        Faraday.new(uri, {ssl: {verify: false}}) do |faraday|
+          faraday.headers = {'Content-Type' => 'application/json'}
+          faraday.token_auth(access_token)
+          faraday.adapter(Faraday.default_adapter)
+        end
+      end
+    end
+  end
+end

data/lib/user_management_api/entity.rb

@@ -0,0 +1,132 @@
+module UserManagementApi
+  class Entity
+
+    class_attribute :_entity_properties
+    class_attribute :_properties
+    self._entity_properties = {}
+    self._properties = []
+
+    def self.entity_attribute(*args)
+      klass = args.pop
+      raise "Invalid arguments" unless klass && klass.is_a?(Class) && args.length > 0
+
+      args.compact.map { |a| a.to_sym }.each do |a|
+        attr_accessor a
+        self._entity_properties[a.to_sym] = klass
+      end
+    end
+
+    def self.attribute(*attrs)
+      attrs.compact.map { |a| a.to_sym }.each do |a|
+        attr_accessor a
+        self._properties << a
+      end
+    end
+
+    class << self
+      alias_method :entity_attributes, :entity_attribute
+      alias_method :attributes, :attribute
+    end
+
+    # Copy properties on inheritance.
+    def self.inherited(subclass)
+      entities = _entity_properties.dup
+      attrs = _properties.dup
+      subclass._entity_properties = entities.each { |k, v| entities[k] = v.dup }
+      subclass._properties = attrs
+      super
+    end
+
+    def initialize(attrs = {})
+      populate_from_json(attrs)
+    end
+
+    def as_json(options = nil)
+      serialize_attributes(_properties + _entity_properties.keys)
+    end
+
+    def to_json(options = nil)
+      MultiJson.dump(as_json(options))
+    end
+
+    def populate_from_json(attrs)
+      return unless attrs
+
+      attrs.each do |k, v|
+        meth = "#{k}=".to_sym
+        if self.respond_to? meth
+          if entity_class = _entity_properties[k.to_sym]
+            assign_entity(meth, v, entity_class)
+          else
+            self.send(meth, v)
+          end
+        end
+      end
+    end
+
+    def serialize_attributes(attrs)
+      json = {}
+      attrs.each do |k|
+        meth = k.to_sym
+        if self.respond_to?(meth)
+          if _entity_properties[k.to_sym]
+            json[k] = serialize_entity(meth)
+          else
+            json[k] = self.send(meth)
+          end
+        end
+      end
+      json
+    end
+
+    def ==(other)
+      other.class == self.class && other.__state == __state
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      state.hash
+    end
+
+    protected
+
+    def __state
+      (_properties + _entity_properties.keys).map do |attr|
+        meth = attr.to_sym
+        if self.respond_to?(meth)
+          self.send(meth)
+        else
+          nil
+        end
+      end
+    end
+
+    private
+
+    def assign_entity(assignment_method, value, klass)
+      case value
+        when nil
+          data = nil
+        when Array
+          data = value.map { |v| klass.new(v) }
+        else
+          data = klass.new(value)
+      end
+
+      self.send(assignment_method, data)
+    end
+
+    def serialize_entity(method)
+      value = self.send(method)
+      case value
+        when nil
+          nil
+        when Array
+          value.map { |v| v.as_json }
+        else
+          value.as_json
+      end
+    end
+  end
+end

data/lib/user_management_api/errors.rb

@@ -0,0 +1,49 @@
+module UserManagementApi
+
+  class ClientConfigurationError < StandardError
+  end
+
+  class TokenError < StandardError
+  end
+
+  class ServerError < StandardError
+  end
+
+  class UnprocessableEntityError < StandardError
+
+    DEFAULT_MESSAGE = 'Remote Server responded with 422: Unprocessable Entity.  No further details available'
+
+    def initialize(faraday_response, parsed_body)
+      @response = faraday_response
+      @body = parsed_body
+      @errors = {}
+      super(build_message)
+    end
+
+    def response
+      @response
+    end
+
+    def errors
+      @errors
+    end
+
+    def formatted_errors
+      @errors.map { |k, v| "#{k}: #{v}"}.join("\n")
+    end
+
+    private
+
+    def build_message
+      msg = DEFAULT_MESSAGE
+
+      if @body && @body.is_a?(Hash) && !@body.empty?
+        @errors = @body
+        msg = "Remove Server returned 422: Unprocessable Entity.  Errors encountered:\n#{formatted_errors}"
+      end
+
+      msg
+    end
+  end
+
+end

data/lib/user_management_api/lookup.rb

@@ -0,0 +1,6 @@
+module UserManagementApi
+  class Lookup < Entity
+    attributes :id, :label, :text
+
+  end
+end

data/lib/user_management_api/paged_collection.rb

@@ -0,0 +1,16 @@
+module UserManagementApi
+  class PagedCollection
+    extend Forwardable
+
+    def_delegators :@collection, :[], :each, :map, :size, :length, :first, :last, :empty?, :present?
+
+    attr_reader :total_count, :total_pages, :current_page, :collection
+
+    def initialize(entity_type, collection_name, data)
+      @total_count = data['total_count']
+      @total_pages = data['total_pages']
+      @current_page = data['current_page']
+      @collection = (data[collection_name.to_s] || []).map { |e| entity_type.new(e) }
+    end
+  end
+end

data/lib/user_management_api/railtie.rb

@@ -0,0 +1,8 @@
+module UserManagementApi
+  class UserManagementApiRailtie < ::Rails::Railtie
+
+    UserManagementApi::Config.configure
+    config.user_management_api = UserManagementApi::Config
+
+  end
+end

data/lib/user_management_api/registration.rb

@@ -0,0 +1,20 @@
+module UserManagementApi
+  class Registration < Entity
+    attributes :institution, :research_statement, :project, :status, :active, :admin, :group_registration, :microdata_access, :max_extract_size, :custom_attributes, :created_at, :updated_at
+    entity_attributes :user, User
+    entity_attributes :field, :occupation, :how_did_you_hear, :research_areas, Lookup
+
+    STATUS = {
+        pending: 'Pending',
+        approved: 'Approved',
+        denied: 'Denied',
+        expired: 'Expired',
+        email_pending: 'Email Pending'
+    }
+
+    STATUS.each do |k, v|
+      define_method("is_#{k}?") { self.status == v }
+    end
+
+  end
+end

data/lib/user_management_api/registration_group.rb

@@ -0,0 +1,8 @@
+module UserManagementApi
+  class RegistrationGroup < Entity
+    attributes :unique_id, :name, :project, :end_date, :active, :status, :created_at, :updated_at, :code, :description
+    entity_attributes :owner, User
+    entity_attributes :field, :course_level, Lookup
+
+  end
+end

data/lib/user_management_api/user.rb

@@ -0,0 +1,6 @@
+module UserManagementApi
+  class User < Entity
+    attributes :unique_id, :email, :first_name, :last_name, :username, :password, :last_login, :created_at, :updated_at
+
+  end
+end

data/lib/user_management_api/version.rb

@@ -0,0 +1,3 @@
+module UserManagementApi
+  VERSION = '0.0.16'
+end