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
1523 lines
43 KiB
JavaScript
Executable File
1523 lines
43 KiB
JavaScript
Executable File
/**
|
|
* Report tables New/Edit
|
|
* @author Erik A. O. <erik@colosa.com>
|
|
*/
|
|
|
|
//grids define
|
|
var availableGrid;
|
|
var selCombo='';
|
|
|
|
var assignedGrid;
|
|
var editor; // row editor for assignedGrid
|
|
var store; // store for assignedGrid
|
|
|
|
//buttons define
|
|
var assignButton;
|
|
var assignAllButton;
|
|
var removeButton;
|
|
var removeAllButton;
|
|
var tmp1 = new Array();
|
|
var pageSize = 50;
|
|
var mainMask = new Ext.LoadMask(Ext.getBody(), {msg: _('ID_PLEASE_WAIT') });
|
|
var bbarpaging;
|
|
//main
|
|
Ext.onReady(function(){
|
|
mainMask = new Ext.LoadMask(Ext.getBody(), {msg: _('ID_PLEASE_WAIT') });
|
|
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: 'rows',
|
|
totalProperty: 'count',
|
|
fields : [
|
|
{name : 'FIELD_UID'},
|
|
{name : 'FIELD_VALIDATE'},
|
|
{name : 'FIELD_NAME'},
|
|
{name : '_index'},
|
|
{name : '_isset'}
|
|
]
|
|
}),
|
|
listeners: {
|
|
load: function() {
|
|
Ext.getCmp('availableGrid').store.sort();
|
|
storeA.setBaseParam('PRO_UID', (PRO_UID !== false? PRO_UID : Ext.getCmp('PROCESS').getValue()));
|
|
mainMask.hide();
|
|
assignedGrid._setTitle();
|
|
}
|
|
},
|
|
baseParams: {
|
|
PRO_UID: ''
|
|
},
|
|
remoteSort: false
|
|
});
|
|
|
|
storeA.setDefaultSort('FIELD_NAME', 'asc');
|
|
|
|
//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
|
|
}, {
|
|
dataIndex:'FIELD_VALIDATE',
|
|
hidden:true,
|
|
hideable:false
|
|
}
|
|
, {
|
|
dataIndex:'_index',
|
|
hidden:true,
|
|
hideable:false
|
|
}, {
|
|
dataIndex:'_isset',
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
storePageSize = new Ext.data.SimpleStore({
|
|
fields: ['size'],
|
|
data: [['20'],['30'],['40'],['50'],['100']],
|
|
autoLoad: true
|
|
});
|
|
|
|
comboPageSize = new Ext.form.ComboBox({
|
|
typeAhead : false,
|
|
mode : 'local',
|
|
triggerAction : 'all',
|
|
store: storePageSize,
|
|
valueField: 'size',
|
|
displayField: 'size',
|
|
width: 50,
|
|
editable: false,
|
|
listeners:{
|
|
select: function(c,d,i){
|
|
//UpdatePageConfig(d.data['size']);
|
|
bbarpaging.pageSize = parseInt(d.data['size']);
|
|
bbarpaging.moveFirst();
|
|
}
|
|
}
|
|
});
|
|
|
|
comboPageSize.setValue(pageSize);
|
|
|
|
bbarpaging = new Ext.PagingToolbar({
|
|
pageSize: pageSize,
|
|
store: storeA,
|
|
displayInfo: true,
|
|
displayMsg: '{0} - {1} of {2}',
|
|
emptyMsg: _('ID_NO_RECORDS')/*,
|
|
items: ['-',_('ID_PAGE_SIZE')+':',comboPageSize]*/
|
|
});
|
|
|
|
//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 : 290,
|
|
stateful : true,
|
|
stateId : 'gridEditReport',
|
|
enableHdMenu : false,
|
|
columnLines : false,
|
|
viewConfig : {forceFit:true},
|
|
cm : cmodelA,
|
|
sm : smodelA,
|
|
store : storeA,
|
|
//loadMask: {message:'Loading...'},
|
|
listeners : {
|
|
rowdblclick: AssignFieldsAction
|
|
},
|
|
tbar: [
|
|
{
|
|
xtype: 'textfield',
|
|
id: 'searchTxt',
|
|
ctCls:'pm_search_text_field',
|
|
allowBlank: true,
|
|
width: 220,
|
|
emptyText: _('ID_ENTER_SEARCH_TERM'),
|
|
listeners: {
|
|
specialkey: function(f,e){
|
|
if (e.getKey() == e.ENTER) {
|
|
filterAvFields();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
text: 'X',
|
|
ctCls:'pm_search_x_button',
|
|
handler: function(){
|
|
Ext.getCmp('searchTxt').setValue('');
|
|
filterAvFields();
|
|
}
|
|
}, {
|
|
text: _('ID_FILTER'),
|
|
handler: function(){
|
|
filterAvFields();
|
|
}
|
|
}
|
|
],
|
|
bbar: bbarpaging
|
|
});
|
|
|
|
var filterAvFields = function() {
|
|
//availableGrid.store.load({params: {textFilter: Ext.getCmp('searchTxt').getValue()}});
|
|
//storeA.setParam('textFilter', Ext.getCmp('searchTxt').getValue());
|
|
storeA.reload({params: {textFilter: Ext.getCmp('searchTxt').getValue(), start: bbarpaging.cursor, limit: pageSize}});
|
|
}
|
|
|
|
//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('removeColumn').disable();
|
|
break;
|
|
case 1:
|
|
var record = Ext.getCmp('assignedGrid').getSelectionModel().getSelected();
|
|
Ext.getCmp('removeButton').enable();
|
|
|
|
if (record.data.field_dyn == '' && record.data.field_name != 'APP_UID' && record.data.field_name != 'APP_NUMBER' && record.data.field_name != 'ROW') {
|
|
Ext.getCmp('removeColumn').enable();
|
|
}
|
|
break;
|
|
default:
|
|
Ext.getCmp('removeButton').enable();
|
|
Ext.getCmp('removeColumn').disable();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
//check column for table columns grid
|
|
var checkColumn = new Ext.grid.CheckColumn({
|
|
header: 'Filter',
|
|
dataIndex: 'FIELD_FILTER',
|
|
id: 'FIELD_FILTER',
|
|
width: 55
|
|
});
|
|
|
|
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
|
|
});
|
|
|
|
|
|
//columns for table columns grid
|
|
var cmColumns = [
|
|
{
|
|
id: 'uid',
|
|
dataIndex: 'uid',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
dataIndex: '_index',
|
|
hidden: true,
|
|
hideable:false
|
|
},
|
|
{
|
|
dataIndex: '_isset',
|
|
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',
|
|
width: 220,
|
|
// use shorthand alias defined above
|
|
editor: {
|
|
xtype: 'displayfield',
|
|
style: 'font-size:11px; padding-left:7px'
|
|
}
|
|
}, {
|
|
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().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: 105,
|
|
editor: new fm.ComboBox({
|
|
typeAhead: true,
|
|
triggerAction: 'all',
|
|
editable: false,
|
|
lazyRender: true,
|
|
mode: 'local',
|
|
displayField:'type',
|
|
valueField:'type_id',
|
|
store: new Ext.data.SimpleStore({
|
|
fields: ['type_id', 'type'],
|
|
//data : [['VARCHAR',_("ID_VARCHAR")],['TEXT',_("ID_TEXT")],['DATE',_("ID_DATE")],['INT',_("ID_INT")],['FLOAT',_("ID_FLOAT")]],
|
|
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();
|
|
if(selCombo != 'DOUBLE'
|
|
&& selCombo != 'TIME'
|
|
&& selCombo != 'DATE'
|
|
&& selCombo != 'DATETIME'
|
|
&& selCombo != 'BOOLEAN'
|
|
&& selCombo != 'REAL'
|
|
&& selCombo != 'FLOAT') {
|
|
Ext.getCmp('sizeEdit').enable();
|
|
} else {
|
|
Ext.getCmp('sizeEdit').disable();
|
|
}
|
|
if(selCombo == 'CHAR' || selCombo == 'VARCHAR') {
|
|
Ext.getCmp('sizeEdit').setMaxValue(((selCombo == 'CHAR')?255:999));
|
|
sizeField.getEl().dom.maxLength = 3;
|
|
} else {
|
|
Ext.getCmp('sizeEdit').setMaxValue(99);
|
|
sizeField.getEl().dom.maxLength = 2;
|
|
}
|
|
if( selCombo == 'CHAR'
|
|
|| selCombo == 'VARCHAR'
|
|
|| selCombo == 'TIME'
|
|
|| selCombo == 'DATE'
|
|
|| selCombo == 'DATETIME'
|
|
|| selCombo == 'BOOLEAN'
|
|
|| selCombo == 'REAL'
|
|
|| selCombo == 'FLOAT'
|
|
|| selCombo == 'DOUBLE') {
|
|
Ext.getCmp('field_incre').disable();
|
|
} else {
|
|
Ext.getCmp('field_incre').enable();
|
|
}
|
|
}
|
|
}//select
|
|
}
|
|
})
|
|
}, {
|
|
id: 'field_size',
|
|
header: _("ID_SIZE"),
|
|
dataIndex: 'field_size',
|
|
width: 50,
|
|
align: 'right',
|
|
editor: sizeField
|
|
}, {
|
|
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_AUTO_INCREMENT'),
|
|
dataIndex: 'field_autoincrement',
|
|
align: 'center',
|
|
width: 100,
|
|
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: '_index'},
|
|
{name: '_isset'},
|
|
{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) {
|
|
//
|
|
},
|
|
beforeedit: function(roweditor, rowIndex) {
|
|
row = assignedGrid.getSelectionModel().getSelected();
|
|
if (row.get('field_name') == 'APP_UID' || row.get('field_name') == 'APP_NUMBER' || row.get('field_name') == 'ROW') {
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
|
|
//table columns grid
|
|
assignedGrid = new Ext.grid.GridPanel({
|
|
title : _('ID_NEW_REPORT_TABLE'),
|
|
region : 'center',
|
|
id : 'assignedGrid',
|
|
ddGroup : 'availableGridDDGroup',
|
|
enableDragDrop : true,
|
|
viewConfig : {forceFit: true},
|
|
cm : cm,
|
|
sm : sm,
|
|
store : store,
|
|
plugins : [editor, checkColumn],
|
|
loadMask: {message: _('ID_LOADING_GRID')},
|
|
tbar : [
|
|
{
|
|
icon: '/images/add-row-after.png',
|
|
text: _("ID_ADD_FIELD"),
|
|
handler: addColumn
|
|
}, {
|
|
id: 'removeColumn',
|
|
icon: '/images/delete-row.png',
|
|
text: _("ID_REMOVE_FIELD"),
|
|
disabled: true,
|
|
handler: removeColumn
|
|
}
|
|
],
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
},
|
|
_setTitle: function() {
|
|
this.setTitle(_('ID_REPORT_TABLE') + ': ' + Ext.getCmp('REP_TAB_NAME').getValue() + ' ('+store.getCount()+' ' + _('ID_COLUMNS') + ')');
|
|
}
|
|
});
|
|
|
|
// (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 : [availableGrid,buttonsPanel,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: true,
|
|
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
|
|
defaultValue = TABLE.DBS_UID;
|
|
comboDbConnections.setDisabled(true);
|
|
}
|
|
else {
|
|
defaultValue = 'workflow';
|
|
}
|
|
|
|
// set current editing process combobox
|
|
var i = this.findExact('DBS_UID', defaultValue, 0);
|
|
if (i > -1){
|
|
comboDbConnections.setValue(this.getAt(i).data.DBS_UID);
|
|
comboDbConnections.setRawValue(this.getAt(i).data.DBS_NAME);
|
|
}
|
|
else {
|
|
// DB COnnection deleted
|
|
Ext.Msg.alert( _('ID_ERROR'), _('ID_DB_CONNECTION_NOT_EXIST') );
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
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'
|
|
});
|
|
|
|
gridsListStore = new Ext.data.Store({
|
|
//autoLoad: true,
|
|
proxy : new Ext.data.HttpProxy({
|
|
url: '../pmTablesProxy/getDynafields',
|
|
method : 'POST'
|
|
}),
|
|
baseParams : {
|
|
PRO_UID : '',
|
|
TYPE: 'GRID'
|
|
},
|
|
reader : new Ext.data.JsonReader( {
|
|
//root : 'processFields',
|
|
fields : [{name : 'FIELD_UID'}, {name : 'FIELD_NAME'}]
|
|
}),
|
|
listeners: {
|
|
load: function(){
|
|
if (TABLE !== false) {
|
|
var i = this.findExact('FIELD_UID', TABLE.ADD_TAB_GRID, 0);
|
|
if (i > -1){
|
|
comboGridsList.setValue(this.getAt(i).data.FIELD_UID);
|
|
comboGridsList.setRawValue(this.getAt(i).data.FIELD_NAME);
|
|
comboGridsList.setDisabled(true);
|
|
|
|
var available = Ext.getCmp('availableGrid');
|
|
available.store.load({
|
|
params: {
|
|
action: "getDynafields",
|
|
PRO_UID: PRO_UID !== false ? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
TYPE: 'GRID',
|
|
GRID_UID: Ext.getCmp('REP_TAB_GRID').getValue(),
|
|
start: 0,
|
|
limit: pageSize
|
|
}
|
|
});
|
|
} else {
|
|
Ext.Msg.alert( _('ID_ERROR'), _('ID_GRID_NO_EXIST') );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
comboGridsList = new Ext.form.ComboBox({
|
|
id: 'REP_TAB_GRID',
|
|
fieldLabel : 'Grid',
|
|
hiddenName : 'FIELD_UID',
|
|
store : gridsListStore,
|
|
emptyText: _("ID_SELECT_GRID"),
|
|
//hidden:true,
|
|
//hideLabel: true,
|
|
//value: 'rp',
|
|
valueField : 'FIELD_UID',
|
|
displayField : 'FIELD_NAME',
|
|
triggerAction : 'all',
|
|
width: 120,
|
|
editable : false,
|
|
mode:'local',
|
|
listeners:{
|
|
afterrender: function(){
|
|
//Ext.getCmp('REP_TAB_GRID').setVisible(false);
|
|
//loadFieldNormal();
|
|
},
|
|
select: function(combo,record,index){
|
|
|
|
//Ext.getCmp('REP_TAB_TYPE').setVisible(true);
|
|
// Ext.getCmp('REP_TAB_GRID').setVisible(true);
|
|
loadFieldsGrids();
|
|
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
processStore = new Ext.data.Store( {
|
|
autoLoad: true,
|
|
proxy : new Ext.data.HttpProxy({
|
|
url: '../pmTablesProxy/getProcessList',
|
|
method : 'POST'
|
|
}),
|
|
baseParams : {
|
|
action: 'getProcessList'
|
|
},
|
|
reader : new Ext.data.JsonReader( {
|
|
fields : [{name : 'PRO_UID'}, {name : 'PRO_TITLE'},{name : 'PRO_DESCRIPTION'}]
|
|
}),
|
|
listeners: {
|
|
load: function() {
|
|
if (TABLE !== false) { // is editing
|
|
// set current editing process combobox
|
|
var i = this.findExact('PRO_UID', TABLE.PRO_UID, 0);
|
|
if (i > -1){
|
|
processComboBox.setValue(this.getAt(i).data.PRO_UID);
|
|
processComboBox.setRawValue(this.getAt(i).data.PRO_TITLE);
|
|
processComboBox.setDisabled(true);
|
|
} else {
|
|
// Process deleted
|
|
Ext.Msg.alert( _('ID_ERROR'), _('ID_PROCESS_NO_EXIST') );
|
|
}
|
|
// setting table attributes for current editing process
|
|
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);
|
|
|
|
// grid
|
|
comboReport.setDisabled(true);
|
|
if (TABLE.ADD_TAB_TYPE == 'GRID') {
|
|
Ext.getCmp('REP_TAB_GRID').setVisible(true);
|
|
gridsListStore.reload({params:{PRO_UID : Ext.getCmp('PROCESS').getValue()}});
|
|
}
|
|
// db connections
|
|
comboDbConnections.getStore().reload({params:{PRO_UID : Ext.getCmp('PROCESS').getValue()}});
|
|
|
|
// loading available fields
|
|
//loadAvFieldsFromArray(avFieldsList);
|
|
//if (TABLE.ADD_TAB_TYPE == 'GRID')
|
|
//loadFieldsGrids();
|
|
//else
|
|
if (TABLE.ADD_TAB_TYPE == 'NORMAL')
|
|
loadFieldNormal();
|
|
|
|
// loading table fields
|
|
loadTableRowsFromArray(TABLE.FIELDS);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
processComboBox = new Ext.form.ComboBox({
|
|
id: 'PROCESS',
|
|
fieldLabel : _("ID_CASESLIST_APP_PRO_TITLE"),
|
|
hiddenName : 'PRO_UID',
|
|
store : processStore,
|
|
emptyText: _("ID_EMPTY_PROCESSES"),
|
|
valueField : 'PRO_UID',
|
|
displayField : 'PRO_TITLE',
|
|
|
|
//width: 180,
|
|
editable : true,
|
|
typeAhead: true,
|
|
mode: 'local',
|
|
autocomplete: true,
|
|
triggerAction: 'all',
|
|
forceSelection: true,
|
|
|
|
listeners:{
|
|
select: function(){
|
|
comboDbConnections.getStore().reload({params:{PRO_UID : Ext.getCmp('PROCESS').getValue()}});
|
|
if (Ext.getCmp('REP_TAB_TYPE').getValue() == 'GRID') {
|
|
gridsListStore.reload({params:{PRO_UID : Ext.getCmp('PROCESS').getValue()}});
|
|
} else {
|
|
loadFieldNormal();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
var items = new Array();
|
|
if (PRO_UID === false)
|
|
items.push(processComboBox);
|
|
|
|
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());
|
|
assignedGrid._setTitle();
|
|
}
|
|
}
|
|
});
|
|
items.push({
|
|
id: 'REP_TAB_DSC',
|
|
fieldLabel: _("ID_DESCRIPTION"),
|
|
xtype:'textarea',
|
|
emptyText: _("ID_SET_TABLE_DESCRIPTION"),
|
|
width: 250,
|
|
height: 40,
|
|
allowBlank: true
|
|
});
|
|
items.push({
|
|
xtype: 'hidden',
|
|
name: 'REP_TAB_GRID',
|
|
value: 'GridComments-463650787492db06640c904001904930'
|
|
});
|
|
items.push({
|
|
xtype: 'compositefield',
|
|
fieldLabel: _("ID_TYPE"),
|
|
msgTarget : 'side',
|
|
anchor : '-20',
|
|
defaults : {flex: 1 },
|
|
items: [comboReport, comboGridsList]
|
|
});
|
|
items.push(comboDbConnections);
|
|
|
|
|
|
var frmDetailsConfig = {
|
|
id:'frmDetails',
|
|
region: 'north',
|
|
labelWidth: 180,
|
|
labelAlign:'right',
|
|
title: ADD_TAB_UID ? _('ID_REPORT_TABLE') : _('ID_NEW_REPORT_TABLE'),
|
|
bodyStyle:'padding:10px',
|
|
waitMsgTarget : true,
|
|
frame: true,
|
|
height: _plugin_permissions !== false ? 224 : 200,
|
|
defaults: {
|
|
allowBlank: false,
|
|
msgTarget: 'side',
|
|
align:'center'
|
|
},
|
|
items: items
|
|
}
|
|
|
|
var frmDetails = new Ext.FormPanel(frmDetailsConfig);
|
|
|
|
southPanel = new Ext.FormPanel({
|
|
region: 'south',
|
|
buttons:[ {
|
|
text: TABLE === false ? _("ID_CREATE") : _("ID_UPDATE"),
|
|
handler: createReportTable
|
|
}, {
|
|
text:_("ID_CANCEL"),
|
|
handler: function() {
|
|
proParam = PRO_UID !== false ? '?PRO_UID='+PRO_UID : '';
|
|
location.href = '../pmTables' + proParam; //history.back();
|
|
}
|
|
}]
|
|
});
|
|
|
|
var viewport = new Ext.Viewport({
|
|
layout: 'border',
|
|
autoScroll: false,
|
|
items:[frmDetails, FieldsPanel, southPanel]
|
|
});
|
|
|
|
/*** Editing routines ***/
|
|
if (TABLE !== false) {
|
|
if(TABLE.ADD_TAB_TYPE != 'GRID')
|
|
Ext.getCmp('REP_TAB_GRID').hide();
|
|
} else {
|
|
Ext.getCmp('REP_TAB_GRID').hide();
|
|
}
|
|
|
|
if (PRO_UID !== false) {
|
|
comboDbConnections.getStore().reload({params:{PRO_UID : PRO_UID}});
|
|
if (Ext.getCmp('REP_TAB_TYPE').getValue() == 'GRID') {
|
|
gridsListStore.reload({params:{PRO_UID : PRO_UID}});
|
|
}
|
|
|
|
if (TABLE === false) {
|
|
if(TABLE.ADD_TAB_TYPE != 'GRID')
|
|
loadFieldNormal();
|
|
}
|
|
}
|
|
|
|
DDLoadFields();
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function createReportTable()
|
|
{
|
|
var tableName = Ext.getCmp('REP_TAB_NAME').getValue().trim();
|
|
var tableDescription = Ext.getCmp('REP_TAB_DSC').getValue().trim();
|
|
|
|
//validate table name
|
|
if(Ext.getCmp('REP_TAB_NAME').getValue().trim() == '') {
|
|
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 process
|
|
PRO_UID = (PRO_UID !== false) ? PRO_UID : ((Ext.getCmp('PROCESS').getValue().trim() != '') ? Ext.getCmp('PROCESS').getValue().trim() : '');
|
|
if(PRO_UID == '') {
|
|
Ext.getCmp('PROCESS').focus();
|
|
PMExt.error(_('ID_ERROR'), _('ID_PROCESS_IS_REQUIRED'), function(){
|
|
Ext.getCmp('PROCESS').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 r=0; r < allRows.getCount(); r++) {
|
|
row = allRows.getAt(r);
|
|
|
|
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;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
columns.push(row.data);
|
|
}
|
|
|
|
Ext.Msg.show({
|
|
title : '',
|
|
msg : TABLE !== false ? _('ID_UPDATING_TABLE') : _('ID_CREATING_TABLE'),
|
|
wait:true,
|
|
waitConfig: {interval:500}
|
|
});
|
|
|
|
Ext.Ajax.request({
|
|
url: '../pmTablesProxy/save',
|
|
params: {
|
|
REP_TAB_UID : TABLE !== false ? TABLE.ADD_TAB_UID : '',
|
|
PRO_UID : PRO_UID !== false? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
REP_TAB_NAME : TABLE !== false ? tableName : 'PMT_' + tableName,
|
|
REP_TAB_DSC : tableDescription,
|
|
REP_TAB_CONNECTION : Ext.getCmp('REP_TAB_CONNECTION').getValue(),
|
|
REP_TAB_TYPE : Ext.getCmp('REP_TAB_TYPE').getValue(),
|
|
REP_TAB_GRID : Ext.getCmp('REP_TAB_TYPE').getValue()=='GRID'? Ext.getCmp('REP_TAB_GRID').getValue(): '',
|
|
columns : Ext.util.JSON.encode(columns)
|
|
},
|
|
success: function(resp){
|
|
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);
|
|
}
|
|
}
|
|
},
|
|
failure: function(obj, resp){
|
|
Ext.Msg.alert( _('ID_ERROR'), resp.result.msg);
|
|
}
|
|
});
|
|
}
|
|
//end createReportTable
|
|
|
|
//add custon column for assignedGrid
|
|
function addColumn()
|
|
{
|
|
if (!verifyTableLimit()) {
|
|
return false;
|
|
}
|
|
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
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 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();
|
|
setReportFields(records);
|
|
};
|
|
|
|
//RemoveButton Functionality
|
|
RemoveFieldsAction = function(){
|
|
records = Ext.getCmp('assignedGrid').getSelectionModel().getSelections();
|
|
//remove from source grid
|
|
unsetReportFields(records);
|
|
};
|
|
|
|
//AssignALLButton Functionality
|
|
AssignAllFieldsAction = function(){
|
|
var avStore = Ext.getCmp('availableGrid').getStore();
|
|
var records = new Array();
|
|
|
|
if (avStore.getCount() > 0){
|
|
for (i=0; i < avStore.getCount(); i++){
|
|
records[i] = avStore.getAt(i);
|
|
}
|
|
setReportFields(records);
|
|
}
|
|
};
|
|
|
|
//RevomeALLButton Functionality
|
|
RemoveAllFieldsAction = function(){
|
|
|
|
if (store.getCount() > 100) {
|
|
PMExt.info(_('ID_NOTICE'), _('ID_ACTION_DISABLED_TO_LOW_PERFORMANCE_1') + _('ID_ACTION_DISABLED_TO_LOW_PERFORMANCE_2') );
|
|
return ;
|
|
}
|
|
|
|
var allRows = Ext.getCmp('assignedGrid').getStore();
|
|
var records = new Array();
|
|
if (allRows.getCount() > 0) {
|
|
for (var i=0; i < allRows.getCount(); i++){
|
|
records[i] = allRows.getAt(i);
|
|
}
|
|
//remove from source grid
|
|
unsetReportFields(records);
|
|
}
|
|
};
|
|
|
|
//INITIAL FIELDS GRIDS
|
|
loadFieldNormal = function(){
|
|
Ext.getCmp('availableGrid').store.removeAll();
|
|
Ext.getCmp('availableGrid').store.load({
|
|
params: {
|
|
action: "getDynafields",
|
|
PRO_UID: PRO_UID !== false ? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
start: 0,
|
|
limit: pageSize
|
|
}
|
|
});
|
|
var assignedGridGotData = Ext.getCmp('assignedGrid').getStore().getCount() > 0;
|
|
if(assignedGridGotData) {
|
|
Ext.MessageBox.confirm('Confirm', 'The row data that you recently created will be deleted?', function(button) {
|
|
if(button=='yes'){
|
|
Ext.getCmp('assignedGrid').store.removeAll();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
loadFieldsGrids = function(){
|
|
var available = Ext.getCmp('availableGrid');
|
|
available.store.removeAll();
|
|
|
|
available.store.load({
|
|
params: {
|
|
action: "getDynafields",
|
|
PRO_UID: PRO_UID !== false ? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
TYPE: 'GRID',
|
|
GRID_UID: Ext.getCmp('REP_TAB_GRID').getValue(),
|
|
start: 0,
|
|
limit: pageSize
|
|
}
|
|
});
|
|
|
|
var assigned = Ext.getCmp('assignedGrid');
|
|
assigned.store.removeAll();
|
|
|
|
};
|
|
|
|
//REFRESH FIELDS GRIDS
|
|
RefreshFields = function(){
|
|
var available = Ext.getCmp('availableGrid');
|
|
available.store.load({params: {"action":"deleteFieldsReportTables", "PRO_UID":PRO_UID }});
|
|
var assigned = Ext.getCmp('assignedGrid');
|
|
assigned.store.load({params: {"action":"assignedFieldsReportTables", "PRO_UID":PRO_UID }});
|
|
};
|
|
|
|
//FAILURE AJAX FUNCTION
|
|
FailureFields = function(){
|
|
Ext.Msg.alert(_('ID_GROUPS'), _('ID_MSG_AJAX_FAILURE'));
|
|
};
|
|
|
|
// 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;
|
|
unsetReportFields(records);
|
|
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){
|
|
//add on target grid
|
|
setReportFields(ddSource.dragData.selections)
|
|
return true;
|
|
}
|
|
});
|
|
//sw_func_groups = true;
|
|
};
|
|
|
|
function setReportFields(records) {
|
|
mainMask.show();
|
|
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
var indexes = new Array();
|
|
|
|
for (i=0; i < records.length; i++) {
|
|
if (!verifyTableLimit()) {
|
|
return false;
|
|
}
|
|
|
|
var meta = mapPMFieldType(records[i].data['FIELD_UID']);
|
|
var typeField = meta.type;
|
|
var sizeField = meta.size;
|
|
if (records[i].data['FIELD_VALIDATE'].toUpperCase() == 'REAL') {
|
|
typeField = 'DOUBLE';
|
|
sizeField = '';
|
|
}
|
|
if (records[i].data['FIELD_VALIDATE'].toUpperCase() == 'INT') {
|
|
typeField = 'INTEGER';
|
|
}
|
|
var row = new PMRow({
|
|
uid : '',
|
|
_index : records[i].data['_index'] !== '' ? records[i].data['_index'] : records[i].data['FIELD_DYN'],
|
|
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 : typeField,
|
|
field_size : sizeField,
|
|
field_key : 0,
|
|
field_null : 1,
|
|
field_filter: 0,
|
|
field_autoincrement : 0
|
|
});
|
|
|
|
store.add(row);
|
|
indexes.push(records[i].data['_index']);
|
|
}
|
|
|
|
//remove from source grid
|
|
Ext.each(records, availableGrid.store.remove, availableGrid.store);
|
|
|
|
if (indexes.length == 0) {
|
|
mainMask.hide();
|
|
return;
|
|
}
|
|
|
|
//update on server
|
|
Ext.Ajax.request({
|
|
url: '../pmTablesProxy/updateAvDynafields',
|
|
params: {
|
|
PRO_UID : PRO_UID !== false? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
indexes : indexes.join(','),
|
|
isset : false
|
|
},
|
|
success: function(resp){
|
|
result = Ext.util.JSON.decode(resp.responseText);
|
|
availableGrid.store.reload();
|
|
}
|
|
});
|
|
}
|
|
|
|
function unsetReportFields(records) {
|
|
mainMask.show();
|
|
|
|
var PMRow = availableGrid.getStore().recordType;
|
|
var indexes = new Array();
|
|
var recordsUsrDef = new Array();
|
|
var fieldName = '';
|
|
|
|
for (i=0; i < records.length; i++) {
|
|
if (records[i].data['field_dyn'] != '') {
|
|
var row = new PMRow({
|
|
FIELD_UID: records[i].data['field_uid'],
|
|
FIELD_NAME: records[i].data['field_dyn']
|
|
});
|
|
availableGrid.getStore().add(row);
|
|
ix = records[i].data['_index'] != '' ? records[i].data['_index'] : records[i].data['field_dyn']
|
|
indexes.push(ix);
|
|
} else {
|
|
if ( records[i].data['field_name'] == 'APP_UID'
|
|
|| records[i].data['field_name'] == 'APP_NUMBER'
|
|
|| records[i].data['field_name'] == 'ROW')
|
|
{
|
|
records[i] = null;
|
|
}
|
|
else {
|
|
if (records[i].data['field_dyn'] == '' || records[i].data['field_dyn'] == null) {
|
|
if (fieldName.length > 0) {
|
|
fieldName += ', '
|
|
}
|
|
fieldName += records[i].data['field_name'];
|
|
recordsUsrDef.push(records[i]);
|
|
records[i] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ext.each(records, assignedGrid.store.remove, assignedGrid.store);
|
|
|
|
if (recordsUsrDef.length > 0 ) {
|
|
PMExt.confirm(_('ID_CONFIRM'), _('ID_CONFIRM_REMOVE_FIELDS') + ' ' + fieldName + '?', function(){
|
|
Ext.each(recordsUsrDef, assignedGrid.store.remove, assignedGrid.store);
|
|
});
|
|
}
|
|
|
|
if (indexes.length == 0) {
|
|
mainMask.hide();
|
|
return;
|
|
}
|
|
|
|
//update on server
|
|
Ext.Ajax.request({
|
|
url: '../pmTablesProxy/updateAvDynafields',
|
|
params: {
|
|
PRO_UID : PRO_UID !== false? PRO_UID : Ext.getCmp('PROCESS').getValue(),
|
|
indexes : indexes.join(','),
|
|
isset : true
|
|
},
|
|
success: function(resp){
|
|
result = Ext.util.JSON.decode(resp.responseText);
|
|
availableGrid.store.reload();
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
function loadTableRowsFromArray(records)
|
|
{
|
|
var PMRow = assignedGrid.getStore().recordType;
|
|
if (records.length == 0) return;
|
|
|
|
for (i=0;i<records.length; i++) {
|
|
|
|
// to map virtual field types
|
|
switch (records[i].FLD_TYPE) {
|
|
case 'TIMESTAMP':
|
|
records[i].FLD_TYPE = 'DATETIME';
|
|
break;
|
|
}
|
|
|
|
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,
|
|
field_null : records[i].FLD_NULL,
|
|
field_autoincrement : records[i].FLD_AUTO_INCREMENT == '1' ? true : false,
|
|
field_filter: records[i].FLD_FILTER == '1' ? true : false,
|
|
_index : ''
|
|
});
|
|
|
|
store.add(row);
|
|
}
|
|
}
|
|
|
|
function loadAvFieldsFromArray(records)
|
|
{
|
|
var PMRow = availableGrid.getStore().recordType;
|
|
|
|
for(i=0; i<records.length; i++) {
|
|
var row = new PMRow({
|
|
FIELD_UID: records[i].FIELD_UID,
|
|
FIELD_NAME: records[i].FIELD_NAME
|
|
});
|
|
|
|
availableGrid.getStore().add(row);
|
|
}
|
|
}
|
|
|
|
function mapPMFieldType(id)
|
|
{
|
|
var meta = id.split('-');
|
|
|
|
switch(meta[1]) {
|
|
case 'text':
|
|
case 'password':
|
|
case 'dropdown':
|
|
case 'yesno':
|
|
case 'checkbox':
|
|
case 'radiogroup':
|
|
case 'hidden':
|
|
typeField='VARCHAR';
|
|
sizeField='32';
|
|
break;
|
|
case 'currency':
|
|
typeField='INTEGER';
|
|
sizeField='11';
|
|
break;
|
|
case 'percentage':
|
|
typeField='FLOAT';
|
|
sizeField='11';
|
|
break;
|
|
case 'date':
|
|
typeField='VARCHAR';
|
|
sizeField='10';
|
|
break;
|
|
case 'textarea':
|
|
typeField='VARCHAR';
|
|
sizeField='255';
|
|
break;
|
|
|
|
default:
|
|
typeField='TEXT';
|
|
sizeField='';
|
|
break;
|
|
}
|
|
|
|
return {type:typeField, size:sizeField};
|
|
}
|
|
|
|
Ext.override(Ext.form.TextField, {
|
|
initComponent: Ext.form.TextField.prototype.initComponent.createInterceptor(function(){
|
|
// This interceptor calls the original TextFields' initComponent method
|
|
// after executing this function.
|
|
if (this.convertToUpperCase) {
|
|
// The following style makes all letters uppercase when typing,
|
|
// but it only affects the display, actual characters are preserved
|
|
// as typed. That is why we need to override the getValue function.
|
|
this.style = "textTransform: uppercase;"
|
|
}
|
|
}),
|
|
|
|
getValue: function(){
|
|
var value = Ext.form.TextField.superclass.getValue.call(this);
|
|
if (this.convertToUpperCase) {
|
|
value = value.toUpperCase();
|
|
}
|
|
return value;
|
|
}
|
|
});
|
|
|
|
|
|
function verifyTableLimit()
|
|
{
|
|
if( store.getCount() >= 255 ) {
|
|
mainMask.hide();
|
|
PMExt.info(_('ID_NOTICE'), _('ID_MAX_LIMIT_COLUMNS_FOR_DATABASE') );
|
|
assignedGrid._setTitle();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function in_array(needle, haystack) {
|
|
for(var i in haystack) {
|
|
if(haystack[i] == needle) return true;
|
|
}
|
|
return false;
|
|
}
|