goldberg_generator 0.2.2

data/templates/vendor/plugins/goldberg/app/models/goldberg/menu_item.rb

@@ -0,0 +1,127 @@
+module Goldberg
+  class MenuItem < ActiveRecord::Base
+    include Goldberg::Model
+    
+    validates_presence_of :name, :label
+    validates_uniqueness_of :name
+    
+    attr_accessor :controller_action, :content_page
+    
+    def above
+      if self.parent_id
+        conditions = 
+          ["parent_id = ? and seq = ?", self.parent_id, self.seq - 1]
+      else
+        conditions = 
+          ["parent_id is null and seq = ?", self.seq - 1]
+      end
+      
+      return MenuItem.find(:first,
+                           :conditions => conditions)
+    end
+    
+    
+    def below
+      if self.parent_id
+        conditions = 
+          ["parent_id = ? and seq = ?", self.parent_id, self.seq + 1]
+      else
+        conditions = 
+          ["parent_id is null and seq = ?", self.seq + 1]
+      end
+      
+      return MenuItem.find(:first,
+                           :conditions => conditions)
+    end
+
+
+    def MenuItem.repack(repack_id)
+      if repack_id
+        items = MenuItem.find(:all,
+                              :conditions => "parent_id = #{repack_id}",
+                              :order => 'seq')
+      else
+        items = MenuItem.find(:all,
+                              :conditions => "parent_id is null",
+                              :order => 'seq')
+      end
+
+      seq = 1
+      for item in items do
+        item.seq = seq
+        item.save!
+        seq += 1
+      end
+    end
+
+
+    def MenuItem.next_seq(parent_id)
+      if parent_id and parent_id.to_i > 0
+        next_seq = MenuItem.find_by_sql("select coalesce(max(seq) + 1, 1) as seq from #{prefix}menu_items where parent_id = #{parent_id}")
+      else
+        next_seq = MenuItem.find_by_sql("select coalesce(max(seq) + 1, 1) as seq from #{prefix}menu_items where parent_id is null")
+      end
+
+      if next_seq
+        return next_seq[0].seq
+      else
+        return 1
+      end
+    end
+
+
+    def MenuItem.items_for_permissions(permission_ids = nil)
+      # Hash for faster & easier lookups
+      if permission_ids
+        perms = {}
+        for id in permission_ids do
+          perms[id] = true
+        end
+      end
+
+      # List of items to return
+      items = []
+
+      menu_items = self.find(:all,
+                             :order => 'parent_id, seq, id')
+      for item in menu_items do
+        if item.controller_action_id.to_i > 0
+          item.controller_action = 
+            ControllerAction.find(item.controller_action_id)
+          if perms
+            if perms.has_key?(item.controller_action.effective_permission.id)
+              items << item
+            end
+          else
+            items << item
+          end
+        elsif item.content_page_id.to_i > 0
+          item.content_page = 
+            ContentPage.find(item.content_page_id)
+          if perms
+            if perms.has_key?(item.content_page.permission_id)
+              items << item
+            end
+          else
+            items << item
+          end
+        end
+      end
+
+      return items
+    end
+    
+    
+    protected
+    
+    
+    def validate
+      unless self.content_page_id.to_i != 0 || controller_action_id.to_i != 0
+        errors.add(:content_page_id, 'A menu item must be attached to either a content page or a controller / action')
+        errors.add(:controller_action_id, 'A menu item must be attached to either a content page or a controller / action')
+      end
+    end
+
+    
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/permission.rb

@@ -0,0 +1,37 @@
+module Goldberg
+  class Permission < ActiveRecord::Base
+    include Goldberg::Model
+
+    has_many :content_pages
+    has_many :site_controllers
+    has_many :controller_actions
+    
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    class << self
+      # Find Permissions for a Role ID or an array of Role IDs.
+      def find_for_role(role_ids)
+        return find_by_sql( ["select p.* from #{prefix}permissions p inner join #{prefix}roles_permissions rp on p.id = rp.permission_id where role_id in (?) order by p.name", role_ids] )
+      end
+      
+      
+      # Find all Permissions for a Role.  This method gets the hierarchy
+      # for the given Role and uses that to get all the Permissions for
+      # the Role and its ancestors.
+      def find_all_for_role(role)
+        roles = role.get_parents
+        roles << role
+        return find_for_role(roles.collect(&:id))
+      end
+      
+
+      # Find Permissions that are not already associated with the given
+      # Role ID.
+      def find_not_for_role(role_id)
+        return find_by_sql( ["select p.* from #{prefix}permissions p where id not in (select permission_id from #{prefix}roles_permissions rp where role_id in (?)) order by name", role_id] )
+      end
+
+    end  # class << self
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/role.rb

