RubyGems - adva - Versions diffs - 0.0.1 - Mend

adva 0.0.1

Files changed (1756) hide show

data/adva_user/app/views/admin/users/_sidebar.html.erb ADDED

@@ -0,0 +1,8 @@
+<% content_for :sidebar do %>
+	<div class="tabs">
+		<div class="tab active">
+		  <%= gravatar_img(@user) %>
+	  </div>
+  </div>
+<% end -%>

data/adva_user/app/views/admin/users/edit.html.erb ADDED

@@ -0,0 +1,7 @@
+<h2><%= t(:'adva.users.titles.edit') %></h2>
+<%= form_for [:admin, @site, @user] do |f| -%>
+  <%= render :partial => 'form', :locals => {:f => f} %>
+<% end -%>
+<%= render :partial => 'sidebar' %>

data/adva_user/app/views/admin/users/index.html.erb ADDED

@@ -0,0 +1,13 @@
+<ul id="users">
+  <% @users.each do |user| %>
+		<li>
+		  <%= gravatar_img(user) %>
+		  <h4><%= link_to user.name, [:admin, @site, user] %></h4>
+		  <p><%= user.email %></p>
+		  <p class="actions">
+		    <%= link_to t(:'adva.links.edit'), [:edit, :admin, @site, user], :class => 'edit' %>
+        <%= link_to t(:'adva.links.delete'), [:admin, @site, user], :class => 'delete', :data => { :confirm => t(:'adva.users.confirm_delete') }, :method => :delete %>
+		  </p>
+		</li>
+	<% end %>
+</ul>

data/adva_user/app/views/admin/users/new.html.erb ADDED

@@ -0,0 +1,5 @@
+<h2><%= t(:'adva.users.titles.new') %></h2>
+<%= form_for [:admin, @site, @user] do |f| -%>
+  <%= render :partial => 'form', :locals => {:f => f} %>
+<% end -%>

data/adva_user/app/views/admin/users/show.html.erb ADDED

@@ -0,0 +1,27 @@
+<h2><%= @user.name %></h2>
+<h3><%= t(:'adva.common.details') %></h3>
+<p>
+  <%= t(:'adva.users.labels.email') %>:
+  <%= @user.email %>
+</p>
+<% if @user.homepage %>
+  <p>
+    <%= t(:'adva.users.labels.url') %>:
+    <%= link_to @user.homepage, @user.homepage %>
+  </p>
+<% end %>
+<h3><%= t(:'adva.common.events') %></h3>
+<p>
+  <%= t(:'adva.users.labels.created_at') %>:
+  <%= @user.created_at %>
+</p>
+<p>
+  <%= t(:'adva.users.labels.updated_at') %>:
+  <%= @user.updated_at %>
+</p>
+<%= render :partial => 'sidebar' %>

data/adva_user/app/views/layouts/login.html.erb ADDED

@@ -0,0 +1,24 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+ 		<meta name="generator" content="adva-cms - Open source content management platform" />
+    <title>adva-cms: <%= controller.controller_name %></title>
+    <%= stylesheet_link_tag "adva_cms/admin" %>
+    <%= javascript_include_tag "adva_cms/application" %>
+    <%= yield :head %>
+  </head>
+  <body>
+    <div id="header">
+    </div>
+    <div class="main">
+      <div id="flashes"><%= render :partial => 'shared/flash' %></div>
+      <div id="content">
+        <%= yield %>
+      </div>
+    </div>
+  </body>
+</html>

data/adva_user/app/views/password/edit.html.erb ADDED

@@ -0,0 +1,14 @@
+<h2><%= t(:'adva.passwords.titles.edit') %></h2>
+<p><%= params[:token].blank? ? t(:'adva.passwords.info.please_enter_new_password_and_token') : t(:'adva.passwords.info.please_enter_new_password') %></p>
+<%= form_for 'user', :url => password_path, :html => { :method => :put } do |f| %>
+  <% f.field_set do %>
+		<%= label_tag(t(:'adva.passwords.attributes.token')) + text_field_tag('token') unless current_user %>
+		<%= f.password_field :password, :label => :"adva.users.attributes.new_password" %>
+  <% end %>
+  <% f.buttons do %>
+		<%= submit_tag t(:'adva.common.save') %>
+	<% end %>
+<% end %>

data/adva_user/app/views/password/new.html.erb ADDED

