zen 0.1a

data/lib/zen/packages/users/lib/users/liquid/users.rb

@@ -0,0 +1,80 @@
+module Users
+  module Liquid
+    ##
+    # Block that can be used to retrieve a number of users and show their details.
+    # Basic usage of this tag is as following:
+    #
+    # bc. {% users limit="10" offset="5" %}
+    #   {{email}}
+    # {% endusers %}
+    #
+    # Note that this tag will retrieve a list of users, if you want to only retrieve
+    # a single user it's best to use the tag "zen_user" defined under Users::Liquid::User.
+    #
+    # The following keys can be set:
+    #
+    # * limit
+    # * offset
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class Users < ::Liquid::Block
+      include ::Zen::Liquid::General
+      
+      ##
+      # Initializes the class, parses the tag and retrieves the users for the specified tag.
+      #
+      # @author Yorick Peterse
+      # @param  [String] tag_name The name of the tag that was called.
+      # @param  [String] arguments All additional arguments passed as a string.
+      # @param  [String] html The HTML inside the block.
+      # @since  0.1
+      # 
+      def initialize tag_name, arguments, markup
+        super
+        
+        @arguments = {
+          'limit'  => nil,
+          'offset' => nil
+        }
+        
+        @arguments = @arguments.merge(parse_key_values(arguments))
+        @users     = []
+        users      = ::Users::Models::User.limit(@arguments['limit'], @arguments['offset'])
+        
+        users.each do |u|
+          hash = {}
+          
+          u.values.each do |k, v|
+            hash[k.to_s] = v
+          end
+          
+          @users.push(hash)
+        end
+      end
+      
+      ##
+      # Renders the tag
+      #
+      # @author Yorick Peterse
+      # @param  [Object] context The Liquid context for the current tag.
+      # @return [Array]
+      #
+      def render context
+        result = []
+        
+        @users.each do |user|
+          user.each do |k, v|
+            context[k] = v
+          end
+          
+          result << render_all(@nodelist, context)
+        end
+        
+        result << render_all(@nodelist, context) if result.empty?
+        return result
+      end
+    end
+  end
+end

data/lib/zen/packages/users/lib/users/model/access_rule.rb

@@ -0,0 +1,29 @@
+module Users
+  module Models
+    ##
+    # Model that represents a single access rule. This model has the following
+    # relations:
+    #
+    # * users (many to one)
+    # * user groups (many to one)
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class AccessRule < Sequel::Model
+      many_to_one :user, :class => "Users::Models::User"
+      many_to_one :user_group, :class => "Users::Models::UserGroup"
+      
+      ##
+      # Validation rules used when creating or updating an access rule.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def validate
+        validates_presence [:extension, :create_access, :read_access, :update_access, :delete_access]
+        validates_type TrueClass, [:create_access, :read_access, :update_access, :delete_access]
+      end
+    end
+  end
+end

data/lib/zen/packages/users/lib/users/model/user.rb

@@ -0,0 +1,96 @@
+module Users
+  module Models
+    ##
+    # Model that represents the very important user. This model
+    # can be used for both CRUD actions as well as authenticating a user.
+    # Passwords are encrypted using Bcrypt using the Ruby Bcrypt gem.
+    #
+    # This model has the following relations:
+    #
+    # * user groups (many to many), eager loads all access rules
+    # * access rules (one to many)
+    #
+    # The following plugins are used by this model:
+    #
+    # * timestamps
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class User < Sequel::Model
+      plugin :timestamps, :create => :created_at, :update => :updated_at
+      
+      many_to_many :user_groups, :class => "Users::Models::UserGroup", :eager => [:access_rules]
+      one_to_many :access_rules, :class => "Users::Models::AccessRule"
+      
+      ##
+      # Try to authenticate the user based on the specified credentials.
+      # If the user credentials were incorrect false will be returned,
+      # true otherwise.
+      #
+      # Note that this method will NOT perform any sanitizing, that should be handled
+      # by the controller instead.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [Hash] creds The specified credentials
+      # @return [Object/Boolean] new instance of the given user.
+      #
+      def self.authenticate creds
+        email    = creds['email']
+        password = creds['password']
+
+        if email.nil? or password.nil?
+          return false
+        end
+
+        user = self[:email => email]
+
+        if !user.nil? and user.password == password and user.status == 'open'
+          Ramaze::Controller.session[:user] = user
+          return user
+        else
+          return false
+        end
+      end
+
+      ##
+      # Generates a new hash based on the specified password. Each
+      # password is generated with a cost of 15, this makes the login
+      # process slower but also more secure.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [String] raw_password The raw password
+      # @return [Void]
+      #
+      def password= raw_password
+        pwd = BCrypt::Password.create(raw_password, :cost => 10)
+        super(pwd)
+      end
+      
+      ##
+      # Returns the current password
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @return [String]
+      #
+      def password
+        BCrypt::Password.new(super)
+      end
+      
+      ##
+      # Specifies all validation rules
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def validate
+        validates_presence [:email, :name]
+        validates_presence :status unless new?
+        validates_format(/[a-zA-Z0-9\.\_\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,4}/, :email)
+      end
+    end
+  end
+end

