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