padrino-admin 0.5.0 → 0.6.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Padrino
+Copyright (c) 2010 Padrino
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,22 +1,75 @@
 = padrino-admin
 
-== Installation
+Padrino has a beautiful Ajax Admin, with these fatures:
 
-To install the 'full-stack' padrino framework, simply grab the latest version from gemcutter:
+Orm Agnostic:: Adapters for datamapper, activerecord, mongomapper, couchdb (now only: datamapper and activerecord)
+Authentication:: Support for Account authentication, Account Permission managment
+Scaffold:: You can simply create a new "admin interface" simply providing a Model
+Ajax Uploads:: You can upload file, manage them and attach them to any model in a quick and simple way (coming soon)
 
-  $ sudo gem install padrino --source http://gemcutter.org
-  
-This will install the necessary padrino gems to get you started.
-Now you are ready to use this gem to enhance your existing Sinatra projects or build new Padrino applications.
+=== Admin Usage
+
+Create a project:
+
+  $ padrino-gen app fun-test
+  $ cd fun-test
+
+For create the admin application:
+
+  fun-test$ padrino-gen admin
 
-You can also install only the padrino-admin gem for more fine-grained use:
+Now follow admin instructions so:
 
-  $ sudo gem install padrino-admin --source http://gemcutter.org
+* edit your config/database.rb
+* run padrino rake dm:migrate
+* run padrino rake seed
+
+Your admin now is "complete", you can start your server with <tt>padrino start</tt> and point your browser to /admin!
+
+For create a new "scaffold" you need to provide only a Model for them like:
+
+  fun-test$ padrino-gen admin_page Post
   
-== Usage
+That's all!!
+
+=== Admin Authentication
+
+Padrino Admin use a model Account for manage role, membership and permissions take the following example:
+
+  access_control.roles_for :any do |role|
+    role.allow "/sessions"
+    # role.deny "/deny/this/always"
+  end
+
+  access_control.roles_for :admin do |role, account|
+    role.allow "/"
+
+    role.project_module :accounts do |project|
+      project.menu :list, "/admin/accounts.js"
+      project.menu :new,  "/admin/accounts/new"
+    end
+  end
+
+  access_control.roles_for :editor do |role, account|
+    role.project_module :posts do |project|
+      project.menu :list, "/admin/posts.js"
+      project.menu :new,  "/admin/posts/new"
+    end
+
+    role.project_module :comments do |project|
+      project.menu :list, "/admin/comments.js"
+      project.menu :new,  "/admin/comments/new"
+    end
+  end
+
+In this example we <tt>grant</tt> "/session" (and each subpaths like /sessions/new) for all users logged and unlogged.
+
+Account with role <tt>admin</tt> can manage <tt>only</tt> accounts because have access to "/admin/accounts/**" paths
+Account with role <tt>editor</tt> can manage <tt>only</tt> post/comments because have access to "/admin/posts/**", "/admin/posts/**" paths
 
-Not implemented yet.
+Another good fature of Padrino admin is that when you define a <tt>Project Module</tt> role you also build the Menu Tree of the Admin. 
+Trust us that in future you appreciate so much this feature.
 
 == Copyright
 
-Copyright (c) 2009 Padrino. See LICENSE for details.
+Copyright (c) 2010 Padrino. See LICENSE for details.

data/Rakefile

@@ -1,6 +1,8 @@
 require 'rubygems'
 require 'rake'
 
+GEM_VERSION = File.read(File.dirname(__FILE__) + '/VERSION')
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
@@ -11,8 +13,9 @@ begin
     gem.homepage = "http://github.com/padrino/padrino-framework/tree/master/padrino-admin"
     gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
     gem.add_runtime_dependency     "json_pure",       ">= 1.2.0"
-    gem.add_runtime_dependency     "padrino-core",    ">= 0.1.1"
-    gem.add_development_dependency "dm-core",         ">= 0.10.2"
+    gem.add_runtime_dependency     "padrino-core",    "= #{GEM_VERSION}"
+    gem.add_runtime_dependency     "padrino-gen",     "= #{GEM_VERSION}"
+    gem.add_runtime_dependency     "tilt",            ">= 0.4"
     gem.add_development_dependency "haml",            ">= 2.2.1"
     gem.add_development_dependency "shoulda",         ">= 0"
     gem.add_development_dependency "mocha",           ">= 0.9.7"
@@ -28,6 +31,7 @@ end
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
+  
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
@@ -35,6 +39,9 @@ end
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
+    Dir[File.dirname(__FILE__) + "/../padrino-*/lib"].each do |padrino_gem|
+      test.libs << padrino_gem
+    end
     test.libs << 'test'
     test.pattern = 'test/**/test_*.rb'
     test.verbose = true
