skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/lib/netzke/grid_interface.rb

@@ -1,156 +0,0 @@
-module Netzke::GridInterface
-  def post_data(params)
-    [:create, :update].each do |operation|
-      data = JSON.parse(params.delete("#{operation}d_records".to_sym)) if params["#{operation}d_records".to_sym]
-      process_data(data, operation) if !data.nil?
-    end
-    {:success => true, :flash => @flash}
-  end
-  
-  def get_data(params = {})
-    if @permissions[:read]
-      records = get_records(params)
-      {:data => records, :total => records.total_records}
-    else
-      flash :error => "You don't have permissions to read data"
-      {:success => false, :flash => @flash}
-    end
-  end
-
-  def delete_data(params = {})
-    if @permissions[:delete]
-      record_ids = JSON.parse(params.delete(:records))
-      klass = config[:data_class_name].constantize
-      klass.delete(record_ids)
-      flash :notice => "Deleted #{record_ids.size} record(s)"
-      success = true
-    else
-      flash :error => "You don't have permissions to delete data"
-      success = false
-    end
-    {:success => success, :flash => @flash}
-  end
-
-  def resize_column(params)
-    raise "Called interface_resize_column while not configured to do so" unless config[:column_resize]
-    l_item = layout_manager_class.by_widget(id_name).layout_items[params[:index].to_i]
-    l_item.width = params[:size]
-    l_item.save!
-    {}
-  end
-  
-  def move_column(params)
-    raise "Called interface_move_column while not configured to do so" unless config[:column_move]
-    layout_manager_class.by_widget(id_name).move_item(params[:old_index].to_i, params[:new_index].to_i)
-    {}
-  end
-
-  # Return the choices for the column
-  def get_cb_choices(params)
-    column = params[:column]
-    query = params[:query]
-    
-    {:data => config[:data_class_name].constantize.choices_for(column, query).map{|s| [s]}}
-  end
-  
-  
-  protected
-
-  # operation => :update || :create
-  def process_data(data, operation)
-    if @permissions[operation]
-      klass = config[:data_class_name].constantize
-      modified_records = 0
-      data.each do |record_hash|
-        record = operation == :create ? klass.create : klass.find(record_hash.delete('id'))
-        logger.debug { "!!! record: #{record.inspect}" }
-        success = true
-        exception = nil
-        
-        # process all attirubutes for the same record (OPTIMIZE: we can use update_attributes separately for regular attributes to speed things up)
-        record_hash.each_pair do |k,v|
-          begin
-            record.send("#{k}=",v)
-          rescue ArgumentError => exc
-            flash :error => exc.message
-            success = false
-            break
-          end
-        end
-        
-        # try to save
-        modified_records += 1 if success && record.save
-
-        # flash eventual errors
-        record.errors.each_full do |msg|
-          flash :error => msg
-        end
-        
-        flash :notice => "#{operation.to_s.capitalize}d #{modified_records} records"
-      end
-    else
-      flash :error => "You don't have permissions to #{operation} data"
-    end
-  end
-  
-  # get records
-  def get_records(params)
-    search_params = normalize_params(params)
-    raise ArgumentError, "No data_class_name specified for widget '#{config[:name]}'" if !config[:data_class_name]
-    records = config[:data_class_name].constantize.all(search_params.clone) # clone needed as searchlogic removes :conditions key from the hash
-    output_array = []
-    records.each do |r|
-      r_array = []
-      self.get_columns.each do |column|
-        r_array << r.send(column[:name])
-      end
-      output_array << r_array
-    end
-
-    # add total_entries accessor to the result
-    class << output_array
-      attr :total_records, true
-    end
-    total_records_count = config[:data_class_name].constantize.count(search_params)
-    output_array.total_records = total_records_count
-
-    output_array
-  end
-  
-  def convert_filters(column_filter)
-    res = {}
-    column_filter.each_pair do |k,v|
-      field = v["field"]
-      case v["data"]["type"]
-      when "string"
-        field << "_contains"
-      when "numeric"
-        field << "_#{v["data"]["comparison"]}"
-      end
-      value = v["data"]["value"]
-      res.merge!({field => value})
-    end
-    res
-  end
-  
-  # make params understandable to searchlogic
-  def normalize_params(params)
-    # filters
-    conditions = params[:filter] && convert_filters(params[:filter])
-    
-    normalized_conditions = {}
-    conditions && conditions.each_pair do |k, v|
-      assoc, method = k.split('__')
-      normalized_conditions.merge!(method.nil? ? {assoc => v} : {assoc => {method => v}})
-    end
-    
-    # sorting
-    order_by = if params[:sort]
-      assoc, method = params[:sort].split('__')
-      method.nil? ? assoc : {assoc => method}
-    end
-    
-    page = params[:start].to_i/params[:limit].to_i + 1 if params[:limit]
-    {:per_page => params[:limit], :page => page, :order_by => order_by, :order_as => params[:dir], :conditions => normalized_conditions}
-  end
-end

data/lib/netzke/grid_js_builder.rb

