deckshuffler 0.0.2

data/lib/authentication/authenticated_system.rb

@@ -0,0 +1,162 @@
+module AuthenticatedSystem
+  def user_name
+    user = current_user()
+    result = nil
+    result = user.login() unless user.nil?()
+    return result
+  end
+  
+  def all_user_names
+    User.find(:all).collect {|user| user.login()}.sort()
+  end
+  
+  protected
+  # Returns true or false if the user is logged in.
+  # Preloads @current_user with the user model if they're logged in.
+  def logged_in?
+   (@current_user ||= session[:user] ? User.find_by_id(session[:user]) : :false).is_a?(User)
+  end
+  
+  # Accesses the current user from the session.
+  def current_user
+    @current_user if logged_in?
+  end
+  
+  # Store the given user in the session.
+  def current_user=(new_user)
+    session[:user] = (new_user.nil? || new_user.is_a?(Symbol)) ? nil : new_user.id
+    @current_user = new_user
+  end
+  
+  # Check if the user is authorized.
+  #
+  # Override this method in your controllers if you want to restrict access
+  # to only a few actions or if you want to check if the user
+  # has the correct rights.
+  #
+  # Example:
+  #
+  #  # only allow nonbobs
+  #  def authorize?
+  #    current_user.login != "bob"
+  #  end
+  def authorized?
+    true
+  end
+  
+  # Filter method to enforce a login requirement.
+  #
+  # To require logins for all actions, use this in your controllers:
+  #
+  #   before_filter :login_required
+  #
+  # To require logins for specific actions, use this in your controllers:
+  #
+  #   before_filter :login_required, :only => [ :edit, :update ]
+  #
+  # To skip this in a subclassed controller:
+  #
+  #   skip_before_filter :login_required
+  #
+  def login_required
+    username, passwd = get_auth_data
+    self.current_user ||= User.authenticate(username, passwd) || :false if username && passwd
+    logged_in? && authorized? ? true : access_denied
+  end
+  
+  # Redirect as appropriate when an access request fails.
+  #
+  # The default action is to redirect to the login screen.
+  #
+  # Override this method in your controllers if you want to have special
+  # behavior in case the user is not authorized
+  # to access the requested action.  For example, a popup window might
+  # simply close itself.
+  def access_denied
+    respond_to do |accepts|
+      accepts.html do
+        store_location
+        redirect_to :controller => '/account', :action => 'login'
+      end
+      accepts.xml do
+        headers["Status"]           = "Unauthorized"
+        headers["WWW-Authenticate"] = %(Basic realm="Web Password")
+        render :text => "Could't authenticate you", :status => '401 Unauthorized'
+      end
+    end
+    false
+  end  
+  
+  # Store the URI of the current request in the session.
+  #
+  # We can return to this location by calling #redirect_back_or_default.
+  def store_location
+    session[:return_to] = request.request_uri
+  end
+  
+  # Redirect to the URI stored by the most recent store_location call or
+  # to the passed default.
+  def redirect_back_or_default(default)
+    session[:return_to] ? redirect_to_url(session[:return_to]) : redirect_to(default)
+    session[:return_to] = nil
+  end
+  
+  # Inclusion hook to make #current_user and #logged_in?
+  # available as ActionView helper methods.
+  def self.included(base)
+    base.send :helper_method, :current_user, :logged_in?
+  end
+  
+  # When called with before_filter :login_from_cookie will check for an :auth_token
+  # cookie and log the user back in if apropriate
+  def login_from_cookie
+    return unless cookies[:auth_token] && !logged_in?
+    user = User.find_by_remember_token(cookies[:auth_token])
+    if user && user.remember_token?
+      user.remember_me
+      self.current_user = user
+      cookies[:auth_token] = { :value => self.current_user.remember_token , :expires => self.current_user.remember_token_expires_at }
+    end
+  end
+  
+  def authenticate(login, password)
+    self.current_user = User.authenticate(login, password)
+    if current_user && (params[:remember_me] == "1")
+      self.current_user.remember_me
+      cookies[:auth_token] = { :value => self.current_user.remember_token , :expires => self.current_user.remember_token_expires_at }
+    end
+    return (! current_user.nil?())
+  end
+  
+  def user_signup!(user_params)
+    @user = User.new(user_params)
+    @user.save!
+    self.current_user = @user
+  end
+  
+  def user_logout()
+    self.current_user.forget_me if logged_in?
+    cookies.delete :auth_token
+    reset_session
+  end
+  
+  private
+  # gets BASIC auth info
+  def get_auth_data
+    user, pass = nil, nil
+    # extract authorisation credentials 
+    if request.env.has_key? 'X-HTTP_AUTHORIZATION' 
+      # try to get it where mod_rewrite might have put it 
+      authdata = request.env['X-HTTP_AUTHORIZATION'].to_s.split 
+    elsif request.env.has_key? 'HTTP_AUTHORIZATION' 
+      # this is the regular location 
+      authdata = request.env['HTTP_AUTHORIZATION'].to_s.split  
+    end 
+    
+    # at the moment we only support basic authentication 
+    if authdata && authdata[0] == 'Basic' 
+      user, pass = Base64.decode64(authdata[1]).split(':')[0..1] 
+    end 
+    return [user, pass] 
+  end
+end

