ucb_rails_user 0.9.0

data/app/models/ucb_rails_user/configuration/email.rb

@@ -0,0 +1,73 @@
+module UcbRailsUser
+  module Configuration
+    class Email
+      ArgumentError = Class.new(StandardError)
+
+      attr_accessor :hash
+
+      def self.configure(config)
+        new(config)
+      end
+
+      def initialize(configuration_hash)
+        return if configuration_hash.nil?
+        raise(ArgumentError, "expected a Hash, got: #{configuration_hash.inspect}") unless configuration_hash.is_a?(Hash)
+
+        self.hash = configuration_hash
+        process_configuration
+      end
+
+      private
+
+      def process_configuration
+        process_default
+        process_delivery_method
+        process_default_url_options
+        process_raise_delivery_errors
+        process_sendmail_settings
+        process_smtp_settings
+        process_subject_prefix
+      end
+
+      # This merges values with existing values
+      def process_default
+        if hash.has_key?('default')
+          ActionMailer::Base.default hash['default']
+        end
+      end
+
+      def process_delivery_method
+        ActionMailer::Base.delivery_method = hash.fetch('delivery_method', :smtp).to_sym
+      end
+
+      def process_default_url_options
+        if hash.has_key?('default_url_options')
+          ActionMailer::Base.default_url_options = hash.fetch('default_url_options').symbolize_keys
+        end
+      end
+
+      def process_raise_delivery_errors
+        ActionMailer::Base.raise_delivery_errors = hash.fetch('raise_delivery_errors', true)
+      end
+
+      def process_sendmail_settings
+        if hash.has_key?('sendmail_settings')
+          ActionMailer::Base.sendmail_settings = hash.fetch('sendmail_settings').symbolize_keys
+        end
+      end
+
+      def process_smtp_settings
+        if hash.has_key?('smtp_settings')
+          ActionMailer::Base.smtp_settings = hash.fetch('smtp_settings').symbolize_keys
+        end
+      end
+
+      def process_subject_prefix
+        prefix = hash.fetch('subject_prefix', '')
+        prefix = prefix.gsub("{env}", Rails.env)
+        UcbRailsUser.config.email_subject_prefix = prefix
+      end
+    end
+
+  end
+end

data/app/models/ucb_rails_user/configuration/exception_notification.rb

@@ -0,0 +1,21 @@
+module UcbRailsUser
+  module Configuration
+
+    class ExceptionNotification
+
+      class << self
+
+        def configure(config)
+          return if config.blank?
+
+          config = config.symbolize_keys
+          config[:email].symbolize_keys!
+          config[:email][:email_prefix] = config[:email][:email_prefix].gsub("{env}", RailsEnvironment.short)
+
+          Rails.application.config.middleware.use ::ExceptionNotification::Rack, config
+        end
+      end
+    end
+
+  end
+end

data/app/models/ucb_rails_user/configuration/ldap.rb

@@ -0,0 +1,50 @@
+module UcbRailsUser
+  module Configuration
+
+    class Ldap
+      attr_accessor :config
+
+      def initialize(config)
+        self.config = config.presence || {}
+      end
+
+      def configure
+        configure_host
+        initialize_ldap
+        test_entries
+      end
+
+      private
+
+      def configure_host
+        UCB::LDAP.host = config.fetch("host", default_host)
+      end
+
+      def initialize_ldap
+        username = config.fetch("username", "")
+        password = config.fetch("password", "")
+        host = config.fetch("host", "")
+        UCB::LDAP.initialize username, password, host
+      end
+
+      def test_entries
+        UCB::LDAP::Person.include_test_entries = config.fetch("include_test_entries", default_include_test_entries)
+      end
+
+      def default_host
+        "nds.berkeley.edu"
+      end
+
+      def default_include_test_entries
+        !Rails.env.production?
+      end
+
+      class << self
+        def configure(config)
+          new(config).configure
+        end
+      end
+    end
+
+  end
+end

data/app/models/ucb_rails_user/ldap_person/entry.rb

