muck-users 0.1.0

data/app/views/users/edit.html.erb

@@ -0,0 +1,45 @@
+<div id="edit-user" class="common-form">
+  <h1><%= t('muck.users.update_user') %></h1>
+
+  <% custom_form_for @user, :url => user_path(@user), :html => {:id => "edit-user-form", :name => 'edit-user-form', :method => :put, :multipart => true } do |f| -%>
+
+   <%= output_errors(t('muck.users.problem_editing_account'), {:class => 'help-box'}, @user) %>
+
+   <%= f.text_field :email, { :label => t('muck.users.email_address'),
+                               :tip => t('muck.users.email_help') } -%>
+    <%= f.text_field :first_name, { :label => t('muck.users.first_name') } %>
+    <%= f.text_field :last_name, { :label => t('muck.users.last_name') } %>
+    <%= image_tag @user.photo.url(:thumb) %>
+    <%= f.file_field :photo, { :label => t('muck.users.upload_photo') } %>
+		<div class="button form-row">
+	  	<%= f.submit t('muck.general.save') %>
+	  </div>
+	  <%= hidden_field_tag :redirect_to, edit_user_path(@user) %>
+	<% end %>
+	
+</div>
+
+<div id="change-password" class="common-form">
+  <h2><%= t('muck.users.change_password') %></h2>
+  <% custom_form_for @user, :url => user_path(@user), :html => { :id => "change-password-form", :name => 'change-password-form', :method => :put } do |f| %>
+    <%= f.password_field :password, { :label => t('muck.users.password'),
+                                      :tip => t('muck.users.password_help')} -%>
+    <%= f.password_field :password_confirmation, { :label => t('muck.users.confirm_password'),
+                                  		             :tip => t('muck.users.password_confirmation_help') } -%>
+  	<div class="button form-row">
+  	  <%= submit_tag t('muck.users.change_password'), :class => 'button' %>
+  	</div>
+  	<%= hidden_field_tag :redirect_to, edit_user_path(@user) %>
+  <% end -%>
+</div>
+
+<% if GlobalConfig.let_users_delete_their_account -%>
+  <div id="delete-account" class="common-form">
+    <% custom_form_for :user, :url => users_path, :html => {:id => "delete-user-form", :name => 'delete-user-form', :method => :delete, :confirm => t("users.confirm_delete_account")} do |f| -%>
+  		<h2><%= t('muck.users.remove_my_account') %></h2>
+  		<div class="button form-row">
+  	  	<%= f.submit t('muck.general.delete_my_account') %>
+  	  </div>
+    <% end -%>
+  </div>
+<% end -%>

data/app/views/users/new.html.erb