data/lib/authentication/authenticated_test_helper.rb

@@ -0,0 +1,113 @@
+module AuthenticatedTestHelper
+  # Sets the current user in the session from the user fixtures.
+  def login_as(user)
+    @request.session[:user] = user ? users(user).id : nil
+  end
+
+  def content_type(type)
+    @request.env['Content-Type'] = type
+  end
+
+  def accept(accept)
+    @request.env["HTTP_ACCEPT"] = accept
+  end
+
+  def authorize_as(user)
+    if user
+      @request.env["HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{users(user).login}:test")}"
+      accept       'application/xml'
+      content_type 'application/xml'
+    else
+      @request.env["HTTP_AUTHORIZATION"] = nil
+      accept       nil
+      content_type nil
+    end
+  end
+
+  # http://project.ioni.st/post/217#post-217
+  #
+  #  def test_new_publication
+  #    assert_difference(Publication, :count) do
+  #      post :create, :publication => {...}
+  #      # ...
+  #    end
+  #  end
+  # 
+  def assert_difference(object, method = nil, difference = 1)
+    initial_value = object.send(method)
+    yield
+    assert_equal initial_value + difference, object.send(method), "#{object}##{method}"
+  end
+
+  def assert_no_difference(object, method, &block)
+    assert_difference object, method, 0, &block
+  end
+
+  # Assert the block redirects to the login
+  # 
+  #   assert_requires_login(:bob) { |c| c.get :edit, :id => 1 }
+  #
+  def assert_requires_login(login = nil)
+    yield HttpLoginProxy.new(self, login)
+  end
+
+  def assert_http_authentication_required(login = nil)
+    yield XmlLoginProxy.new(self, login)
+  end
+
+  def reset!(*instance_vars)
+    instance_vars = [:controller, :request, :response] unless instance_vars.any?
+    instance_vars.collect! { |v| "@#{v}".to_sym }
+    instance_vars.each do |var|
+      instance_variable_set(var, instance_variable_get(var).class.new)
+    end
+  end
+end
+
+class BaseLoginProxy
+  attr_reader :controller
+  attr_reader :options
+  def initialize(controller, login)
+    @controller = controller
+    @login      = login
+  end
+
+  private
+    def authenticated
+      raise NotImplementedError
+    end
+    
+    def check
+      raise NotImplementedError
+    end
+    
+    def method_missing(method, *args)
+      @controller.reset!
+      authenticate
+      @controller.send(method, *args)
+      check
+    end
+end
+
+class HttpLoginProxy < BaseLoginProxy
+  protected
+    def authenticate
+      @controller.login_as @login if @login
+    end
+    
+    def check
+      @controller.assert_redirected_to :controller => 'account', :action => 'login'
+    end
+end
+
+class XmlLoginProxy < BaseLoginProxy
+  protected
+    def authenticate
+      @controller.accept 'application/xml'
+      @controller.authorize_as @login if @login
+    end
+    
+    def check
+      @controller.assert_response 401
+    end
+end

data/lib/authentication/user.rb

