goldberg_generator 0.2.2

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/permissions_controller.rb

@@ -0,0 +1,60 @@
+module Goldberg
+  class PermissionsController < ApplicationController
+    include Goldberg::Controller
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    def index
+      list
+      render :action => 'list'
+    end
+
+    def list
+      @permissions = Permission.find(:all, :order => 'name')
+    end
+
+    def show
+      @permission = Permission.find(params[:id])
+      @pages = ContentPage.find_for_permission(params[:id])
+      @actions = ControllerAction.find_for_permission(params[:id])
+    end
+
+    def new
+      @permission = Permission.new
+    end
+
+    def create
+      @permission = Permission.new(params[:permission])
+      if @permission.save
+        flash[:notice] = 'Permission was successfully created.'
+        Role.rebuild_cache
+        redirect_to :action => 'list'
+      else
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      @permission = Permission.find(params[:id])
+    end
+
+    def update
+      @permission = Permission.find(params[:id])
+      if @permission.update_attributes(params[:permission])
+        flash[:notice] = 'Permission was successfully updated.'
+        Role.rebuild_cache
+        redirect_to :action => 'show', :id => @permission
+      else
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      Permission.find(params[:id]).destroy
+      Role.rebuild_cache
+      redirect_to :action => 'list'
+    end
+  end
+end

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/roles_controller.rb

@@ -0,0 +1,85 @@
+module Goldberg
+  class RolesController < ApplicationController
+    include Goldberg::Controller
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    def index
+      list
+      render :action => 'list'
+    end
+
+    def list
+      @roles = Role.find(:all,
+                         :order => 'name')
+    end
+
+    def show
+      @role = Role.find(params[:id])
+      @rps = RolesPermission.find_for_role(@role.id)
+      @roles = @role.get_parents
+      foreign
+    end
+
+    def new
+      @role = Role.new
+      foreign()
+    end
+
+    def create
+      @role = Role.new(params[:role])
+      if @role.save
+        Role.rebuild_cache
+        flash[:notice] = 'Role was successfully created.'
+        redirect_to :action => 'list'
+      else
+        foreign
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      @role = Role.find(params[:id])
+      foreign
+    end
+
+    def update
+      @role = Role.find(params[:id])
+      if @role.update_attributes(params[:role])
+        Role.rebuild_cache
+        @role = Role.find(params[:id])
+        flash[:notice] = 'Role was successfully updated.'
+        redirect_to :action => 'show', :id => @role.id
+      else
+        foreign
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      Role.find(params[:id]).destroy
+      redirect_to :action => 'list'
+    end
+
+    protected
+
+    def foreign
+      if @role.id
+        @other_roles = Role.find(:all,
+                                 :conditions => ['id not in (?)', @role.id],
+                                 :order => 'name')
+      else
+        @other_roles = Role.find(:all,
+                                 :order => 'name')
+      end
+      @other_roles ||= Array.new
+      @other_roles.unshift Role.new(:id => nil, :name => '(none)')
+      @users = User.find(:all,
+                         :conditions => ['role_id = ?', @role.id],
+                         :order => 'name')
+    end
+    
+  end
+end

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/roles_permissions_controller.rb

@@ -0,0 +1,65 @@
+module Goldberg
+  class RolesPermissionsController < ApplicationController
+    include Goldberg::Controller
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    def index
+      list
+      render :action => 'list'
+    end
+
+    def list
+      @roles_permissions = RolesPermission.find(:all)
+    end
+
+    def show
+      @roles_permission = RolesPermission.find(params[:id])
+    end
+
+    def new
+      @roles_permission = RolesPermission.new
+    end
+
+    def new_permission_for_role
+      @roles_permission = RolesPermission.new
+      @roles_permission.role_id = params[:id]
+      @role = Role.find(params[:id])
+      @permissions = Permission.find_not_for_role(params[:id])
+    end
+
+    def create
+      @roles_permission = RolesPermission.new(params[:roles_permission])
+      if @roles_permission.save
+        flash[:notice] = 'RolesPermission was successfully created.'
+        redirect_to :controller => 'roles', :action => 'show', 
+        :id => @roles_permission.role_id
+      else
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      @roles_permission = RolesPermission.find(params[:id])
+    end
+
+    def update
+      @roles_permission = RolesPermission.find(params[:id])
+      if @roles_permission.update_attributes(params[:roles_permission])
+        flash[:notice] = 'RolesPermission was successfully updated.'
+        redirect_to :action => 'show', :id => @roles_permission
+      else
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      rp = RolesPermission.find(params[:id])
+      role = rp.role_id
+      rp.destroy
+      redirect_to :controller => 'roles', :action => 'show', :id => role
+    end
+  end
+end

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/site_controllers_controller.rb

