0541bc24fa
- Imposible crear report tables
- El problema consiste en lo siguiente:
> QA tiene backups de sus workspaces, y el mismo es restaurado
una y otra vez
> El workspace que se muestra en la imagen "wsqa" tiene mal creado el archivo
"processmaker/shared/sites/wsqa/pmt-propel/workflow/config/schema.xml"
ahi hay un error, que es el sgte:
<column name="NOMBRE" type="" required="false"/>
...
<column name="APELLIDO" type="" required="false"/>
el atributo type esta vacio, y el mismo ocasiona el problema, lo que quiere
decir que antes en un intento de crear un ReportTable colocaron el campo
type vacio lo que causo que se cree mal el archivo schema.xml
- Si el archivo schema.xml se creo mal, ahi no se puede hacer nada, se tendra que
corregir el mismo manualmente
- Se ha mejorado el campo "Type" para ReportTables y PMTables para que trabaje siempre
mostrando un valor y no que muestre vacio al principio
* Available from version ProcessMaker-2.5.2-testing.1
1180 lines
34 KiB
JavaScript
Executable File
1180 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
|
|
},
|
|
{
|
|
id: 'field_uid',
|
|
dataIndex: 'field_uid',
|
|
hidden: true
|
|
},
|
|
{
|
|
id: 'field_key',
|
|
dataIndex: 'field_key',
|
|
hidden: true
|
|
},
|
|
{
|
|
id: 'field_null',
|
|
dataIndex: 'field_null',
|
|
hidden: true
|
|
},
|
|
{
|
|
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" || selCombo == "TINYINT" || selCombo == "SMALLINT") {
|
|
//Enable All
|
|
}
|
|
|
|
if (selCombo == "DECIMAL" || selCombo == "DOUBLE" || selCombo == "FLOAT" || selCombo == "REAL") {
|
|
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,
|
|
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;
|
|
}
|