@@ -0,0 +1,51 @@
+<div id="registration" class="common-form">
+	<h1><%= t('muck.users.register_account', :application_name => GlobalConfig.application_name) %></h1>
+	<p><%= t('muck.users.already_registered') %> <a href="<%=login_url%>"><%= t('muck.users.sign_in_now') %></a></p>
+
+	<% custom_form_for :user, :url => users_path, :html => {:id => "register-user-form", :name => 'register-user-form'} do |f| -%>
+	
+		<%= output_errors(t('muck.users.problem_creating_account'), {:class => 'help-box'}, @user) %>
+ 		
+ 		<%= f.text_field :login, { :label => t('muck.users.choose_member_name'), 
+ 		                           :extra_html => '<span id="username-availibility" class="availability"></span>', 
+ 		                           :tip => t('muck.users.username_help'),
+ 		                           :required_label => t('muck.users.username') } -%>
+ 		<%= f.text_field :email, { :label => t('muck.users.email_address'),
+ 		                           :tip => t('muck.users.email_help'),
+ 		                           :extra_html => '<span id="email-availibility" class="availability"></span>' } -%>
+		<%= f.password_field :password, { :label => t('muck.users.password'),
+		                                  :tip => t('muck.users.password_help')} -%>
+		<%= f.password_field :password_confirmation, { :label => t('muck.users.confirm_password'),
+                                                   :tip => t('muck.users.password_confirmation_help') } -%>
+	  <%= f.file_field :photo, { :label => t('muck.users.upload_photo') } %>
+		<% if GlobalConfig.use_recaptcha -%>
+		<div class="recaptcha">
+			<%= recaptcha_tags %>
+		</div>
+		<% end -%>
+		
+		<div class="button form-row">
+	  	<%= f.submit t('muck.users.sign_up_now') %>
+	  </div>
+	  
+	<% end %>
+</div>
+
+<% content_for :javascript do -%>
+  jQuery("#user_login").blur(function(){
+    jQuery.post("is_login_available",{ user_login:jQuery(this).val() } ,function(data){
+    	jQuery("#username-availibility").html(data);    
+    }); 
+  });
+	jQuery("#user_login").keydown(function() { 
+		jQuery("#username-availibility").html(''); 
+	});
+	jQuery("#user_email").blur(function(){
+    jQuery.post("is_email_available",{ user_email:jQuery(this).val() } ,function(data){
+    	jQuery("#email-availibility").html(data);    
+    }); 
+  });
+	jQuery("#user_email").keydown(function() { 
+		jQuery("#email-availibility").html(''); 
+	});
+<% end -%>

data/app/views/users/show.html.erb

@@ -0,0 +1,4 @@
+<div id="user" class="common-content">
+  <h1><%= I18n.t('muck.users.my_dashboard') %></h1>
+  <%= h @user.login %>
+</div>

data/app/views/users/welcome.html.erb

@@ -0,0 +1,4 @@
+<div id="welcome" class="common-content">
+  Welcome to muck.  This system provides the basic components to help you build your website.
+  <%= link_to 'View Your Account', user_path(current_user) %>
+</div>

data/config/muck_users_routes.rb

@@ -0,0 +1,56 @@
+ActionController::Routing::Routes.draw do |map|
+  
+  # users
+  map.resources :users, :controller => 'muck/users',
+                        :member => { :enable => :put, :welcome => :get, :activation_instructions => :get }, 
+                        :collection => { :is_login_available => :post, :is_email_available => :post }
+  
+  map.with_options(:controller => 'muck/users') do |users| 
+    users.signup "/signup",  :action => 'new'
+    users.signup_complete "/users/signup_complete/:id",  :action => 'welcome'
+    users.activation_complete "/users/activation_complete/:id", :action => 'welcome'
+    users.signup_complete_activation_required '/signup_complete_activate/:id', :action => 'activation_instructions'
+    users.is_login_available '/is_login_available', :action => 'is_login_available'
+    users.is_email_available '/is_email_available', :action => 'is_email_available'
+    users.account "account", :action => 'show'
+  end
+  
+  # activations
+  map.resources :activations, :controller => 'muck/activations'
+  map.with_options(:controller => 'muck/activations') do |activations|
+    activations.activate '/activate/:activation_code', :action => 'new'
+  end
+  
+  # passwords
+  map.resource :password_resets, :controller => 'muck/password_resets'
+  
+  map.with_options(:controller => 'muck/password_resets') do |password_resets|
+    password_resets.forgot_password "/forgot_password", :action => 'new'
+    password_resets.reset_password "/reset_password/:id", :action => 'edit'
+  end
+
+  # username
+  map.resource :username_request, :controller => 'muck/username_request'
+
+  map.with_options(:controller => 'muck/username_request') do |username_request|
+    username_request.forgot_username "/forgot_username", :action => 'new'
+  end
+  
+  # sessions
+  map.resource :user_session, :controller => 'muck/user_sessions'
+  map.with_options(:controller => 'muck/user_sessions') do |user_sessions|
+    user_sessions.login "/login", :action => 'new'
+    user_sessions.logout "/logout", :action => 'destroy'
+    user_sessions.signup_complete_login_required '/signup_complete_login/:id', :action => 'new'
+  end
+
+  # admin
+    map.namespace :admin do |a|
+      a.resources :users, :controller => 'muck/users', :collection => { :inactive => :get, :inactive_emails => :get, :activate_all => :get, :search => :post, :ajax_search => :post }
+      a.resources :roles, :controller => 'muck/roles'
+      a.resources :permissions, :controller => 'muck/permissions'
+    end
+  
+  # public (replace with something more useful in your application)
+  map.public_user '/profiles/:id', :controller => 'default', :action => 'index'
+end