@@ -0,0 +1,157 @@
+module Goldberg
+  class SiteControllersController < ApplicationController
+    include Goldberg::Controller
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    def index
+      list
+      render :action => 'list'
+    end
+
+    def list
+      @builtin_site_controllers = SiteController.find(:all,
+                                                      :conditions => "builtin = 1",
+                                                      :order => 'name')
+      @app_site_controllers = 
+        SiteController.find(:all,
+                            :conditions => "builtin is null or builtin = 0",
+                            :order => 'name')
+      classify_controllers
+    end
+
+    def show
+      @site_controller = SiteController.find(params[:id])
+      @actions = ControllerAction.find(:all,
+                                       :conditions => ['site_controller_id = ?',
+                                                       params[:id] ],
+                                       :order => 'name')
+    end
+
+    def new
+      foreign
+      @site_controller = SiteController.new
+    end
+
+    def new_called
+      foreign
+      @site_controller = SiteController.new(:name => params[:id].gsub(/\%2F/, '/'))
+      render :action => 'new'
+    end
+
+    def create
+      @site_controller = SiteController.new(params[:site_controller])
+      if @site_controller.save
+        flash[:notice] = 'SiteController was successfully created.'
+        Role.rebuild_cache
+        redirect_to :action => 'list'
+      else
+        foreign
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      @site_controller = SiteController.find(params[:id])
+      foreign
+    end
+
+    def update
+      @site_controller = SiteController.find(params[:id])
+      if @site_controller.update_attributes(params[:site_controller])
+        flash[:notice] = 'SiteController was successfully updated.'
+        Role.rebuild_cache
+        redirect_to :action => 'show', :id => @site_controller
+      else
+        foreign
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      SiteController.find(params[:id]).destroy
+      Role.rebuild_cache
+      redirect_to :action => 'list'
+    end
+
+
+    protected 
+
+
+    def foreign
+      @permissions = Permission.find(:all, :order => 'name')
+    end
+
+
+
+    # @unknown contains ApplicationController class objects hashed by
+    # name, while @app, @builtin and @missing are arrays of
+    # SiteController ActiveRecord objects.
+
+    def classify_controllers
+      from_classes = SiteController.classes
+      
+      from_db = SiteController.find(:all,
+                                    :order => 'name')
+      known = Hash.new
+      @missing = Array.new
+      for dbc in from_db do
+        if from_classes.has_key? dbc.name
+          known[dbc.name] = dbc
+        else
+          @missing << dbc
+        end
+      end
+
+      @unknown = Hash.new
+      @app = Array.new
+      @builtin = Array.new
+
+      for name in from_classes.keys.sort do
+        if known.has_key? name
+          if known[name].builtin == 1
+            @builtin << known[name]
+          else
+            @app << known[name]
+          end
+        else
+          @unknown[name] = from_classes[name]
+        end
+      end
+
+      @has_missing = (@missing.length > 0) ? true : false
+      @has_unknown = (@unknown.keys.length > 0) ? true : false
+      @has_app     = (@app.length > 0)     ? true : false
+      @has_builtin = (@builtin.length > 0) ? true : false
+
+      return
+    end
+
+    
+    # Given a controller name, returns an array of available actions to
+    # which that controller will respond.
+
+    def controller_actions(controller_name)
+      
+      controllers = controller_classes()
+      actions = Hash.new()
+      
+      if @controller_classes.has_key? controller_name
+        controller = @controller_classes[controller_name]
+
+        for method in controller.public_instance_methods do
+          actions[method] = true
+        end
+
+        for hidden in controller.hidden_actions do
+          actions.delete hidden
+        end
+      end
+      
+      return actions.keys
+    end  # def controller_actions
+
+  end  # class
+end

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/system_settings_controller.rb

@@ -0,0 +1,75 @@
+module Goldberg
+  class SystemSettingsController < ApplicationController
+    include Goldberg::Controller
+
+    def index
+      list
+      render :action => 'list'
+    end
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    def list
+      @system_settings = SystemSettings.find(:first)
+      redirect_to :action => :show, :id => @system_settings
+    end
+
+    def show
+      foreign()
+      @system_settings = SystemSettings.find(:first)
+    end
+
+    def new
+      @system_settings = SystemSettings.find(:first)
+      if @system_settings != nil
+        redirect_to :action => :edit, :id => @system_settings.id
+      else
+        foreign()
+        @system_settings = SystemSettings.new
+      end
+    end
+
+    def create
+      @system_settings = SystemSettings.new(params[:system_settings])
+      if @system_settings.save
+        flash[:notice] = 'SystemSettings was successfully created.'
+        redirect_to :action => 'list'
+      else
+        render :action => 'new'
+      end
+    end
+
+    def edit
+      foreign()
+      @system_settings = SystemSettings.find(params[:id])
+    end
+
+    def update
+      @system_settings = SystemSettings.find(params[:id])
+      if @system_settings.update_attributes(params[:system_settings])
+        flash[:notice] = 'SystemSettings was successfully updated.'
+        redirect_to :action => 'show', :id => @system_settings
+      else
+        foreign
+        render :action => 'edit'
+      end
+    end
+
+    def destroy
+      SystemSettings.find(params[:id]).destroy
+      redirect_to :action => 'list'
+    end
+
+    protected
+
+    def foreign
+      @roles = Role.find(:all, :order => 'name')
+      @self_reg_roles = @roles.clone
+      @self_reg_roles.unshift Role.new(:id => nil, :name => '(none)')
+      @pages = ContentPage.find(:all, :order => 'name')
+    end
+
+  end
+end

