124bc2b932
- Cuando se crea un PMTable dentro del ProcessMaker, al querer seleccionar qué columnas mostrar en el formulario de creación, en la lista se muestra columnas vacías, las cuales no tienen label ni nombre. - Disabled of hidden fields in rows pmTables.
1193 lines
34 KiB
JavaScript
Executable File
1193 lines
34 KiB
JavaScript
Executable File
/**
|
|
* PM tables Edit
|
|
* @author Erik A. O. <erik@colosa.com>
|
|
*/
|
|
|
|
var store;
|
|
var storeP;
|
|
var storeA;
|
|
var cmodelP;
|
|
var smodelA;
|
|
var smodelP;
|
|
var availableGrid;
|
|
var assignButton;
|
|
var assignAllButton;
|
|
var removeButton;
|
|
var removeAllButton;
|
|
|
|
var store;
|
|
var editor;
|
|
var selCombo='';
|
|
|
|
Ext.onReady(function(){
|
|
|
|
var fm = Ext.form;
|
|
var fieldsCount = 0;
|
|
// store for available fields grid
|
|
storeA = new Ext.data.GroupingStore( {
|
|
proxy : new Ext.data.HttpProxy({
|
|
url: '../pmTablesProxy/getDynafields'
|
|
}),
|
|
reader : new Ext.data.JsonReader( {
|
|
root: 'processFields',
|
|
fields : [{name : 'FIELD_UID'}, {name : 'FIELD_NAME'}]
|
|
}),
|
|
listeners: {
|
|
load: function() {
|
|
|
|
}
|
|
}
|
|
});
|
|
//column model for available fields grid
|
|
cmodelA = new Ext.grid.ColumnModel({
|
|
defaults: {
|
|
width: 55,
|
|
sortable: true
|
|
},
|
|
columns: [
|
|
{
|
|
id:'FIELD_UID',
|
|
dataIndex: 'FIELD_UID',
|
|
hidden:true,
|
|
hideable:false
|
|
}, {
|
|
header : _("ID_DYNAFORM_FIELDS"),
|
|
dataIndex : 'FIELD_NAME',
|
|
sortable : true,
|
|
align:'left'
|
|
}
|
|
]
|
|
});
|
|
//selection model for available fields grid
|
|
smodelA = new Ext.grid.RowSelectionModel({
|
|
selectSingle: false,
|
|
listeners:{
|
|
selectionchange: function(sm){
|
|
switch(sm.getCount()){
|
|
case 0: Ext.getCmp('assignButton').disable(); break;
|
|
default: Ext.getCmp('assignButton').enable(); break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
//grid for table columns grid
|
|
availableGrid = new Ext.grid.GridPanel({
|
|
layout: 'fit',
|
|
region: 'center',
|
|
id: 'availableGrid',
|
|
ddGroup : 'assignedGridDDGroup',
|
|
enableDragDrop : true,
|
|
stripeRows : true,
|
|
autoWidth : true,
|
|
stripeRows : true,
|
|
height : 100,
|
|
width : 200,
|
|
stateful : true,
|
|
stateId : 'gridEdit',
|
|
enableColumnResize : true,
|
|
enableHdMenu : true,
|
|
frame : false,
|
|
columnLines : false,
|
|
viewConfig : {forceFit:true},
|
|
cm: cmodelA,
|
|
sm: smodelA,
|
|
store: storeA,
|
|
listeners: {rowdblclick: AssignFieldsAction}
|
|
});
|
|
|
|
//selecion model for table columns grid
|
|
sm = new Ext.grid.RowSelectionModel({
|
|
selectSingle: false,
|
|
listeners:{
|
|
selectionchange: function(sm){
|
|
switch(sm.getCount()){
|
|
case 0:
|
|
//Ext.getCmp('removeButton').disable();
|
|
Ext.getCmp('editColumn').disable();
|
|
Ext.getCmp('removeColumn').disable();
|
|
break;
|
|
case 1:
|
|
Ext.getCmp('editColumn').enable();
|
|
Ext.getCmp('removeColumn').enable();
|
|
break;
|
|
default:
|
|
//Ext.getCmp('removeButton').enable();
|
|
Ext.getCmp('editColumn').disable();
|
|
Ext.getCmp('removeColumn').enable();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
var sizeField = new fm.NumberField({
|
|
name: 'sizeEdit',
|
|
id: 'sizeEdit',
|
|
allowBlank: true,
|
|
allowDecimals: false,
|
|
allowNegative: false,
|
|
disabled: true,
|
|
nanText: 'This field should content a number',
|
|
minValue: 1,
|
|
maxValue: 99,
|
|
minLength: 0
|
|
});
|
|
|
|
//check column for tablesizeField columns grid
|
|
var checkColumn = new Ext.grid.CheckColumn({
|
|
header: 'Filter',
|
|
dataIndex: 'FIELD_FILTER',
|
|
id: 'FIELD_FILTER',
|
|
width: 55
|
|
});
|
|
//columns for table columns grid
|
|
var cmColumns = [
|
|
{
|
|
id: 'uid',
|
|
dataIndex: 'uid',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
id: 'field_uid',
|
|
dataIndex: 'field_uid',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
id: 'field_key',
|
|
dataIndex: 'field_key',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
id: 'field_null',
|
|
dataIndex: 'field_null',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
id: 'field_dyn',
|
|
header: _("ID_DYNAFORM_FIELD"),
|
|
dataIndex: 'field_dyn',
|
|
hidden: true
|
|
}, {
|
|
id: 'field_name',
|
|
header: _("ID_FIELD_NAME"),
|
|
dataIndex: 'field_name',
|
|
width: 220,
|
|
editor: {
|
|
xtype: 'textfield',
|
|
allowBlank: true,
|
|
listeners:{
|
|
change: function(f,e){
|
|
this.setValue(this.getValue().replace(/\s/g,'').toUpperCase());
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
id: 'field_label',
|
|
header: _("ID_FIELD_LABEL"),
|
|
dataIndex: 'field_label',
|
|
width: 220,
|
|
editor:{
|
|
xtype: 'textfield',
|
|
allowBlank: true
|
|
}
|
|
}, {
|
|
id: 'field_type',
|
|
header: _("ID_TYPE"),
|
|
dataIndex: 'field_type',
|
|
width: 75,
|
|
editor: new fm.ComboBox({
|
|
typeAhead: true,
|
|
editable: false,
|
|
lazyRender: true,
|
|
mode: 'local',
|
|
displayField:'type',
|
|
valueField:'type_id',
|
|
autocomplete: true,
|
|
triggerAction: 'all',
|
|
forceSelection: true,
|
|
store: new Ext.data.SimpleStore({
|
|
fields: ['type_id', 'type'],
|
|
data: columnsTypes,
|
|
sortInfo: {field:'type_id', direction:'ASC'}
|
|
}),
|
|
listeners: {
|
|
beforerender: function (combo)
|
|
{
|
|
if (combo.getValue() == "" && combo.store.getAt(0)) {
|
|
combo.setValue(combo.store.getAt(0).get(combo.valueField));
|
|
}
|
|
},
|
|
beforeshow: function (combo)
|
|
{
|
|
if (combo.getValue() == "" && combo.store.getAt(0)) {
|
|
combo.setValue(combo.store.getAt(0).get(combo.valueField));
|
|
}
|
|
},
|
|
'select': function(combo, row, index) {
|
|
if( cm && cm instanceof Ext.grid.ColumnModel) {
|
|
if(selCombo != combo.getValue()) {
|
|
Ext.getCmp('sizeEdit').setValue('');
|
|
}
|
|
selCombo = combo.getValue();
|
|
|
|
var swSize = 1; //Enable
|
|
var swNull = 1;
|
|
var swPK = 1;
|
|
var swAI = 1;
|
|
|
|
//Date
|
|
if (selCombo == "DATE" || selCombo == "DATETIME" || selCombo == "TIME") {
|
|
swSize = 0; //Disable
|
|
swPK = 0;
|
|
swAI = 0;
|
|
}
|
|
|
|
//Numbers
|
|
if (selCombo == "INTEGER" || selCombo == "BIGINT") {
|
|
//Enable All
|
|
}
|
|
|
|
if (selCombo == "TINYINT" || selCombo == "SMALLINT") {
|
|
swSize = 0;
|
|
}
|
|
|
|
if (selCombo == "DECIMAL" || selCombo == "FLOAT") {
|
|
swPK = 0;
|
|
swAI = 0;
|
|
}
|
|
|
|
if (selCombo == "DOUBLE" || selCombo == "REAL") {
|
|
swSize = 0;
|
|
swPK = 0;
|
|
swAI = 0;
|
|
}
|
|
|
|
//String
|
|
if (selCombo == "CHAR" || selCombo == "VARCHAR") {
|
|
swAI = 0;
|
|
}
|
|
|
|
if (selCombo == "LONGVARCHAR") {
|
|
swPK = 0;
|
|
swAI = 0;
|
|
}
|
|
|
|
//Boolean
|
|
if (selCombo == "BOOLEAN") {
|
|
swSize = 0;
|
|
swNull = 0;
|
|
swPK = 0;
|
|
swAI = 0;
|
|
}
|
|
|
|
if (swNull == 1) {
|
|
Ext.getCmp("field_null").enable();
|
|
} else {
|
|
Ext.getCmp("field_null").disable();
|
|
Ext.getCmp("field_null").setValue(false);
|
|
}
|
|
|
|
if (swPK == 1) {
|
|
Ext.getCmp("field_primary_key").enable();
|
|
} else {
|
|
Ext.getCmp("field_primary_key").disable();
|
|
Ext.getCmp("field_primary_key").setValue(false);
|
|
}
|
|
|
|
if (swAI == 1) {
|
|
Ext.getCmp("field_incre").enable();
|
|
} else {
|
|
Ext.getCmp("field_incre").disable();
|
|
Ext.getCmp("field_incre").setValue(false);
|
|
}
|
|
|
|
if (swSize == 1) {
|
|
Ext.getCmp("sizeEdit").enable();
|
|
|
|
if (selCombo == "CHAR" || selCombo == "VARCHAR" || selCombo == "LONGVARCHAR") {
|
|
Ext.getCmp("sizeEdit").setMaxValue(((selCombo == "CHAR") ? 255 : 999));
|
|
sizeField.getEl().dom.maxLength = 3;
|
|
} else {
|
|
Ext.getCmp("sizeEdit").setMaxValue(99);
|
|
sizeField.getEl().dom.maxLength = 2;
|
|
}
|
|
} else {
|
|
Ext.getCmp("sizeEdit").disable();
|
|
Ext.getCmp("sizeEdit").setValue("");
|
|
}
|
|
}
|
|
}//select
|
|
}
|
|
})
|
|
}, {
|
|
id: 'field_size',
|
|
header: _("ID_SIZE"),
|
|
dataIndex: 'field_size',
|
|
width: 50,
|
|
align: 'right',
|
|
editor: sizeField
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_NULL'),
|
|
dataIndex: 'field_null',
|
|
align: 'center',
|
|
width: 50,
|
|
trueText: _('ID_YES'),
|
|
falseText: _('ID_NO'),
|
|
editor: {
|
|
xtype: 'checkbox',
|
|
id: 'field_null',
|
|
checked: false,
|
|
disabled: true
|
|
}
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_PRIMARY_KEY'),
|
|
dataIndex: 'field_key',
|
|
align: 'center',
|
|
width: 80,
|
|
trueText: _('ID_YES'),
|
|
falseText: _('ID_NO'),
|
|
editor: {
|
|
xtype: 'checkbox',
|
|
id: 'field_primary_key',
|
|
disabled: true,
|
|
inputValue: 'always'
|
|
}
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_AUTO_INCREMENT'),
|
|
dataIndex: 'field_autoincrement',
|
|
align: 'center',
|
|
width: 80,
|
|
trueText: _('ID_YES'),
|
|
falseText: _('ID_NO'),
|
|
editor: {
|
|
xtype: 'checkbox',
|
|
id: 'field_incre',
|
|
disabled: true,
|
|
inputValue: 'always'
|
|
}
|
|
}
|
|
];
|
|
|
|
//if permissions plugin is enabled
|
|
if (TABLE !== false && TABLE.ADD_TAB_TAG == 'plugin@simplereport') {
|
|
cmColumns.push({
|
|
xtype: 'booleancolumn',
|
|
header: 'Filter',
|
|
dataIndex: 'field_filter',
|
|
align: 'center',
|
|
width: 50,
|
|
trueText: _('ID_YES'),
|
|
falseText: _('ID_NO'),
|
|
editor: {
|
|
xtype: 'checkbox'
|
|
}
|
|
})
|
|
}
|
|
|
|
//column model for table columns grid
|
|
var cm = new Ext.grid.ColumnModel({
|
|
// specify any defaults for each column
|
|
defaults: {
|
|
resizable: false,
|
|
sortable: true // columns are not sortable by default
|
|
},
|
|
columns:cmColumns
|
|
});
|
|
//store for table columns grid
|
|
store = new Ext.data.ArrayStore({
|
|
fields: [
|
|
{name: 'uid', type: 'string'},
|
|
{name: 'field_uid', type: 'string'},
|
|
{name: 'field_key', type: 'string'},
|
|
{name: 'field_name', type: 'string'},
|
|
{name: 'field_label', type: 'string'},
|
|
{name: 'field_type'},
|
|
{name: 'field_size', type: 'float'},
|
|
{name: 'field_null', type: 'float'},
|
|
{name: 'field_autoincrement', type: 'float'},
|
|
{name: 'field_filter', type: 'string'}
|
|
]
|
|
});
|
|
//row editor for table columns grid
|
|
editor = new Ext.ux.grid.RowEditor({
|
|
saveText: _("ID_UPDATE"),
|
|
listeners: {
|
|
canceledit: function(grid,obj){
|
|
if ( grid.record.data.field_label == '' && grid.record.data.field_name == '') {
|
|
store.remove(grid.record);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
editor.on({
|
|
afteredit: function(roweditor, changes, record, rowIndex) {
|
|
//
|
|
},
|
|
afteredit: function(roweditor, rowIndex) {
|
|
row = assignedGrid.getSelectionModel().getSelected();
|
|
//if a column was set as PK so can't be null
|
|
if (row.get('field_key') == true) {
|
|
row.data.field_null = false;
|
|
|
|
}
|
|
row.commit();
|
|
}
|
|
});
|
|
|
|
//table columns grid
|
|
assignedGrid = new Ext.grid.GridPanel({
|
|
//title: 'Columns',
|
|
region: 'center',
|
|
id: 'assignedGrid',
|
|
ddGroup : 'availableGridDDGroup',
|
|
enableDragDrop : true,
|
|
enableColumnResize : true,
|
|
enableColumnMove: false,
|
|
viewConfig : {forceFit:true},
|
|
cm: cm,
|
|
sm: sm,
|
|
store: store,
|
|
plugins: [editor, checkColumn],
|
|
tbar: [
|
|
{
|
|
icon: '/images/add-row-after.png',
|
|
text: _("ID_ADD_FIELD"),
|
|
handler: addColumn
|
|
}, {
|
|
id: 'editColumn',
|
|
icon: '/images/edit-row.png',
|
|
text: _("ID_EDIT_FIELD"),
|
|
disabled: true,
|
|
handler: editColumn
|
|
}, {
|
|
id: 'removeColumn',
|
|
icon: '/images/delete-row.png',
|
|
text: _("ID_REMOVE_FIELD"),
|
|
disabled: true,
|
|
handler: removeColumn
|
|
}
|
|
],
|
|
|
|
border: false,
|
|
|
|
listeners: {
|
|
render: function(grid) {
|
|
var ddrow = new Ext.dd.DropTarget(grid.getView().mainBody, {
|
|
ddGroup: 'availableGridDDGroup',
|
|
copy: false,
|
|
notifyDrop: function(dd, e, data) {
|
|
var ds = grid.store;
|
|
var sm = grid.getSelectionModel();
|
|
var rows = sm.getSelections();
|
|
if (dd.getDragData(e)) {
|
|
var cindex = dd.getDragData(e).rowIndex;
|
|
//skipping primary keys, we can't reorder
|
|
if (store.data.items[cindex].data.field_key)
|
|
return;
|
|
|
|
if (typeof(cindex) != "undefined") {
|
|
for(var i = 0; i < rows.length; i++) {
|
|
//skipping primary keys, we can't reorder
|
|
if (rows[i].data.field_key )
|
|
continue;
|
|
|
|
var srcIndex = ds.indexOfId(rows[i].id);
|
|
ds.remove(ds.getById(rows[i].id));
|
|
if (i > 0 && cindex < srcIndex) {
|
|
cindex++;
|
|
}
|
|
ds.insert(cindex, rows[i]);
|
|
}
|
|
sm.selectRecords(rows);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
assignedGrid.getSelectionModel().on('selectionchange', function(sm){
|
|
//alert('s');
|
|
});
|
|
|
|
// (vertical) selection buttons
|
|
buttonsPanel = new Ext.Panel({
|
|
width : 40,
|
|
layout : {
|
|
type:'vbox',
|
|
padding:'0',
|
|
pack:'center',
|
|
align:'center'
|
|
},
|
|
defaults:{margins:'0 0 35 0'},
|
|
items:[
|
|
{ xtype:'button',text: '>',
|
|
handler: AssignFieldsAction,
|
|
id: 'assignButton', disabled: true
|
|
},
|
|
{ xtype:'button',text: '<',
|
|
handler: RemoveFieldsAction,
|
|
id: 'removeButton', disabled: true
|
|
},
|
|
{ xtype:'button',text: '>>',
|
|
handler: AssignAllFieldsAction,
|
|
id: 'assignButtonAll', disabled: false},
|
|
{ xtype:'button',text: '<<',
|
|
handler: RemoveAllFieldsAction,
|
|
id: 'removeButtonAll', disabled: false
|
|
}
|
|
]
|
|
|
|
});
|
|
|
|
|
|
FieldsPanel = new Ext.Panel({
|
|
//title: _('ID_FIELDS'),
|
|
region : 'center',
|
|
//autoWidth : true,
|
|
width: 150,
|
|
layout : 'hbox',
|
|
defaults : { flex : 1 }, //auto stretch
|
|
layoutConfig : { align : 'stretch' },
|
|
items : [assignedGrid],
|
|
viewConfig : {forceFit:true}
|
|
|
|
});
|
|
|
|
searchTextA = new Ext.form.TextField ({
|
|
id: 'searchTextA',
|
|
ctCls:'pm_search_text_field',
|
|
allowBlank: true,
|
|
width: 110,
|
|
emptyText: _('ID_ENTER_SEARCH_TERM'),
|
|
listeners: {
|
|
specialkey: function(f,e){
|
|
if (e.getKey() == e.ENTER) {
|
|
DoSearchA();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
searchTextP = new Ext.form.TextField ({
|
|
id: 'searchTextP',
|
|
ctCls:'pm_search_text_field',
|
|
allowBlank: true,
|
|
width: 110,
|
|
emptyText: _('ID_ENTER_SEARCH_TERM'),
|
|
listeners: {
|
|
specialkey: function(f,e){
|
|
if (e.getKey() == e.ENTER) {
|
|
DoSearchP();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
var types = new Ext.data.SimpleStore({
|
|
fields: ['REP_TAB_TYPE', 'type'],
|
|
data : [['NORMAL',_("ID_GLOBAL")],['GRID',_("ID_GRID")]]
|
|
});
|
|
|
|
comboReport = new Ext.form.ComboBox({
|
|
id : 'REP_TAB_TYPE',
|
|
name: 'type',
|
|
fieldLabel: 'Type',
|
|
hiddenName : 'REP_TAB_TYPE',
|
|
mode: 'local',
|
|
store: types,
|
|
displayField:'type',
|
|
valueField:'REP_TAB_TYPE',
|
|
width: 120,
|
|
typeAhead: true,
|
|
triggerAction: 'all',
|
|
editable:false,
|
|
lazyRender: true,
|
|
value: typeof TABLE.ADD_TAB_TYPE != 'undefined'? TABLE.ADD_TAB_TYPE : 'NORMAL',
|
|
listeners: {
|
|
select: function(combo,record,index){
|
|
if (this.getValue()=='NORMAL') {
|
|
Ext.getCmp('REP_TAB_GRID').setVisible(false);
|
|
loadFieldNormal();
|
|
} else {
|
|
Ext.getCmp('availableGrid').store.removeAll();
|
|
Ext.getCmp('REP_TAB_GRID').setVisible(true);
|
|
Ext.getCmp('REP_TAB_GRID').setValue('');
|
|
gridsListStore.reload({params:{PRO_UID : PRO_UID !== false ? PRO_UID : Ext.getCmp('PROCESS').getValue()}});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
dbConnectionsStore = new Ext.data.Store({
|
|
autoLoad: false,
|
|
proxy : new Ext.data.HttpProxy({
|
|
url: '../pmTablesProxy/getDbConnectionsList',
|
|
method : 'POST'
|
|
}),
|
|
baseParams : {
|
|
PRO_UID : ''
|
|
},
|
|
reader : new Ext.data.JsonReader( {
|
|
fields : [{name : 'DBS_UID'}, {name : 'DBS_NAME'}]
|
|
}),
|
|
listeners: {
|
|
load: function() {
|
|
if (TABLE !== false) { // is editing
|
|
// set current editing process combobox
|
|
var i = this.findExact('DBS_UID', TABLE.DBS_UID, 0);
|
|
if (i > -1){
|
|
comboDbConnections.setValue(this.getAt(i).data.DBS_UID);
|
|
comboDbConnections.setRawValue(this.getAt(i).data.DBS_NAME);
|
|
comboDbConnections.setDisabled(true);
|
|
} else {
|
|
// DB COnnection deleted
|
|
Ext.Msg.alert( _('ID_ERROR'), _('ID_DB_CONNECTION_NOT_EXIST') );
|
|
}
|
|
} else {
|
|
comboDbConnections.setValue('rp');
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
comboDbConnections = new Ext.form.ComboBox({
|
|
id: 'REP_TAB_CONNECTION',
|
|
fieldLabel : _("ID_DB_CONNECTION"),
|
|
hiddenName : 'DBS_UID',
|
|
store : dbConnectionsStore,
|
|
//value: 'rp',
|
|
valueField : 'DBS_UID',
|
|
displayField : 'DBS_NAME',
|
|
triggerAction : 'all',
|
|
editable : false,
|
|
mode:'local'
|
|
});
|
|
|
|
var tbar = new Array();
|
|
var items = new Array();
|
|
|
|
items.push({
|
|
id: 'REP_TAB_NAME',
|
|
fieldLabel: _("ID_TABLE_NAME") + ' <span style="font-size:9">('+_("ID_AUTO_PREFIX") + ' "PMT")</span>',
|
|
xtype:'textfield',
|
|
emptyText: _("ID_SET_A_TABLE_NAME"),
|
|
width: 250,
|
|
autoCreate: {tag: "input", type: "text", autocomplete: "off", maxlength: sizeTableName },
|
|
stripCharsRe: /(\W+)/g,
|
|
listeners:{
|
|
change: function(){
|
|
this.setValue(this.getValue().toUpperCase());
|
|
}
|
|
}
|
|
});
|
|
items.push({
|
|
id: 'REP_TAB_DSC',
|
|
fieldLabel: _("ID_DESCRIPTION"),
|
|
xtype:'textarea',
|
|
emptyText: _("ID_SET_TABLE_DESCRIPTION"),
|
|
width: 250,
|
|
height: 40,
|
|
allowBlank: true
|
|
});
|
|
|
|
items.push(
|
|
{
|
|
layout: "column",
|
|
style: "margin-left: 255px;",
|
|
hidden: (dataNumRows > 0)? false : true,
|
|
items: [
|
|
{
|
|
xtype: "checkbox",
|
|
id: "chkKeepData",
|
|
name: "chkKeepData",
|
|
boxLabel: _("ID_PMTABLE_DATA_KEEP")
|
|
}
|
|
]
|
|
}
|
|
);
|
|
|
|
//items.push(comboDbConnections);
|
|
|
|
var frmDetails = new Ext.FormPanel({
|
|
id :'frmDetails',
|
|
region : 'north',
|
|
labelWidth: 250,
|
|
labelAlign :'right',
|
|
title : ADD_TAB_UID ? _('ID_PMTABLE') : _('ID_NEW_PMTABLE'),
|
|
bodyStyle :'padding:10px',
|
|
frame : true,
|
|
height: 170,
|
|
items : items,
|
|
//tbar : tbar,
|
|
waitMsgTarget : true,
|
|
defaults: {
|
|
allowBlank : false,
|
|
msgTarget : 'side',
|
|
align :'center'
|
|
}
|
|
});
|
|
|
|
|
|
southPanel = new Ext.FormPanel({
|
|
region: 'south',
|
|
buttons:[
|
|
{
|
|
text: TABLE === false ? _("ID_CREATE") : _("ID_UPDATE"),
|
|
handler: function() {
|
|
if (TABLE === false || dataNumRows == 0 || Ext.getCmp("chkKeepData").checked == true) {
|
|
createReportTable();
|
|
}
|
|
else {
|
|
PMExt.confirm(_('ID_CONFIRM'), _('ID_PMTABLE_SAVE_AND_DATA_LOST'), createReportTable);
|
|
}
|
|
}
|
|
}, {
|
|
text:_("ID_CANCEL"),
|
|
handler: function() {
|
|
proParam = PRO_UID !== false ? '?PRO_UID='+PRO_UID : '';
|
|
location.href = '../pmTables' + proParam;
|
|
}
|
|
}
|
|
]
|
|
});
|
|
|
|
var viewport = new Ext.Viewport({
|
|
layout: 'border',
|
|
autoScroll: false,
|
|
items:[frmDetails, FieldsPanel, southPanel]
|
|
});
|
|
|
|
/*** Editing routines ***/
|
|
if (TABLE !== false) {
|
|
Ext.getCmp('REP_TAB_NAME').setValue(TABLE.ADD_TAB_NAME);
|
|
Ext.getCmp('REP_TAB_NAME').setDisabled(true);
|
|
Ext.getCmp('REP_TAB_DSC').setValue(TABLE.ADD_TAB_DESCRIPTION);
|
|
|
|
loadTableRowsFromArray(TABLE.FIELDS);
|
|
}
|
|
|
|
if (dataNumRows > 0) {
|
|
var tpl = new Ext.Template(
|
|
'<div id="fb" style="border: 1px solid #FF0000; background-color:#FFAAAA; display:none; padding:15px; color:#000000; font-size:12px;">'+
|
|
'<b>Warning: </b> ' + dataNumRows + ' ' + _('ID_PMTABLE_DATA_EXISTS_WARNINIG') + ' <a href="#" id="hideWarning">[ '+_('ID_HIDE')+' ]</a></div>'
|
|
);
|
|
var newEl = tpl.insertFirst(document.getElementById('assignedGrid'));
|
|
|
|
Ext.fly('hideWarning').on('click', function() {
|
|
Ext.fly(newEl).slideOut('t',{remove:true});
|
|
});
|
|
Ext.fly(newEl).slideIn();
|
|
}
|
|
|
|
});
|
|
|
|
// actions
|
|
|
|
function createReportTable()
|
|
{
|
|
var tableName = Ext.getCmp('REP_TAB_NAME').getValue().trim();
|
|
var tableDescription = Ext.getCmp('REP_TAB_DSC').getValue().trim();
|
|
|
|
//validate table name
|
|
if (tableName == '') {
|
|
Ext.getCmp('REP_TAB_NAME').focus();
|
|
PMExt.error(_('ID_ERROR'), _('ID_TABLE_NAME_IS_REQUIRED'), function(){
|
|
Ext.getCmp('REP_TAB_NAME').focus();
|
|
});
|
|
return false;
|
|
}
|
|
|
|
// validate table name length
|
|
if(tableName.length < 4) {
|
|
PMExt.error(_('ID_ERROR'), _('ID_TABLE_NAME_TOO_SHORT'), function(){
|
|
Ext.getCmp('REP_TAB_NAME').focus();
|
|
});
|
|
return false;
|
|
}
|
|
|
|
var allRows = assignedGrid.getStore();
|
|
var columns = new Array();
|
|
var hasSomePrimaryKey = false;
|
|
|
|
//validate columns count
|
|
if(allRows.getCount() == 0) {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT7'));
|
|
return false;
|
|
}
|
|
var fieldsNames = new Array();
|
|
// Reserved Words
|
|
var reservedWords = new Array('DESC');
|
|
|
|
|
|
for (var i = 0; i < allRows.getCount(); i++) {
|
|
row = allRows.getAt(i);
|
|
|
|
if (in_array(row.data['field_name'], fieldsNames)) {
|
|
PMExt.error(_('ID_ERROR'),_('ID_PMTABLES_ALERT1') + ' <b>' + row.data['field_name']+'</b>');
|
|
return false;
|
|
}
|
|
|
|
for (j=0; j < reservedWords.length; j++) {
|
|
if (row.data['field_name'] == reservedWords[j]) {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_RESERVED_FIELDNAME_WARNING', reservedWords[j]));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// validate that fieldname is not empty
|
|
if(row.data['field_name'].trim() == '') {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT2'));
|
|
return false;
|
|
}
|
|
|
|
if(row.data['field_label'].trim() == '') {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT3'));
|
|
return false;
|
|
}
|
|
|
|
if (row.data['field_type'] == '') {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT4') + ' <b>'+row.data['field_name']+'</b>');
|
|
return false;
|
|
}
|
|
|
|
// validate field size for varchar & int column types
|
|
if ((row.data['field_type'] == 'VARCHAR' || row.data['field_type'] == 'INTEGER') && row.data['field_size'] == '') {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT5')+' '+row.data['field_name']+' ('+row.data['field_type']+').');
|
|
return false;
|
|
}
|
|
|
|
if (row.data['field_key']) {
|
|
hasSomePrimaryKey = true;
|
|
}
|
|
fieldsNames.push(row.data['field_name']);
|
|
columns.push(row.data);
|
|
}
|
|
|
|
if (!hasSomePrimaryKey) {
|
|
PMExt.error(_('ID_ERROR'), _('ID_PMTABLES_ALERT6'));
|
|
return;
|
|
}
|
|
|
|
Ext.Msg.show({
|
|
title : '',
|
|
msg : TABLE !== false ? _('ID_UPDATING_TABLE') : _('ID_CREATING_TABLE'),
|
|
wait:true,
|
|
waitConfig: {interval:500}
|
|
});
|
|
|
|
var p = {
|
|
REP_TAB_UID: (TABLE !== false)? TABLE.ADD_TAB_UID : "",
|
|
PRO_UID: "",
|
|
REP_TAB_NAME: (TABLE !== false)? tableName : "PMT_" + tableName,
|
|
REP_TAB_DSC: tableDescription,
|
|
REP_TAB_CONNECTION: "workflow",
|
|
REP_TAB_TYPE: "",
|
|
REP_TAB_GRID: "",
|
|
columns: Ext.util.JSON.encode(columns)
|
|
};
|
|
|
|
if (dataNumRows > 0) {
|
|
p.keepData = (Ext.getCmp("chkKeepData").checked == true)? 1 : 0;
|
|
}
|
|
|
|
Ext.Ajax.request({
|
|
url: '../pmTablesProxy/save',
|
|
params: p,
|
|
success: function(resp){
|
|
try {
|
|
result = Ext.util.JSON.decode(resp.responseText);
|
|
Ext.MessageBox.hide();
|
|
|
|
if (result.success) {
|
|
proParam = PRO_UID !== false ? '?PRO_UID='+PRO_UID : '';
|
|
location.href = '../pmTables' + proParam; //history.back();
|
|
} else {
|
|
PMExt.error(_('ID_ERROR'), result.type +': '+result.msg);
|
|
if (window.console && window.console.firebug) {
|
|
window.console.log(result.msg);
|
|
window.console.log(result.trace);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
if (dbg) {
|
|
_showDebugWin(resp.responseText);
|
|
} else {
|
|
PMExt.error( _('ID_ERROR'), _('ID_SOMETHING_WRONG'));
|
|
}
|
|
}
|
|
},
|
|
failure: function(obj, resp){
|
|
Ext.Msg.alert( _('ID_ERROR'), resp.result.msg);
|
|
}
|
|
});
|
|
}
|
|
//end createReportTable
|
|
|
|
function _showDebugWin(content)
|
|
{
|
|
dbgWin = new Ext.Window({
|
|
title: '',
|
|
id: 'dbgWin',
|
|
layout: 'fit',
|
|
width: 570,
|
|
height: 400,
|
|
modal: false,
|
|
autoScroll: true,
|
|
maximizable: true,
|
|
//closeAction: 'hide',
|
|
maximizable : false,
|
|
items: [],
|
|
x: 0,
|
|
y: 0,
|
|
html: '<pre>' + content + '</pre>'
|
|
});
|
|
|
|
dbgWin.show();
|
|
}
|
|
|
|
function addColumn() {
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
//var meta = mapPMFieldType(records[i].data['FIELD_UID']);
|
|
var row = new PMRow({
|
|
uid : '',
|
|
field_uid : '',
|
|
field_dyn : '',
|
|
field_name : '',
|
|
field_label: '',
|
|
field_type : '',
|
|
field_size : '',
|
|
field_key : 0,
|
|
field_null : 1
|
|
});
|
|
var len = assignedGrid.getStore().data.length;
|
|
|
|
editor.stopEditing();
|
|
store.insert(len, row);
|
|
assignedGrid.getView().refresh();
|
|
assignedGrid.getSelectionModel().selectRow(len);
|
|
editor.startEditing(len);
|
|
}
|
|
|
|
function editColumn()
|
|
{
|
|
var row = Ext.getCmp('assignedGrid').getSelectionModel().getSelected();
|
|
var selIndex = store.indexOfId(row.id);
|
|
editor.stopEditing();
|
|
assignedGrid.getView().refresh();
|
|
assignedGrid.getSelectionModel().selectRow(selIndex);
|
|
editor.startEditing(selIndex);
|
|
}
|
|
|
|
function removeColumn()
|
|
{
|
|
PMExt.confirm(_('ID_CONFIRM'), _('ID_CONFIRM_REMOVE_FIELD'), function(){
|
|
var records = Ext.getCmp('assignedGrid').getSelectionModel().getSelections();
|
|
Ext.each(records, Ext.getCmp('assignedGrid').store.remove, Ext.getCmp('assignedGrid').store);
|
|
});
|
|
}
|
|
|
|
|
|
////ASSIGNBUTON FUNCTIONALITY
|
|
AssignFieldsAction = function(){
|
|
records = Ext.getCmp('availableGrid').getSelectionModel().getSelections();
|
|
|
|
for(i=0; i < records.length; i++){
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
var meta = mapPMFieldType(records[i].data['FIELD_UID']);
|
|
var row = new PMRow({
|
|
uid : '',
|
|
field_uid : records[i].data['FIELD_UID'],
|
|
field_dyn : records[i].data['FIELD_NAME'],
|
|
field_name : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_label : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_type : meta.type,
|
|
field_size : meta.size,
|
|
field_key : 0,
|
|
field_null : 1
|
|
});
|
|
|
|
store.add(row);
|
|
}
|
|
|
|
//remove from source grid
|
|
Ext.each(records, Ext.getCmp('availableGrid').store.remove, Ext.getCmp('availableGrid').store);
|
|
};
|
|
//RemoveButton Functionality
|
|
RemoveFieldsAction = function(){
|
|
|
|
records = Ext.getCmp('assignedGrid').getSelectionModel().getSelections();
|
|
var PMRow = availableGrid.getStore().recordType;
|
|
for(i=0; i < records.length; i++){
|
|
if (records[i].data['field_dyn'] != '' && records[i].data['field_name'] != 'APP_UID' && records[i].data['field_name'] != 'APP_NUMBER' && records[i].data['field_name'] != 'ROW') {
|
|
var row = new PMRow({
|
|
FIELD_UID : records[i].data['field_uid'],
|
|
FIELD_NAME : records[i].data['field_dyn']
|
|
});
|
|
availableGrid.getStore().add(row);
|
|
} else {
|
|
records[i] = null;
|
|
}
|
|
}
|
|
//remove from source grid
|
|
Ext.each(records, Ext.getCmp('assignedGrid').store.remove, Ext.getCmp('assignedGrid').store);
|
|
};
|
|
|
|
//AssignALLButton Functionality
|
|
AssignAllFieldsAction = function(){
|
|
var available = Ext.getCmp('availableGrid');
|
|
var allRows = available.getStore();
|
|
var arrAux = new Array();
|
|
records = new Array()
|
|
|
|
if (allRows.getCount() > 0){
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
for (i=0; i < allRows.getCount(); i++){
|
|
records[i] = allRows.getAt(i);
|
|
var meta = mapPMFieldType(records[i].data['FIELD_UID']);
|
|
var row = new PMRow({
|
|
uid : '',
|
|
field_uid : records[i].data['FIELD_UID'],
|
|
field_dyn : records[i].data['FIELD_NAME'],
|
|
field_name : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_label : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_type : meta.type,
|
|
field_size : meta.size,
|
|
field_key : 0,
|
|
field_null : 1
|
|
});
|
|
|
|
store.add(row);
|
|
}
|
|
//remove from source grid
|
|
Ext.each(records, Ext.getCmp('availableGrid').store.remove, Ext.getCmp('availableGrid').store);
|
|
}
|
|
|
|
};
|
|
|
|
//RevomeALLButton Functionality
|
|
RemoveAllFieldsAction = function(){
|
|
var allRows = Ext.getCmp('assignedGrid').getStore();
|
|
var records = new Array();
|
|
if (allRows.getCount() > 0) {
|
|
var PMRow = availableGrid.getStore().recordType;
|
|
for (var i=0; i < allRows.getCount(); i++){
|
|
records[i] = allRows.getAt(i);
|
|
if (records[i].data['field_dyn'] != '' && records[i].data['field_name'] != 'APP_UID' && records[i].data['field_name'] != 'APP_NUMBER' && records[i].data['field_name'] != 'ROW') {
|
|
var row = new PMRow({
|
|
FIELD_UID : records[i].data['field_uid'],
|
|
FIELD_NAME : records[i].data['field_dyn']
|
|
});
|
|
availableGrid.getStore().add(row);
|
|
} else {
|
|
records[i] = null;
|
|
}
|
|
}
|
|
//remove from source grid
|
|
Ext.each(records, Ext.getCmp('assignedGrid').store.remove, Ext.getCmp('assignedGrid').store);
|
|
}
|
|
};
|
|
|
|
// drag & drop handler
|
|
var DDLoadFields = function(){
|
|
var availableGridDropTargetEl = availableGrid.getView().scroller.dom;
|
|
var availableGridDropTarget = new Ext.dd.DropTarget(availableGridDropTargetEl, {
|
|
ddGroup : 'availableGridDDGroup',
|
|
notifyDrop : function(ddSource, e, data){
|
|
|
|
var records = ddSource.dragData.selections;
|
|
var PMRow = availableGrid.getStore().recordType;
|
|
|
|
for (i=0; i < records.length; i++){
|
|
if (records[i].data['field_dyn'] != '' && records[i].data['field_name'] != 'APP_UID' && records[i].data['field_name'] != 'APP_NUMBER' && records[i].data['field_name'] != 'ROW') {
|
|
var row = new PMRow({
|
|
FIELD_UID: records[i].data['field_uid'],
|
|
FIELD_NAME: records[i].data['field_dyn']
|
|
});
|
|
availableGrid.getStore().add(row);
|
|
} else if (records[i].data['field_dyn'] != '') {
|
|
records[i] = null;
|
|
}
|
|
}
|
|
|
|
Ext.each(records, ddSource.grid.store.remove, ddSource.grid.store);
|
|
return true;
|
|
}
|
|
});
|
|
|
|
//droptarget on grid forassignment
|
|
var assignedGridDropTargetEl = assignedGrid.getView().scroller.dom;
|
|
var assignedGridDropTarget = new Ext.dd.DropTarget(assignedGridDropTargetEl, {
|
|
ddGroup : 'assignedGridDDGroup',
|
|
notifyDrop : function(ddSource, e, data){
|
|
|
|
var records = ddSource.dragData.selections;
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
|
|
//add on target grid
|
|
for (i=0; i < records.length; i++){
|
|
//arrAux[r] = records[r].data['FIELD_UID'];
|
|
var meta = mapPMFieldType(records[i].data['FIELD_UID']);
|
|
var row = new PMRow({
|
|
uid : '',
|
|
field_uid : records[i].data['FIELD_UID'],
|
|
field_dyn : records[i].data['FIELD_NAME'],
|
|
field_name : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_label : records[i].data['FIELD_NAME'].toUpperCase(),
|
|
field_type : meta.type,
|
|
field_size : meta.size,
|
|
field_key : 0,
|
|
field_null : 1
|
|
});
|
|
|
|
store.add(row);
|
|
}
|
|
//remove from source grid
|
|
Ext.each(records, availableGrid.store.remove, availableGrid.store);
|
|
|
|
return true;
|
|
}
|
|
});
|
|
//sw_func_groups = true;
|
|
};
|
|
|
|
function loadTableRowsFromArray(records)
|
|
{
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
if (records.length == 0) return;
|
|
|
|
for (i=0;i<records.length; i++) {
|
|
var row = new PMRow({
|
|
uid : records[i].FLD_UID,
|
|
field_uid : records[i].FLD_DYN_UID,
|
|
field_dyn : records[i].FLD_DYN_NAME,
|
|
field_name : records[i].FLD_NAME,
|
|
field_label: records[i].FLD_DESCRIPTION,
|
|
field_type : records[i].FLD_TYPE,
|
|
field_size : records[i].FLD_SIZE,
|
|
field_key : records[i].FLD_KEY == '1' ? true : false,
|
|
field_null : records[i].FLD_NULL == '1' ? true : false,
|
|
field_autoincrement : records[i].FLD_AUTO_INCREMENT == '1' ? true : false,
|
|
field_filter: records[i].FLD_FILTER == '1' ? true : false
|
|
});
|
|
store.add(row);
|
|
}
|
|
}
|
|
|
|
|
|
function in_array(needle, haystack) {
|
|
for(var i in haystack) {
|
|
if(haystack[i] == needle) return true;
|
|
}
|
|
return false;
|
|
}
|