// ---------------------------------------------------------------
// SqlDriDialog
// ---------------------------------------------------------------
function SqlDriDialog(wrkfolder) {
require(["dojo/text!desktop/text/sqldridialog.html",
"dijit/layout/ContentPane",
"dijit/Dialog", "dijit/registry",
"dijit/form/TextBox", "dijit/form/Button",
"dojo/dom-construct", "dojo/dom"],
function(snippet, ContentPane, Dialog, registry, TextBox, Button, domConstruct, dom) {
//console.log ("SqlDriLoad snippet: ", snippet);
if (registry.byId("sqlDrillDialog")) {
registry.byId("sqlDrillDialog").show();
return;
}
var sqlDrillDialog = new Dialog({
id: "sqlDrillDialog",
title: "Drilldown",
style: "width: 1000px; height: 700px;",
content: snippet
});
sqlDrillDialog.show();
SqlDriLoad(wrkfolder);
});
}
// ---------------------------------------------------------------
// SqlDriLoad:
// ---------------------------------------------------------------
function SqlDriLoad(wrkfolder) {
console.log ("SqlDriLoad wrkflder: ", wrkfolder);
require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
function(ready, dojo, xhr, registry){
var urlString = wrkfolder.sqldripath;
xhr(urlString, {
handleAs: "text",
method: "GET"
}).then(function(data){
var jsonResponse = dojo.fromJson(data);
//console.log("SqlGetMessage jsonResponse: ", jsonResponse);
SqlDriNav(jsonResponse);
}, function(err){
// Handle the error condition
}, function(evt){
// XHR2 events
});
});
}
// -----------------------------------------------------------
//
// -----------------------------------------------------------
function SqlDriNav(jsonResponse) {
require(["dojo/ready", "dijit/registry"],
function(ready, registry){
var sql = jsonResponse;
//console.log ("SqlDriNav sql", sql);
//console.log ("SqlDriNav registry: ", registry);
//console.log ("SqlDriNav registry(hdmSqlDri): ", registry.byId("hdmSqlDri"));
hugmarSettings.sql = sql;
if (sql.env.cltype == "SUBFILE") {
domConstruct.destroy("hdmSqlDriGrpBy");
SqlDriWhere(sql); // Where
SqlDriOrdBy(sql); // Order By
SqlDriButtons(sql);
}
if (sql.env.cltype == "SUBFGROUP") {
SqlDriWhere(sql); // Where
SqlDriGrpBy(sql); // Group By
SqlDriOrdBy(sql); // Order By
SqlDriButtons(sql);
}
return;
});
}
// -----------------------------------------------------------
//
// -----------------------------------------------------------
function SqlDriButtons(sql) {
//console.log ("SqlDriButtons I am here: ");
require(["dojo/dom", "dojo/dom-construct", "dijit/registry"],
function(dom, domConstruct, registry){
var sqlButton = registry.byId("hdmSqlDriBut0");
if (sqlButton) {
sqlButton.destroyRecursive(true);
}
var sqlButton = registry.byId("hdmSqlDriBut1");
if (sqlButton) {
sqlButton.destroyRecursive(true);
}
var sqlButton = registry.byId("hdmSqlDriBut2");
if (sqlButton) {
sqlButton.destroyRecursive(true);
}
var parNode = dom.byId("hdmSqlDriButtons");
// Confirm
parNode.appendChild(domConstruct.create("div", {id: "hdmSqlDriBut0"}));
SqlDriOneBut("hdmSqlDriBut0", "Confirm", "gif38", "confirm", "Confirm Sql Changes", sql);
// Cancel
parNode.appendChild(domConstruct.create("div", {id: "hdmSqlDriBut1"}));
SqlDriOneBut("hdmSqlDriBut1", "Cancel", "gif33", "cancel", "Cancel Sql Changes", sql);
// Refresh
//parNode.appendChild(domConstruct.create("div", {id: "hdmSqlDriBut2"}));
//SqlDriOneBut("hdmSqlDriBut2", "Refresh", "gif42", "refresh", "Refresh Sql Edit Panes", sql);
return;
});
}
// -----------------------------------------------------------
//
// -----------------------------------------------------------
function SqlDriOneBut(domID, label, icon, action, title, sql) {
require(["dojo/dom", "dijit/registry", "dijit/form/Button"],
function(dom, registry, Button){
//console.log ("SqlDriOneBut I am here: ");
var sqlButton = registry.byId(domID);
if (sqlButton) {
sqlButton.destroyRecursive(true);
}
var dom = dom.byId(domID);
var sqlButton = new Button({
label: label,
iconClass: icon,
jsId: action,
sqlEnv: sql.env,
onClick: function(evt) {
var butNode = dijit.getEnclosingWidget(evt.target);
//console.log("SqlDriOneBut onClick butNode: ", butNode);
switch (butNode.jsId) {
case 'cancel': SqlDriCancel(butNode.jsId, butNode.sqlEnv); break;
case 'confirm': SqlDriConfirm(butNode.jsId, butNode.sqlEnv); break;
case 'refresh': SqlDriWhere(sql); break;
}
},
title: title
}, dom);
});
}
// -----------------------------------------------------------
// Remove Sql Tab
// -----------------------------------------------------------
function SqlDriCancel(sqlType, sqlEnv) {
require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
function(ready, dojo, xhr, registry){
console.log ("SqlDriCancel: hugmarSettings: ", hugmarSettings);
var jsCaller = "SqlDriCancel";
var jsonObj = SqlDriSetJsonObj(jsCaller,"HWEBNAFB4","sqlcancel", hugmarSettings);
//jsonObj.gridenv = hjsonGridControl.env;
jsonObj.procparm = sqlType;
jsonObj.sqlrow.type = sqlType;
var jsonString = dojo.toJson(jsonObj);
var urlString = hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
dojo.xhrGet({
url: urlString, handleAs: "json",
load: function(jsonResponse, ioArgs) {
console.log("SqlDriCancel jsonResponse: ", jsonResponse);
if (registry.byId("sqlDrillDialog")) {
registry.byId("sqlDrillDialog").destroyRecursive(false);
return jsonResponse;
}
return jsonResponse;
},
error: function(jsonResponse, ioArgs) {
SqlDriXhrGetError("SqlDriCancel", ioArgs);
return jsonResponse; }
});
return;
});
return;
}
// -----------------------------------------------------------
// SqlDriConfirm: function to Confirm Sql Control Change
// -----------------------------------------------------------
function SqlDriConfirm(sqlType, sqlEnv) {
require(["dojo/ready", "dojo/dom", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
function(ready, dom, dojo, xhr, registry){
console.log ("SqlDriConfirm: hugmarSettings ", hugmarSettings);
var jsCaller = "SqlDriConfirm";
var jsonObj = SqlDriSetJsonObj(jsCaller,"HWEBNAFB4","sqlconfirm", hugmarSettings);
jsonObj.gridenv = sqlEnv;
jsonObj.procparm = "sqlconfirm";
jsonObj.sqlrow.type = sqlType;
var jsonString = dojo.toJson(jsonObj);
var urlString = hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
if (registry.byId("sqlDrillDialog")) {
registry.byId("sqlDrillDialog").destroyRecursive(false);
}
registry.byId("hdmMainStandby").show();
dojo.xhrGet({
url: urlString, handleAs: "json",
load: function(jsonResponse, ioArgs) {
console.log("SqlDriConfirm jsonResponse: ", jsonResponse);
SqlDriConfirmRsp(registry, dom, jsonResponse, sqlEnv);
return jsonResponse; },
error: function(jsonResponse, ioArgs) {
SqlDriXhrGetError("SqlDriConfirm", ioArgs);
return jsonResponse; }
});
return;
});
}
// -----------------------------------------------------------
// Sql Control Confirm Response
// -----------------------------------------------------------
function SqlDriConfirmRsp(registry, dom, jsonResponse, sqlEnv) {
console.log ("SqlDriConfirmRsp: jsonResponse ", jsonResponse);
//alert("Send Refresh Here")
jsonResponse.javascript = "hdfTopToolServer";
hdfiServerRsp(jsonResponse)
return;
}
// -----------------------------------------------------------
// SqlDriGridRefresh:
// -----------------------------------------------------------
function SqlDriGridRebuild(registry, dom, prvResponse, sqlEnv) {
console.log("SqlDriGridRebuild prvResponse: ", prvResponse);
var jsCaller = "SqlDriGridRebuild";
if (prvResponse.refreshprocid) {
var procId = prvResponse.refreshprocid;
var docId = prvResponse.refreshdoc;
}
else {
var procId = "v2TopCtl";
var docId = "DGA_SqlRebuild";
}
require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr"],
function(ready, dojo, xhr){
var jsonObj = SqlDriSetJsonObj(jsCaller, docId, procId, hugmarSettings);
jsonObj.procparm = "Rebuild";
jsonObj.sqlenv = sqlEnv;
jsonObj.sqlenv.action = "Rebuild";
var jsonString = dojo.toJson(jsonObj);
var urlString = hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
console.log("SqlDriGridRefresh urlString: ", urlString);
alert ("SqlDriGridRefresh Before hdfiServerGet: check Console");
hdfiServerGet(jsCaller, urlString);
return;
});
}
// -----------------------------------------------------------
// Set Standard JSON URL Parameters
// -----------------------------------------------------------
function SqlDriSetJsonObj(jsCaller, procId, docName, hugmarSettings) {
var jsonObj = {
javascript: jsCaller,
procid: procId,
procparm: " ",
handle: hugmarSettings.host.handle,
userid: hugmarSettings.nav.username,
usercls: hugmarSettings.host.userclass,
docfolder: hugmarSettings.host.wrkfolder,
docname: docName + ".json",
format: "json",
sqlrow: {},
sqlenv: {},
gridenv: {},
webid: new Date().getTime()
};
return jsonObj;
}
// -----------------------------------------------------------
// SqlDri HTTP Error
// -----------------------------------------------------------
function SqlDriXhrGetError(origin, ioArgs) {
var message = "";
switch(ioArgs.xhr.status){
case 200:
message = origin + ": The IBM server responded normally, but an error occurred on the JavaScript client";
break;
case 404:
message = origin + ": The requested page on the IBM server was not found";
break;
case 500:
message = origin + ": The IBM server reported an error.";
break;
case 407:
message = origin + ": You need to authenticate with a proxy.";
break;
default:
message = origin + ": Unknown error.";
}
require(["dojo/ready", "dijit/Dialog"],
function(ready, Dialog){
var dialog = new Dialog({
title: "SqlDriXhrGet HTTP Server Error: ",
style: "width: 400px",
content: message + " " + "Please Contact IT"});
dialog.show();
});
return;
}
// -----------------------------------------------------------
// SqlDriGrpBy:
// ----------------------------------------------------------
function SqlDriGrpBy(sql) {
require(["dojo/dom", "dojo/dom-construct", "dijit/registry", "dojo/domReady!"],
function(dom, domConstruct, registry){
if (registry.byId("hdmSqlDriGrpByGrid")) {
registry.byId("hdmSqlDriGrpByGrid").destroyRecursive(true);
}
var dgridDomNode = domConstruct.create("div", {id: "hdmSqlDriGrpByGrid"});
domConstruct.place(dgridDomNode, "hdmSqlDriGrpByPane");
SqlDriGrpByGrid(sql); // Grid
});
return;
}
// -----------------------------------------------------------
// Load Group By Grid
// -----------------------------------------------------------
function SqlDriGrpByGrid(sql) {
//console.log("SqlDriGrpBy sql: ", sql);
require(["dgrid/OnDemandGrid",
"dgrid/Selection",
"dgrid/Keyboard",
"dgrid/selector",
"dgrid/Editor",
"dgrid/extensions/ColumnHider",
"dgrid/extensions/DijitRegistry",
"dijit/form/ComboBox",
"dijit/form/FilteringSelect",
"dijit/registry",
"dstore/Memory",
"dojo/store/Memory", "dojo/store/Observable",
"dojo/data/ObjectStore", "dojo/dom",
"dojo/dom-style", "dojo/_base/declare",
"dojo/_base/lang", "dojo/domReady!"],
function(Grid,
Selection,
Keyboard,
selector,
Editor,
ColumnHider,
DijitRegistry,
ComboBox,
FilteringSelect,
registry,
Memory,
DojoMemory, Observable,
ObjectStore, dom,
domStyle, declare, lang){
var grpByCol = SqlDriGrpByCol(sql);
//console.log("SqlDriGrpBy grpByCol: ", grpByCol);
//var dgridDomNode = dom.byId("hdmSqlDriGrpByGrid");
//console.log("SqlDriGrpBy dgridDomNode: ", dgridDomNode);
if (registry.byId("hdmSqlDriGrpByGrid")) {
grid = registry.byId("hdmSqlDriGrpByGrid");
console.log("SqlDriGrpBy refresh: ", grid);
grid.refresh();
return;
}
else {
var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
id : "hdmSqlDriGrpByGrid",
collection: Observable(new Memory({data: sql.grpdata})),
columns: grpByCol,
selectionMode: "none"
}, "hdmSqlDriGrpByGrid");
}
grid.on("dgrid-datachange", function(evt){
var rowid = grid.cell(evt).row.data.id;
var colid = grid.cell(evt).column.id;
var rowInt = parseInt(rowid);
var grpData = hugmarSettings.sql.grpdata[rowInt-1];
switch (colid) {
case 'fldname': grpData.fldname = evt.value; break;
case 'grpflag': grpData.grpflag = evt.value; break;
default: console.log("SqlDriGrpByEdit Unknown Column ID: ", colid);
}
grpData.confirm = 'x';
hugmarSettings.sql.grpdata[rowInt-1] = grpData;
SqlDriGrpByGrid(hugmarSettings.sql);
});
grid.on(".dgrid-row .dgrid-cell:click", function(evt){
evt.preventDefault(); // prevent default browser context menu
var selectedRow = grid.cell(evt).row.data;
var selectedCell = grid.cell(evt).column;
if (selectedCell.field === "confirm" && selectedRow.confirm == "x") {
console.log("cell clicked: selectedRow ", selectedRow);
SqlDriGrpByEdit("grpby", selectedRow, sql.env);
}
});
});
}
// -----------------------------------------------------------
// Edit and Error Check Where Cell
// -----------------------------------------------------------
function SqlDriGrpByEdit(sqlType, selectedRow, sqlEnv) {
require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
function(ready, dojo, xhr, registry){
var rowInt = parseInt(selectedRow.id);
var grpData = hugmarSettings.sql.grpdata[rowInt-1];
console.log("SqlDriGrpByEdit grpData: ", grpData);
var jsCaller = "SqlDriGrpByEdit";
var jsonObj = SqlDriSetJsonObj(jsCaller,"HWEBNAFB4", "SqlDri", hugmarSettings);
jsonObj.procparm = "sqlchange";
jsonObj.sqlenv = sqlEnv;
jsonObj.sqlrow = grpData;
jsonObj.sqlrow.sqltype = sqlType;
jsonObj.sqlrow.rrn = selectedRow.id;
jsonObj.sqlrow.filler = " ";
var jsonString = dojo.toJson(jsonObj);
//console.log("SqlDriGrpByEdit jsonString: ", jsonString);
var urlString = hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
dojo.xhrGet({
url: urlString, handleAs: "json",
load: function(jsonResponse, ioArgs) {
console.log("SqlDriGrpByEdit jsonResponse: ", jsonResponse);
hugmarSettings.sql.grpdata = jsonResponse.grpdata;
hugmarSettings.sql.orddata = jsonResponse.orddata;
hugmarSettings.sql.ordfld = jsonResponse.ordfld;
SqlDriGrpBy(hugmarSettings.sql);
SqlDriOrdBy(hugmarSettings.sql);
return jsonResponse; },
error: function(jsonResponse, ioArgs) {
SqlDriXhrGetError("SqlDriGrpByEdit", ioArgs);
return jsonResponse; }
});
});
return;
}
// -----------------------------------------------------------
// Get Sql GrpBy Columns:
// -----------------------------------------------------------
function SqlDriGrpByCol(sql) {
var grpByCol = [];
require(["dgrid/Editor",
"dijit/form/CheckBox",
"dijit/form/ComboBox",
"dijit/form/FilteringSelect",
"dojo/store/Memory",
"dojo/store/Observable" ],
function(Editor,
CheckBox,
ComboBox,
FilteringSelect,
DojoMemory,
Observable ){
grpByCol = [
{field: "id", id: "id", label: "", className: ["dgsshidden"]},
{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false,
formatter: function(val){
switch (val) {
case '1': image = '
"; break; // Blank
case '2': image = '
"; break; // Confirmed
case 'x': image = '
"; break; // Dirty
}
return image;
}
},
{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
editor: FilteringSelect,
//editOn: 'click',
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: sql.grpfld
})),
maxHeight: 400,
style: "width:180px;"
}
},
{field: "grpflag", id: "grpflag", label: "Grouping", className: ["dgss120px"], sortable: false,
editor: FilteringSelect,
//editOn: 'click',
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: [
{"id": "", "name": ""},
{"id": "C", "name": "Combined"},
{"id": "D", "name": "Description Only"},
{"id": "F", "name": "Field Only"},
{"id": "S", "name": "Split Columns"}
]
})),
maxHeight: 120,
style: "width:120px;"
}
}
];
});
return grpByCol;
}
// -----------------------------------------------------------
// SqlDriOrdBy:
// ----------------------------------------------------------
function SqlDriOrdBy(sql) {
require(["dojo/dom", "dojo/dom-construct", "dijit/registry"],
function(dom, domConstruct, registry){
if (registry.byId("hdmSqlDriOrdByGrid")) {
registry.byId("hdmSqlDriOrdByGrid").destroyRecursive(true);
}
var dgridDomNode = domConstruct.create("div", {id: "hdmSqlDriOrdByGrid"});
domConstruct.place(dgridDomNode, "hdmSqlDriOrdByPane");
SqlDriOrdByGrid(sql); // Grid
});
return;
}
// -----------------------------------------------------------
// SqlDriOrdBy:
// ----------------------------------------------------------
function SqlDriOrdByGrid(sql) {
//console.log("SqlDriOrdBy sql: ", sql);
require(["dgrid/OnDemandGrid",
"dgrid/Selection",
"dgrid/Keyboard",
"dgrid/selector",
"dgrid/Editor",
"dgrid/extensions/ColumnHider",
"dgrid/extensions/DijitRegistry",
"dijit/form/CheckBox",
"dijit/form/ComboBox",
"dijit/form/FilteringSelect",
"dijit/registry",
"dstore/Memory",
"dojo/store/Memory",
"dojo/store/Observable",
"dojo/data/ObjectStore", "dojo/dom",
"dojo/dom-style", "dojo/_base/declare",
"dojo/_base/lang", "dojo/domReady!"],
function(Grid,
Selection,
Keyboard,
selector,
Editor,
ColumnHider,
DijitRegistry,
CheckBox,
ComboBox,
FilteringSelect,
registry,
Memory,
DojoMemory,
Observable,
ObjectStore, dom,
domStyle, declare, lang){
var ordByCol = SqlDriOrdByCol(sql);
//console.log("SqlDriOrdBy ordByCol: ", ordByCol);
if (registry.byId("hdmSqlDriOrdByGrid")) {
grid = registry.byId("hdmSqlDriOrdByGrid");
grid.refresh();
return;
}
else {
var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
id : "hdmSqlDriOrdByGrid",
collection: Observable(new Memory({data: sql.orddata})),
columns: ordByCol,
selectionMode: "none"
}, "hdmSqlDriOrdByGrid");
}
grid.on("dgrid-datachange", function(evt){
var rowid = grid.cell(evt).row.data.id;
var colid = grid.cell(evt).column.id;
var rowInt = parseInt(rowid);
var ordData = hugmarSettings.sql.orddata[rowInt-1];
switch (colid) {
case 'fldname': ordData.fldname = evt.value; break;
case 'fldsort': ordData.fldsort = evt.value; break;
case 'subtot': ordData.subtot = evt.value; break;
default: console.log("SqlDriOrdByEdit Unknown Column ID: ", colid);
}
ordData.confirm = 'x';
hugmarSettings.sql.orddata[rowInt-1] = ordData;
SqlDriOrdByGrid(hugmarSettings.sql);
});
grid.on(".dgrid-row .dgrid-cell:click", function(evt){
evt.preventDefault(); // prevent default browser context menu
var selectedRow = grid.cell(evt).row.data;
var selectedCell = grid.cell(evt).column;
if (selectedCell.field == "confirm" && selectedRow.confirm == "x") {
console.log("cell clicked: selectedRow ", selectedRow);
SqlDriOrdByEdit("ordby", selectedRow, sql.env);
}
});
});
return;
}
// -----------------------------------------------------------
// Edit and Error Check OrdBy Cell
// -----------------------------------------------------------
function SqlDriOrdByEdit(sqlType, selectedRow, sqlEnv) {
require(["dojo/ready", "dojo/_base/json", "dojo/request/xhr", "dijit/registry"],
function(ready, dojo, xhr, registry){
var rowInt = parseInt(selectedRow.id);
var ordData = hugmarSettings.sql.orddata[rowInt-1];
console.log("SqlDriOrdByEdit ordData: ", ordData);
var jsCaller = "SqlDriOrdByEdit";
var jsonObj = SqlDriSetJsonObj(jsCaller,"HWEBNAFB4", "SqlDrill", hugmarSettings);
jsonObj.procparm = "sqlchange";
jsonObj.sqlenv = sqlEnv;
jsonObj.sqlrow = ordData;
jsonObj.sqlrow.sqltype = sqlType;
jsonObj.sqlrow.rrn = selectedRow.id;
jsonObj.sqlrow.filler = " ";
var jsonString = dojo.toJson(jsonObj);
console.log("SqlDriOrdByEdit jsonString: ", jsonString);
var urlString = hugmarSettings.host.pgmdir + "/hwebhtp120.pgm?json=" + jsonString;
dojo.xhrGet({
url: urlString, handleAs: "json",
load: function(jsonResponse, ioArgs) {
console.log("SqlDriOrdByEdit jsonResponse: ", jsonResponse);
hugmarSettings.sql.orddata = jsonResponse.orddata;
SqlDriOrdBy(hugmarSettings.sql);
return jsonResponse; },
error: function(jsonResponse, ioArgs) {
SqlDriXhrGetError("SqlDriOrdByEdit", ioArgs);
return jsonResponse; }
});
/*
xhr(urlString, {
handleAs: "text",
method: "GET"
}).then(function(data){
console.log("SqlDriOrdByEdit data: ", data);
}, function(err){
// Handle the error condition
}, function(evt){
// XHR2
console.log("SqlDriOrdByEdit XHR2 evt: ", evt);
});
*/
});
return;
}
// -----------------------------------------------------------
// Get Sql OrdBy Columns:
// -----------------------------------------------------------
function SqlDriOrdByCol(sql) {
var ordByCol = [];
require(["dgrid/Editor",
"dijit/form/CheckBox",
"dijit/form/ComboBox",
"dijit/form/FilteringSelect",
"dojo/store/Memory",
"dojo/store/Observable" ],
function(Editor,
CheckBox,
ComboBox,
FilteringSelect,
DojoMemory,
Observable ){
if (sql.env.cltype == "SUBFILE") {
ordByCol = [
{field: "id", id: "id", label: "", className: ["dgsshidden"]},
{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false,
formatter: function(val){
switch (val) {
case '1': image = '"; break; // Blank
case '2': image = '"; break; // Confirmed
case 'x': image = '"; break; // Dirty
}
return image;
}
},
{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
editor: FilteringSelect,
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: sql.ordfld
})),
maxHeight: 400,
style: "width:180px;"
}
},
{field: "fldsort", id: "fldsort", label: "Sort", className: ["dgss80px"], sortable: false,
editor: FilteringSelect,
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: [
{"id": "blank", "name": ""},
{"id": "A", "name": "Ascend"},
{"id": "D", "name": "Descend"}
]
})),
maxHeight: 120,
style: "width:80px;"
}
}
];
}
if (sql.env.cltype == "SUBFGROUP") {
ordByCol = [
{field: "id", id: "id", label: "", className: ["dgsshidden"]},
{field: "confirm", id: "confirm", label: " ", className: ["dgss40px"], sortable: false,
formatter: function(val){
switch (val) {
case '1': image = '"; break; // Blank
case '2': image = '"; break; // Confirmed
case 'x': image = '"; break; // Dirty
}
return image;
}
},
{field: "fldname", id: "fldname", label: "field name", className: ["dgss180px"], sortable: false,
editor: FilteringSelect,
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: sql.ordfld
})),
maxHeight: 400,
style: "width:180px;"
}
},
{field: "fldsort", id: "fldsort", label: "Sort", className: ["dgss60px"], sortable: false,
editor: FilteringSelect,
editorArgs: {
store: Observable(new DojoMemory({
idProperty: "id",
data: [
{"id": "blank", "name": ""},
{"id": "A", "name": "Ascend"},
{"id": "D", "name": "Descend"}
]
})),
maxHeight: 120,
style: "width:80px;"
}
},
{field: "subtot", id: "subtot", label: "Total", className: ["dgss30px"], sortable: false,
editor: CheckBox,
get: function(item){
//console.log("get: ", item);
if (item.subtot == true) {return true;}
else {return false;}},
set: function(item){
//console.log("set: ", item);
return item.subtot == false;},
editorArgs: { }
}
];
}
});
return ordByCol;
}
// -----------------------------------------------------------
// SqlDriWhere:
// ----------------------------------------------------------
function SqlDriWhere(sql) {
//console.log("SqlDriWhere sql: ", sql);
require(["dojo/dom", "dojo/dom-construct", "dijit/layout/ContentPane", "dijit/registry"],
function(dom, domConstruct, ContentPane, registry){
if (registry.byId("hdmSqlDriWhereGrid")) {
registry.byId("hdmSqlDriWhereGrid").destroyRecursive(true);
}
var dgridDomNode = domConstruct.create("div", {id: "hdmSqlDriWhereGrid"});
domConstruct.place(dgridDomNode, "hdmSqlDriWherePane");
SqlDriWhereGrid(sql); // Grid
});
return;
}
// ----------------------------------------------------------
// SqlDriWhereGrid:
// ----------------------------------------------------------
function SqlDriWhereGrid(sql) {
//console.log("SqlDriWhereGrid sql: ", sql);
require(["dgrid/OnDemandGrid",
"dgrid/Selection",
"dgrid/Keyboard",
"dgrid/selector",
"dgrid/Editor",
"dgrid/extensions/ColumnHider",
"dgrid/extensions/DijitRegistry",
"dijit/form/FilteringSelect",
"dijit/registry",
"dstore/Memory", "dstore/Trackable",
"dojo/store/Memory", "dojo/store/Observable",
"dojo/data/ObjectStore", "dojo/dom",
"dojo/dom-style", "dojo/_base/declare",
"dojo/_base/lang", "dojo/domReady!"],
function(Grid,
Selection,
Keyboard,
selector,
Editor,
ColumnHider,
DijitRegistry,
FilteringSelect,
registry,
Memory, Trackable,
DojoMemory, Observable,
ObjectStore, dom,
domStyle, declare, lang){
var whereCol = [
{field: "id", id: "id", label: "", className: ["dgsshidden"]},
{field: "confirm", id: "confirm", label: " ", className: ["dgsshidden"], sortable: false},
{field: "andor", id: "andor", label: " ", className: ["dgss30px"], sortable: false},
{field: "brck1", id: "brck1",label: " ", className: ["dgss15px"], sortable: false},
{field: "fldname", id: "fldname", label: "field name", className: ["dgss120px"], sortable: false},
{field: "oper", id: "oper", label: "operation", className: ["dgss90px"], sortable: false},
{field: "opand", id: "opand", label: "Operand", className: ["dgss300px"], sortable: false},
{field: "brck2", id: "brck2", label: " ", className: ["dgss15px"], sortable: false}
];
var grid = new (declare([Grid, Selection, Editor, DijitRegistry, Keyboard]))({
id : "hdmSqlDriWhereGrid",
collection: Observable(new Memory({data: sql.whedata})),
columns: whereCol,
selectionMode: "none"
}, "hdmSqlDriWhereGrid");
});
return;
}