@@ -0,0 +1,67 @@
+require 'digest/sha1'
+class User < ActiveRecord::Base
+  # Virtual attribute for the unencrypted password
+  attr_accessor :password
+
+  validates_presence_of     :login, :email
+  validates_presence_of     :password,                   :if => :password_required?
+  validates_presence_of     :password_confirmation,      :if => :password_required?
+  validates_length_of       :password, :within => 6..40, :if => :password_required?
+  # Password format validation needs to be 1-9, a-z, A-Z, special characters at least 3 of those
+  # validates_format_of :password, :with => XXX :if => :password_required?
+  validates_confirmation_of :password,                   :if => :password_required?
+  validates_length_of       :login,    :within => 5..40
+  validates_length_of       :email,    :within => 3..100
+  validates_format_of :email, :with => /^[^@]+@[^.]+[.][^.]+/
+  validates_uniqueness_of   :login, :email, :case_sensitive => false
+  before_save :encrypt_password
+
+  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
+  def self.authenticate(login, password)
+    u = find_by_login(login) # need to get the salt
+    u && u.authenticated?(password) ? u : nil
+  end
+
+  # Encrypts some data with the salt.
+  def self.encrypt(password, salt)
+    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+  end
+
+  # Encrypts the password with the user salt
+  def encrypt(password)
+    self.class.encrypt(password, salt)
+  end
+
+  def authenticated?(password)
+    crypted_password == encrypt(password)
+  end
+
+  def remember_token?
+    remember_token_expires_at && Time.now.utc < remember_token_expires_at 
+  end
+
+  # These create and unset the fields required for remembering users between browser closes
+  def remember_me
+    self.remember_token_expires_at = 2.weeks.from_now.utc
+    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
+    save(false)
+  end
+
+  def forget_me
+    self.remember_token_expires_at = nil
+    self.remember_token            = nil
+    save(false)
+  end
+
+  protected
+    # before filter 
+    def encrypt_password
+      return if password.blank?
+      self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
+      self.crypted_password = encrypt(password)
+    end
+    
+    def password_required?
+      crypted_password.blank? || !password.blank?
+    end
+end

data/lib/authentication/user_notifier.rb

@@ -0,0 +1,22 @@
+class UserNotifier < ActionMailer::Base
+  def signup_notification(user)
+    setup_email(user)
+    @subject    += 'Please activate your new account'
+    @body[:url]  = "http://YOURSITE/account/activate/#{user.activation_code}"
+  end
+  
+  def activation(user)
+    setup_email(user)
+    @subject    += 'Your account has been activated!'
+    @body[:url]  = "http://YOURSITE/"
+  end
+  
+  protected
+  def setup_email(user)
+    @recipients  = "#{user.email}"
+    @from        = "ADMINEMAIL"
+    @subject     = "[YOURSITE] "
+    @sent_on     = Time.now
+    @body[:user] = user
+  end
+end

data/lib/authentication/user_observer.rb

@@ -0,0 +1,9 @@
+class UserObserver < ActiveRecord::Observer
+  def after_create(user)
+    UserNotifier.deliver_signup_notification(user)
+  end
+
+  def after_save(user)
+    UserNotifier.deliver_activation(user) if user.recently_activated?
+  end
+end

data/lib/cards_csv_exporter.rb

@@ -0,0 +1,33 @@
+require 'csv'
+
+class CardsCSVExporter
+  TITLE = ["id","type","title","description","status","size","priority","functional sets","milestone","owner"]
+
+  def export(cards, file, include_headers = true)
+    raise ArgumentError.new("Invalid File. File should not be nil.") unless (! file.nil?())
+    CSV::Writer.generate(file) do |csv|
+      if (include_headers)
+        csv<<(TITLE)
+      end
+      for card in cards
+        status = card.status()
+        status_name = nil
+        status_name = status.name() unless (status.nil?())
+        
+        size = card.estimated_size()
+        size_string = nil
+        size_string = size.human_day_approximate() unless (size.nil?())
+        
+        priority = card.priority()
+        priority_string = nil
+        priority_string = priority.rank() unless (priority.nil?())
+        
+        milestone = card.target_milestone()
+        milestone_name = nil
+        milestone_name = milestone.name() unless (milestone.nil?())
+      
+        csv<<([card.id(),card.card_type().name(),card.title(),card.description().gsub($/," "),status_name,size_string,priority_string,card.functional_sets().collect {|functional_set| functional_set.name()}.join('|'),milestone_name,card.owner_name()])
+      end
+    end unless (cards.empty?())
+  end
+end

