lipsiadmin 2.9

data/lib/view/helpers/ext/store.rb

@@ -0,0 +1,103 @@
+module Lipsiadmin#:nodoc:
+  module Ext#:nodoc:
+    # Generate a new Ext.data.GroupingStore
+    # 
+    # Examples:
+    # 
+    #   var store = new Ext.data.GroupingStore({
+    #     reader: new Ext.data.JsonReader({
+    #       id:'id', 
+    #       totalProperty:'count', root:'results',
+    #       fields:[{
+    #       name: "accounts.name"
+    #     },{
+    #       name: "accounts.categories.name"
+    #     },{
+    #       type: "date",
+    #       renderer: Ext.util.Format.dateRenderer(),
+    #       name: "accounts.date",
+    #       dateFormat: "c"
+    #     },{
+    #       type: "date",
+    #       renderer: Ext.util.Format.dateTimeRenderer(),
+    #       name: "accounts.datetime",
+    #       dateFormat: "c"
+    #     } ]}),
+    #     proxy: new Ext.data.HttpProxy({ url:'/backend/accounts.json' }),
+    #     remoteSort: true
+    #   });
+    # 
+    #   grid.store do |store|
+    #     store.url "/backend/accounts.json"
+    #     store.add "accounts.name"
+    #     store.add "accounts.categories.name"
+    #     store.add "accounts.date", :type => :date
+    #     store.add "accounts.datetime", :type => :datetime
+    #   end
+    #
+    class Store < Component
+      attr_accessor :items
+      
+      def initialize(options={}, &block)#:nodoc:
+        @items   = []
+        super("Ext.data.GroupingStore", options, &block)
+        remoteSort l(true)                  if config[:remoteSort].blank?
+        baseParams("_method" => "GET")      if config[:baseParams].blank?
+      end
+      
+      # The url for getting the json data
+      def url(value)
+        @url = value
+      end
+      
+      # This add automatically fields from an array
+      def fields(fields)
+        fields.each { |options| add(nil, options) }
+      end
+
+      # Add fields to a Ext.data.JsonReader 
+      # 
+      # Examples:
+      # 
+      #   {
+      #     type: "date",
+      #     renderer: Ext.util.Format.dateTimeRenderer(),
+      #     name: "accounts.datetime",
+      #     dateFormat: "c"
+      #   }
+      # 
+      #   add "accounts.datetime", :type => :datetime
+      #
+      def add(name=nil, options={})#:nodoc:
+        options[:name] = name if name
+        case options[:type]
+          when :date     then options.merge!({ :type => "date", :dateFormat => "Y-m-d" })
+          when :datetime then options.merge!({ :type => "date", :dateFormat => "c" })
+        end
+        raise ComponentError, "You must provide a Name for all fields" if options[:name].blank?
+        @items << Configuration.new(options)
+      end
+      
+      # Return the javascript for create a new Ext.data.GroupingStore 
+      def to_s
+        raise ComponentError, "You must provide the correct var the store."       if get_var.blank?
+        raise ComponentError, "You must provide the url for get the store data."  if @url.blank? && config[:proxy].blank?
+        raise ComponentError, "You must provide some fields for get build store." if items.blank?
+        config[:proxy]  = default_proxy  if config[:proxy].blank?
+        config[:reader] = default_reader if config[:reader].blank?
+        super
+      end
+      
+      private
+        def default_proxy
+          l("new Ext.data.HttpProxy(#{Configuration.new(:url => @url).to_s(2)})")
+        end
+
+        def default_reader
+          options = { :id => "id", :totalProperty => "count", :root => "results", :fields => l("["+items.collect { |i| i.to_s(3) }.join(",")+"]")  }
+          l("new Ext.data.JsonReader(#{Configuration.new(options).to_s(2)})")
+        end
+
+    end
+  end
+end

data/lib/view/helpers/ext/templates/grid_functions.js.erb

