2015년 5월 6일 수요일

Grid Cell Merge

cellProcess : function (grid, target) {
        var gridView = grid.getView();
        var cnt=0;
        var prevData = "";
        var flagCell = "";
        
        Ext.each(gridView.getNodes(), function(items){
         var curData = items.childNodes[target].textContent;
         if(prevData != curData) {
         flagCell = items.childNodes[target];
         prevData = curData;
         cnt=0;
         } else {
         cnt++;
         Ext.get(items.childNodes[target]).destroy();
         }
         if(cnt !=0) {
         Ext.get(flagCell).set({rowspan: cnt+1});
         }                            
        });
        
    }

metaData.tdAttr title

{dataIndex: 'message', text: 'MESSAGE', width: 540,
     renderer: function (value , metaData , record , rowIndex , colIndex , store , view) {
                         var textWidth = new Ext.util.TextMetrics().getWidth(value);
                         var cellWidth = metaData.column.width;
                         if(cellWidth < textWidth)
                         metaData.tdAttr = String().concat('title="', value, '"');

                         return value;
     }
},

DynamicGridPanel


/**
* Ext.ux.grid.DynamicGridPanel
*/
Ext.define('Ext.ux.grid.DynamicGridPanel', {
    extend: 'Ext.grid.GridPanel',
    alias: 'widget.dynamicgrid',
    /**
    * initialising the components
    */
    initComponent: function(){
        /**
        * set the config we want
        */
        var config = {
            columns:[],
            rowNumberer: false
        };
       
        // appy to this config
        Ext.apply(this, config);
        // apply to the initialConfig
        Ext.apply(this.initialConfig, config);
        // call the arguments
        this.callParent(arguments);
    },
    /**
    * When the store is loading then reconfigure the column model of the grid
    */
    storeLoad: function()
    {
        /**
        * JSON data returned from server has the column definitions
        */
        if(typeof(this.store.proxy.reader.jsonData.columns) === 'object') {
            var columns = [];
            /**
            * adding RowNumberer as we need to add them
            * before other columns to display first
            */
            if(this.rowNumberer) { columns.push(Ext.create('Ext.grid.RowNumberer')); }
            /**
            * assign new columns from the json data columns
            */
            Ext.each(this.store.proxy.reader.jsonData.columns, function(column){
                columns.push(column);
            });
            /**
            *  reconfigure the column model of the grid
            */
            this.reconfigure(this.store, columns);
        }
    },
    /**
    * assign the event to itself when the object is initialising
    */
    onRender: function(ct, position){
            /**
            *  well, old fashion way, but works well.
            */
            Ext.ux.grid.DynamicGridPanel.superclass.onRender.call(this, ct, position);
            /**
            * hook the store load event to our function
            */
            this.store.on('load', this.storeLoad, this);
    }
});





// Start loading the page      
Ext.onReady(function(){
    // we need to define the model but the field values will be parsed
    // automatically since we provided fields in the metaData from server
   Ext.define('dynamicModel', {
     extend: 'Ext.data.Model',
     //set the proxy
     proxy: {
       type: 'rest',
       url: 'data.php' // the sample server address
     }
   });
   // create a data store
   var myStore = Ext.create('Ext.data.Store', {
         model:'dynamicModel',
         autoLoad:true,
   });  
   // create dynamic grid
   var myGrid = {
       title:'Dynamic Grid',
       xtype:'dynamicgrid',
       forceFit:true,
       region:'center',
       store:myStore,
       dockedItems: [{
         xtype: 'pagingtoolbar',
         store: myStore,
         dock: 'bottom',
         displayInfo: true
       }]            
   };
    // finally, build the main layout once all the pieces are ready.
    Ext.create('Ext.container.Viewport', {
        layout:'border',
        items:[myGrid]
    });
});