@@ -1,276 +0,0 @@
-module Netzke::GridJsBuilder
-  def js_base_class 
-    'Ext.grid.EditorGridPanel'
-  end
-
-  def js_bbar
-    <<-JS.l
-    (config.rowsPerPage) ? new Ext.PagingToolbar({
-      pageSize:config.rowsPerPage, 
-      items:config.actions, 
-      store:ds, 
-      emptyMsg:'Empty'}) : config.actions
-    JS
-  end
-
-  def js_default_config
-    super.merge({
-      :store => "ds".l,
-      :cm => "cm".l,
-      :sel_model => "new Ext.grid.RowSelectionModel()".l,
-      :auto_scroll => true,
-      :click_to_edit => 2,
-      :track_mouse_over => true,
-      # :bbar => "config.actions".l,
-      :bbar => js_bbar,
-      :plugins => "plugins".l,
-      
-      #custom configs
-      :auto_load_data => true
-    })
-  end
-  
-  def js_before_constructor
-    <<-JS
-    var plugins = [];
-  	if (!config.columns) this.feedback('No columns defined for grid '+config.id);
-    this.recordConfig = [];
-    Ext.each(config.columns, function(column){this.recordConfig.push({name:column.name})}, this);
-    this.Row = Ext.data.Record.create(this.recordConfig);
-
-    var ds = new Ext.data.Store({
-        proxy: this.proxy = new Ext.data.HttpProxy({url:config.interface.getData}),
-        reader: new Ext.data.ArrayReader({root: "data", totalProperty: "total", successProperty: "succes", id:0}, this.Row),
-        remoteSort: true,
-        listeners:{'loadexception':{
-          fn:this.loadExceptionHandler,
-          scope:this
-        }}
-    });
-    
-    this.cmConfig = [];
-    Ext.each(config.columns, function(c){
-      var editor = c.readOnly ? null : Ext.netzke.editors[c.showsAs](c, config);
-
-      this.cmConfig.push({
-        header: c.label || c.name,
-        dataIndex: c.name,
-        hidden: c.hidden,
-        width: c.width,
-        editor: editor,
-        sortable: true
-      })
-    }, this);
-
-    var cm = new Ext.grid.ColumnModel(this.cmConfig);
-    
-    this.addEvents("refresh");
-    
-    // Filters
-    if (config.columnFilters) {
-      var filters = []
-      Ext.each(config.columns, function(c){
-        filters.push({type:Ext.netzke.filterMap[c.showsAs], dataIndex:c.name})
-      })
-    	var gridFilters = new Ext.grid.GridFilters({filters:filters});
-      plugins.push(gridFilters);
-    }
-    
-    JS
-  end
-  
-  def js_config
-    res = super
-    # we pass column config at the time of instantiating the JS class
-    res.merge!(:columns => get_columns || config[:columns]) # first try to get columns from DB, then from config
-    res.merge!(:data_class_name => config[:data_class_name])
-    res
-  end
-
-  def js_listeners
-    super.merge({
-      :columnresize => (config[:column_resize] ? {:fn => "this.onColumnResize".l, :scope => this} : nil),
-      :columnmove => (config[:column_move] ? {:fn => "this.onColumnMove".l, :scope => this} : nil)
-    })
-  end
-  
-  
-  def js_extend_properties
-    {
-      :on_widget_load => <<-JS.l,
-        function(){
-          // auto-load
-          if (this.initialConfig.autoLoadData) {
-            // if we have a paging toolbar, load the first page, otherwise
-            if (this.getBottomToolbar().changePage) this.getBottomToolbar().changePage(0); else this.store.load();
-          }
-        }
-      JS
-      
-      :load_exception_handler => <<-JS.l,
-      function(proxy, options, response, error){
-        if (response.status == 200 && (responseObject = Ext.decode(response.responseText)) && responseObject.flash){
-          this.feedback(responseObject.flash)
-        } else {
-          if (error){
-            this.feedback(error.message);
-          } else {
-            this.feedback(response.statusText)
-          }  
-        }
-      }        
-      JS
-    
-      :add => <<-JS.l,
-        function(){
-          var rowConfig = {};
-          Ext.each(this.initialConfig.columns, function(c){
-            rowConfig[c.name] = c.defaultValue || ''; // FIXME: if the user is happy with all the defaults, the record won't be 'dirty'
-          }, this);
-          
-          var r = new this.Row(rowConfig); // TODO: add default values
-          r.set('id', -r.id); // to distinguish new records by negative values
-          this.stopEditing();
-      		this.store.add(r);
-      		this.store.newRecords = this.store.newRecords || []
-      		this.store.newRecords.push(r);
-          // console.info(this.store.newRecords);
-          this.tryStartEditing(this.store.indexOf(r));
-      	}
-      JS
-    
-      :edit => <<-JS.l,
-        function(){
-          var row = this.getSelectionModel().getSelected();
-          if (row){
-            this.tryStartEditing(this.store.indexOf(row))
-          }
-        }
-      JS
-    
-      # try editing the first editable (not hidden, not read-only) sell
-      :try_start_editing => <<-JS.l,
-      	function(row){
-      	  if (row == null) return;
-      		var editableColumns = this.getColumnModel().getColumnsBy(function(columnConfig, index){
-      			return !columnConfig.hidden && !!columnConfig.editor;
-      		});
-      		// console.info(editableColumns);
-      		var firstEditableColumn = editableColumns[0];
-      		if (firstEditableColumn){
-      			this.startEditing(row, firstEditableColumn.id);
-      		}
-      	}
-      JS
-
-      :delete => <<-JS.l,
-        function() {
-          if (this.getSelectionModel().hasSelection()){
-            Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
-              if (btn == 'yes') {
-                var records = []
-                this.getSelectionModel().each(function(r){
-          		    records.push(r.get('id'));
-                }, this);
-        		    Ext.Ajax.request({
-            			url: this.initialConfig.interface.deleteData,
-            			params: {records: Ext.encode(records)},
-            			success:function(r){ 
-            				var m = Ext.decode(r.responseText);
-            				this.store.reload();
-                    // this.loadWithFeedback();
-            				this.feedback(m.flash);
-            			},
-            			scope:this
-            		});
-              }
-            }, this);
-          }
-        }
-      JS
-      :submit => <<-JS.l,
-        function(){
-
-          var newRecords = [];
-          if (this.store.newRecords){
-        		Ext.each(this.store.newRecords, function(r){
-        		  newRecords.push(r.getChanges())
-        		  r.commit() // commit the changes, so that they are not picked up by getModifiedRecords() further down
-        		}, this);
-        		delete this.store.newRecords;
-        	}
-      		
-        	var updatedRecords = [];
-      		Ext.each(this.store.getModifiedRecords(),
-      			function(record) {
-      				var completeRecordData = {};
-      				Ext.apply(completeRecordData, Ext.apply(record.getChanges(), {id:record.get('id')}));
-      				updatedRecords.push(completeRecordData);
-      			}, 
-      		this);
-          
-          if (newRecords.length > 0 || updatedRecords.length > 0) {
-        		Ext.Ajax.request({
-        			url:this.initialConfig.interface.postData,
-        			params: {
-        			  updated_records: Ext.encode(updatedRecords), 
-        			  created_records: Ext.encode(newRecords),
-        			  filters: this.store.baseParams.filters
-        			},
-        			success:function(response){
-        				var m = Ext.decode(response.responseText);
-        				if (m.success) {
-        					this.store.reload();
-                  // this.loadWithFeedback();
-        					this.store.commitChanges();
-        					this.feedback(m.flash);
-        				} else {
-        					this.feedback(m.flash);
-        				}
-        			},
-        			failure:function(response){
-        				this.feedback('Bad response from server');
-        			},
-        			scope:this
-        		});
-          }
-          
-        }
-      JS
-   
-      :refresh_click => <<-JS.l,
-        function() {
-          // console.info(this);
-          // if (this.fireEvent('refresh', this) !== false) this.loadWithFeedback();
-          if (this.fireEvent('refresh', this) !== false) this.store.reload();
-        }
-      JS
-      
-      :on_column_resize => <<-JS.l,
-        function(index, size){
-          // var column = this.getColumnModel().getDataIndex(index);
-          Ext.Ajax.request({
-            url:this.initialConfig.interface.resizeColumn,
-            params:{
-              index:index,
-              size:size
-            }
-          })
-        }
-      JS
-      
-      :on_column_move => <<-JS.l
-        function(oldIndex, newIndex){
-          Ext.Ajax.request({
-            url:this.initialConfig.interface.moveColumn,
-            params:{
-              old_index:oldIndex,
-              new_index:newIndex
-            }
-          })
-        }
-      JS
-      
-    }
-  end
-end