@@ -0,0 +1,13 @@
+<h2><%= t(:'adva.passwords.titles.new') %></h2>
+<%= form_tag password_path do %>
+  <fieldset>
+    <p><%= t(:'adva.passwords.info.please_enter_email_to_reset_password') %></p>
+		<%= label_tag 'user[email]', t(:"adva.users.attributes.email") %>
+	  <%= text_field_tag 'user[email]' %>
+	</fieldset>
+  <% buttons do %>
+    <%= submit_tag t(:'adva.passwords.links.reset') %>
+  <% end %>
+<% end %>

data/adva_user/app/views/password_mailer/reset_password_email.html.erb ADDED

	@@ -0,0 +1,3 @@
1	+ <%= t(:'adva.passwords.notifications.reset_password.body', :name => @user.name, :link => @reset_link, :token => @token) %>
2	+
3	+

data/adva_user/app/views/password_mailer/updated_password_email.html.erb ADDED

	@@ -0,0 +1 @@
1	+ <%= t(:'adva.passwords.notifications.password_updated.body', :name => @user.name) %>

data/adva_user/app/views/session/new.html.erb ADDED

@@ -0,0 +1,17 @@
+<div id="centered_box">
+  <%= form_for @user, :url => session_path, :html => {:id => 'login'} do |f| %>
+    <%= hidden_field_tag :return_to, params[:return_to] if params[:return_to] %>
+  	<fieldset>
+  		<%= f.text_field :email, :class => 'big', :label => "Email" %>
+  		<%= f.password_field :password, :class => 'big', :label => "Password" %>
+  		<%= check_box_tag 'user[remember_me]', 1, @remember_me, :id => 'user_remember_me' %>
+			<%= label_tag :user_remember_me, t(:'adva.session.labels.remember_me'), :class => 'inline light' %>
+    </fieldset>
+  	<fieldset>
+  	  <%= submit_tag "Login", :id => 'commit' %> <%= t(:'adva.common.connector.or')%>
+  	  <%= link_to t(:'adva.passwords.titles.new'), new_password_path %>
+    </fieldset>
+  <% end %>
+</div>

data/adva_user/config/initializers/menus.rb ADDED

@@ -0,0 +1,25 @@
+module Menus
+  module Admin
+    class Users < Menu::Group
+      define do
+        id :main
+        parent Sites.new.build(scope).find(:users)
+        menu :left, :class => 'left' do
+          item :users, :action => :index, :resource => [@site, :user]
+        end
+        menu :actions, :class => 'actions' do
+          activates object.parent.find(:users)
+          item :new, :action => :new, :resource => [@site, :user]
+          if @user && !@user.new_record?
+            item :show,   :url => admin_site_user_path(@site, @user)
+            item :edit,   :url => edit_admin_site_user_path(@site, @user)
+            # item :show,   :action  => :show, :resource => @user
+            # item :edit,   :action  => :edit, :resource => @user
+            item :delete, :content => link_to("Delete", [:admin, @site, @user], :method => :delete)
+          end
+        end
+      end
+    end
+  end
+end

data/adva_user/config/routes.rb ADDED

@@ -0,0 +1,14 @@
+Rails.application.routes.draw do
+  get "login" => "session#new"
+  delete "logout" => "session#destroy"
+  resource :session,     :controller => "session"
+  resource :password,    :controller => "password"
+  namespace :admin do
+    resources :users
+    resources :sites do
+      resources :users
+    end
+  end
+end

data/adva_user/db/migrate/20080402000001_create_users_table.rb ADDED

@@ -0,0 +1,33 @@
+class CreateUsersTable < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string     :first_name,       :limit => 40
+      t.string     :last_name,        :limit => 40
+      t.string     :email,            :limit => 100
+      t.string     :homepage
+      t.string     :about
+      t.string     :signature
+      t.string     :password_hash,    :limit => 40
+      t.string     :password_salt,    :limit => 40
+      t.string     :ip
+      t.string     :agent
+      t.string     :referer
+      t.string     :remember_me,      :limit => 40
+      t.string     :token_key,        :limit => 40
+      t.datetime   :token_expiration
+      t.boolean    :anonymous,        :default => false
+      t.timestamps
+      t.datetime   :verified_at
+      t.datetime   :deleted_at
+    end
+  end
+  def self.down
+    drop_table :users
+  end
+end

data/adva_user/db/migrate/20080402000005_create_memberships_table.rb ADDED

@@ -0,0 +1,13 @@
+class CreateMembershipsTable < ActiveRecord::Migration
+  def self.up
+    create_table :memberships, :force => true do |t|
+      t.references :site
+      t.references :user
+      t.timestamps
+    end
+  end
+  def self.down
+    drop_table :memberships
+  end
+end