data/lib/zen/packages/users/lib/users/model/user_group.rb

@@ -0,0 +1,38 @@
+module Users
+  module Models
+    ##
+    # Model that represents a single user group. This model has the following
+    # relations:
+    #
+    # * users (many to many)
+    # * access rules (one to many)
+    #
+    # This model uses the following plugins:
+    #
+    # * sluggable
+    # 
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class UserGroup < Sequel::Model
+      many_to_many :users, :class => "Users::Models::User"
+      one_to_many :access_rules, :class => "Users::Models::AccessRule"
+      
+      plugin :sluggable , :source => :name, :freeze => false
+      
+      ##
+      # Validation rules for each user group used when
+      # creating or updating a group.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def validate
+        validates_presence [:name, :super_group]
+        validates_presence :slug unless new?
+        validates_unique :slug
+        validates_type TrueClass, :super_group
+      end
+    end
+  end
+end

data/lib/zen/packages/users/lib/users/public/admin/js/users/access_rules.js

@@ -0,0 +1,43 @@
+window.addEvent('domready', function()
+{
+  // Hide the fields that allow a user to pick a user or group
+  // for an access rule. Each field (and thus the select element)
+  // will be shown when the corresponding radio button is selected.
+  var radios = $$('input[name="rule_applies"]');
+  var divs   = []
+  
+  radios.each(function(radio)
+  {
+    var value = radio.get('value');
+    
+    if ( value !== "0" )
+    {
+      value = $(value);
+
+      if ( radio.get('checked') == false )
+      {
+        value.setStyle('display', 'none'); 
+      }
+      
+      divs.push(value);
+    }
+    
+    radio.addEvent('click', function()
+    {
+      var radio_value = this.get('value');
+      
+      divs.each(function(div)
+      {
+        if ( div.get('id') == radio_value )
+        {
+          div.setStyle('display', 'block');
+        }
+        else
+        {
+          div.setStyle('display', 'none');
+        }
+      });
+    });
+  });
+
+});

data/lib/zen/packages/users/lib/users/view/admin/access_rules/edit.xhtml

@@ -0,0 +1,7 @@
+<article>
+  <header>
+    <h1>#{get_breadcrumbs}</h1>
+  </header>
+  
+  #{render_partial :form}
+</article>

data/lib/zen/packages/users/lib/users/view/admin/access_rules/form.xhtml

@@ -0,0 +1,68 @@
+#{
+  form_for(@access_rule, :method => :post, :action => @form_save_url) do |f|
+    
+    users        = {}
+    groups       = {}
+    extensions   = {}
+    rule_applies = ''
+    
+    if !@access_rule.user_id.nil?
+      rule_applies = 'div_user_id'
+    else
+      rule_applies = 'div_user_group_id'
+    end
+    
+    Users::Models::User.select(:id, :name).each do |user|
+      users[user.id.to_s] = user.name
+    end
+    
+    Zen::Package.extensions.each do |ident, ext|
+      extensions[ident] = ext.name
+    end
+    
+    Users::Models::UserGroup.select(:id, :name).each do |group|
+      groups[group.id.to_s] = group.name
+    end
+    
+    # ---------------------
+    
+    f.input_hidden :id, @access_rule.id
+    f.input_hidden :csrf_token, get_csrf_token
+    
+    f.input_radio @rules_lang.labels[:rule_applies], :rule_applies, rule_applies,
+      :values => @rules_lang.special[:rule_applies_hash]
+    
+    f.g.div :id => 'div_user_id' do
+      f.select @rules_lang.labels[:user], :user_id, :values => users,
+        :selected => @access_rule.user_id, :size => 1
+    end
+    
+    f.g.div :id => 'div_user_group_id' do
+      f.select @rules_lang.labels[:user_group], :user_group_id, :values => groups,
+        :selected => @access_rule.user_group_id, :size => 1
+    end
+      
+    # ---------------------
+    
+    f.select @rules_lang.labels[:extension], :extension, :values => extensions,
+      :selected => @access_rule.extension, :size => 1
+    
+    f.input_radio @rules_lang.labels[:create], :create_access, @access_rule.create_access,
+      :values => @rules_lang.special[:boolean_hash].invert
+      
+    f.input_radio @rules_lang.labels[:read], :read_access, @access_rule.read_access,
+      :values => @rules_lang.special[:boolean_hash].invert
+      
+    f.input_radio @rules_lang.labels[:update], :update_access, @access_rule.update_access,
+      :values => @rules_lang.special[:boolean_hash].invert
+    
+    f.input_radio @rules_lang.labels[:delete], :delete_access, @access_rule.delete_access,
+      :values => @rules_lang.special[:boolean_hash].invert
+    
+    f.g.div :class => 'clearfix' do
+      f.g.div :class => 'button' do
+        f.g.input :type => 'submit', :value => @rules_lang.buttons[:save]
+      end
+    end
+  end
+}