data/lib/netzke/preference_grid.rb

@@ -1,43 +0,0 @@
-module Netzke
-  # GUI for Preference class
-  class PreferenceGrid < PropertyGrid
-    def initialize(*args)
-      super
-      config[:default_properties] ||= []
-      NetzkePreference.custom_field = config[:host_widget_name]
-      
-      # Create default properties
-      config[:default_properties].each do |p|
-        NetzkePreference[p[:name]] = p[:value] if NetzkePreference[p[:name]].nil?
-      end
-    end
-    
-    def load_source(params = {})
-      # config[:data_class_name] = 'NetzkePreference'
-      config[:conditions] ||= {}
-      
-      data_class = NetzkePreference
-      records = data_class.find(:all, :conditions => {:custom_field => config[:host_widget_name]})
-      
-      NetzkePreference.custom_field = config[:host_widget_name]
-      
-      source = {}
-      records.each do |r|
-        source.merge!(r.name => NetzkePreference[r.name])
-      end
-      
-      {:source => source}
-    end
-    
-    def submit_source(params = {})
-      data = JSON.parse(params[:data])
-      NetzkePreference.custom_field = config[:host_widget_name]
-      data.each_pair do |k,v|
-        NetzkePreference[k.underscore] = v
-      end
-      
-      {:success => true, :flash => @flash}
-    end
-    
-  end
-end