@@ -0,0 +1,51 @@
+<%= @sm %>.on('selectionchange', function(){
+  var n = <%= @sm %>.getSelected();
+  var btns = <%= @tbar %>.items.map;
+
+   if(!n){
+    btns.remove.disable();
+    btns.edit.disable();
+     return;
+  } else {
+    btns.remove.enable();
+    btns.edit.enable();
+    return;
+   }
+});
+
+function add(){
+  Backend.app.load('<%= @new_path.blank? ? "#{@base_path}/new" : @new_path %>');
+}
+
+function edit(){
+  Backend.app.load('<%= @edit_path || @base_path %>/'+<%= @sm %>.getSelected().id+'/edit');
+}
+
+function remove(){
+  Ext.Msg.confirm(Backend.locale.messages.confirm.title, String.format(Backend.locale.messages.confirm.message, <%= @sm %>.getCount()), function(btn, text){
+    if (btn == 'yes'){
+      <%= @sm %>.each(function(r){
+        Backend.app.mask();
+        Ext.Ajax.request({
+          url: '<%= @destroy_path || @base_path %>/'+r.id,
+          method: 'DELETE',
+          params: {<%= @forgery_protection_token %>: '<%= @authenticity_token %>'},
+          success: function(result, request){
+            Backend.app.unmask();
+            var resultValue = Ext.decode(result.responseText); 
+            if (resultValue.success == true){
+              <%= @store %>.remove(r);
+            } else { 
+              Ext.MessageBox.alert(Backend.locale.messages.alert.title, resultValue.msg);
+              return;
+            }
+          },                
+          failure: function(result, request) {
+            Backend.app.unmask();
+            Ext.Msg.alert(Backend.locale.messages.alert.title, Backend.locale.messages.alert.message);
+          }
+        });
+      })
+    }
+  });
+}

data/lib/view/helpers/ext/tool_bar.rb

@@ -0,0 +1,40 @@
+module Lipsiadmin
+  module Ext
+    # Generate a new Ext.Toolbar
+    # 
+    #   Examples:
+    # 
+    #     var toolBar = new Ext.Toolbar([{
+    #         handler: show();,
+    #         text: "Add",
+    #         other: "...",
+    #         icon: "..."
+    #       },{
+    #         handler: Backend.app.loadHtml('/accounts/'+accounts_grid.getSelected().id+'/edit'),
+    #         text: "Edit",
+    #         other: "..."
+    #     }]);
+    #
+    #   grid.tbar do |bar|
+    #     bar.add "Add",  :handler => bar.l("show();"), :icon => "...", :other => "..."
+    #     bar.add "Edit", :handler => bar.l("Backend.app.loadHtml('/accounts/'+accounts_grid.getSelected().id+'/edit')"), :other => "..."
+    #   end
+    #
+    class ToolBar < Component
+      attr_accessor :items
+      def initialize(options={}, &block)#:nodoc:
+        super("Ext.Toolbar", { :items => [] }.merge(options), &block)
+      end
+      
+      # Add new items to a Ext.Toolbar
+      # 
+      #   # Generates: { handler: show();, text: "Add", other: "...", icon: "..." }
+      #   add "Add",  :handler => bar.l("show();"), :icon => "...", :other => "..."
+      # 
+      def add(name, options={})
+        options[:text] = name
+        config[:items] << Configuration.new(options)
+      end
+    end
+  end
+end

data/lib/view/helpers/ext_helper.rb