data/lib/zen/packages/users/lib/users/view/admin/access_rules/index.xhtml

@@ -0,0 +1,85 @@
+<article>
+  <header>
+    <h1>#{get_breadcrumbs}</h1>
+  </header>
+  
+  <form method="post" action="#{@form_delete_url}">
+    <input type="hidden" name="csrf_token" value="#{get_csrf_token}" />
+    
+    <?r if @access_rules and !@access_rules.empty? ?>
+    
+    <table class="table">
+      <thead>
+        <tr>
+          <?r if user_authorized?([:delete]) ?>
+          <th>
+            <input type="checkbox" />
+          </th>
+          <?r end ?>
+          
+          <th>#{@rules_lang.labels[:id]}</th>
+          <th>#{@rules_lang.labels[:extension]}</th>
+          <th>#{@rules_lang.labels[:create]}</th>
+          <th>#{@rules_lang.labels[:read]}</th>
+          <th>#{@rules_lang.labels[:update]}</th>
+          <th>#{@rules_lang.labels[:delete]}</th>
+          <th>#{@rules_lang.labels[:user]}</th>
+          <th>#{@rules_lang.labels[:user_group]}</th>
+        </tr>
+      </thead>
+      <tbody>
+        <?r @access_rules.each do |rule| ?>
+        <tr>
+          <?r if user_authorized?([:delete]) ?>
+          <td>
+            <input type="checkbox" name="access_rule_ids[]" value="#{rule.id}" />
+          </td>
+          <?r end ?>
+          
+          <td>#{rule.id}</td>
+          
+          <?r if user_authorized?([:update]) ?>
+          <td>#{anchor_to(rule.extension, "admin/access_rules/edit/#{rule.id}")}</td>
+          <?r else ?>
+          <td>#{rule.extension}</td>
+          <?r end ?>
+          
+          <td>#{@rules_lang.special[:boolean_hash][rule.create_access]}</td>
+          <td>#{@rules_lang.special[:boolean_hash][rule.read_access]}</td>
+          <td>#{@rules_lang.special[:boolean_hash][rule.update_access]}</td>
+          <td>#{@rules_lang.special[:boolean_hash][rule.delete_access]}</td>
+          <td>
+            <?r if !rule.user_id.nil? ?>
+            #{rule.user.name}
+            <?r end ?>
+          </td>
+          <td>
+            <?r if !rule.user_group_id.nil? ?>
+            #{rule.user_group.name}
+            <?r end ?>
+          </td>
+        </tr>
+        <?r end ?>
+      </tbody>
+    </table>
+    
+    <?r else ?>
+    <p>#{@rules_lang.messages[:no_rules]}</p>
+    <?r end ?>
+    
+    <div class="clearfix">
+      
+      <?r if user_authorized?([:create]) ?>
+      <div class="button">
+        #{anchor_to(@rules_lang.buttons[:new], "admin/access_rules/new")}
+      </div>
+      <?r end ?>
+      
+      <?r if user_authorized?([:delete]) and @access_rules and !@access_rules.empty? ?>
+      <div class="button">
+        <input type="submit" value="#{@rules_lang.buttons[:delete]}" />
+      </div>
+      <?r end ?>
+    </div>
+  </form>
+</article>