@@ -0,0 +1,62 @@
+module UcbRailsUser::LdapPerson
+  class Entry
+
+    # include ActiveAttr::Model  <--- doesn't work with 4.0 (mass assign. security)
+    include ::ActiveAttr::Attributes
+    include ::ActiveAttr::BasicModel
+    include ::ActiveAttr::BlockInitialization
+    include ::ActiveAttr::MassAssignment
+
+    attribute :uid
+    attribute :calnet_id
+    attribute :employee_id
+    attribute :student_id
+    attribute :first_name
+    attribute :last_name
+    attribute :email
+    attribute :phone
+    attribute :departments
+    attribute :affiliations
+    attribute :affiliate_id
+    attribute :inactive
+
+    def full_name
+      "#{first_name()} #{last_name()}"
+    end
+
+    def last_first
+      "#{last_name}, #{first_name}"
+    end
+
+    def last_first_downcase
+      last_first.downcase
+    end
+
+    # Currently only used in rspec
+    def ==(other)
+      uid == other.uid
+    end
+
+    class << self
+
+      def new_from_ldap_entry(ldap_entry)
+        new(
+          :uid => ldap_entry.uid,
+          :calnet_id => ldap_entry.berkeleyedukerberosprincipalstring.first,
+          :employee_id => ldap_entry.employeenumber,
+          :student_id => ldap_entry.attributes["student_id"],
+          :first_name => ldap_entry.givenname.first,
+          :last_name => ldap_entry.sn.first,
+          :email => ldap_entry.mail.first,
+          :phone => ldap_entry.phone,
+          :departments => ldap_entry.berkeleyeduunithrdeptname,
+          :affiliations => ldap_entry.berkeleyeduaffiliations,
+          :affiliate_id => ldap_entry.berkeleyeduaffid.first,
+          :inactive => ldap_entry.expired? || false
+        )
+      end
+
+    end
+
+  end
+end

data/app/models/ucb_rails_user/ldap_person/finder.rb

@@ -0,0 +1,87 @@
+module UcbRailsUser::LdapPerson
+  class Finder
+    BlankSearchTermsError = Class.new(StandardError)
+    PersonNotFound = Class.new(StandardError)
+
+    def benchmark(message = "Benchmarking")
+      result = nil
+      ms = Benchmark.ms { result = yield }
+      Rails.logger.debug "#{message} #{ms}"
+      result
+    end
+
+    def find_by_uid(uid)
+      benchmark("find_by_uid(#{uid})") do
+        find_by_attributes(:uid => uid.to_s).first ||
+          find_expired_by_attributes(:uid => uid.to_s).first
+      end
+    end
+
+    def find_by_uid!(uid)
+      find_by_uid(uid) or raise(PersonNotFound, "uid=#{uid.inspect}")
+    end
+
+    def find_by_first_last(first_name, last_name, options={})
+      raise BlankSearchTermsError unless first_name.present? || last_name.present?
+
+      find_by_attributes({:givenname => first_name, :sn => last_name}, options).tap do |entries|
+        if options[:sort]
+          sort_symbol = options[:sort]
+          entries.sort_by!(&options[:sort])
+        end
+      end
+    end
+
+    def find_by_affiliate_id(affiliate_id)
+      find_by_attributes("berkeleyEduAffID" => affiliate_id)
+    end
+
+    def find_by_attributes(attributes, options={})
+      attributes.each { |k, v| attributes.delete(k) if v.blank?  }
+
+      search_opts = { :filter => build_filter(attributes, options) }
+      search_opts[:return_result] = options[:return_result] if options.has_key?(:return_result)
+      search_opts[:size] = options[:size] if options.has_key?(:size)
+
+      UCB::LDAP::Person.
+        search(search_opts).
+        map { |ldap_entry| Entry.new_from_ldap_entry(ldap_entry) }
+    end
+
+    def find_expired_by_attributes(attributes)
+      attributes.each { |k, v| attributes.delete(k) if v.blank?  }
+      UCB::LDAP::ExpiredPerson.
+        search(:filter => build_filter(attributes)).
+        map { |ldap_entry| Entry.new_from_ldap_entry(ldap_entry) }
+    end
+
+    def build_filter(attrs, options={})
+      operator = options[:operator] || :&
+      filter_parts = attrs.map { |k, values|
+        Array(values).map{|v| build_filter_part(k, v) }
+      }.flatten
+      filter = filter_parts.inject { |accum, filter| accum.send(operator, filter) }
+      filter
+    end
+
+    def build_filter_part(key, value)
+      value = key.to_s == 'uid' ? value : "#{value}*"
+      Net::LDAP::Filter.eq(key.to_s, value)
+    end
+
+    class << self
+      def klass
+        if Rails.env.test? || UcbRailsUser[:omniauth_provider] == :developer
+          UcbRailsUser::LdapPerson::TestFinder
+        else
+          UcbRailsUser::LdapPerson::Finder
+        end
+      end
+
+      def method_missing(method, *args)
+        klass.new.send(method, *args)
+      end
+    end
+
+  end
+end

data/app/models/ucb_rails_user/ldap_person/test_finder.rb