data/adva_user/db/migrate/20090625124502_create_accounts.rb ADDED

@@ -0,0 +1,13 @@
+class CreateAccounts < ActiveRecord::Migration
+  def self.up
+    create_table :accounts do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+  def self.down
+    drop_table :accounts
+  end
+end

data/adva_user/db/migrate/20090625133231_add_account_to_user.rb ADDED

@@ -0,0 +1,10 @@
+class AddAccountToUser < ActiveRecord::Migration
+  def self.up
+    add_column  :users, :account_id, :integer
+    add_index   :users, :account_id
+  end
+  def self.down
+    remove_column :users, :account_id
+  end
+end

data/adva_user/lib/action_controller/authenticate_anonymous.rb ADDED

@@ -0,0 +1,70 @@
+# Auto-registers and re-authenticates anonymous users based on a single token
+# that's stored in the session. This is for anonymous posting of blog comments,
+# editing wikipages etc. and allows to do such things as:
+#
+# * store user information in the user table (which keeps the model and db
+#   structure clean) and
+# * allow users to (e.g.) edit their comment based on this anonymous login.
+module ActionController
+  module AuthenticateAnonymous
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    module ClassMethods
+      def authenticates_anonymous_user
+        return if authenticates_anonymous_user?
+        include InstanceMethods
+        alias_method_chain :current_user, :anonymous
+        alias_method_chain :authenticated?, :anonymous
+      end
+      def authenticates_anonymous_user?
+        included_modules.include? InstanceMethods
+      end
+    end
+    module InstanceMethods
+      def current_user_with_anonymous
+        @current_user ||= (current_user_without_anonymous || login_or_register_anonymous)
+      end
+      def authenticated_with_anonymous?
+        !!current_user and !current_user.anonymous?
+      end
+      def login_or_register_anonymous
+        anonymous = try_login_anonymous || User.anonymous
+        anonymous = register_or_update_anonymous anonymous if params[:user]
+        login_anonymous! anonymous if anonymous
+        anonymous
+      end
+      def try_login_anonymous
+        # try to authenticate if token is present
+        validate_token User, session[:anonymous_token] if session[:anonymous_token]
+      end
+      def register_or_update_anonymous(anonymous)
+        # if :name and :email params are passed either register a new Anonymous or update the existing one
+        anonymous.update_attributes params[:user].merge(request_info)
+        anonymous
+      end
+      def login_anonymous!(anonymous)
+        # set a new session token and expiration
+        token = anonymous.assign_token('anonymous', 3.hour.from_now)
+        anonymous.save
+        session[:anonymous_token] = "#{anonymous.id};#{token}"
+        cookies[:aid] = anonymous.id.to_s unless anonymous.new_record?
+      end
+      def request_info
+        { :ip      => request.env["REMOTE_ADDR"],
+          :agent   => request.env["HTTP_USER_AGENT"],
+          :referer => request.env["HTTP_REFERER"] }
+      end
+    end
+  end
+end

data/adva_user/lib/action_controller/authenticate_user.rb ADDED

