Open-ILS/web/reports/oils_rpt_builder.js

   1 /** initializes reports, some basid display settings,
   2   * grabs and builds the IDL tree
   3   */
   4 function oilsInitReportBuilder() {
   5         if(!oilsInitReports()) return false;
   6         oilsReportBuilderReset();
   7         DOM.oils_rpt_table.onclick =
   8                 function(){hideMe(DOM.oils_rpt_column_editor)};
   9         oilsDrawRptTree(
  10                 function() {
  11                         hideMe(DOM.oils_rpt_tree_loading);
  12                         unHideMe(DOM.oils_rpt_table);
  13                 }
  14         );
  15
  16         DOM.oils_rpt_builder_save_template.onclick = oilsReportBuilderSave;
  17 }
  18
  19 function oilsReportBuilderReset() {
  20         var n = (oilsRpt) ? oilsRpt.name : "";
  21         oilsRpt = new oilsReport();
  22         oilsRpt.name = n;
  23         oilsRptDisplaySelector  = DOM.oils_rpt_display_selector;
  24         oilsRptFilterSelector   = DOM.oils_rpt_filter_selector;
  25         oilsRptAggFilterSelector= DOM.oils_rpt_agg_filter_selector;
  26         removeChildren(oilsRptDisplaySelector);
  27         removeChildren(oilsRptFilterSelector);
  28         removeChildren(oilsRptAggFilterSelector);
  29         oilsRptDebug();
  30         oilsRptResetParams();
  31 }
  32
  33 function oilsReportBuilderSave() {
  34
  35         var tmpl = new rt();
  36         tmpl.name(DOM.oils_rpt_builder_new_name.value);
  37         tmpl.description(DOM.oils_rpt_builder_new_desc.value);
  38         tmpl.owner(USER.id());
  39         tmpl.folder(new CGI().param('folder'));
  40         tmpl.data(js2JSON(oilsRpt.def));
  41
  42         if(!confirm('Name : '+tmpl.name() + '\nDescription: ' + tmpl.description()+'\nSave Template?'))
  43                 return;
  44
  45         debugFMObject(tmpl);
  46         //return; /* XXX */
  47
  48
  49         var req = new Request(OILS_RPT_CREATE_TEMPLATE, SESSION, tmpl);
  50         req.callback(
  51                 function(r) {
  52                         var res = r.getResultObject();
  53                         if( res != 0 ) {
  54                                 oilsRptAlertSuccess();
  55                                 _l('oils_rpt.xhtml');
  56                         }
  57                 }
  58         );
  59
  60         req.send();
  61 }
  62
  63
  64
  65 /* adds an item to the display window */
  66 function oilsAddRptDisplayItem(path, name, tform, params) {
  67         if( ! oilsAddSelectorItem(oilsRptDisplaySelector, path, name) )
  68                 return;
  69
  70         /* add the selected columns to the report output */
  71         name = (name) ? name : oilsRptPathCol(path);
  72         if( !tform ) tform = 'Bare';
  73
  74         var aggregate = oilsRptGetIsAgg(tform);
  75
  76         /* add this item to the select blob */
  77         var sel = {
  78                 relation: hex_md5(oilsRptPathRel(path)),
  79                 _relation: oilsRptPathRel(path),
  80                 path : path,
  81                 alias:    name,
  82                 column:   { transform: tform, colname: oilsRptPathCol(path) }
  83         };
  84
  85         if( params ) sel.column.params = params;
  86
  87         if(!oilsRptGetIsAgg(tform)) {
  88                 var select = [];
  89                 var added = false;
  90                 for( var i = 0; i < oilsRpt.def.select.length; i++ ) {
  91                         var item = oilsRpt.def.select[i];
  92                         if( !added && oilsRptGetIsAgg( item.column.transform ) ) {
  93                                 select.push(sel);
  94                                 added = true;
  95                         }
  96                         select.push(item);
  97                 }
  98                 if(!added) select.push(sel);
  99                 oilsRpt.def.select = select;
 100         } else {
 101                 oilsRpt.def.select.push(sel);
 102         }
 103
 104
 105         mergeObjects( oilsRpt.def.from, oilsRptBuildFromClause(path));
 106         oilsRptDebug();
 107 }
 108
 109 function oilsRptGetIsAgg(tform) {
 110         return OILS_RPT_TRANSFORMS[tform].aggregate;
 111
 112         /* DEPRECATED */
 113         var sel = $n(DOM.oils_rpt_tform_table,'selector');
 114         for( var i = 0; i < sel.options.length; i++ ) {
 115                 var opt = sel.options[i];
 116                 if( opt.getAttribute('value') == tform )
 117                         return opt.getAttribute('aggregate');
 118         }
 119 }
 120
 121 /* takes a column path and builds a from-clause object for the path */
 122 function oilsRptBuildFromClause(path) {
 123
 124         /* the path is the full path (relation) from the source
 125                 object to the column in question (e.g. au-home_ou-aou-name)*/
 126         var parts = path.split(/-/);
 127
 128         /* the final from clause */
 129         var obj = {};
 130
 131         /* reference to the current position in the from clause */
 132         var tobj = obj;
 133
 134         var newpath = "";
 135
 136         /* walk the path, fleshing the from clause as we go */
 137         for( var i = 0; i < parts.length; i += 2 ) {
 138
 139                 var cls = parts[i]; /* class name (id) */
 140                 var col = parts[i+1]; /* column name */
 141
 142                 /* a "node" is a class description from the IDL, it
 143                         contains relevant info, plus a list of "fields",
 144                         or column objects */
 145                 var node = oilsIDL[cls];
 146                 var pkey = oilsRptFindField(node, node.pkey);
 147
 148                 /* a "field" is a parsed version of a column from the IDL,
 149                         contains datatype, column name, etc. */
 150                 var field = oilsRptFindField(node, col);
 151
 152                 /* re-construct the path as we go so
 153                         we know what all we've seen thus far */
 154                 newpath = (newpath) ? newpath + '-'+ cls : cls;
 155
 156                 /* extract relevant info */
 157                 tobj.table = node.table;
 158                 tobj.path = newpath;
 159                 tobj.alias = hex_md5(newpath);
 160
 161                 _debug('field type is ' + field.type);
 162                 if( i == (parts.length - 2) ) break;
 163
 164                 /* we still have columns left in the path, keep adding join's */
 165                 var path_col = col;
 166                 if(field.reltype != 'has_a')
 167                         col = pkey.name + '-' + col;
 168
 169                 tobj.join = {};
 170                 tobj = tobj.join;
 171
 172                 tobj[col] = {};
 173                 tobj = tobj[col];
 174                 if( field.type == 'link' )
 175                         tobj.key = field.key;
 176
 177                 newpath = newpath + '-'+ path_col;
 178         }
 179
 180         _debug("built 'from' clause: path="+path+"\n"+formatJSON(js2JSON(obj)));
 181         return obj;
 182 }
 183
 184
 185 /* removes a specific item from the display window */
 186 function oilsDelDisplayItem(val) {
 187         oilsDelSelectorItem(oilsRptDisplaySelector, val);
 188 }
 189
 190 /* removes selected items from the display window */
 191 function oilsDelSelectedDisplayItems() {
 192         var list = oilsDelSelectedItems(oilsRptDisplaySelector);
 193
 194         _debug('deleting list: ' + list);
 195
 196         /* remove the de-selected columns from the report output */
 197         oilsRpt.def.select = grep( oilsRpt.def.select,
 198                 function(i) {
 199                         for( var j = 0; j < list.length; j++ ) {
 200                                 var d = list[j]; /* path */
 201                                 var col = i.column;
 202
 203                                 _debug('in delete, looking at list = '+d+' : col = ' +
 204                                         col.colname + ' : relation = ' + i.relation + ' : encoded = ' + hex_md5(oilsRptPathRel(d)) );
 205
 206                                 if( hex_md5(oilsRptPathRel(d)) == i.relation && oilsRptPathCol(d) == col.colname ) {
 207                                         return false;
 208                                 }
 209                         }
 210                         return true;
 211                 }
 212         );
 213
 214         if(!oilsRpt.def.select) oilsRpt.def.select = [];
 215
 216         for( var j = 0; j < list.length; j++ ) {
 217                 /* if there are no items left in the "select", "where", or "having" clauses
 218                         for the given relation, trim this relation from the "from" clause */
 219                 debug('seeing if we can prune from clause with relation = ' + hex_md5(oilsRptPathRel(list[j])));
 220                 if(     !grep(oilsRpt.def.select,
 221                                 function(i){ return (i.relation == hex_md5(oilsRptPathRel(list[j]))); })
 222                         && !grep(oilsRpt.def.where,
 223                                 function(i){ return (i.relation == hex_md5(oilsRptPathRel(list[j]))); })
 224                         && !grep(oilsRpt.def.having,
 225                                 function(i){ return (i.relation == hex_md5(oilsRptPathRel(list[j]))); })
 226                 ) {
 227                         _debug('pruning from clause');
 228                         oilsRptPruneFromClause(oilsRptPathRel(list[j]));
 229                 }
 230         }
 231
 232         oilsRptDebug();
 233 }
 234
 235
 236 /* for each item in the path list, remove the associated data
 237         from the "from" clause */
 238
 239 function oilsRptPruneFromClause(relation, node) {
 240         _debug("removing relation from 'from' clause " + relation);
 241         if(!node) node = oilsRpt.def.from.join;
 242
 243         for( var i in node ) {
 244                 _debug("looking at node "+node[i].path);
 245                 // first, descend into the tree, and prune leaves first
 246                 if( node[i].join ) {
 247                         oilsRptPruneFromClause(relation, node[i].join);
 248                         if(oilsRptObjectKeys(node[i].join).length == 0) delete node[i].join;
 249                 }
 250         }
 251
 252         _debug(js2JSON(node));
 253
 254         // if we're at an unused empty leaf, remove it
 255         if(  !node.join ) {
 256
 257                 var key = oilsRptObjectKeys(node)[0];
 258                 _debug("pruning from clause with "+node[key].alias);
 259
 260                 if(     !grep(oilsRpt.def.select,
 261                                 function(n){ _debug(n.relation); return (n.relation == node[key].alias)})
 262                         && !grep(oilsRpt.def.where,
 263                                 function(n){ _debug(n.relation); return (n.relation == node[key].alias)})
 264                         && !grep(oilsRpt.def.having,
 265                                 function(n){ _debug(n.relation); return (n.relation == node[key].alias)})
 266                 ) {
 267                         delete node[i];
 268                         return true;
 269                 }
 270         }
 271
 272         return false;
 273 }
 274
 275 function oilsRptMkFilterTags(path, tform, filter) {
 276         var name = oilsRptMakeLabel(path);
 277         if(tform) name += ' ('+tform+')';
 278         name += ' "' + filter + '"';
 279         var epath = path + ':'+filter+':';
 280         if(tform) epath += tform;
 281
 282         return [ name, epath ];
 283 }
 284
 285
 286 /* adds an item to the display window */
 287 function oilsAddRptFilterItem(path, tform, filter) {
 288         _debug("Adding filter item for "+path+" tform="+tform+" filter="+filter);
 289
 290         var name = oilsRptMkFilterTags(path, tform, filter);
 291         var epath = name[1];
 292         name = name[0];
 293
 294         if( ! oilsAddSelectorItem(oilsRptFilterSelector, epath, name) )
 295                 return;
 296
 297         var where = {
 298                 relation: hex_md5(oilsRptPathRel(path)),
 299                 _relation: oilsRptPathRel(path),
 300                 path : path,
 301                 column:   { transform: tform, colname: oilsRptPathCol(path) },
 302                 condition : {}
 303         };
 304         if( filter == 'is' || filter == 'is not' )
 305                 where.condition[filter] = null;
 306         else where.condition[filter] = oilsRptNextParam();
 307
 308         switch(tform) {
 309                 case 'substring' : where.column.params = oilsRptNextParam();
 310         }
 311
 312         oilsRpt.def.where.push(where);
 313         mergeObjects( oilsRpt.def.from, oilsRptBuildFromClause(path));
 314         oilsRptDebug();
 315 }
 316
 317 /* removes a specific item from the display window */
 318 //function oilsDelFilterItem(path) {
 319         //oilsDelSelectorItem(oilsRptFilterSelector, path);
 320 //}
 321
 322 /* removes selected items from the display window */
 323 function oilsDelSelectedFilterItems() {
 324
 325         /* the values in this list are formed:  <path>:<operation>:<transform> */
 326         var list = oilsDelSelectedItems(oilsRptFilterSelector);
 327
 328         var flist = [];
 329
 330         for( var i = 0; i < list.length; i++ ) {
 331                 var item = list[i];
 332                 flist.push( {
 333                         path:           item.replace(/:.*/,''),
 334                         operation:      item.replace(/.*:(.*):.*/,'$1'),
 335                         tform:  item.replace(/.*?:.*?:(.*)/,'$1')
 336                 });
 337         }
 338
 339
 340         /* XXX refactor the below to take operation and transform into account
 341                 since the same path can be used multiple times as long as a different
 342                 filter and/or transform is used */
 343
 344         /* remove the de-selected columns from the report output */
 345         oilsRpt.def.where = grep( oilsRpt.def.where,
 346                 function(i) {
 347                         for( var j = 0; j < flist.length; j++ ) {
 348                                 var fil = flist[j];
 349                                 var col = i.column;
 350                                 var frel = oilsRptPathRel(fil.path);
 351                                 var fcol = oilsRptPathCol(fil.path);
 352
 353                                 var op = oilsRptObjectKeys(i.condition)[0];
 354
 355                                 if(     frel == i.relation &&
 356                                                 fcol == col.colname &&
 357                                                 fil.operation == op &&
 358                                                 fil.tform == col.transform ) {
 359                                                 /* we have found a where clause with the same
 360                                                         relation, column,  operation and transform */
 361
 362                                                 /* we aren't setting params on template build.. */
 363                                                 //var param = (i.column.params) ? i.columns.params.match(/::P\d*/) : null;
 364                                                 //if( param ) delete oilsRpt.params[param];
 365                                                 //param = (i.condition[op]) ? i.condition[op].match(/::P\d*/) : null;
 366                                                 //if( param ) delete oilsRpt.params[param];
 367
 368                                                 return false;
 369                                 }
 370                         }
 371                         return true;
 372                 }
 373         );
 374
 375         if(!oilsRpt.def.where)
 376                 oilsRpt.def.where = [];
 377
 378
 379         for( var j = 0; j < flist.length; j++ ) {
 380                 var path = flist[j].path;
 381                 var rel = oilsRptPathRel(path);
 382                 /* if there are no items left in the "select", "where", or "having" clauses
 383                         for the given relation, trim this relation from the "from" clause */
 384
 385                 var func = function(i){ return (i.relation == rel); };
 386
 387                 if(     !grep(oilsRpt.def.select, func) &&
 388                                 !grep(oilsRpt.def.where, func) &&
 389                                 !grep(oilsRpt.def.having, func) ) {
 390
 391                         _debug("pruning item with path "+ path + ' and relation '+ rel);
 392
 393                         oilsRptPruneFromClause(oilsRptPathRel(path));
 394                 }
 395         }
 396
 397         oilsRptDebug();
 398 }
 399
 400 /* adds an item to the display window */
 401 function oilsAddRptAggFilterItem(val) {
 402         oilsAddSelectorItem(oilsRptAggFilterSelector, val);
 403 }
 404
 405 /* removes a specific item from the display window */
 406 function oilsDelAggFilterItem(val) {
 407         oilsDelSelectorItem(oilsRptAggFilterSelector, val);
 408 }
 409
 410 /* removes selected items from the display window */
 411 function oilsDelSelectedAggFilterItems() {
 412         var list = oilsDelSelectedItems(oilsRptAggFilterSelector);
 413
 414         /* remove the de-selected columns from the report output */
 415         oilsRpt.def.having = grep( oilsRpt.def.having,
 416                 function(i) {
 417                         for( var j = 0; j < list.length; j++ ) {
 418                                 var d = list[j];
 419                                 var col = i.column;
 420
 421                                 /* if this columsn has a transform,
 422                                         it will be an object { tform => column } */
 423                                 if( typeof col != 'string' )
 424                                         for( var c in col ) col = col[c];
 425
 426                                 /* if this transform requires params, the column
 427                                         will be the first item in the param set array */
 428                                 if( typeof col != 'string' ) col = col[0];
 429
 430                                 if( oilsRptPathRel(d) == i.relation && oilsRptPathCol(d) == col ) {
 431                                         var param = (i.alias) ? i.alias.match(/::P\d*/) : null;
 432                                         if( param ) delete oilsRpt.params[param];
 433                                         return false;
 434                                 }
 435                         }
 436                         return true;
 437                 }
 438         );
 439
 440         if(!oilsRpt.def.having) {
 441                 oilsRpt.def.having = [];
 442                 oilsReportBuilderReset();
 443
 444         } else {
 445                 for( var j = 0; j < list.length; j++ )
 446                         /* if there are no items left in the "select", "where", or "having" clauses
 447                                 for the given relation, trim this relation from the "from" clause */
 448                         if(     !grep(oilsRpt.def.select,
 449                                         function(i){ return (i.relation == oilsRptPathRel(list[j])); })
 450                                 && !grep(oilsRpt.def.where,
 451                                         function(i){ return (i.relation == oilsRptPathRel(list[j])); })
 452                                 && !grep(oilsRpt.def.having,
 453                                         function(i){ return (i.relation == oilsRptPathRel(list[j])); })
 454                         ) oilsRptPruneFromClause(oilsRptPathRel(list[j]));
 455         }
 456
 457         oilsRptDebug();
 458 }
 459
 460
 461 /* adds an item to the display window */
 462 function oilsAddSelectorItem(sel, val, name) {
 463         name = (name) ? name : oilsRptMakeLabel(val);
 464         _debug("adding selector item "+name+' = ' +val);
 465         for( var i = 0; i < sel.options.length; i++ ) {
 466                 var opt = sel.options[i];
 467                 if( opt.value == val ) return false;
 468         }
 469         insertSelectorVal( sel, -1, name, val );
 470         return true;
 471 }
 472
 473
 474 /* removes a specific item from the display window */
 475 function oilsDelSelectorItem(sel, val) {
 476         _debug("deleting selector item "+val);
 477         var opts = sel.options;
 478         for( var i = 0; i < opts.length; i++ ) {
 479                 var opt = opts[i];
 480                 if( opt.value == val )  {
 481                         if( i == opts.length - 1 )
 482                                 opts[i] = null;
 483                         else opts[i] = opts[i+1];
 484                         return;
 485                 }
 486         }
 487 }
 488
 489 /* removes selected items from the display window */
 490 function oilsDelSelectedItems(sel) {
 491         var list = getSelectedList(sel);
 492         for( var i = 0; i < list.length; i++ )
 493                 oilsDelSelectorItem(sel, list[i]);
 494         return list;
 495 }
 496
 497
 498 /* hides the different field editor tabs */
 499 function oilsRptHideEditorDivs() {
 500         hideMe(DOM.oils_rpt_tform_div);
 501         hideMe(DOM.oils_rpt_filter_div);
 502         hideMe(DOM.oils_rpt_agg_filter_div);
 503 }
 504
 505
 506 /**
 507   This draws the 3-tabbed window containing the transform,
 508   filter, and aggregate filter picker window
 509   */
 510 function oilsRptDrawDataWindow(path) {
 511         var col = oilsRptPathCol(path);
 512         var cls = oilsRptPathClass(path);
 513         var field = oilsRptFindField(oilsIDL[cls], col);
 514
 515         appendClear(DOM.oils_rpt_editor_window_label, text(oilsRptMakeLabel(path)));
 516         appendClear(DOM.oils_rpt_editor_window_datatype, text(field.datatype));
 517
 518         _debug("setting update data window for column "+col+' on class '+cls);
 519
 520         var div = DOM.oils_rpt_column_editor;
 521         /* set a preliminary top position so the page won't bounce around */
 522         div.setAttribute('style','top:'+oilsMouseX+'px');
 523
 524         /* unhide the div so we can determine the dimensions */
 525         unHideMe(div);
 526
 527         /* don't let them see the floating div until the position is fully determined */
 528         div.style.visibility='hidden';
 529
 530         oilsRptDrawTransformWindow(path, col, cls, field);
 531         oilsRptDrawFilterWindow(path, col, cls, field);
 532
 533         //oilsRptSetFilters(field.datatype);
 534
 535         //oilsRptDoFilterWidgets();
 536
 537         //DOM.oils_rpt_filter_tform_selector.onchange = oilsRptDoFilterWidgets;
 538
 539         buildFloatingDiv(div, 600);
 540
 541         /* now let them see it */
 542         div.style.visibility='visible';
 543
 544         oilsRptSetDataWindowActions(div);
 545 }
 546
 547
 548 function oilsRptSetDataWindowActions(div) {
 549         /* give the tab links behavior */
 550         DOM.oils_rpt_tform_tab.onclick =
 551                 function(){oilsRptHideEditorDivs();unHideMe(DOM.oils_rpt_tform_div)};
 552         DOM.oils_rpt_filter_tab.onclick =
 553                 function(){oilsRptHideEditorDivs();unHideMe(DOM.oils_rpt_filter_div)};
 554         DOM.oils_rpt_agg_filter_tab.onclick =
 555                 function(){oilsRptHideEditorDivs();unHideMe(DOM.oils_rpt_agg_filter_div)};
 556
 557         DOM.oils_rpt_tform_tab.onclick();
 558         DOM.oils_rpt_column_editor_close_button.onclick = function(){hideMe(div);};
 559 }
 560
 561
 562 function oilsRptDrawFilterWindow(path, col, cls, field) {
 563
 564         var fsel = $n(DOM.oils_rpt_filter_op_table,'selector');
 565         for( var i = 0; i < fsel.options.length; i++ ){
 566                 var opt = fsel.options[i];
 567                 var dt = opt.getAttribute('datatype');
 568                 _debug(dt);
 569
 570                 /* add a special case for boolean objects, since the only
 571                         operation that makes sense is "="  */
 572                 if( field.datatype == 'bool' ) {
 573                         hideMe(opt);
 574                         if( opt.getAttribute('value') == '=' )
 575                                 unHideMe(opt);
 576
 577                 } else {
 578                         if( dt && dt != field.datatype )
 579                                 hideMe(opt);
 580                         else unHideMe(opt);
 581                 }
 582         }
 583
 584         var tformPicker = new oilsRptTformPicker( {
 585                         node : DOM.oils_rpt_filter_tform_table,
 586                         datatype : field.datatype,
 587                         non_aggregate : true
 588                 }
 589         );
 590
 591         DOM.oils_rpt_filter_submit.onclick = function() {
 592                 oilsAddRptFilterItem(
 593                         path, tformPicker.getSelected(), getSelectorVal(fsel));
 594         }
 595
 596
 597         /*
 598         DOM.oils_rpt_filter_submit.onclick = function() {
 599                 var tsel = $n(DOM.oils_rpt_filter_tform_table,'selector');
 600                 var tform = getSelectorVal(tsel);
 601                 var filter = getSelectorVal(fsel);
 602                 oilsAddRptFilterItem(path, tform, filter);
 603         }
 604         oilsRptShowFilters($n(DOM.oils_rpt_filter_tform_table,'selector'), field.datatype, false, true);
 605         */
 606
 607         /*
 608         oilsRptCurrentFilterTform = new oilsRptTFormManager(DOM.oils_rpt_filter_tform_table);
 609         oilsRptCurrentFilterTform.build(field.datatype, false, true);
 610         oilsRptCurrentFilterOpManager = new oilsRptOpManager(DOM.oils_rpt_filter_op_table);
 611         */
 612 }
 613
 614 function oilsRptShowFilters( selector, dtype, show_agg, show_noagg ) {
 615         for( var i = 0; i < selector.options.length; i++ ) {
 616                 var opt = selector.options[i];
 617                 var t = opt.getAttribute('datatype');
 618                 if( t && t != dtype ){
 619                         hideMe(opt);
 620                 } else {
 621                         var ag = opt.getAttribute('aggregate');
 622                         if( ag && show_agg )
 623                                 unHideMe(opt);
 624                         else if( ag && ! show_agg )
 625                                 hideMe(opt)
 626                         else if( !ag && show_noagg )
 627                                 unHideMe(opt);
 628                         else hideMe(opt);
 629                 }
 630         }
 631 }
 632
 633
 634 /* draws the transform window */
 635 function oilsRptDrawTransformWindow(path, col, cls, field) {
 636         DOM.oils_rpt_tform_label_input.value = oilsRptMakeLabel(path);
 637         var dtype = field.datatype;
 638
 639         var tformPicker = new oilsRptTformPicker( {
 640                         node : DOM.oils_rpt_tform_table,
 641                         datatype : field.datatype,
 642                         non_aggregate : true,
 643                         aggregate : true
 644                 }
 645         );
 646
 647         DOM.oils_rpt_tform_submit.onclick =
 648                 function(){
 649                         oilsAddRptDisplayItem(path,
 650                                 DOM.oils_rpt_tform_label_input.value, tformPicker.getSelected() );
 651                 };
 652
 653
 654         DOM.oils_rpt_tform_label_input.focus();
 655         DOM.oils_rpt_tform_label_input.select();
 656
 657         /*
 658         oilsRptCurrentTform = new oilsRptTFormManager(DOM.oils_rpt_tform_table);
 659         oilsRptCurrentTform.build(dtype, true, true);
 660         */
 661
 662         /*
 663         _debug($n(DOM.oils_rpt_tform_table,'selector'));
 664
 665         oilsRptShowFilters($n(DOM.oils_rpt_tform_table,'selector'), dtype, true, true);
 666         */
 667
 668         /*
 669         oilsRptHideTformFields();
 670         oilsRptUnHideTformFields(dtype);
 671         */
 672
 673         _debug("Building transform window for datatype "+dtype);
 674
 675         /*
 676         unHideMe($('oils_rpt_tform_'+dtype+'_div'));
 677         $('oils_rpt_tform_all_raw').checked = true;
 678         */
 679 }
 680
 681 /*
 682 function oilsRptHideTformFields() {
 683         var rows = DOM.oils_rpt_tform_tbody.childNodes;
 684         for( var i = 0; i < rows.length; i++ )
 685                 if( rows[i] && rows[i].nodeType == 1 )
 686                         hideMe(rows[i]);
 687 }
 688
 689 function oilsRptUnHideTformFields(dtype) {
 690         var rows = DOM.oils_rpt_tform_tbody.childNodes;
 691         for( var i = 0; i < rows.length; i++ ) {
 692                 var row = rows[i]
 693                 if( row && row.nodeType == 1 &&
 694                         (row.getAttribute('datatype')=='all'
 695                                 || row.getAttribute('datatype') == dtype)) {
 696                         unHideMe(row);
 697                 }
 698         }
 699 }
 700
 701
 702 function oilsRptGetTform(datatype) {
 703         for( var i in oilsRptTransforms[datatype] )
 704                 if( $('oils_rpt_tform_'+datatype+'_'+oilsRptTransforms[datatype][i]).checked )
 705                         return oilsRptTransforms[datatype][i];
 706         for( var i in oilsRptTransforms.all )
 707                 if( $('oils_rpt_tform_all_'+oilsRptTransforms.all[i]).checked )
 708                         return oilsRptTransforms.all[i];
 709         return null;
 710 }
 711 */
 712
 713
 714 /*
 715 function getRptTformParams(type, tform) {
 716         switch(type) {
 717                 case 'string' :
 718                         switch(tform) {
 719                                 case 'substring' :
 720                                         return [
 721                                                 DOM.oils_rpt_tform_string_substring_offset.value,
 722                                                 DOM.oils_rpt_tform_string_substring_length.value];
 723                         }
 724         }
 725 }
 726 */
 727
 728
 729 /* given a transform selector, this displays the appropriate
 730         transforms for the given datatype.
 731         if aggregate is true, is displays the aggregate transforms */
 732 /*
 733 function oilsRptSetTransforms(sel, dtype, show_agg, show_noagg) {
 734         for( var i = 0; i < sel.options.length; i++ ) {
 735                 var opt = sel.options[i];
 736                 var t = opt.getAttribute('datatype');
 737                 if( t && t != dtype ){
 738                         hideMe(opt);
 739                 } else {
 740                         var ag = opt.getAttribute('aggregate');
 741                         if( ag && show_agg )
 742                                 unHideMe(opt);
 743                         else if( ag && ! show_agg )
 744                                 hideMe(opt)
 745                         else if( !ag && show_noagg )
 746                                 unHideMe(opt);
 747                         else
 748                                 hideMe(opt);
 749                 }
 750         }
 751 }
 752 */
 753
 754
 755 /* displays the correct filter-transforms for the given datatype */
 756 /*
 757 function oilsRptSetFilters(dtype) {
 758
 759         DOM.oils_rpt_filter_submit.onclick = function() {
 760                 var data = oilsRptDoFilterWidgets();
 761                 alert(js2JSON(data));
 762         }
 763
 764         var sel = DOM.oils_rpt_filter_tform_selector;
 765         for( var i = 0; i < sel.options.length; i++ ) {
 766                 var opt = sel.options[i];
 767                 _debug(opt.getAttribute('op'));
 768                 var t = opt.getAttribute('datatype');
 769                 if( t && t != dtype ) hideMe(opt);
 770                 else unHideMe(opt);
 771         }
 772 }
 773 */
 774
 775 /* hides all of the filter widgets */
 776 /*
 777 function oilsRptHideFilterWidgets(node) {
 778         if(!node)
 779                 node = DOM.oils_rpt_filter_tform_widget_td;
 780         if( node.nodeType != 1 ) return;
 781         if( node.getAttribute('widget') ) {
 782                 hideMe(node);
 783         } else {
 784                 var cs = node.childNodes;
 785                 for( var i = 0; cs && i < cs.length; i++ )
 786                         oilsRptHideFilterWidgets(cs[i]);
 787         }
 788 }
 789 */
 790
 791
 792 /* hides/unhides the appropriate widgets and returns the parameter
 793         array appropriate for the selected widget */
 794 /*
 795 function oilsRptDoFilterWidgets() {
 796         filter = getSelectorVal(DOM.oils_rpt_filter_tform_selector);
 797         oilsRptHideFilterWidgets();
 798         var op = null;
 799         var tform = null;
 800         var params = null;
 801
 802         switch(filter) {
 803
 804                 case 'equals':
 805                         if(!op) op = 'equals';
 806                 case 'like':
 807                         if(!op) op = 'like';
 808                 case 'ilike':
 809                         if(!op) op = 'ilike';
 810                 case 'gt':
 811                         if(!op) op = '>';
 812                 case 'gte':
 813                         if(!op) op = '>=';
 814                 case 'lt':
 815                         if(!op) op = '<';
 816                 case 'lte':
 817                         if(!op) op = '<=';
 818                 case 'in':
 819                         if(!op) op = 'in';
 820                 case 'not_in':
 821                         if(!op) op = 'not in';
 822                 case 'between':
 823                         if(!op) op = 'between';
 824                 case 'not_between':
 825                         if(!op) op = 'not between';
 826                         unHideMe(DOM.oils_rpt_filter_tform_input);
 827                         params = [DOM.oils_rpt_filter_tform_input.value];
 828                         break;
 829
 830                 case 'date_between':
 831                         if(!op) op = 'between';
 832                 case 'date_not_between':
 833                         if(!op) op = 'not between';
 834                         tform = 'date';
 835                         var d = new Date();
 836                         unHideMe(DOM.oils_rpt_filter_tform_date_1);
 837                         unHideMe(DOM.oils_rpt_filter_tform_date_2);
 838                         unHideMe(DOM.oils_rpt_filter_tform_date_hint);
 839                         DOM.oils_rpt_filter_tform_date_1.value = mkYearMonDay();
 840                         DOM.oils_rpt_filter_tform_date_2.value = mkYearMonDay();
 841                         params = [
 842                                 DOM.oils_rpt_filter_tform_date_1.value,
 843                                 DOM.oils_rpt_filter_tform_date_2.value
 844                         ];
 845                         break;
 846
 847                 case 'dow_between':
 848                         op = 'between';
 849                         if(!tform) tform = 'dow';
 850                 case 'dow_not_between':
 851                         if(!op) op = 'not between';
 852                         if(!tform) tform = 'dow';
 853                         break;
 854
 855                 case 'dom_between':
 856                         op = 'between';
 857                         if(!tform) tform = 'dom';
 858                 case 'dom_not_between':
 859                         if(!op) op = 'not between';
 860                         if(!tform) tform = 'dom';
 861                         break;
 862
 863                 case 'month_between':
 864                         op = 'between';
 865                         if(!tform) tform = 'moy';
 866                 case 'month_not_between':
 867                         if(!op) op = 'not between';
 868                         if(!tform) tform = 'moy';
 869                         break;
 870
 871                 case 'quarter_between':
 872                         op = 'between';
 873                         if(!tform) tform = 'qoy';
 874                 case 'quarter_not_between':
 875                         if(!op) op = 'not between';
 876                         if(!tform) tform = 'qoy';
 877                         break;
 878
 879                 case 'year_between':
 880                         if(!op) op = 'between';
 881                         if(!tform) tform = 'year_trunc';
 882                 case 'year_not_between':
 883                         if(!op) op = 'not between';
 884                         if(!tform) tform = 'year_trunc';
 885                         break;
 886
 887                 case 'age_between':
 888                         if(!op) op = 'between';
 889                         if(!tform) tform = 'age';
 890                 case 'age_not_between':
 891                         if(!op) op = 'not between';
 892                         if(!tform) tform = 'age';
 893                         break;
 894
 895                 case 'substring':
 896                         if(!tform) tform = 'substring';
 897                         break;
 898
 899                 case 'lower':
 900                         if(!op) op = '';
 901                         if(!tform) tform = 'dow';
 902
 903                 case 'upper':
 904                         if(!op) op = '';
 905                         if(!tform) tform = 'dow';
 906
 907                 case 'round':
 908                         if(!op) op = '';
 909                         if(!tform) tform = 'dow';
 910
 911                 case 'int':
 912                         if(!op) op = '';
 913                         if(!tform) tform = 'dow';
 914         }
 915
 916         return { op : op, params : params, tform : tform };
 917 }
 918  */
 919
 920
 921
 922