@@ -0,0 +1,150 @@
+require 'view/helpers/ext/component'
+require 'view/helpers/ext/grid'
+require 'view/helpers/ext/column_model'
+require 'view/helpers/ext/tool_bar'
+require 'view/helpers/ext/configuration'
+require 'view/helpers/ext/store'
+
+module Lipsiadmin
+  module View
+    module Helpers
+      # Module containing the methods useful for ext/prototype
+      module ExtHelper
+      
+        def self.included(base)#:nodoc:
+          base.class_eval do
+            alias_method_chain :to_s, :refactoring
+          end
+        end
+      
+        def to_s_with_refactoring #:nodoc:
+          returning javascript = @lines * $/ do
+            source = javascript.dup
+          end
+        end
+      
+        # Hide all open dialogs
+        def hide_dialogs
+          record "Ext.Msg.getDialog().hide()"
+        end
+      
+        # Replaces the inner HTML of the Main Panel of +Backend+.
+        #
+        # +options_for_render+ may be either a string of HTML to insert, or a hash
+        # of options to be passed to ActionView::Base#render.  For example:
+        #
+        #   # Replaces the inner HTML of the Main Panel of +Backend+.
+        #   # Generates:  Backend.app.update("-- Contents of 'person' partial --");
+        #   page.update :partial => 'person', :object => @person
+        #      
+        def update(*options_for_render)
+          call "Backend.app.update", render(*options_for_render), true
+        end
+      
+        # Load html/js and eval it's code
+        # 
+        #   # Generates: Backend.app.loadJs('/my/javascript.js');
+        #   load(:controller => :my, :action => :javascript, :format => :js)
+        #
+        def load(location, cache = false)
+          url = location.is_a?(String) ? location : @context.url_for(location)
+          call "Backend.app.load", url, cache
+        end
+      
+        # Show errors (if they are) for the given +objects+ and show a Ext.Message 
+        # with explanation of the errors or if errors are empty, a congratulation message.
+        # 
+        #   # Generates: 
+        #   #   Ext.Msg.show({
+        #   #     title:Backend.locale.messages.alert.title,
+        #   #     msg: '<ul>Name can't be blank!</ul>',
+        #   #     buttons: Ext.Msg.OK,
+        #   #     minWidth: 400
+        #   #   })
+        #   show_errors_for(@account)
+        #
+        def show_errors_for(*objects)
+          count   = objects.inject(0) {|sum, object| sum + object.errors.count }
+          unless count.zero?
+            error_messages = objects.map {|object| object.errors.full_messages.map {|msg| "<li>#{msg}</li>" } }
+            record "Ext.Msg.show({
+                      title:    Backend.locale.messages.alert.title,
+                      msg:      '<ul>#{escape_javascript(error_messages.join)}</ul>',
+                      buttons:  Ext.Msg.OK,
+                      minWidth: 400
+                    });"
+          else
+            record "Ext.Msg.alert(Backend.locale.messages.compliments.title, Backend.locale.messages.compliments.message);"
+          end
+        end
+
+        # Show a Ext.alert popup
+        # 
+        #   # Generates: Ext.Msg.alert('Hey!', 'Hello World')
+        #   ext_alert('Hey!', 'Hello World')
+        #
+        def ext_alert(title, message)
+          call "Ext.Msg.alert", title, message
+        end
+
+        # Unmask the Backend App
+        # 
+        #   # Generates: Backend.app.unmask()
+        #   unmask
+        #
+        def unmask
+          call "Backend.app.unmask"
+        end
+        
+        # Mask the Backend App
+        # 
+        #   # Generates: Backend.app.mask('Hello World')
+        #   mask("Hello World")
+        #
+        def mask(title=nil)
+          call "Backend.app.mask", title
+        end        
+      
+        # Create a javascript function
+        # 
+        #   # Generates: function() { window.show(); };
+        #   page.fn("window.show();")
+        #   or
+        #   page.fn { |p| p.call "window.show" }
+        #
+        def fn(function=nil, &block)
+          if function
+            record "function() { #{literal(function)} }"
+          else
+            record block_to_function(function || block)
+          end
+        end
+      
+        # Generate a full customizable Ext.GridPanel
+        #
+        # Examples:
+        #
+        #   page.grid do |grid|
+        #     grid.id "grid-posts"
+        #     grid.title "List all Post"
+        #     grid.base_path "/backend/posts"
+        #     grid.forgery_protection_token request_forgery_protection_token
+        #     grid.authenticity_token form_authenticity_token
+        #     grid.tbar  :default
+        #     grid.store do |store|
+        #       store.url "/backend/posts.json"
+        #       store.fields @column_store.store_fields
+        #     end
+        #     grid.columns do |columns|
+        #       columns.fields @column_store.column_fields
+        #     end
+        #     grid.bbar  :store => grid.get_store, :pageSize => params[:limit]
+        #   end
+        # 
+        def grid(&block)
+          self << Lipsiadmin::Ext::Grid.new(&block)
+        end
+      end
+    end
+  end
+end