data/lib/cards_csv_importer.rb

@@ -0,0 +1,87 @@
+require 'csv'
+
+class CardsCSVImporter
+  TITLE = ["type","title","description","size","priority","functional sets","milestone"]
+  
+  def import(file)
+    raise ArgumentError.new("Invalid File. File should not be nil.") unless (! file.nil?())
+    @create_objects = Array.new()
+    @errors = Array.new()
+    @row_count=0
+    CSV::Reader.parse(file) do |row|
+      @row_count += 1
+      if (TITLE != row)
+        if (row.size() == TITLE.size())
+          parsed_row = parse_row(row, @row_count, @errors)
+          @create_objects = @create_objects + parsed_row
+        else
+          @errors<< "line #{@row_count.to_s()} is invalid (expected #{TITLE.size().to_s()} cells, found #{row.size().to_s()})\n#{row.join(',')}"
+        end
+      end
+    end
+    raise ArgumentError.new("Failed parsing:\n\t #{@errors.join('\n\t')}") unless @errors.empty?()
+    return @create_objects
+  end
+  
+  private
+  def parse_row(row, row_number, errors)
+    has_errors = false
+    card = Card.new()
+    created_objects = []
+    if (row[0].nil?()) || (row[0].strip() == "")
+      has_errors = true
+      errors<<("line #{row_number.to_s()} is invalid (Expected a card type).")
+    else
+      card_type_name = row[0].strip()
+      card_type = CardType.find(:first, :conditions => "name = \"#{card_type_name}\"")
+      if (card_type == nil)
+        card_type = CardType.new({:name => card_type_name})
+        created_objects<<(card_type)
+      end
+      card.card_type=(card_type)
+    end
+    card.title=(row[1].strip())
+    card.description=(row[2].strip())
+    if (! row[3].nil?()) && (row[3].strip() != "")
+      card_size = CardSize.find(:first, :conditions => "human_day_approximate = #{row[3]}")
+      if (card_size.nil?())
+        card_size = CardSize.new({:name => "Imported Size", :human_day_approximate => row[3]})
+        created_objects<<(card_size)
+      end
+      card.estimated_size=(card_size)
+    end
+    if (! row[4].nil?()) && (row[4].strip() != "")
+      priority = Priority.find(:first, :conditions => "rank = #{row[4]}")
+      if (priority.nil?())
+        priority = Priority.new({:name => row[4]})
+        priority[:rank]=(row[4])
+        created_objects<<(priority)
+      end
+      card.priority=(priority)
+    end
+    if (! row[5].nil?()) && (row[5].strip() != "")
+      functional_set_names = row[5].split("|").collect {| name | name.strip()}
+      functional_sets = FunctionalSet.find(:all, :conditions => "name IN (#{functional_set_names.collect{|name| "\"#{name}\""""}.join(",")})")
+      missing_functional_sets = functional_set_names - functional_sets.collect {|functional_set| functional_set.name()}
+      for name in missing_functional_sets
+        functional_set = FunctionalSet.new({:name => name})
+        created_objects<<(functional_set)
+        functional_sets<<(functional_set)
+      end
+      card.functional_sets=(functional_sets)
+    end
+    
+    if (! row[6].nil?())  && (row[6].strip() != "")
+      milestone_name = row[6].strip()
+      milestone = Milestone.find(:first, :conditions => "name = \"#{milestone_name}\"")
+      if (milestone.nil?())
+        milestone = Milestone.new({:name => milestone_name, :description => "Imported Milestone"})
+        created_objects<<(milestone)
+      end
+      card.target_milestone=(milestone)
+    end
+    created_objects<<(card) unless (has_errors)
+    created_objects.clear() if (has_errors)
+    return created_objects
+  end
+end