data/db/migrate/20090320174818_create_muck_permissions_and_roles.rb

@@ -0,0 +1,16 @@
+class CreateMuckPermissionsAndRoles < ActiveRecord::Migration
+  
+  create_table "permissions", :force => true do |t|
+    t.integer  "role_id",    :null => false
+    t.integer  "user_id",    :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "roles", :force => true do |t|
+    t.string   "rolename"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+  
+end

data/db/migrate/20090512013727_add_photo_to_user.rb

@@ -0,0 +1,13 @@
+class AddPhotoToUser < ActiveRecord::Migration
+  def self.up
+    add_column :users, :photo_file_name, :string
+    add_column :users, :photo_content_type, :string
+    add_column :users, :photo_file_size, :integer
+  end
+
+  def self.down
+    remove_column :users, :photo_file_name
+    remove_column :users, :photo_content_type
+    remove_column :users, :photo_file_size
+  end
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/action_controller/authentic_application.rb

@@ -0,0 +1,213 @@
+module ActionController
+    
+  module AuthenticApplication
+    
+    # Module automatically mixed into the all controllers
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+      end
+      # Inclusion hook to make #current_user and #logged_in?, etc available as ActionView helper methods.
+      base.send :helper_method, :current_user_session, :current_user, :logged_in?, :admin?, :is_me?, :is_owner?
+      base.send :filter_parameter_logging, :password, :password_confirmation
+    end
+        
+    module InstanceMethods
+      
+      protected
+      
+      # Returns true or false if the user is logged in.
+      def logged_in?
+        !current_user.blank?
+      end
+
+      def current_user_session
+        return @current_user_session if defined?(@current_user_session)
+        @current_user_session = UserSession.find
+      end
+
+      def current_user
+        return @current_user if defined?(@current_user)
+        @current_user = current_user_session && current_user_session.record
+      end
+
+      def login_required
+        unless logged_in?
+          store_location
+          flash[:notice] = I18n.t('muck.users.login_requred')
+          access_denied
+        end
+      end
+
+      def not_logged_in_required
+        if logged_in?
+          store_location
+          flash[:notice] = t('muck.users.logout_required')
+          enforce_logout_required
+        end
+      end
+      
+      def check_role(role)
+        unless logged_in? && current_user.has_role?(role)
+          if logged_in?
+            permission_denied
+          else
+            store_referer
+            access_denied
+          end
+        end
+      end
+
+      def admin?
+        logged_in? && current_user.admin?
+      end    
+
+      # check to see if the current user is the owner of the specified object
+      def is_owner?(obj)
+        obj.user_id == current_user.id
+      end
+      
+      def is_owner?(user, user_id)
+        user.id == user_id
+      end
+      
+      # check to see if the given user is the same as the current user
+      def is_me?(user)
+        user == current_user
+      end
+
+      # checks permissions on an object.  Redirects if the current user
+      # doesn't own it or have admin rights
+      def protect_owner(obj)
+        if is_owner?(obj) || admin?
+          true
+        else
+          permission_denied
+          false
+        end
+      end
+
+      # allow or deny access depending on options specified
+      def allowed_access?(options)
+        if !options[:owner].nil? && !options[:object_user_id].nil?
+          return true if is_owner?(options[:owner], options[:object_user_id])
+        end
+
+        options[:permit_roles].each do |role|
+          return true if current_user.has_role?(role)
+        end
+
+        # access denied
+        permission_denied
+        false 
+      end
+
+      def can_access?(user, object, roles, &block)
+        if logged_in? && user.is_in_role?(event, roles)
+          content = capture(&block)
+          concat(content, block.binding)
+        end
+      end
+
+      def is_mine?(user, &block)
+        if logged_in? && (current_user.id == user.id)
+          content = capture(&block)
+          concat(content, block.binding)
+        end 
+      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 |format|
+          format.html do
+            store_location
+            flash[:error] = I18n.t('muck.users.access_denied')
+            redirect_to login_path
+          end
+          format.xml do
+            request_http_basic_authentication 'Web Password'
+          end
+        end
+      end
+
+      def permission_denied      
+        respond_to do |format|
+          format.html do
+            #Put your domain name here ex. http://www.example.com
+            domain_name = GlobalConfig.application_base_url
+            http_referer = session[:refer_to]
+            if http_referer.nil?
+              store_referer
+              http_referer = ( session[:refer_to] || domain_name )
+            end
+            flash[:error] = I18n.t('muck.users.permission_denied')
+            #The [0..20] represents the 21 characters in http://localhost:3000
+            #You have to set that to the number of characters in your domain name
+            if http_referer[0..domain_name.length] != domain_name  
+              session[:refer_to] = nil
+              redirect_to root_path
+            else
+              redirect_to_referer_or_default(root_path)  
+            end
+          end
+          format.xml do
+            headers["Status"]           = "Unauthorized"
+            headers["WWW-Authenticate"] = %(Basic realm="Web Password")
+            render :text => I18n.t('muck.users.permission_denied'), :status => '401 Unauthorized'
+          end
+          format.js do
+            render :text => I18n.t('muck.users.permission_denied')
+          end
+        end
+      end
+
+      def enforce_logout_required
+        respond_to do |format|
+          format.html do
+            redirect_to current_user
+          end
+        end
+      end
+      
+      # Store the URI of the current request in the session.
+      # We can return to this location by calling #redirect_back_or_default.
+      # Only store html requests so we don't redirect a user back to and rss or xml feed
+      def store_location
+        if request.format == :html
+          session[:return_to] = request.request_uri
+        end
+      end
+
+      def store_referer
+        session[:refer_to] = request.env["HTTP_REFERER"]
+      end
+
+      # Redirect to the URI stored by the most recent store_location call or
+      # to the passed default.
+      def redirect_back_or_default(default)
+        redirect_to(session[:return_to] || default)
+        session[:return_to] = nil
+      end
+
+      def redirect_to_referer_or_default(default)
+        redirect_to(session[:refer_to] || default)
+        session[:refer_to] = nil
+      end
+
+      # Called from #current_user.  Now, attempt to login by basic authentication information.
+      # def login_from_basic_auth
+      #   authenticate_with_http_basic do |username, password|
+      #     self.current_user = User.authenticate(username, password)
+      #   end
+      # end
+
+    end
+  end
+end