@@ -0,0 +1,201 @@
+module ActionController
+  # Module automatically mixed into the all controllers making the
+  # application of authentication easy. See
+  # Login::ControllerIntegration::ClassMethods for how to apply
+  # authentication.
+  module AuthenticateUser
+    def self.included(target)
+      target.extend(ClassMethods)
+      target.send(:include, InstanceMethods)
+      target.helper_method(:logged_in?, :authenticated?)
+    end
+    # Methods available as macro-style methods on any controller
+    module ClassMethods
+      # Sets up the controller so that authentication is required. If
+      # the user is not authenticated then they will be redirected to
+      # the login screen.
+      #
+      # The page requested will be saved so that once the login has
+      # occured they will be sent back to the page they first
+      # requested. If no page was requested (they went to the login
+      # page directly) then they will be directed to profiles/home
+      # after login which is a placeholder for the app to override.
+      #
+      # Options given are passed directly to the before_filter method
+      # so feel free to provide :only and :except options.
+      def authentication_required
+        before_filter :require_authentication
+      end
+      # Will remove authentication from certain actions. Options given
+      # are passed directly to skip_before_filter so feel free to use
+      # :only and :except options.
+      #
+      # This method is useful in cases where you have locked down the
+      # entire application by putting authentication_required in your
+      # ApplicationController but then want to open an action back up
+      # in a specific controller.
+      def no_authentication_required
+        skip_before_filter :require_authentication
+      end
+    end
+    # Methods callable from within actions
+    module InstanceMethods
+      def authenticate_user(credentials)
+        User.authenticate(credentials).tap do |user|
+          if user
+            # prevent session hijacking - unnecessary according to http://dev.rubyonrails.org/ticket/10108
+            # reset_session_except :return_location
+            session[:uid] = user.id
+            set_user_cookie!(user)
+          end
+        end
+      end
+      # Will retrieve the current_user. Will not force a login but
+      # simply load the current user if a person is logged in. If
+      # you need the user object loaded with extra options (such as
+      # eager loading) then create a private method called
+      # "user_find_options" on your controller that returns a hash
+      # of the find options you want.
+      #
+      # This method will also inform the models of the current user
+      # if the current user is logged in and the "User" class responds
+      # to the class method current_user=. This is a nice way to
+      # communciate the current user down to the model level for
+      # model-level security. This means you will want to call this
+      # method at least once before using the model-level security.
+      # Usually you will call it in a before filter. This method is
+      # called automatically when authentication_required is applied to
+      # an action.
+      def current_user
+        @current_user ||= begin
+          # Check for session[:uid] here? That would mean that for token auth the
+          # user always needs to be logged out (e.g. in UserController#create).
+          # Looks a bit more robust this way:
+          try_login
+          if session && session[:uid]
+            user = find_current_user
+            set_user_cookie!(user)
+            user
+          end
+        end
+      end
+      def authenticated?
+        !!current_user
+      end
+      alias :logged_in? :authenticated?
+      # killed this because it's just the wrong way to do it
+      #
+      # # Will store the current params so that we can return here on
+      # # successful login. If you want to redirect to the login yourself
+      # # (perhaps you are applying your own security instead of just
+      # # determining if the user is logged in) then you will want to
+      # # call this before issuing your redirect to the login screen.
+      # def store_return_location
+      #   session[:return_location] = params
+      # end
+      private
+        # Will actually test to see if the user is authorized
+        def require_authentication
+          # No matter what the app does a user can always login, forgot
+          # password and register. The controllers provided by this
+          # plugin alreaddy have these controllers/actions on an
+          # exception list but this prevents a mistake an overridden
+          # controller from preventing the normal login behavior.
+          %w(session password user).each do |c|
+  	        %w(new create).each do |a|
+              return if (controller_name == c) && (action_name == a)
+            end
+  	      end
+          # If we cannot get the current user store the requested page
+          # and send them to the login page.
+          if current_user.nil? or current_user.anonymous?
+            redirect_to login_url(:return_to => request.url) and false
+          end
+        end
+        def logout
+          reset_session
+          forget_me!
+        end
+        def forget_me!
+          cookies[:remember_me] = nil
+          cookies[:uid] = nil
+          cookies[:uname] = nil
+        end
+        def remember_me!
+          token = current_user.assign_token!('remember me')
+          cookies[:remember_me] = { :value => "#{current_user.id};#{token}", :expires => 10.years.from_now }
+        end
+        def set_user_cookie!(user = current_user)
+          if user
+            cookies[:uid] = user.id.to_s
+            cookies[:uname] = user.name
+          end
+        end
+        # There are a few ways that a user can login without going through
+        # a login screen. These methods all rely on authenticating with
+        # the information given in the request. If any of these methods
+        # are successful then session[:uid] will be set with the current
+        # user id and current_user will return the current user
+        def try_login
+          if user = http_auth_login || validation_login || remember_me_login
+            session[:uid] = user.id
+          end
+        end
+        # Will attempt to authenticate with HTTP Auth. HTTP Auth will not
+        # be required. We are just checking if it is provided mainly for
+        # RESTful requests.
+        def http_auth_login
+          # FIXME: Implement
+        end
+        # Will use the URL param :token to see if we can do a token
+        # authentication.
+        def validation_login
+          validate_token User, params[:token]
+        end
+        # Will check for a :remember_me cookie for a token that will
+        # authenticate the user.
+        def remember_me_login
+          validate_token User, cookies[:remember_me]
+        end
+        # The tokens are stored in various places as id;token. This method
+        # will split that out and validate it. If everything is successful
+        # then the user object is returned. Otherwise nil is returned.
+        # The full token should be passed in.
+        def validate_token(klass, token, options = {})
+          return nil if token.blank?
+          return nil unless token =~ /\;/
+          uid, token = token.split ';'
+          if object = klass.find_by_id(uid)
+            return object if object.authenticate(token)
+          end
+          nil
+        end
+        def find_current_user
+          User.find_by_id(session[:uid])
+        end
+    end
+  end
+end