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