authlogic_wind 0.1.0 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/authlogic_wind.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{authlogic_wind}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["James Stuart"]
@@ -24,7 +24,13 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "authlogic_wind.gemspec",
+     "init.rb",
      "lib/authlogic_wind.rb",
+     "lib/authlogic_wind/acts_as_authentic.rb",
+     "lib/authlogic_wind/helper.rb",
+     "lib/authlogic_wind/session.rb",
+     "lib/wind_callback_filter.rb",
+     "rails/init.rb",
      "test/authlogic_wind_test.rb",
      "test/test_helper.rb"
   ]

data/init.rb

@@ -0,0 +1 @@
+File.dirname(__FILE__) + "/rails/init.rb"

data/lib/authlogic_wind/acts_as_authentic.rb

@@ -0,0 +1,84 @@
+require 'net/http'
+require 'net/https'
+
+# This module is responsible for adding wind functionality to Authlogic. Checkout the README for more info and please
+# see the sub modules for detailed documentation.
+module AuthlogicWind
+  # This module is responsible for adding in the wind functionality to your models. It hooks itself into the
+  # acts_as_authentic method provided by Authlogic.
+  module ActsAsAuthentic
+    # Adds in the neccesary modules for acts_as_authentic to include and also disabled password validation if
+    # wind is being used.
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        add_acts_as_authentic_module(Methods, :prepend)
+      end
+    end
+    
+    module Config
+      # The name of the wind login field in the database.
+      #
+      # * <tt>Default:</tt> :wind_login, :login, or :username, if they exist
+      # * <tt>Accepts:</tt> Symbol
+      def wind_login_field(value = nil)
+        rw_config(:wind_login_field, value, first_column_to_exist(nil, :wind_login, :login, :username))
+      end
+      alias_method :wind_login_field=, :wind_login_field
+
+      # Whether or not to validate the wind_login field. If set to false ALL wind validation will need to be
+      # handled by you.
+      #
+      # * <tt>Default:</tt> true
+      # * <tt>Accepts:</tt> Boolean
+      def validate_wind_login(value = nil)
+        rw_config(:validate_wind_login, value, true)
+      end
+      alias_method :validate_wind_login=, :validate_wind_login
+
+
+      def find_by_wind_login_field(login)
+        find(wind_login_field, login)
+      end
+    end
+    
+    module Methods
+      # Set up some simple validations
+      def self.included(klass)
+        klass.class_eval do
+          validate :validate_by_wind, :if => :authenticating_with_wind?
+
+          validates_uniqueness_of :wind_login, :scope => validations_scope, :if => :using_wind?
+          validates_length_of_password_field_options validates_length_of_password_field_options.merge(:if => :validate_password_with_wind?)
+          validates_confirmation_of_password_field_options validates_confirmation_of_password_field_options.merge(:if => :validate_password_with_wind?)
+          validates_length_of_password_confirmation_field_options validates_length_of_password_confirmation_field_options.merge(:if => :validate_password_with_wind?)
+          
+          
+        end
+      end
+
+      
+      
+      private
+      
+      def authenticating_with_wind?
+        
+        # Controller isn't available in all contexts (e.g. irb)
+        return false unless session_class.controller
+        
+        # Initial request when user presses one of the button helpers
+        (session_class.controller.params && !session_class.controller.params[:login_with_wind].blank?) ||
+        # When the oauth provider responds and we made the initial request
+        (wind_response && session_class.controller.session && session_class.controller.session[:wind_request_class] == self.class.name)
+      end
+      
+      def validate_password_with_wind?
+        !using_wind? && require_password?
+      end
+
+      def using_wind?
+        !wind_login.blank?
+      end
+    end
+  end
+end

data/lib/authlogic_wind/helper.rb

@@ -0,0 +1,16 @@
+module AuthlogicWind
+  module Helper
+    def oauth_register_button(options = {})
+      oauth_button('register_with_oauth', options)
+    end
+    
+    def oauth_login_button(options = {})
+      oauth_button('login_with_oauth', options)
+    end
+  
+  private
+    def oauth_button(name, options = {})
+      "<input type='submit' value='#{options[:value]}' name='#{name}' id='user_submit' class='#{options[:class]}'/>"
+    end
+  end
+end

data/lib/authlogic_wind/session.rb