data/lib/active_record/acts/muck_user.rb

@@ -0,0 +1,192 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module MuckUser #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def acts_as_muck_user(options = {})
+
+          has_many :permissions
+          has_many :roles, :through => :permissions
+
+          named_scope :by_newest, :order => "created_at DESC"
+          named_scope :active, :conditions => "activated_at IS NOT NULL"
+          named_scope :inactive, :conditions => "activated_at IS NULL"    
+          named_scope :recent, lambda { { :conditions => ['created_at > ?', 1.week.ago] } }
+          
+          email_name_regex  = '[\w\.%\+\-]+'.freeze
+          domain_head_regex = '(?:[A-Z0-9\-]+\.)+'.freeze
+          domain_tld_regex  = '(?:[A-Z]{2}|com|org|net|edu|gov|mil|biz|info|mobi|name|aero|jobs|museum)'.freeze
+          email_regex       = /\A#{email_name_regex}@#{domain_head_regex}#{domain_tld_regex}\z/i
+          
+          has_attached_file :photo, 
+                            :styles => { :medium => "300x300>",
+                                         :thumb => "100x100>",
+                                         :icon => "50x50>" },
+                            :default_url => "/images/profile_default.jpg"
+                            
+          class_eval <<-EOV
+            validates_format_of :login, :with => /^[a-z0-9-]+$/i, :message => 'may only contain letters, numbers or a hyphen.'
+            validates_format_of :email, :with => email_regex, :message => 'does not look like a valid email address.'
+            
+            # prevents a user from submitting a crafted form that bypasses activation
+            attr_protected :crypted_password, :password_salt, :persistence_token, :single_access_token, :perishable_token, :login_count,
+                           :failed_login_count, :last_request_at, :last_login_at, :current_login_at, :current_login_ip, :last_login_ip, 
+                           :terms_of_service, :time_zone, :disabled_at, :activated_at, :created_at, :updated_at, :photo_file_name, 
+                           :photo_content_type, :photo_file_size
+          EOV
+
+          include ActiveRecord::Acts::MuckUser::InstanceMethods
+          extend ActiveRecord::Acts::MuckUser::SingletonMethods
+          
+        end
+      end
+
+      # class methods
+      module SingletonMethods
+        def do_search( query )           
+           User.find(:all, :conditions => [ "email LIKE ? OR first_name LIKE ? OR last_name LIKE ?", '%' + query + '%', '%' + query + '%', '%' + query + '%' ])
+        end
+        
+        def inactive_count
+          User.count :conditions => "activated_at is null"
+        end
+
+        def activate_all
+          User.update_all("activated_at = '#{Time.now}'", 'activated_at IS NULL')
+        end            
+        
+        # Finds the user with the corresponding activation code, activates their account and returns the user.
+        #
+        # Raises:
+        #  +User::ActivationCodeNotFound+ if there is no user with the corresponding activation code
+        #  +User::AlreadyActivated+ if the user with the corresponding activation code has already activated their account
+        def find_and_activate!(activation_code)
+          raise ArgumentError if activation_code.nil?
+          user = find_by_activation_code(activation_code)
+          raise ActivationCodeNotFound if !user
+          raise AlreadyActivated.new(user) if user.active?
+          user.send(:activate!)
+          user
+        end
+        
+        # checks to see if a given login is already in the database
+        def login_exists?(login)
+          if User.find_by_login(login).nil?
+            false
+          else
+            true
+          end
+        end
+
+        # checks to see if a given email is already in the database
+        def email_exists?(email)
+          if User.find_by_email(email).nil?
+            false
+          else
+            true
+          end
+        end
+          
+      end
+      
+      # All the methods available to a record that has had <tt>acts_as_muck_user</tt> specified.
+      module InstanceMethods
+        
+        def deliver_welcome_email
+          MuckUserMailer.deliver_welcome_notification(self) if GlobalConfig.send_welcome
+        end
+        
+        def deliver_activation_confirmation!
+          reset_perishable_token!
+          MuckUserMailer.deliver_activation_confirmation(self)
+        end
+        
+        def deliver_activation_instructions!
+          reset_perishable_token!
+          MuckUserMailer.deliver_activation_instructions(self)
+        end
+        
+        def deliver_password_reset_instructions!
+          if self.active?
+            reset_perishable_token!  
+            MuckUserMailer.deliver_password_reset_instructions(self)
+          else
+            MuckUserMailer.deliver_password_not_active_instructions(self)
+          end
+        end
+
+        def deliver_username_request!
+          MuckUserMailer.deliver_username_request(self)
+        end
+        
+        
+        # Since password reset doesn't need to change openid_identifier,
+        # we save without block as usual.
+        def reset_password!(user)
+          self.password = user[:password]
+          self.password_confirmation = user[:password_confirmation]
+          save
+        end
+                
+        def has_role?(rolename)
+          @roles ||= self.roles.map{|role| role.rolename}
+          return false unless @roles
+          @roles.include?(rolename)
+        end
+
+        def admin?
+          has_role?('administrator')
+        end
+
+        def can_edit?(user)
+          return false if user.nil?
+          self.id == user.id || user.admin?
+        end
+                
+        def to_xml(options = {})
+          options[:except] ||= []
+          options[:except] << :email << :crypted_password << :salt << :remember_token << :remember_token_expires_at << :activation_code
+          options[:except] << :activated_at << :password_reset_code << :enabled << :terms_of_service << :can_send_messages << :identity_url
+          options[:except] << :tmp_password << :protected_profile << :public_profile    
+          super
+        end
+                
+        # Authlogic automatically executes the following methods
+        def active?
+          !activated_at.blank?
+        end
+
+        # def approved?
+        # end
+        # 
+        # def confirmed?
+        # end
+        
+        def activate!
+          self.update_attribute(:activated_at, Time.now.utc)
+        end
+        
+        def short_name
+          CGI::escapeHTML(self.first_name) || self.display_name
+        end
+
+        def full_name
+          if self.first_name.blank? && self.last_name.blank?
+            self.display_name rescue 'Deleted user'
+          else
+            ((CGI::escapeHTML(self.first_name) || '') + ' ' + (CGI::escapeHTML(self.last_name) || '')).strip
+          end
+        end
+
+        def display_name
+          CGI::escapeHTML(self.login)
+        end
+        
+      end 
+    end
+  end
+end