@@ -0,0 +1,57 @@
+module UcbRailsUser::LdapPerson
+  class TestFinder
+    PersonNotFound = Class.new(StandardError)
+
+    def find_by_uid(uid)
+      uid.presence and find_by_attributes(:uid => uid.to_s).first
+    end
+
+    def find_by_uid!(uid)
+      find_by_uid(uid) || raise(PersonNotFound, "uid=#{uid.inspect}")
+    end
+
+    def find_by_first_last(first_name, last_name, options={})
+      find_by_attributes(:first_name => first_name, :last_name => last_name)
+    end
+
+    def find_by_affiliate_id(affiliate_id)
+      find_by_attributes("affiliate_id" => affiliate_id)
+    end
+
+    def find_by_attributes(attributes)
+      self.class.entries.select { |entry| entry_matches_attributes(entry, attributes) }
+    end
+
+    def entry_matches_attributes(entry, attributes)
+      attributes.keys.all? do |key|
+        value = attributes[key].to_s.downcase
+        value.blank? || (entry.respond_to?(key) && entry.send(key).to_s.downcase.include?(value))
+      end
+    end
+
+    def self.entries
+      [
+        new_entry("1", 'art', "Art", "Andrews", "art@example.com", "999-999-0001", "Dept 1", "011"),
+        new_entry("2", 'beth', "Beth", "Brown", "beth@example.com", "999-999-0002", "Dept 2", "012"),
+        new_entry("61065", 'runner', "Steven", "Hansen", "runner@berkeley.edu", "999-999-9998", "EAS", "0161065"),
+        new_entry("191501", 'stevedowney', "Steve", "Downey", "sldowney@berkeley.edu", "999-999-9999", "EAS", "01191501"),
+      ]
+    end
+
+    def self.new_entry(uid, calnet_id, fn, ln, email, phone, depts, employee_id = nil, affiliate_id = nil)
+      ::UcbRailsUser::LdapPerson::Entry.new(
+        :uid => uid,
+        :calnet_id => calnet_id,
+        :first_name => fn,
+        :last_name => ln,
+        :email => email,
+        :phone => phone,
+        :departments => depts,
+        :employee_id => employee_id,
+        :affiliate_id => affiliate_id,
+        :inactive => false
+      )
+    end
+
+  end
+end

data/app/models/ucb_rails_user/user_ldap_service.rb

@@ -0,0 +1,65 @@
+class UcbRailsUser::UserLdapService
+
+  class << self
+
+    def create_user_from_uid(uid)
+      UcbRailsUser.logger.debug "create_user_from_uid #{uid}"
+
+      ldap_entry = UcbRailsUser::LdapPerson::Finder.find_by_uid!(uid)
+      create_user_from_ldap_entry(ldap_entry)
+    end
+
+    def create_user_from_ldap_entry(ldap_entry)
+      UcbRailsUser.logger.debug "create_user_from_ldap_entry #{ldap_entry.uid}"
+
+      User.create! do |u|
+        u.ldap_uid = ldap_entry.uid
+        u.employee_id = ldap_entry.employee_id
+        u.affiliate_id = ldap_entry.affiliate_id
+        u.student_id = ldap_entry.student_id
+        u.first_name = ldap_entry.first_name
+        u.last_name = ldap_entry.last_name
+        u.email = ldap_entry.email
+        u.inactive_flag = ldap_entry.inactive
+      end
+    end
+
+    def update_user_from_uid(uid)
+      UcbRailsUser.logger.debug "update_user_from_uid #{uid}"
+
+      ldap_entry = UcbRailsUser::LdapPerson::Finder.find_by_uid!(uid)
+      update_user_from_ldap_entry(ldap_entry)
+    end
+
+    def update_user_from_ldap_entry(ldap_entry)
+      UcbRailsUser.logger.debug "update_user_from_ldap_entry #{ldap_entry.uid}"
+
+      User.find_by_ldap_uid!(ldap_entry.uid).tap do |user|
+        user.employee_id = ldap_entry.employee_id if user.respond_to?(:employee_id=)
+        user.first_name = ldap_entry.first_name
+        user.last_name = ldap_entry.last_name
+        user.email = ldap_entry.email
+        user.save(validate: false)
+      end
+    end
+
+    def create_or_update_user(uid)
+      if user = User.find_by_ldap_uid(uid)
+        update_user_from_uid(uid)
+      else
+        create_user_from_uid(uid)
+      end
+    end
+
+    def create_or_update_user_from_entry(entry)
+      # LDAP returns some values as Net::BER::BerIdentifiedString instances, and not
+      # all DBs seem to handle that well (e.g. Oracle) - we might want to fix LDAP library
+      # to smooth this over?
+      if user = User.find_by_ldap_uid(entry.uid.to_s)
+        update_user_from_ldap_entry(entry)
+      else
+        create_user_from_ldap_entry(entry)
+      end
+    end
+  end
+end

data/app/models/ucb_rails_user/user_session_manager/active_in_user_table.rb

@@ -0,0 +1,29 @@
+module UcbRailsUser
+  module UserSessionManager
+    class ActiveInUserTable < Base
+
+      def login(uid)
+        self.uid = uid
+
+        if user_table_entry && people_ou_entry
+          UcbRailsUser::UserLdapService.update_user_from_ldap_entry(people_ou_entry).tap do |user|
+            user.touch(:last_login_at)
+          end
+        else
+          false
+        end
+      end
+
+      def current_user(uid)
+        User.find_by_ldap_uid(uid)
+      end
+
+      private
+
+      def user_table_entry
+        active_user
+      end
+
+    end
+  end
+end