@@ -0,0 +1,185 @@
+module AuthlogicWind
+  module Session
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        include Methods
+      end
+    end
+    
+    module Config
+      # The host of your WIND server.
+      #
+      # * <tt>Default:</tt> nil
+      # * <tt>Accepts:</tt> String
+      def wind_host(value = nil)
+        rw_config(:wind_host, value)
+      end
+      alias_method :wind_host=, :wind_host
+
+      # The service name of your WIND server.
+      #
+      # * <tt>Default:</tt> nil
+      # * <tt>Accepts:</tt> String
+      def wind_service(value = nil)
+        rw_config(:wind_service, value)
+      end
+      alias_method :wind_service=, :wind_service
+      
+   
+      def find_by_wind_method(value = nil)
+        rw_config(:find_by_wind_method, value, :find_by_wind_login)
+      end
+      alias_method :find_by_wind_method=, :find_by_wind_method
+   
+      
+      # Add this in your Session object to Auto Register a new user using openid via sreg
+      def auto_register(value=nil)
+        rw_config(:auto_register,value,false)
+      end
+      
+      alias_method :auto_register=,:auto_register
+      
+    end
+    
+    
+    module Methods
+      def self.included(klass)
+        klass.class_eval do
+          validate :validate_by_wind, :if => :authenticating_with_wind?
+        end
+      end
+
+      def credentials=(value)
+        super
+        values = value.is_a?(Array) ? value : [value]
+        hash = values.first.is_a?(Hash) ? values.first.with_indifferent_access : nil
+        self.record = hash[:priority_record] if !hash.nil? && hash.key?(:priority_record)
+      end
+      
+      def save(&block)
+        block = nil if redirecting_to_wind_server?
+        super(&block)
+      end
+      
+      
+      private
+        def authenticating_with_wind?
+          # Initial request when user presses one of the button helpers
+          (controller.params && !controller.params[:login_with_wind].blank?) ||
+          # When the oauth provider responds and we made the initial request
+          (wind_response && controller.session && controller.session[:wind_request_class] == self.class.name)
+        end
+        
+        def using_wind?
+          respond_to(:wind_login) && !wind_login.blank?
+        end
+      
+        def authenticate_with_wind
+          
+          if @record
+            self.attempted_record = record
+
+            if !attempted_record
+              errors.add_to_base("Could not find user in our database.")
+            end
+
+          else
+            uni = generate_verified_login
+            if uni
+              self.attempted_record = search_for_record(find_by_wind_method, uni) 
+              if !attempted_record
+                if auto_register?
+                  self.attempted_record = klass.new(:login => uni, :wind_login => uni)
+                  self.attempted_record.reset_persistence_token
+                else
+                  errors.add_to_base("Could not find UNI #{uni} in our database")
+                end
+              end
+            else
+              errors.add_to_base("WIND Ticket did not verify properly.")
+            end  
+          end
+          
+        end
+        
+        def wind_host
+          self.class.wind_host
+        end
+        
+        def wind_service
+          self.class.wind_service
+        end
+
+        def find_by_wind_method
+          self.class.find_by_wind_method
+        end
+
+        def auto_register?
+          self.class.auto_register == true
+        end
+        
+        def validate_by_wind
+          validate_email_field = false
+          if wind_response.blank?
+            redirect_to_wind
+          else
+            authenticate_with_wind
+          end
+        end
+
+
+        def redirecting_to_wind_server?
+          authenticating_with_wind? && wind_response.blank?
+        end
+
+        def redirect_to_wind
+          # Store the class which is redirecting, so we can ensure other classes
+          # don't get confused and attempt to use the response
+          wind_controller.session[:wind_request_class] = self.class.name
+
+          # Tell our rack callback filter what method the current request is using
+          wind_controller.session[:wind_callback_method]      = wind_controller.request.method
+
+          wind_controller.redirect_to wind_controller.url_for(:host => wind_host, :controller => "login", :protocol => "https", :service => wind_service, :destination => build_callback_url)
+        end
+
+        def build_callback_url
+          wind_controller.url_for :controller => wind_controller.controller_name, :action => wind_controller.action_name
+        end
+
+        def generate_verified_login
+          if (ticketid = wind_controller.params[:ticketid])
+            url = "/validate?ticketid=#{ticketid}"
+        		h = Net::HTTP.new("wind.columbia.edu", 443)
+        		h.use_ssl = true
+        		resp, data = h.get(url, nil)
+        		uni = data.split[1] unless data[0,2] == "no"
+        		return uni
+          else
+            nil
+          end
+        end
+
+        def wind_response
+          wind_controller.params && wind_controller.params[:ticketid]
+        end
+
+        def wind_controller
+          is_auth_session? ? controller : session_class.controller
+        end
+
+        def wind
+          is_auth_session? ? self.class.wind_consumer : session_class.wind_consumer
+        end
+
+        def is_auth_session?
+          self.is_a?(Authlogic::Session::Base)
+        end
+
+
+    end
+  
+  end
+  
+end

data/lib/authlogic_wind.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + "/authlogic_wind/acts_as_authentic"
-require File.dirname(__FILE__) + "/authlogic_wind/session"
-require File.dirname(__FILE__) + "/authlogic_wind/helper"
+require "authlogic_wind/acts_as_authentic"
+require "authlogic_wind/session"
+require "authlogic_wind/helper"
 
 ActiveRecord::Base.send(:include, AuthlogicWind::ActsAsAuthentic)
 Authlogic::Session::Base.send(:include, AuthlogicWind::Session)

data/lib/wind_callback_filter.rb

@@ -0,0 +1,13 @@
+class WindCallbackFilter
+  def initialize(app)
+    @app = app
+  end
+  
+  def call(env)
+    unless env["rack.session"][:wind_callback_method].blank?
+      # env["QUERY_STRING"].gsub!(/ticketid\=/,"user_session[ticketid]=")
+      env["REQUEST_METHOD"] = env["rack.session"].delete(:wind_callback_method).to_s.upcase
+    end
+    @app.call(env)
+  end
+end

data/rails/init.rb

@@ -0,0 +1,10 @@
+require "authlogic_wind"
+require "wind_callback_filter"
+
+# Throw callback rack app into the middleware stack
+ActionController::Dispatcher.middleware = ActionController::MiddlewareStack.new do |m|
+  ActionController::Dispatcher.middleware.each do |klass|
+    m.use klass
+  end
+  m.use WindCallbackFilter
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: authlogic_wind
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - James Stuart
@@ -49,7 +49,13 @@ files:
 - Rakefile
 - VERSION
 - authlogic_wind.gemspec
+- init.rb
 - lib/authlogic_wind.rb
+- lib/authlogic_wind/acts_as_authentic.rb
+- lib/authlogic_wind/helper.rb
+- lib/authlogic_wind/session.rb
+- lib/wind_callback_filter.rb
+- rails/init.rb
 - test/authlogic_wind_test.rb
 - test/test_helper.rb
 has_rdoc: true