@@ -58,3 +65,20 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+
+spec = Gem::Specification.new do |s| 
+  s.name              = "foo"
+  s.version           = "1.0.1"
+  s.author            = "Davide D'Agostino"
+  s.email             = "d.dagostino@lipsiasoft.com"
+  s.homepage          = "http://www.lipsiadmin.com"
+  s.rubyforge_project = "lipsiadmin"
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = "Lipsiadmin is a new revolutionary admin for your projects.Lipsiadmin is based on Ext Js 2.0. framework (with prototype adapter) and is ready for Rails 2.0. This admin is for newbie developper but also for experts, is not entirely written in javascript because the aim of developper wose build in a agile way web/site apps so we use extjs in a new intelligent way a mixin of 'old' html and new ajax functions, for example ext manage the layout of page, grids, tree and errors, but form are in html code."
+  s.files             = FileList["CHANGELOG", "README.rdoc", "MIT-LICENSE", "Rakefile", "init.rb", "{lipsiadmin_generators,lib,resources,tasks}/**/*"].to_a
+  s.has_rdoc          = true
+  s.requirements << "ImageMagick"
+  s.add_dependency('haml')
+  s.add_dependency('rails', '>= 2.2.1')
+end

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.1

data/lib/padrino-admin/access_control.rb

@@ -6,7 +6,8 @@ module Padrino
   #   
   #   class EcommerceDemo < Padrino::Application
   #     enable :authentication
-  #     set :redirect_back_or_default, "/login" # or your page
+  #     set :login_page, "/login" # or your login page
+  #     enable :store_location # if you want know what is the page that need authentication
   #     set :use_orm, :active_record # or :data_mapper, :mongo_mapper
   # 
   #     access_control.roles_for :any do
@@ -37,7 +38,7 @@ module Padrino
   # 
   #   class AdminDemo < Padrino::Application
   #     enable :authentication
-  #     set :redirect_to_default, "/" # or your page
+  #     set :login_page, "/sessions/new" # or your page
   #     
   #     access_control.roles_for :any do |role|
   #       role.allow "/sessions"
@@ -123,9 +124,8 @@ module Padrino
   module AccessControl
 
     def self.registered(app)
-      app.helpers Padrino::AccessControl::Helpers
+      app.helpers Padrino::Admin::Helpers
       app.before { login_required }
-      app.set :redirect_to_default, "/"
       if app.respond_to?(:use_orm)
         Padrino::Admin::Adapters.register(app.use_orm)
       else
@@ -134,9 +134,9 @@ module Padrino
     end
 
     class Base
-
       class << self
-        
+        attr_reader :roles
+
         def inherited(base) #:nodoc:
           base.class_eval("@@cache={}; @authorizations=[]; @roles=[]; @mappers=[]")
           base.send(:cattr_reader, :cache)
@@ -192,11 +192,13 @@ module Padrino
 
       def can?(request_path)
         return true if @allowed.empty?
