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