data/lib/view/helpers/view_helper.rb

@@ -0,0 +1,222 @@
+require "date"
+require 'action_view/helpers/tag_helper'
+module Lipsiadmin
+  module View
+    module Helpers#:nodoc:
+      # Returns text_area, text_field, password_field with 
+      # a default extjs css style.
+      # 
+      module FormHelper
+        def self.included(base)#:nodoc:
+          base.alias_method_chain :text_area, :style
+          base.alias_method_chain :text_field, :style
+          base.alias_method_chain :password_field, :style
+        end
+
+        # Returns text_area with extjs style
+        # alias for text_area, for use the original tag use:
+        # 
+        #   text_area_without_style
+        # 
+        def text_area_with_style(name, value = nil, options = {})
+          options[:class] ||= "x-form-field"
+          options[:style] ||= "width:100%;height:80px"
+          text_area_without_style(name, value, options)
+        end
+
+        # Returns text_field with extjs style
+        # alias for text_field, for use the original tag use:
+        # 
+        #   text_field_without_style
+        #        
+        def text_field_with_style(name, method, options = {})
+          options[:class] ||= "x-form-text"
+          options[:style] ||= "width:100%"
+          text_field_without_style(name, method, options)
+        end
+        
+        # Returns password_field with extjs style
+        # alias for password_field, for use the original tag use:
+        # 
+        #   password_field_without_style
+        #        
+        def password_field_with_style(name, method, options = {})
+          options[:class] ||= "x-form-text"
+          options[:style] ||= "width:100%"
+          password_field_without_style(name, method, options)
+        end
+      end
+
+      # Returns text_area_tag, text_field_tag, password_field_tag with 
+      # a default extjs css style.
+      #      
+      module FormTagHelper
+        
+        def self.included(base)#:nodoc:
+          base.alias_method_chain :text_field_tag, :style
+          base.alias_method_chain :text_area_tag, :style
+          base.alias_method_chain :password_field_tag, :style
+        end
+
+        # Returns text_area_tag with extjs style
+        # alias for text_area_tag, for use the original tag use:
+        # 
+        #   text_area_tag_without_style
+        # 
+        def text_area_tag_with_style(name, value = nil, options = {})
+          options[:class] ||= "x-form-field"
+          options[:style] ||= "width:100%;height:80px"
+          text_area_tag_without_style(name, value, options)
+        end
+
+        # Returns text_field_tag with extjs style
+        # alias for text_field_tag, for use the original tag use:
+        # 
+        #   text_field_tag_without_style
+        # 
+        def text_field_tag_with_style(name, value = nil, options = {})
+          options[:class] ||= "x-form-text"
+          options[:style] ||= "width:100%"
+          text_field_tag_without_style(name, value, options)
+        end
+        
+        # Returns password_field_tag with extjs style
+        # alias for password_field_tag, for use the original tag use:
+        # 
+        #   password_field_tag_style
+        # 
+        def password_field_tag_with_style(name, value = nil, options = {})
+          options[:class] ||= "x-form-text"
+          options[:style] ||= "width:100%"
+          password_field_tag_without_style(name, value, options)
+        end
+      end
+      
+      module DateHelper
+        # Returns an ExtJs Calendar
+        # 
+        #   Examples:
+        #     =ext_date_select :post, :created_at
+        #       
+        def ext_date_select(object_name, method, options = {}, html_options = {})
+          InstanceTag.new(object_name, method, self, options.delete(:object)).to_ext_date_select_tag(options, html_options)
+        end
+      
+        # Returns an ExtJs Calendar and a Time selector
+        # 
+        #   Examples:
+        #     =ext_datetime_select :post, :updated_at
+        #
+        def ext_datetime_select(object_name, method, options = {}, html_options = {})
+          InstanceTag.new(object_name, method, self, options.delete(:object)).to_ext_datetime_select_tag(options, html_options)
+        end
+      end
+
+      module CountrySelectHelper
+        # Return select and option tags for the given object and method, using country_options_for_select to generate the list of option tags.
+        def country_select(object, method, priority_countries = nil, options = {}, html_options = {})
+          InstanceTag.new(object, method, self, options.delete(:object)).to_country_select_tag(priority_countries, options, html_options)
+        end
+        # Returns a string of option tags for pretty much any country in the world. Supply a country name as +selected+ to
+        # have it marked as the selected option tag. You can also supply an array of countries as +priority_countries+, so
+        # that they will be listed above the rest of the (long) list.
+        #
+        # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
+        def country_options_for_select(selected = nil, priority_countries = nil)
+          country_options = ""
+
+          if priority_countries
+            country_options += options_for_select(priority_countries, selected)
+            country_options += "<option value=\"\" disabled=\"disabled\">-------------</option>\n"
+          end
+
+          return country_options + options_for_select(COUNTRIES, selected)
+        end
+        # All the countries included in the country_options output.
+        COUNTRIES = ["Afghanistan", "Aland Islands", "Albania", "Algeria", "American Samoa", "Andorra", "Angola",
+          "Anguilla", "Antarctica", "Antigua And Barbuda", "Argentina", "Armenia", "Aruba", "Australia", "Austria",
+          "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin",
+          "Bermuda", "Bhutan", "Bolivia", "Bosnia and Herzegowina", "Botswana", "Bouvet Island", "Brazil",
+          "British Indian Ocean Territory", "Brunei Darussalam", "Bulgaria", "Burkina Faso", "Burundi", "Cambodia",
+          "Cameroon", "Canada", "Cape Verde", "Cayman Islands", "Central African Republic", "Chad", "Chile", "China",
+          "Christmas Island", "Cocos (Keeling) Islands", "Colombia", "Comoros", "Congo",
+          "Congo, the Democratic Republic of the", "Cook Islands", "Costa Rica", "Cote d'Ivoire", "Croatia", "Cuba",
+          "Cyprus", "Czech Republic", "Denmark", "Djibouti", "Dominica", "Dominican Republic", "Ecuador", "Egypt",
+          "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Ethiopia", "Falkland Islands (Malvinas)",
+          "Faroe Islands", "Fiji", "Finland", "France", "French Guiana", "French Polynesia",
+          "French Southern Territories", "Gabon", "Gambia", "Georgia", "Germany", "Ghana", "Gibraltar", "Greece", "Greenland", "Grenada", "Guadeloupe", "Guam", "Guatemala", "Guernsey", "Guinea",
+          "Guinea-Bissau", "Guyana", "Haiti", "Heard and McDonald Islands", "Holy See (Vatican City State)",
+          "Honduras", "Hong Kong", "Hungary", "Iceland", "India", "Indonesia", "Iran, Islamic Republic of", "Iraq",
+          "Ireland", "Isle of Man", "Israel", "Italy", "Jamaica", "Japan", "Jersey", "Jordan", "Kazakhstan", "Kenya",
+          "Kiribati", "Korea, Democratic People's Republic of", "Korea, Republic of", "Kuwait", "Kyrgyzstan",
+          "Lao People's Democratic Republic", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libyan Arab Jamahiriya",
+          "Liechtenstein", "Lithuania", "Luxembourg", "Macao", "Macedonia, The Former Yugoslav Republic Of",
+          "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands", "Martinique",
+          "Mauritania", "Mauritius", "Mayotte", "Mexico", "Micronesia, Federated States of", "Moldova, Republic of",
+          "Monaco", "Mongolia", "Montenegro", "Montserrat", "Morocco", "Mozambique", "Myanmar", "Namibia", "Nauru",
+          "Nepal", "Netherlands", "Netherlands Antilles", "New Caledonia", "New Zealand", "Nicaragua", "Niger",
+          "Nigeria", "Niue", "Norfolk Island", "Northern Mariana Islands", "Norway", "Oman", "Pakistan", "Palau",
+          "Palestinian Territory, Occupied", "Panama", "Papua New Guinea", "Paraguay", "Peru", "Philippines",
+          "Pitcairn", "Poland", "Portugal", "Puerto Rico", "Qatar", "Reunion", "Romania", "Russian Federation",
+          "Rwanda", "Saint Barthelemy", "Saint Helena", "Saint Kitts and Nevis", "Saint Lucia",
+          "Saint Pierre and Miquelon", "Saint Vincent and the Grenadines", "Samoa", "San Marino",
+          "Sao Tome and Principe", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Sierra Leone", "Singapore",
+          "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa",
+          "South Georgia and the South Sandwich Islands", "Spain", "Sri Lanka", "Sudan", "Suriname",
+          "Svalbard and Jan Mayen", "Swaziland", "Sweden", "Switzerland", "Syrian Arab Republic",
+          "Taiwan, Province of China", "Tajikistan", "Tanzania, United Republic of", "Thailand", "Timor-Leste",
+          "Togo", "Tokelau", "Tonga", "Trinidad and Tobago", "Tunisia", "Turkey", "Turkmenistan",
+          "Turks and Caicos Islands", "Tuvalu", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom",
+          "United States", "United States Minor Outlying Islands", "Uruguay", "Uzbekistan", "Vanuatu", "Venezuela",
+          "Viet Nam", "Virgin Islands, British", "Virgin Islands, U.S.", "Wallis and Futuna", "Western Sahara",
+          "Yemen", "Zambia", "Zimbabwe"] unless const_defined?("COUNTRIES")
+      end
+
+      class InstanceTag < ActionView::Helpers::InstanceTag#:nodoc:
+        include CountrySelectHelper
+        
+        def to_ext_date_select_tag(options = {}, html_options = {})
+          to_ext_datetime_select_tag({ :hideTime => true.to_l }.merge(options), html_options)
+        end
+
+        def to_ext_datetime_select_tag(options = {}, html_options = {})
+          html_options = html_options.stringify_keys
+          html_options = DEFAULT_FIELD_OPTIONS.merge(html_options)
+          html_options["type"] = "hidden"
+          html_options["value"] ||= value_before_type_cast(object)
+          html_options["value"] &&= html_escape(html_options["value"])
+          add_default_name_and_id(html_options)
+          options = { :applyTo => html_options["id"], :dateFormat => I18n.t("extjs.dateFormat") }.merge(options)
+          tag("input", html_options) +
+          content_tag(:script, "new Ext.form.DateTimeField(#{options.to_json});", :type => Mime::JS)
+        end
+        
+        def to_country_select_tag(priority_countries, options, html_options)
+          html_options = html_options.stringify_keys
+          add_default_name_and_id(html_options)
+          value = value(object)
+          content_tag("select",
+            add_options(
+              country_options_for_select(value, priority_countries),
+              options, value
+            ), html_options
+          )
+        end
+      end
+
+      module FormBuilder#:nodoc:
+        def ext_date_select(method, options = {}, html_options = {})
+          @template.ext_date_select(@object_name, method, options.merge(:object => @object), html_options)
+        end
+
+        def ext_datetime_select(method, options = {}, html_options = {})
+          @template.ext_datetime_select(@object_name, method, options.merge(:object => @object), html_options)
+        end
+        
+        def country_select(method, priority_countries = nil, options = {}, html_options = {})
+          @template.country_select(@object_name, method, priority_countries, options.merge(:object => @object), html_options)
+        end
+      end
+    end
+  end
+end