+        request_path = "/" if request_path.blank?
         @allowed.any? { |path| request_path =~ /^#{path}/ } && !cannot?(request_path)
       end
 
       def cannot?(request_path)
         return false if @denied.empty?
+        request_path = "/" if request_path.blank?
         @denied.any? { |path| request_path =~ /^#{path}/ }
       end
 

data/lib/padrino-admin/adapters/ar.rb

@@ -13,7 +13,7 @@ module Padrino
               named_scope :ext_search, lambda { |params|
                 conditions = nil
 
-                if !params[:query].blank? && !params[:fields].blank?
+                if params[:query].present? && params[:fields].present?
                   filters = params[:fields].split(",").collect { |f| "#{f} LIKE ?" }.compact
                   conditions = [filters.join(" OR ")].concat((1..filters.size).collect { "%#{params[:query]}%" })
                 end
@@ -47,6 +47,12 @@ module Padrino
               options[:count] ||= 1
               I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => [:model, :attributes]))
             end
+
+            # Alias method for get columns
+            def properties
+              columns
+            end
+
           end
         end
 

data/lib/padrino-admin/adapters/dm.rb

@@ -15,9 +15,23 @@ module Padrino
           module InstanceMethods
             # This method allow us to don't see deprecations
             def new_record?; new?; end
+
+            # Returns a String, which Padrino uses for constructing an URL to this object. 
+            # The default implementation returns this record‘s id as a String, or nil if this record‘s unsaved.
+            def to_param
+              # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+              (id = self.id) ? id.to_s : nil # Be sure to stringify the id for routes
+            end
+
+            # Update attributes is deprecated but for compatibility with AR we support them.
+            def update_attributes(attributes = {})
+              update(attributes)
+            end
           end
-          
+
           module ClassMethods
+            attr_accessor :_table_name
+
             def self_and_descendants #:nodoc:
               klass = self
               classes = [klass]
@@ -50,7 +64,7 @@ module Padrino
 
             # Return the name of the sql table
             def table_name
-              storage_names[:default]
+              self.name.downcase.pluralize # storage_names[:default] this some times give an error
             end
 
             # Perform a basic fulltext search/ordering for the given columns
@@ -61,8 +75,6 @@ module Padrino
             # In this example we search in columns name, surname, company the string daddye and then we order by
             # column +name+
             def ext_search(params)
-              params.symbolize_keys!
-
               # We need a basic query
               query = {}
 
@@ -78,14 +90,12 @@ module Padrino
             end
 
             def ext_paginate(params)
-              params.symbolize_keys!
-
               # We need a basic query
               query = {}
 
               # First we need to sort our record
-              if params[:sort].present? && params[:dir].to_s =~ /^(asc|desc)$/
-                query[:order] = [params[:sort].to_sym.send(params[:dir].to_s.downcase)]
+              if params[:sort].present? && params[:dir].to_s =~ /^(asc|desc)$/i
+                query[:order] = [params[:sort].to_s.gsub(/#{table_name}\./i,'').to_sym.send(params[:dir].to_s.downcase)]
               end
 
               # Now time to limit/offset it

data/lib/padrino-admin/adapters.rb

@@ -11,24 +11,48 @@ module Padrino
       def self.register(adapter, klass=nil)
         klass ||= Account
         case adapter
-          when :active_record
+          when :activerecord
             ActiveRecord::Base.send(:include, Padrino::Admin::Adapters::Ar::Base)
             klass.send(:include, Padrino::Admin::Adapters::Ar::Account)
-          when :data_mapper
+          when :datamapper
             DataMapper::Model.descendants.each { |d| d.send(:include, Padrino::Admin::Adapters::Dm::Base) }
             klass.send(:include, Padrino::Admin::Adapters::Dm::Account)
-          when :mongo_mapper
+          # Not yet finished
+          when :mongomapper
             MongoMapper::Document.append_inclusions(Padrino::Admin::Adapters::Mm::Base)
             klass.send(:include, Padrino::Admin::Adapters::Mm::Account)
           else
             raise Padrino::Admin::AdapterError, "The adapter #{adapter.inspect} is not supported, available adapters are: " + 
-                                                ":active_record, :data_mapper, :mongo_mapper"
+                                                ":activerecord, :datamapper, :mongomapper"
         end
       end
 
       # Here standard extension
       module Base
-        # TODO
+        def self.included(base)
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
+        end
+
+        module InstanceMethods
+        end
+
+        module ClassMethods
+          # This method generate store and column config.
+          # for lazinies hands instead supply:
+          # 
+          #   Model.column_store("./../views/model/store.jml")
+          # 
+          # you can:
+          # 
+          #   Model.column_store(options.views, "models/store")
+          def column_store(*args)
+            path   = File.join(*args)
+            path   = Dir[path + ".{jml,jaml}"].first.to_s if path !~ /(\.jml|\.jaml)$/
+            config = YAML.load_file(path)
+            Padrino::ExtJs::ColumnStore.new(self, config)
+          end
+        end
       end
       # Here extension for account
       # 
@@ -54,7 +78,7 @@ module Padrino
         module ClassMethods
           # This method it's for authentication purpose
           def authenticate(email, password)
-            account = first(:conditions => { :email => email })
+            account = first(:conditions => { :email => email }) if email.present?
             account && account.password_clean == password ? account : nil
           end
         end

data/lib/padrino-admin/ext_js/column_store.rb

@@ -0,0 +1,142 @@
+module Padrino
+  module ExtJs
+    # Return column config, and store config/data for ExtJS ColumnModel and Store
+    class ColumnStore
+      attr_reader :data
+
+      def initialize(klass_model, config) #:nodoc
+        @model = klass_model
+        table_name = @model.table_name || @model.class.to_s.downcase.pluralize
+        @data = config["columns"].map do |column|
+
+          # Reformat our config
+          column["header"]     ||= column["method"].to_s
+          column["dataIndex"]  ||= column["method"]
+          column["sortable"]   ||= column["sortable"].nil? ? true : column["sortable"]
+          column["header"]       = @model.human_attribute_name(column["header"]) # try to translate with I18n the column name
+
+          # Try to reformat the dataIndex
+          data_indexes = Array(column["dataIndex"]).collect do |data_index|
+            if data_index =~ /\./ # if we have some like categories.names we use this
+              cols = data_index.split(".")
+              column["name"] ||= cols[0] + "[" + cols[1..-1].join("][") + "]" # accounts.name will be => accounts[name]
+            else
+              column["name"] ||= "#{table_name.singularize}[#{data_index}]"
+              data_index = "#{table_name}.#{data_index}"
+            end
+            data_index
+          end
+
+          # Now we join our data indexes
+          column["dataIndex"] = data_indexes.compact.uniq.join(",")
+
+          # Reformat mapping like a div id
+          column["mapping"] ||= column["name"].sub(/\[/,"_").sub(/\]$/, "").sub(/\]\[/,"_")
+
+          # Now is necessary for our columns an ID
+          # TODO: check duplicates here
+          column["id"] = column["mapping"]
+
+          # Finally we can return our column
+          column
+        end
+      end
+
+      # Return an array config for build an Ext.grid.ColumnModel() config
+      def column_fields
+        data = @data.map do |data|
+          data     = data.dup
+          editor   = parse_column_editor(data.delete("editor"))
+          renderer = parse_column_renderer(data.delete("renderer"))
+          data.merge!(editor)   if editor
+          data.merge!(renderer) if renderer
+          data.delete("method")
+          data.delete("mapping")
+          data
+        end
+        JSON.pretty_generate(data)
+      end
+
+      # Return an array config for build an Ext.data.GroupingStore()
+      def store_fields
+        data = @data.map do |data|
+          type = parse_store_renderer(data["renderer"])
+          hash = { :name => data["dataIndex"] , :mapping => data["mapping"] }
+          hash.merge!(type) if type
+          hash
+        end
+        JSON.pretty_generate(data)
+      end
+
+      # Return data for a custom collection for the ExtJS Ext.data.GroupingStore() json
+      def store_data_from(collection)
+        collection.map do |c|
+          @data.dup.inject({ "id" => c.id }) do |options, data|
+            options[data["mapping"]] = (c.instance_eval(data["method"]) rescue I18n.t("admin.labels.not_found"))
+            options
+          end
+        end
+      end
+
+      # Return a searched and paginated data collection for the ExtJS Ext.data.GroupingStore() json
+      # You can pass options like:
+      # 
+      #   Examples
+      #   
+      #     store_data(params, :conditions => "found = 1")
+      #     store_data(params, :include => :posts)
+      # 
+      def store_data(params={}, options={})
+        # Some can tell me that this method made two identical queries one for count one for paginate.
+        # We don't use the select count because in some circumstances require much time than select *.
+        params[:limit]     ||= 50
+        collection           = @model.all(options).ext_search(params)
+        collection_count     = collection.length
+        collection_paginated = collection.ext_paginate(params)
+        { :results => store_data_from(collection_paginated), :count => collection_count }.to_json
+      end
+
+      private
+        def parse_store_renderer(renderer)
+          case renderer
+            when "date"          then { :type => "date", :dateFormat => "Y-m-d" }
+            when "datetime"      then { :type => "date", :dateFormat => "c" }
+            when "time_to_date"  then { :type => "date", :dateFormat => "c" }
+          end
+        end
+
+        def parse_column_editor(editor)
+          case editor
+            when "checkbox"      then { :checkbox => true }
+            when "combo"         then { :editor => "new Ext.form.ComboBox()".to_l }
+            when "datefield"     then { :editor => "new Ext.form.DateField()".to_l }
+            when "numberfield"   then { :editor => "new Ext.form.NumberField()".to_l }
+            when "radio"         then { :editor => "new Ext.form.Radio()".to_l }
+            when "textarea"      then { :editor => "new Ext.form.TextArea()".to_l }
+            when "textfield"     then { :editor => "new Ext.form.TextField()".to_l }
+            when "timefield"     then { :editor => "new Ext.form.TimeField()".to_l }
+            when "datetimefield" then { :editor => "new Ext.form.DateTimeField()".to_l }
+          end
+        end
+
+        def parse_column_renderer(renderer)
+          case renderer
+            when "time_to_date" then { :renderer => "Ext.util.Format.dateRenderer()".to_l }
+            when "date"         then { :renderer => "Ext.util.Format.dateRenderer()".to_l }
+            when "datetime"     then { :renderer => "Ext.util.Format.dateTimeRenderer()".to_l }
+            when "percentage"   then { :renderer => "Ext.util.Format.percentage".to_l }
+            when "eur_money"    then { :renderer => "Ext.util.Format.eurMoney".to_l }
+            when "us_money"     then { :renderer => "Ext.util.Format.usMoney".to_l }
+            when "boolean"      then { :renderer => "Ext.util.Format.boolRenderer".to_l }
+            when "capitalize"   then { :renderer => "Ext.util.Format.capitalize".to_l }
+            when "file_size"    then { :renderer => "Ext.util.Format.fileSize".to_l }
+            when "downcase"     then { :renderer => "Ext.util.Format.lowercase".to_l }
+            when "trim"         then { :renderer => "Ext.util.Format.trim".to_l }
+            when "undef"        then { :renderer => "Ext.util.Format.undef".to_l }
+            when "upcase"       then { :renderer => "Ext.util.Format.uppercase".to_l }
+          end
+        end
+
+    end
+  end
+end