$total = 100;
// you can pre-define the required property parameters
$output["metaData"]["idProperty"]="id";
$output["metaData"]["totalProperty"]="total";
$output["metaData"]["successProperty"]="success";
$output["metaData"]["root"]="data";
// you can parse field values via your database schema
$output["metaData"]["fields"][]=array("name"=>"id","type"=>"int");
$output["metaData"]["fields"][]=array("name"=>"name","type"=>"string");
$output["metaData"]["fields"][]=array("name"=>"firstName","type"=>"string");
$output["metaData"]["fields"][]=array("name"=>"lastName","type"=>"string");
// you can parse column values via your database schema
$output["columns"][]=array("dataIndex"=>"id","header"=>"ID", "width"=>10);
$output["columns"][]=array("dataIndex"=>"name","header"=>"User Name","width"=>20);
$output["columns"][]=array("dataIndex"=>"firstName","header"=>"First Name");
$output["columns"][]=array("dataIndex"=>"lastName","header"=>"Last Name");
// the misc properties
$output["total"]=$total;
$output["success"]=true;
$output["message"]="success";
// parse pages  
$start = $_GET['start'] + 1;
$max = $_GET['start'] + $_GET['limit'];
// make sample data
for($i = $start; $i <= $max; $i++ ){
 $output["data"][]= array(
                "id"=>$i,
                "name"=>"UserName-". $i,
                "firstName"=>"My First Name No. ". $i,
                "lastName"=>"My Last Name No. ". $i);
}  
// output the value
echo json_encode($output);

checkcolumn

Ext.define('My.ux.checkcolumn', {
    extend: 'Ext.grid.column.CheckColumn',
    alias: 'widget.mycheckcolumn',


    text : '&#160;',
    sortable: false,
    draggable: false,
    resizable: false,
    hideable: false,
    menuDisabled: true,
    cls: Ext.baseCSSPrefix + 'column-header-checkbox'
});
var store = Ext.create('Ext.data.Store', {
    fields : ['name', 'email', 'phone', 'active'],
    data   : {
        items : [
            { name : 'Lisa',  email : 'lisa@simpsons.com',  phone : '555-111-1224', active : true  },
            { name : 'Bart',  email : 'bart@simpsons.com',  phone : '555-222-1234', active : true  },
            { name : 'Homer', email : 'home@simpsons.com',  phone : '555-222-1244', active : false },
            { name : 'Marge', email : 'marge@simpsons.com', phone : '555-222-1254', active : true  }
        ]
    },
    proxy  : {
        type   : 'memory',
        reader : {
            type : 'json',
            root : 'items'
        }
    }
});
Ext.create('Ext.grid.Panel', {
    title    : 'Simpsons',
    height   : 200,
    width    : 400,
    renderTo : Ext.getBody(),
    store    : store,
    columns  : [
        { text : 'Name', dataIndex : 'name' },
        { text : 'Email', dataIndex : 'email', flex : 1 },
        { text : 'Phone', dataIndex : 'phone' },
        { xtype : 'mycheckcolumn', text : 'Active', dataIndex : 'active', width: 30 }
    ]
});

ViewModel Stores

stores: {
    treeStore: {
        type:'tree',
        model: 'Model',
        name:'Store',
        root: {
            id: 'TOP',
            orgnztId:'TOP',
            text: 'Root',
            expanded: true
        },
        rootVisible: true,
        remoteSort: false,
        autoLoad: true,
        autoSync: false
    },
    Store:{
        model: 'Model',
        name:'userListStore',
        remoteSort: false,
        autoLoad: false,
        autoSync: false
    },
}

Model.save()

var userAthrInfo = Ext.create('model', record.getData());

userAthrInfo.set('athrEndDt', '1');
userAthrInfo.dirty = true;
userAthrInfo.phantom = true;
userAthrInfo.save();

ORACLE 날짜 및 시간계산

SELECT
    sysdate,
    sysdate + 1,
    sysdate + 3/24,
    sysdate + 1/24/60,
    sysdate + 1/24/60/60,
    sysdate + 1/1440,
    sysdate + 1/86400
FROM
    dual;

2015년 4월 19일 일요일

Ext.data.proxy.Ajax Extend