@@ -0,0 +1,68 @@
+require "goldberg/credentials"
+require "goldberg/menu"
+
+module Goldberg
+  class Role < ActiveRecord::Base
+    include Goldberg::Model
+
+    has_many :users
+    
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    serialize :cache
+
+    class << self
+      def Role.rebuild_cache
+        roles = Role.find(:all)
+        
+        for role in roles do
+        role.cache = nil ; role.save # we have to do this to clear it
+          
+          role.cache = Hash.new
+          role.rebuild_credentials
+          role.rebuild_menu
+          role.save
+        end
+      end
+    end  # class << self
+      
+    def rebuild_credentials
+      self.cache[:credentials] = Credentials.new(self.id)
+    end
+
+    def rebuild_menu
+      menu = Menu.new(self)
+      self.cache[:menu] = menu
+    end
+
+    def get_parents
+      parents = Array.new
+      seen = Hash.new
+
+      current = self.id
+      
+      while current
+        role = Role.find(current)
+        if role 
+          if not seen.has_key?(role.id)
+            parents << role
+            seen[role.id] = true
+            current = role.parent_id
+          else
+            current = nil
+          end
+        else
+          current = nil
+        end
+      end
+
+      return parents
+    end
+
+    def get_start_path
+      self.start_path || Goldberg.settings.get_start_path
+    end
+    
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/roles_permission.rb

@@ -0,0 +1,18 @@
+module Goldberg
+  class RolesPermission < ActiveRecord::Base
+    include Goldberg::Model
+
+    validates_presence_of :role_id, :permission_id
+    
+    def RolesPermission.find_for_role(role_ids)
+      querystr = <<-END
+select rp.*, p.name 
+from #{prefix}roles_permissions rp inner join #{prefix}permissions p 
+  on rp.permission_id = p.id 
+where role_id in (?) order by p.name
+END
+      return find_by_sql([querystr, role_ids])
+    end
+    
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/site_controller.rb

@@ -0,0 +1,59 @@
+module Goldberg
+  class SiteController < ActiveRecord::Base
+    include Goldberg::Model
+
+    belongs_to :permission
+    has_many :controller_actions, :order => 'name', :dependent => :destroy
+    
+    validates_presence_of :name, :permission_id
+    validates_uniqueness_of :name
+
+    def self.classes
+      for path in ActionController::Routing.controller_paths do
+        self.load_class_files(path)
+      end  
+
+      classes = Hash.new
+      
+      ObjectSpace.each_object(Class) do |klass|
+        if klass.respond_to? :controller_path
+          if (klass.to_s != ApplicationController.to_s and
+              klass.ancestors.map{|c|c.to_s}.include?(ApplicationController.to_s))
+            classes[klass.controller_path] = klass
+          end
+        end
+      end
+      
+      return classes
+    end
+    
+    
+    def self.load_class_files(path)
+      prereqs = []
+      files = []
+      dirs = []
+      for file in Dir.glob("#{path}/*").sort do
+        if file.match /_controller\.rb$/
+          files << file
+        elsif file.match /\.rb$/
+          prereqs << file
+        elsif File.directory? file
+          dirs << file
+        end
+      end
+
+      (prereqs + files).each do |file|
+        begin
+          load file
+        rescue
+          logger.info "Couldn't load file '#{file}' (already loaded?)"
+        end
+      end
+
+      dirs.each do |dir|
+        self.load_class_files(dir)
+      end
+    end
+    
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/system_settings.rb

