ucb_rails 0.0.1 → 0.0.2

data/README.md

@@ -1,10 +1,17 @@
 # UCB Rails
 
+[![Gem Version](https://badge.fury.io/rb/ucb_rails.png)](http://badge.fury.io/rb/ucb_rails)
+[![Build Status](https://travis-ci.org/stevedowney/ucb_rails.png)](https://travis-ci.org/stevedowney/ucb_rails)
+[![Coverage Status](https://coveralls.io/repos/stevedowney/ucb_rails/badge.png?branch=master)](https://coveralls.io/r/stevedowney/ucb_rails?branch=master)
+[![Code Climate](https://codeclimate.com/github/stevedowney/ucb_rails.png)](https://codeclimate.com/github/stevedowney/ucb_rails)
+
 Get a jump start on your Rails project at UCB.  Includes:
 
 * CalNet authentication with [omniauth-cas](https://github.com/dlindahl/omniauth-cas)
 * LDAP integration with [ucb_ldap](https://rubygems.org/gems/ucb_ldap)
 * includes several other gems including:
+  * [bootstrap-view-helpers](https://github.com/stevedowney/bootstrap-view-helpers)
+  * [user_announcements](https://github.com/stevedowney/user_announcements)
   * [rails_environment](https://github.com/stevedowney/rails_environment)
 
 ## Installation
@@ -12,14 +19,37 @@ Get a jump start on your Rails project at UCB.  Includes:
 Add it to your Gemfile
 
 ```ruby
-gem install 'ucb_rails'
+gem 'ucb_rails'
+
+# bleeding edge
+gem 'ucb_rails', git: 'https://github.com/stevedowney/ucb_rails'
+```
+
+From the command line, install the `ucb_rails` gem:
+
+```sh
+bundle install
+rails g ucb_rails:install
+```
+
+Run installers for included gems:
+
+```sh
+rails generate user_announcements:install
+rails generate simple_form:install --bootstrap
+```
+
+Run migrations:
+
+```sh
+rake db:migrate
 ```
 
-From the command line:
+Remove superseded files:
 
 ```sh
-$ bundle install
-$ rails g ucb_rails:install
+rm public/index.html
+rm app/views/layouts/application.html.erb  
 ```
 
 Restart your server and point your browser to:

data/app/controllers/ucb_rails/admin/base_controller.rb

@@ -0,0 +1,4 @@
+class UcbRails::Admin::BaseController < ApplicationController
+  before_filter :ensure_admin_user
+  
+end

data/app/controllers/ucb_rails/admin/users_controller.rb

@@ -0,0 +1,70 @@
+class UcbRails::Admin::UsersController < UcbRails::Admin::BaseController
+  before_filter :find_user, :only => [:edit, :update, :destroy]
+  
+  def index
+    respond_to do |format|
+      format.html { @users = UcbRails::User.all }
+      # format.json { render json: UsersDatatable.new(view_context) }
+    end
+  end
+  
+  def edit
+  end
+  
+  def create
+    uid = params.fetch(:uid)
+    if user = UcbRails::User.find_by_uid(uid)
+      flash[:warning] = "User already exists"
+    else
+      user = UcbRails::UserLdapService.create_user_from_uid(uid)
+      flash[:notice] = 'Record created'#msg_created(user)
+    end
+    # render :js => %(window.location.href = '#{ucb_rails_admin_user_path}')
+    render :js => %(window.location.href = '#{edit_ucb_rails_admin_user_path(user)}')
+  end
+  
+  def update
+    if @user.update_attributes(params.fetch(:ucb_rails_user), :without_protection => true)
+      redirect_to(ucb_rails_admin_users_path, notice: 'Record updated')
+    else
+      render("edit")
+    end
+  end
+  
+  def destroy
+    if @user.destroy
+      flash[:notice] = 'Record deleted' #msg_destroyed(@user)
+    else
+      flash[:error] = @user.errors[:base].first
+    end
+
+    redirect_to(ucb_rails_admin_users_path)
+  end
+
+  def ldap_search
+    @lps_entries = UcbRails::LdapPerson::Finder.find_by_first_last(
+      params.fetch(:first_name),
+      params.fetch(:last_name), 
+      :sort => :last_first_downcase
+    )
+    @lps_existing_uids = UcbRails::User.where(uid: @lps_entries.map(&:uid)).pluck(:uid)
+
+    render 'ucb_rails/lps/search'
+  end
+
+  def typeahead_search
+    tokens = params.fetch(:query).to_s.strip.split(/\s+/)
+    wheres = tokens.map { |e| 'first_last_name like ?' }.join(' and ')
+    values = tokens.map { |e| "%#{e}%" }
+    where = ["#{wheres}", *values]
+    results = UcbRails::User.where(*where).limit(10)
+    render json: results.map { |r| {uid: r.uid, first_last_name: r.first_last_name} }
+  end
+  
+  private
+
+  def find_user
+    @user ||= UcbRails::User.find(params.fetch(:id))
+  end
+  
+end

data/app/controllers/ucb_rails/bootstrap_controller.rb

@@ -0,0 +1,34 @@
+class UcbRails::BootstrapController < ApplicationController
+  skip_before_filter :ensure_authenticated_user
+  
+  def index
+    if RailsEnvironment.not_development?
+      raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
+    end
+
+    if UcbRails::User.count > 0
+      return render_text("Can't bootstrap.  Already have users.")
+    end
+    
+    if uid.present?
+      UCB::LDAP::Person.find_by_uid(uid).tap do |e|
+        return render_text("Bad uid: #{uid.inspect}") if e.blank?
+        user = UcbRails::UserLdapService.create_user_from_uid(uid)
+        user.update_attributes({admin: true}, without_protection: true)
+        redirect_to login_path
+      end
+    else
+      return render_text "Must provide a uid: /ucb_rails/bootstrap/:uid"
+    end
+  end
+  
+  private
+  
+  def uid
+    params[:uid]
+  end
+  
+  def render_text(text)
+    render text: text
+  end
+end

data/app/controllers/ucb_rails/controller_methods.rb

@@ -1,22 +1,83 @@
+# Various controller methods mixed in to the host app.
+# 
+# Most are also helper methods.
 module UcbRails::ControllerMethods
-  
   extend ActiveSupport::Concern
 
-    included do
-      helper_method :current_ldap_person, :logged_in?
+  included do
+    rescue_from UcbRails::LdapPerson::Finder::BlankSearchTermsError do
+      render :js => %(alert("Enter search terms"))
     end
 
+    before_filter :ensure_authenticated_user
+    before_filter :log_request
+    
+    after_filter  :remove_user_settings
+    
+    helper_method :admin?, :current_ldap_person, :current_user, :logged_in?
+  end
+
+  def admin?
+    current_user.try(:admin?)
+  end  
+
+  def current_user
+    @current_user ||= begin
+      UcbRails.logger.debug 'recalc of current_user'
+      user_session_manager.current_user(session[:uid])
+    end
+  end
+  
+  # Returns +true+ if there is a logged in user
+  #
+  # @return [true] if user logged in
+  # @return [false] if user not logged in
   def logged_in?
-    session[:uid].present?
+    current_user.present?
+  end
+  
+  def log_request
+    user_session_manager.log_request(current_user)
   end
   
+  def remove_user_settings
+  end
+  
+  # Returns an instance of UCB::LDAP::Person if there is a logged in user
+  #
+  # @return [UCB::LDAP::Person] if user logged in
+  # @return [nil] if user not logged in
   def current_ldap_person
     if logged_in?
-      UCB::LDAP::Person.find_by_uid(session[:uid])
+      @current_ldap_person ||= begin
+        UcbRails.logger.debug 'recalc of current_ldap_person'
+        user_session_manager.people_ou_entry(session[:uid])
+      end
+    end
+  end
+
+  def ensure_admin_user
+    admin? or redirect_to not_authorized_path
+  end
+  
+  # Before filter that redirects redirects to +login_url+ unless user is logged in
+  #
+  # @return [nil]
+  def ensure_authenticated_user
+    unless session.has_key?(:uid)
+      session[:original_url] = request.env['REQUEST_URI']
+      redirect_to login_url
     end
   end
 
-  module ClassMethods
+  def user_session_manager
+    @user_session_manager ||= begin
+      UcbRails.logger.debug "creating new user_session_manager"
+      klass = UcbRails[:user_session_manager] || UcbRails::UserSessionManager::ActiveInUserTable
+      klass.to_s.classify.constantize.new
+    end
+  rescue NameError
+    raise "Could not find UcbRails user_session_manager: #{klass}"
   end
   
 end

data/app/controllers/ucb_rails/home_controller.rb

@@ -1,5 +1,10 @@
 class UcbRails::HomeController < ApplicationController
   
+  # Renders either a "logged in" page or a "logged out" page.
+  # Mainly used for getting going with the +ucb_rails+ gem.  
+  # Not intended for production use.
+  #
+  # @return [nil]
   def index
     if logged_in?
       render 'logged_in'

data/app/controllers/ucb_rails/ldap_person_search_controller.rb

@@ -0,0 +1,15 @@
+class UcbRails::LdapPersonSearchController < ApplicationController
+  NoSearchTermError = Class.new(StandardError)
+  
+  skip_before_filter :ensure_authenticated_user
+
+  def search
+    @lps_entries = UcbRails::LdapPerson::Finder.find_by_first_last(
+      params.fetch(:first_name),
+      params.fetch(:last_name),
+      :sort => :last_first_downcase
+    )
+    render 'ucb_rails/lps/search'
+  end
+    
+end

data/app/controllers/ucb_rails/sessions_controller.rb

@@ -1,26 +1,51 @@
+# Manages starting and ending of sessions, i.e., logging in and out.
 class UcbRails::SessionsController < ApplicationController
   
-  skip_before_filter :ensure_authenticated_user
+  skip_before_filter :ensure_authenticated_user, :log_request
 
+  # Redirects to authentication provider
+  #
+  # @return [nil]
   def new
-    provider = params.fetch(:provider, :cas)
+    provider = UcbRails[:omniauth_provider] || :cas
     redirect_to "/auth/#{provider}"
   end
 
+  # Login user after authentication by provider
+  #
+  # @return [nil] 
   def create
-    session[:uid] = request.env['omniauth.auth'].uid
-    session[:provider] = request.env['omniauth.auth'].provider
-    # UserSessionManager.login(session[:uid])
-    redirect_to session[:original_url] || root_path
+    uid = request.env['omniauth.auth'].uid
+    session[:omniauth_provider] = request.env['omniauth.auth'].provider
+    
+    if user_session_manager.login(uid)
+      session[:uid] = uid
+      redirect_to session[:original_url] || root_path
+    else
+      redirect_to not_authorized_path
+    end
   end
    
+  # Log user out 
+  #
+  # @return [nil]
   def destroy
-    # UserSessionManager.logout(current_user)
-    provider = session[:provider]
+    user_session_manager.logout(current_user)
+    provider = session[:omniauth_provider]
     reset_session
     redirect_to redirect_url(provider)
   end
   
+  # Action called when unauthorized access attempted
+  #
+  # @return [nil]
+  def not_authorized
+    render(:text => "Not Authorized", :status => 401)
+  end
+
+  # Handler for authentication failure.
+  #
+  # @return [nil]
   def failure
     Rails.logger.debug("Authentication Failed for: #{request.env['omniauth.auth']}")
     render(:text => "Not Authorized", :status => 401)

data/app/helpers/ucb_rails/admin/users_helper.rb

@@ -0,0 +1,14 @@
+module UcbRails::Admin::UsersHelper
+  
+  def link_to_new_user
+    button('New User', :primary, 
+      class: 'ldap-person-search',
+      data: {
+        search_url: ldap_search_ucb_rails_admin_users_path,
+        result_link_url: ucb_rails_admin_users_path,
+        result_link_http_method: 'post',
+      }
+    )
+  end
+  
+end

data/app/helpers/ucb_rails/extractable_helper.rb

@@ -0,0 +1,17 @@
+# These methods should be extracted into own gem.
+module UcbRails::ExtractableHelper
+  
+  def ucbr_table_tag(*args)
+    options = canonicalize_options(args.extract_options!)
+    
+    ar_class = args.first
+    if ar_class.respond_to?(:haml_attributes)
+      options[:id] ||= ar_class.haml_attributes["id"]
+      options = ensure_class(options, ar_class.haml_attributes["class"])
+    end
+
+    bs_table_tag(options) do
+      yield
+    end
+  end
+end

data/app/helpers/ucb_rails/icons_helper.rb

@@ -0,0 +1,7 @@
+module UcbRails::IconsHelper
+  
+  def announcements_text
+    icon('bullhorn', 'Announcements')
+  end
+  
+end

data/app/helpers/ucb_rails/ldap_person_search_helper.rb

@@ -0,0 +1,21 @@
+module UcbRails::LdapPersonSearchHelper
+  
+  def link_to_ldap_person_entry(entry)
+    UcbRails::Renderer::LdapPersonSearchResultLink.new(self, entry).html
+  end
+  
+  def ldap_entry_class(entry)
+    Array['ldap-result'].tap do |result|
+      result << 'ldap-result-exists' if ldap_already_include?(entry.uid)
+    end
+  end
+  
+  def ldap_already_include?(uid)
+    ldap_person_search_existing_uids.include?(uid.to_s)
+  end
+  
+  def ldap_person_search_existing_uids
+    @ldap_person_search_existing_uids ||= (@lps_existing_uids || []).map(&:to_s)
+  end
+  
+end

data/app/helpers/ucb_rails/lps_typeahead_helper.rb

@@ -0,0 +1,50 @@
+module UcbRails::LpsTypeaheadHelper
+  
+  def lps_typeahead_search_field(options={})
+    name = options.delete(:name) || 'person_search'
+    required = options.delete(:required)
+    label = options.delete(:label) || 'User'
+    value = options.delete(:value) || params[name]
+    placeholder = options.delete(:placeholder) || 'Type name to search'
+    hint = options.delete(:hint) || 'Click icon to search CalNet'
+    
+    result_link_text = options.delete(:result_link_text) || 'Select'
+    result_link_class = options.delete(:result_link_class) || 'lps-typeahead-item'
+    
+    uid_dom_id = options.delete(:uid_dom_id) || 'uid'
+    search_url = options.delete(:search_url) || typeahead_search_ucb_rails_admin_users_path
+    
+    content_tag(:div, class: 'control-group lps-typeahead') do
+      label_tag(name, class: label_classes(required)) do
+        required_marker(required) +
+        label
+         
+      end +
+      content_tag(:div, class: 'controls') do
+        content_tag(:div, class: 'input-append') do
+          text_field_tag(name, value, placeholder: placeholder, class: 'typeahead-lps-search', data: { uid_dom_id: uid_dom_id, url: search_url }) +
+          content_tag(:span, class: 'add-on') do
+            icon('search', class: 'ldap-person-search', data: {search_field_name: name, result_link_text: result_link_text, result_link_class: result_link_class})
+          end
+        end +
+        content_tag(:p, hint, class: 'help-block')
+      end
+    end
+  end
+  
+  private
+  
+  def label_classes(required)
+    Array['control-label'].tap do |klasses|
+      klasses << 'required' if required
+    end
+  end
+  
+  def required_marker(required)
+    if required
+      content_tag(:abbr, '*', title: 'required') + ' '
+    else
+      ''
+    end
+  end
+end

data/app/helpers/ucb_rails/renderer/base.rb

@@ -0,0 +1,52 @@
+# Base class for helper objects inspired by http://railscasts.com/episodes/101-refactoring-out-helper-object
+#
+# Use of such classes is indicated when you have:
+#
+# * helper methods calling each other, especially if ...
+# * helper methods are passing around variables (which will become instance variables) 
+# * the same case/if logic in many methods, indicating a requirement for class hierarchy
+#
+# Your helper class's methods can just do calculations which are subsituted into
+# html in the views, or the methods can generate html as well.  This is helpful
+# when the html is conditional on some other object's state.
+#
+# You have access to all the helper methods available to the view that creates
+# the instance.
+#
+# Implementing helper classes should inherit from Renderer::Base and the template
+# instance should be passed as an argument to the constructor.
+#
+#   # app/helpers/renderer/my_renderer.rb
+#   class MyRenderer < Renderer::Base
+#   ...
+#   end
+#
+#   # app/views/a_controller/a_view.html.erb
+#   <% renderer = MyRenderer.new(self) %>   # must pass in template
+#   ...
+#   <div>
+#     <%= renderer.div_content %>
+#   </div>
+class UcbRails::Renderer::Base
+  
+  # Holds reference to view template
+  attr_accessor :template
+  
+  # Options to pass to renderer
+  attr_accessor :options
+  
+  # Returns new instance of renderer.  The _template_ argument is the view template.
+  def initialize(template, options = {})
+    self.template = template
+    self.options = options
+  end
+  
+  private
+  
+  # Method missing sends all calls to template instance.  This techniuqe
+  # provides access to helper methods available to the template.
+  def method_missing(*args, &block)
+    template.send(*args, &block)
+  end
+
+end

data/app/helpers/ucb_rails/renderer/ldap_person_search_result_link.rb

@@ -0,0 +1,81 @@
+module UcbRails
+  module Renderer
+    
+    class LdapPersonSearchResultLink < Base
+      attr_accessor :entry
+      
+      def initialize(template, entry, options={})
+        super template, options
+        self.entry = entry
+      end
+      
+      def html
+        exists? ? exists_html : button(text, :mini, :primary, link_options)
+      end
+      
+      private
+      
+      def exists?
+        ldap_person_search_existing_uids.include?(entry.uid.to_s)
+      end
+      
+      def exists_html
+        params["result-link-exists-text"] || 'Exists'
+      end
+      
+      def text
+        @text ||= params["result-link-text"].presence || "Add"
+      end
+      
+      def link_options
+        {
+          class: classes,
+          url: item_url,
+          data: {
+            remote: remote,
+            method: http_method,
+            uid: entry.uid,
+            first_name: entry.first_name,
+            last_name: entry.last_name,
+            email: entry.email,
+          }
+        }
+      end
+      
+      def classes
+        extra_class = params['result-link-class'].presence || 'result-link-default'
+        "result-link #{extra_class}"
+      end
+      
+      def item_url
+        url_param.present? ? url_and_person_params : '#'
+      end
+      
+      def remote
+        url_param.present?
+      end
+
+      def http_method
+        params['result-link-http-method'] || :get
+      end
+      
+      def url_param
+        params["result-link-url"]
+      end
+      
+      def url_and_person_params
+        connector = url_param.include?("?") ? '&' : '?'
+        "#{url_param}#{connector}#{person_params.to_query}"
+      end
+      
+      def person_params
+        {
+          uid: entry.uid,
+          first_name: entry.first_name,
+          last_name: entry.last_name,
+        }
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,54 @@
+module UcbRails::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 :first_name
+    attribute :last_name
+    attribute :email
+    attribute :phone
+    attribute :departments
+    attribute :affiliations
+  
+    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,
+          :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
+        )
+      end
+      
+    end
+    
+  end
+end