09a1854d8a
When adding a field, the 'Field Name' must be an string without spaces in the middle, because this makes the name of some funtions were generated wrong, like getColosa Email() when it must be like getColosaEmail() or getColosa_Email(). So, this field in the creating PM Table form, was validated to transform any string into a string without spaces.
1057 lines
29 KiB
JavaScript
Executable File
1057 lines
29 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;
|
|
|
|
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 : 'grid',
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
//check column for table 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(" ","").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:true,
|
|
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 : [['VARCHAR',_("ID_VARCHAR")],['TEXT',_("ID_TEXT")],['DATE',_("ID_DATE")],['INT',_("ID_INT")],['FLOAT',_("ID_FLOAT")]],
|
|
data: columnsTypes,
|
|
sortInfo: {field:'type_id', direction:'ASC'}
|
|
})
|
|
})
|
|
}, {
|
|
id: 'field_size',
|
|
header: _("ID_SIZE"),
|
|
dataIndex: 'field_size',
|
|
width: 50,
|
|
align: 'right',
|
|
editor: new fm.NumberField({
|
|
allowBlank: true
|
|
})
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_NULL'),
|
|
dataIndex: 'field_null',
|
|
align: 'center',
|
|
width: 50,
|
|
trueText: 'Yes',
|
|
falseText: 'No',
|
|
editor: {
|
|
xtype: 'checkbox'
|
|
}
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_PRIMARY_KEY'),
|
|
dataIndex: 'field_key',
|
|
align: 'center',
|
|
width: 80,
|
|
trueText: 'Yes',
|
|
falseText: 'No',
|
|
editor: {
|
|
xtype: 'checkbox'
|
|
}
|
|
}, {
|
|
xtype: 'booleancolumn',
|
|
header: _('ID_AUTO_INCREMENT'),
|
|
dataIndex: 'field_autoincrement',
|
|
align: 'center',
|
|
width: 80,
|
|
trueText: 'Yes',
|
|
falseText: 'No',
|
|
editor: {
|
|
xtype: 'checkbox'
|
|
}
|
|
}
|
|
];
|
|
|
|
//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: 'Yes',
|
|
falseText: 'No',
|
|
editor: {
|
|
xtype: 'checkbox'
|
|
}
|
|
})
|
|
}
|
|
|
|
//column model for table columns grid
|
|
var cm = new Ext.grid.ColumnModel({
|
|
// specify any defaults for each column
|
|
defaults: {
|
|
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,
|
|
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('ERROR', 'Something was 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;
|
|
}
|