@@ -0,0 +1,112 @@
+module Goldberg
+  class SystemSettings < ActiveRecord::Base
+    set_table_name 'system_settings'
+    include Goldberg::Model
+    
+    attr_accessor :public_role, :default_markup_style
+    attr_accessor :site_default_page, :not_found_page, :permission_denied_page,
+    :session_expired_page
+
+    # Make sure that all the standard pages have been set.
+    validates_presence_of :public_role_id, :site_default_page_id, :not_found_page_id,
+    :permission_denied_page_id, :session_expired_page_id
+
+    # If self-reg is enabled, ensure there is a self-reg role set.
+    validates_each :self_reg_enabled do |record, attr, value|
+      result = true
+      if value and not (record.self_reg_role_id and record.self_reg_role_id > 0)
+        record.errors.add attr, <<-END
+If self-registration is enabled, you must specify the default Role to
+assign to self-registered users.
+END
+        result = false
+      end
+
+      if value and not (record.self_reg_confirmation_error_page_id and
+                        record.self_reg_confirmation_error_page_id > 0)
+        record.errors.add attr, <<-END
+If self-registration is enabled, you must specify an error page to be
+displayed to any users who try to access the site, but who are not yet
+confirmed.
+END
+        result = false
+      end
+      result
+    end
+    
+    def public_role
+      @public_role ||= Role.find(self.public_role_id)
+    end
+    
+    def site_default_page
+      @site_default_page ||= ContentPage.find(self.site_default_page_id)
+    end
+    
+    def not_found_page
+      @not_found_page ||= ContentPage.find(self.not_found_page_id)
+    end
+    
+    def permission_denied_page
+      @permission_denied_page ||= ContentPage.find(self.permission_denied_page_id)
+    end
+    
+    def session_expired_page
+      @session_expired_page ||= ContentPage.find(self.session_expired_page_id)
+    end
+
+    def self_reg_confirmation_error_page
+      @self_reg_confirmation_error_page ||=
+        ContentPage.find(self.self_reg_confirmation_error_page_id)
+    end
+    
+    # Returns an array of system page settings for a given page,
+    # or nil if the page is not a system page.
+    def system_pages(pageid)
+      pages = Array.new
+      
+      if self.site_default_page_id == pageid
+        pages << "Site default page"
+      end
+      if self.not_found_page_id == pageid
+        pages << "Not found page"
+      end
+      if self.permission_denied_page_id == pageid
+        pages << "Permission denied page"
+      end
+      if self.session_expired_page_id == pageid
+        pages << "Session expired page"
+      end
+
+      if self.self_reg_confirmation_error_page_id == pageid
+        pages << "Self-registration confirmation error page"
+      end
+      
+      if pages.length > 0
+        return pages
+      else
+        return nil
+      end
+    end
+
+    def get_start_path
+      if self.start_path and self.start_path.length > 0
+        self.start_path
+      else
+        "/"
+      end
+    end
+    
+    def self_reg_role
+      @self_reg_role ||= self.self_reg_role_id ? Role.find(self.self_reg_role_id) :
+        Role.new(:id => nil, :name => '(none)')
+    end
+
+    def self_reg_confirmation_error_page
+      @self_reg_confirmation_error_page ||= (self.self_reg_confirmation_error_page_id ?
+                                             ContentPage.find(self.self_reg_confirmation_error_page_id) :
+                                             ContentPage.new(:id => nil, :name => '(none)')
+                                             )
+    end
+
+  end
+end

data/templates/vendor/plugins/goldberg/app/models/goldberg/user.rb

@@ -0,0 +1,69 @@
+require 'digest/sha1'
+
+module Goldberg
+  class User < ActiveRecord::Base
+    include Goldberg::Model
+
+    belongs_to :role
+    
+    validates_presence_of :name, :role_id, :password
+    validates_uniqueness_of :name
+    
+    attr_accessor :clear_password
+    attr_accessor :confirm_password
+
+    def before_validation
+      if self.clear_password  # Only update password if changed
+        self.password_salt = self.object_id.to_s + rand.to_s
+        self.password = Digest::SHA1.hexdigest(self.password_salt +
+                                               self.clear_password)
+      end
+    end
+      
+    def before_save
+      if self.self_reg_confirmation_required
+        self.set_confirmation_key
+      end
+    end
+    
+    def after_save
+      self.clear_password = nil
+    end
+    
+    def check_password(clear_password)
+      self.password == Digest::SHA1.hexdigest(self.password_salt.to_s +
+                                              clear_password)
+    end
+
+    def set_confirmation_key
+      self.confirmation_key = Digest::SHA1.hexdigest(self.object_id.to_s +
+                                                       rand.to_s)
+    end
+
+    def email_valid?
+      self.email &&
+        self.email.length > 0 &&
+        # http://regexlib.com/DisplayPatterns.aspx
+        self.email =~ /\A.+@[^\.].*\.[a-z]{2,}\z/
+    end
+
+    def get_start_path
+      if self.start_path and self.start_path.length > 0
+        self.start_path
+      else
+        self.role.get_start_path
+      end
+    end
+
+    class << self
+      def random_password
+        letters = ('A' .. 'Z').to_a + ('a' .. 'z').to_a
+        password = (1 .. 6).collect do
+          letters[ (rand * letters.length).to_i ]
+        end
+        password.to_s
+      end
+    end  # class methods
+    
+  end
+end