Ext.define('Tequiol.store.JsonRpc', {
  requires: ['Tequiol.util.Md5', 'Tequiol.util.Base64'],
  extend:'Ext.data.proxy.Ajax',
  alias:'proxy.jsonrpc',

  reader:{
    type:'json',
    root:'result'
  },

  statics: {
    /**
     * @private
     * Stores authentication data.
     */
    authentication:'',

    /**
     * @public
     * Changes the authentication data and generates a new client id for the connection.
     * @param username to log in
     * @param password to log in
     */
    setAuth:function (username, password) {
      var clientId = Ext.create('Tequiol.util.Md5').checksum(Math.random());
      this.authentication = Ext.create('Tequiol.util.Base64').encode(clientId + '-' + username + ':' + password);
    },

    /**
     * @public
     * returns true, if authentication data is available (does not tell, if the user is logged in)
     */
    hasAuth:function () {
      return this.authentication != '';
    }
  },

  constructor:function (config) {
    config = config || {};
    this.url = config.url || '/json';
    this.method = config.method || '';
    this.params = config.params || {};
    this.callParent([config]);
  },

  /**
   * @private
   * Modified headers for authentication and adds JSON-RPC header to the data request.
   * @param operation
   */
  buildRequest:function(operation) {
    var request = this.callParent([operation]);

    this.headers = {
      'Authorization':'Basic ' + this.self.authentication,
      'Content-Type':'application/json; charset=UTF-8'
    };

    Ext.apply(request, {
      jsonData:{
        version:'1.1',
        method:this.method,
        params:this.params
      },
      params: {} // get rid of GET params
    });

    return request;
  },

  /**
   * @private
   * Method is always POST.
   * @param request
   */
  getMethod: function(request) {
    return 'POST';
  }
});

Grid 컬럼내에서 방향키 안먹을 때

Ext.define('Ext.patch,EXTJS16166', {
    override: 'Ext.view.View',
    compatibility: '5.1.0.107',
    handleEvent: function(e) {
        var me = this,
        isKeyEvent = me.keyEventRe.test(e.type),
        nm = me.getNavigationModel();
        e.view = me;
        if (isKeyEvent) {
            e.item = nm.getItem();
            e.record = nm.getRecord();
        }
        if (!e.item) {
            e.item = e.getTarget(me.itemSelector);
        }
        if (e.item && !e.record) {
            e.record = me.getRecord(e.item);
        }
        if (me.processUIEvent(e) !== false) {
            me.processSpecialEvent(e);
        }
        if (isKeyEvent && !Ext.fly(e.target).isInputField()) {
            if (e.getKey() === e.SPACE || e.isNavKeyPress(true)) {
                e.preventDefault();
            }
        }
    }
});

tree getChecked

Ext.require([
    'Ext.tree.*',
    'Ext.data.*',
    'Ext.window.MessageBox'
]);

Ext.onReady(function() {
    var store = Ext.create('Ext.data.TreeStore', {
        proxy: {
            type: 'ajax',
            url: 'check-nodes.json'
        },
        sorters: [{
            property: 'leaf',
            direction: 'ASC'
        }, {
            property: 'text',
            direction: 'ASC'
        }]
    });

    var tree = Ext.create('Ext.tree.Panel', {
        store: store,
        rootVisible: false,
        useArrows: true,
        frame: true,
        title: 'Check Tree',
        renderTo: 'tree-div',
        width: 200,
        height: 250,
        dockedItems: [{
            xtype: 'toolbar',
            items: {
                text: 'Get checked nodes',
                handler: function(){
                    var records = tree.getView().getChecked(),
                        names = [];
                 
                    Ext.Array.each(records, function(rec){
                        names.push(rec.get('text'));
                    });
                 
                    Ext.MessageBox.show({
                        title: 'Selected Nodes',
                        msg: names.join('<br />'),
                        icon: Ext.MessageBox.INFO
                    });
                }
            }
        }]
    });
});

form submit


form.api ={submit: 'incidentreceipt.setOrder'};
Ext.Msg.confirm('알림' "Are you sure you want to save?", function(button, text) {
    if (button == 'yes') {
        var form = _window.getForm();
        var values = form.getValues();
       
        if (form.isValid()){
            form.submit({
                params: values,
                scope: this,
                success: function(form, action) {
                },
                failure: function(form, action) {
                }
            });
        }
        else {
              form.getFields().findBy(function(field) {
                     var activeError =  field.getActiveError();
                     if (!Ext.isEmpty(activeError ))
                     {
                        return false;
                     };
               });
        }
    }
});

getSelectionModel, getSelection

var _selectionModel = grid.getSelectionModel();
if ( _selectionModel.hasSelection())
{
var _selectedRecords = _selectionModel.getSelection();
};

store load params callback

store.load({params : record.data ,
    callback : function (records , operation , success ) {
    if ( records.length > 0 )
    {
   
    }
    }
});