data/templates/vendor/plugins/goldberg/app/controllers/goldberg/users_controller.rb

@@ -0,0 +1,293 @@
+require 'digest/sha1'
+
+module Goldberg
+  class UsersController < ApplicationController
+    include Goldberg::Controller
+
+    # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
+    verify :method => :post, :only => [ :destroy, :create, :update ],
+    :redirect_to => { :action => :list }
+
+    before_filter do
+      @self_reg = false
+      @delegate_reg = false
+      true  # proceed...
+    end
+    before_filter :foreign,
+    :only => [:new,    :delegate_register, :create, :delegate_create,
+              :edit,   :delegate_edit,     :update, :delegate_update]
+    before_filter :enable_self_reg,
+    :only => [:self_show, :self_register, :self_create, :self_edit,
+              :self_update, :confirm_registration, :confirm_registration_submit]
+    before_filter :enable_delegate_reg,
+    :only => [:delegate_list, :delegate_show, :delegate_register,
+              :delegate_create, :delegate_edit, :delegate_update,
+              :delegate_destroy]
+    
+    def list
+      if @delegate_reg
+        conditions = ['role_id in (?)', Goldberg.credentials.role_ids]
+      else
+        conditions = nil
+      end
+      @users = User.find(:all, :conditions => conditions, :order => 'name')
+      render :action => 'list'
+    end
+    alias_method :delegate_list, :list
+    
+    def show
+      if @self_reg
+        @user = Goldberg.user
+      else
+        @user = User.find(params[:id])
+      end
+      if @user
+        if @user.role_id
+          @role = Role.find(@user.role_id)
+        else
+          @role = Role.new(:id => nil, :name => '(none)')
+        end
+        render :action => 'show'
+      else
+        render :nothing => true
+      end
+    end
+    alias_method :self_show, :show
+    alias_method :delegate_show, :show
+    
+    def new
+      @user = User.new
+      render :action => 'new'
+    end
+    alias_method :self_register, :new
+    alias_method :delegate_register, :new
+    
+    def create
+      @user = User.new(params[:user])
+      if @self_reg
+        @user.role_id = Goldberg.settings.self_reg_role_id
+        @user.self_reg_confirmation_required =
+          Goldberg.settings.self_reg_confirmation_required
+        if Goldberg.settings.self_reg_send_confirmation_email
+          if not @user.email_valid?
+            flash.now[:error] = 'A valid email address is required!'
+            render :action => 'new'
+            return
+          end
+        end
+      end
+      
+      if params[:user][:clear_password].length == 0 or
+          params[:user][:confirm_password] != params[:user][:clear_password]
+        flash.now[:error] = 'Password invalid!'
+        render :action => 'new'
+      else
+        if @user.save
+          flash.now[:notice] = 'User was successfully created.'
+          if @self_reg
+            if Goldberg.settings.self_reg_confirmation_required
+              if Goldberg.settings.self_reg_send_confirmation_email
+                confirm_email = UserMailer.create_confirmation_request(@user)
+                UserMailer.deliver(confirm_email)
+              end
+              render :action => 'create'
+            else
+              AuthController.set_user(session, @user.id)
+              redirect_to @user.get_start_path
+            end
+          else
+            redirect_to :action => 'list'
+          end
+        else
+          render :action => 'new'
+        end
+      end
+    end
+    alias_method :self_create, :create
+    alias_method :delegate_create, :create
+
+    # Invoked when a user clicks on a link in a self-registration
+    # email.  Displays a form where the user can enter their username
+    # and password.
+    def confirm_registration
+      @user = User.find_by_confirmation_key(params[:id])
+      @user or flash.now[:error] = 'Sorry, but there is no such confirmation required.'
+      render :action => 'confirm_registration'
+    end
+
+    def confirm_registration_submit
+      @user = User.find(params[:id])
+      # Check password and key etc.
+      if @user and @user.self_reg_confirmation_required and
+          @user.confirmation_key == params[:user][:confirmation_key] and
+          @user.check_password(params[:user][:clear_password])
+        # Confirmed: remove confirmation flag and confirmation key,
+        # save user.
+        @user.self_reg_confirmation_required = false
+        @user.confirmation_key = nil
+        if @user.save
+          flash.now[:notice] = 'Registration confirmed.'
+          AuthController.set_user(session, @user.id)
+          render :action => 'confirm_registration_submit'
+        else
+          flash.now[:error] = 'Could not save confirmation!'
+          render :action => 'confirm_registration'
+        end
+      else
+        flash.now[:error] = 'Self-registration confirmation invalid!'
+        render :action => 'confirm_registration'
+      end
+    end
+    
+    def edit
+      if @self_reg
+        @user = Goldberg.user
+      else
+        @user = User.find(params[:id])
+      end
+      if @user
+        if @user.role_id
+          @role = Role.find(@user.role_id)
+        end
+        render :action => 'edit'
+      else
+        render :nothing => true
+      end
+    end
+    alias_method :self_edit, :edit
+    alias_method :delegate_edit, :edit
+    
+    def update
+      if @self_reg
+        @user = Goldberg.user
+      else
+        @user = User.find(params[:id])
+      end
+      if @user
+        if params[:user]['clear_password'] == ''
+          params[:user].delete('clear_password')
+        end
+
+        # Not allowed to change your own role.
+        if @self_reg
+          params[:user][:role_id] = @user.role_id
+        end
+        
+        if params[:user][:clear_password] and
+            params[:user][:clear_password].length > 0 and
+            params[:user][:confirm_password] != params[:user][:clear_password]
+          flash.now[:error] = 'Password invalid!'
+          render :action => 'edit'
+        else
+          if @user.update_attributes(params[:user])
+            flash.now[:notice] = 'User was successfully updated.'
+            redirect_to :action => (@self_reg ? 'self_show' : 'show'),
+            :id => @user
+          else
+            render :action => 'edit'
+          end
+        end
+      end  # if @user
+    end  # def update
+    alias_method :self_update, :update
+    alias_method :delegate_update, :update
+    
+    def destroy
+      User.find(params[:id]).destroy
+      redirect_to :action => 'list'
+    end
+    alias_method :delegate_destroy, :destroy
+
+    def forgot_password
+      render :action => 'forgot_password'
+    end
+
+    def forgot_password_submit
+      @user = User.find_by_name_and_email(params[:user][:name],
+                                          params[:user][:email])
+      if @user
+        if (not @user.self_reg_confirmation_required)
+          @user.set_confirmation_key
+          if @user.save
+            # Send email with confirmation key
+            reset_email = UserMailer.create_reset_password_request(@user)
+            UserMailer.deliver(reset_email)
+            render :action => 'forgot_password_submit'
+          else
+            render :action => 'forgot_password'
+          end
+        else
+          flash.now[:error] = "You can't reset your password because your account is not yet confirmed."
+          render :action => 'forgot_password'
+        end
+      else
+        flash.now[:error] = "No such user/email."
+        render :action => 'forgot_password'
+      end
+    end
+    
+    def reset_password
+      # Find user by confirmation key.
+      # Render form with confirmation key, username and email.
+      @user = User.find_by_confirmation_key(params[:id])
+      if @user
+        render :action => 'reset_password'
+      else
+        flash.now[:error] = 'Sorry, but we received no such password reset request.'
+        render :action => 'forgot_password'
+      end
+    end
+
+    def reset_password_submit
+      @user = User.find_by_confirmation_key(params[:id])
+      if @user
+        if (not @user.self_reg_confirmation_required)
+          # set @user.clear_password
+          password = @user.class.random_password
+          @user.clear_password = password
+          @user.password_expired = true
+          if @user.save
+            # Send email with confirmation key
+            password_email = UserMailer.create_reset_password(@user, password)
+            UserMailer.deliver(password_email)
+            render :action => 'reset_password_submit'
+          else
+            render :action => 'reset_password'
+          end
+        else
+          flash.now[:error] = "You can't reset your password because your account is not yet confirmed."
+          render :action => 'forgot_password'
+        end
+      else
+        flash.now[:error] = "No such password reset request for user."
+        render :action => 'forgot_password'
+      end
+    end
+    
+    protected
+
+    def foreign
+      if @delegate_reg
+        conditions = ['id in (?)', Goldberg.credentials.role_ids]
+      else
+        conditions = nil
+      end
+      @roles = Role.find(:all, :conditions => conditions, :order => 'name')
+    end
+
+    def enable_self_reg
+      @self_reg = (Goldberg.settings.self_reg_enabled || false)
+      # (This will also halt the filter chain if self-reg is NOT enabled.)
+    end
+
+    def enable_delegate_reg
+      @delegate_reg = true
+    end
+    
+    def enable_password_change
+      @password_change = true
+      true  # proceed...
+    end
+
+  end
+end