data/lib/muck-users/exceptions.rb

@@ -0,0 +1,5 @@
+class MuckUsersEngine
+  module Exceptions
+    class InvalidPasswordResetCode < StandardError; end
+  end
+end

data/lib/muck-users/initialize_routes.rb

@@ -0,0 +1,8 @@
+class ActionController::Routing::RouteSet
+  def load_routes_with_muck_users!
+    muck_users_routes = File.join(File.dirname(__FILE__), *%w[.. .. config muck_users_routes.rb])
+    add_configuration_file(muck_users_routes) unless configuration_files.include? muck_users_routes
+    load_routes_without_muck_users!
+  end
+  alias_method_chain :load_routes!, :muck_users
+end

data/lib/muck-users/tasks.rb

@@ -0,0 +1,46 @@
+require 'rake'
+require 'rake/tasklib'
+require 'fileutils'
+
+module Disguise
+  class Tasks < ::Rake::TaskLib
+    def initialize
+      define
+    end
+  
+    private
+    def define
+      
+      namespace :muck do
+        namespace :users do
+          desc "Sync files from muck users."
+          task :sync do
+            path = File.join(File.dirname(__FILE__), *%w[.. ..])
+            system "rsync -ruv #{path}/db ."
+            system "rsync -ruv #{path}/public ."
+          end
+
+          desc "Setup default admin user"
+          task :create_admin => :environment do
+            ['administrator'].each {|r| Role.create(:rolename => r) }
+            user = User.new
+            user.login = "admin"
+            user.email = GlobalConfig.admin_email
+            user.password = "asdfasdf"
+            user.password_confirmation = "asdfasdf"
+            user.first_name = "Administrator"
+            user.last_name = "Administrator"
+            user.save
+            user.activate!
+
+            user.roles << Role.find_by_rolename('administrator')
+
+            puts 'created admin user'
+          end
+        end
+      end
+      
+    end
+  end
+end
+Disguise::Tasks.new

data/lib/muck-users.rb

@@ -0,0 +1,7 @@
+require 'muck-users/exceptions'
+
+ActionController::Base.send :include, ActionController::AuthenticApplication
+ActiveRecord::Base.class_eval { include ActiveRecord::Acts::MuckUser }
+ActiveRecord::Base.class_eval { include MuckUsersEngine::Exceptions }
+
+I18n.load_path += Dir[ File.join(File.dirname(__FILE__), '..', 'locales', '*.{rb,yml}') ]