Open-ILS/web/reports/oils_rpt_folder_window.js

   1
   2
   3
   4
   5 /* generic folder window class */
   6 oilsRptSetSubClass('oilsRptFolderWindow', 'oilsRptObject');
   7 function oilsRptFolderWindow(type, folderId) {
   8         this.init();
   9         var node = oilsRptCurrentFolderManager.findNode(type, folderId);
  10         this.selector = DOM.oils_rpt_folder_contents_selector;
  11         this.folderNode = node;
  12         this.type = type;
  13 }
  14
  15
  16 oilsRptFolderWindow.prototype.draw = function() {
  17
  18         _debug('drawing folder window for ' + this.folderNode.folder.name() );
  19
  20         var obj = this;
  21         setSelector(DOM.oils_rpt_output_limit_selector, oilsRptOutputLimit);
  22         setSelector(DOM.oils_rpt_output_limit_selector_2, oilsRptOutputLimit2);
  23
  24         DOM.oils_rpt_output_limit_selector.onchange = function() {
  25                 oilsRptOutputLimit = getSelectorVal(DOM.oils_rpt_output_limit_selector);
  26                 obj.draw();
  27         }
  28
  29         DOM.oils_rpt_output_limit_selector_2.onchange = function() {
  30                 oilsRptOutputLimit2 = getSelectorVal(DOM.oils_rpt_output_limit_selector_2);
  31                 obj.draw();
  32         }
  33
  34         var mine = ( this.folderNode.folder.owner().id() == USER.id() );
  35
  36         if( mine  && this.type == 'template')
  37                 unHideMe(DOM.oils_rpt_folder_window_contents_new_template.parentNode);
  38         else hideMe(DOM.oils_rpt_folder_window_contents_new_template.parentNode);
  39
  40         unHideMe(DOM.oils_rpt_folder_window_contents_div);
  41         hideMe(DOM.oils_rpt_folder_manager_div);
  42         hideMe(DOM.oils_rpt_top_folder);
  43
  44         DOM.oils_rpt_folder_window_manage_tab.onclick = function() {
  45                 unHideMe(DOM.oils_rpt_folder_window_contents_div);
  46                 hideMe(DOM.oils_rpt_folder_manager_div);
  47         }
  48         DOM.oils_rpt_folder_window_edit_tab.onclick = function() {
  49                 hideMe(DOM.oils_rpt_folder_window_contents_div);
  50                 unHideMe(DOM.oils_rpt_folder_manager_div);
  51         }
  52
  53         this.setFolderEditActions();
  54
  55         hideMe(DOM.oils_rpt_template_folder_new_report);
  56         unHideMe(DOM.oils_rpt_folder_table_right_td);
  57         hideMe(DOM.oils_rpt_folder_table_alt_td);
  58         this.drawFolderDetails();
  59
  60         DOM.oils_rpt_folder_content_action_go.onclick =
  61                 function() {obj.doFolderAction()}
  62
  63         this.fetchFolderData();
  64
  65         var sel = DOM.oils_rpt_folder_contents_action_selector;
  66         var x = true;
  67         for( var i = 0; i < sel.options.length; i++ ) {
  68                 var opt = sel.options[i];
  69
  70                 if( !mine && opt.getAttribute('value').match(/move/) ) {
  71                         hideMe(opt);
  72                         continue;
  73                 }
  74
  75                 if( opt.getAttribute('type') == this.type ) {
  76                         if(x && !opt.disabled) {
  77                                 opt.selected = true;
  78                                 x = false;
  79                         }
  80                         unHideMe(opt);
  81                 } else hideMe(opt);
  82         }
  83
  84         this.drawEditActions();
  85
  86         var porg = PERMS.SHARE_REPORT_FOLDER;
  87         if( porg < 1 )
  88                 DOM.oils_rpt_folder_manager_share_opt.disabled = true;
  89 }
  90
  91 oilsRptFolderWindow.prototype.drawEditActions = function() {
  92
  93         DOM.oils_rpt_folder_window_contents_new_template.onclick = function() {
  94                 var s = location.search+'';
  95                 s = s.replace(/\&folder=\d+/g,'');
  96                 s = s.replace(/\&ct=\d+/g,'');
  97                 goTo( 'oils_rpt_builder.xhtml'+s+'&folder='+obj.folderNode.folder.id());
  98         }
  99
 100
 101         if( this.folderNode.folder.owner().id() != USER.id() )
 102                 hideMe(DOM.oils_rpt_folder_manager_tab_table);
 103         else
 104                 unHideMe(DOM.oils_rpt_folder_manager_tab_table);
 105
 106         if( isTrue(this.folderNode.folder.shared())) {
 107                 DOM.oils_rpt_folder_manager_share_opt.disabled = true;
 108                 DOM.oils_rpt_folder_manager_unshare_opt.disabled = false;
 109         } else {
 110                 DOM.oils_rpt_folder_manager_share_opt.disabled = false;
 111                 DOM.oils_rpt_folder_manager_unshare_opt.disabled = true;
 112         }
 113
 114         this.hideFolderActions();
 115         var obj = this;
 116
 117         DOM.oils_rpt_folder_manager_actions_submit.onclick = function() {
 118                 var act = getSelectorVal(DOM.oils_rpt_folder_manager_actions);
 119                 _debug("doing folder action: " + act);
 120                 obj.hideFolderActions();
 121                 switch(act) {
 122                         case 'change_name':
 123                                 unHideMe(DOM.oils_rpt_folder_manager_change_name_div);
 124                                 break;
 125                         case 'create_sub_folder':
 126                                 var porg = PERMS.SHARE_REPORT_FOLDER;
 127                                 if( porg < 1 )
 128                                         DOM.oils_rpt_folder_manager_sub_shared.disabled = true;
 129                                 removeChildren(DOM.oils_rpt_folder_manager_sub_lib_picker);
 130                                 unHideMe(DOM.oils_rpt_folder_manager_create_sub);
 131                                 obj.myOrgSelector = new oilsRptMyOrgsWidget(
 132                                         DOM.oils_rpt_folder_manager_sub_lib_picker, USER.ws_ou(), porg)
 133                                 obj.myOrgSelector.draw();
 134                                 break;
 135                         case 'delete':
 136                                 obj.doFolderDelete();
 137                                 break;
 138                         case 'share':
 139                                 obj.shareFolder();
 140                                 break;
 141                         case 'unshare':
 142                                 obj.unShareFolder();
 143                                 break;
 144                 }
 145         }
 146
 147 }
 148
 149
 150 oilsRptFolderWindow.prototype.shareFolder = function() {
 151         var folder = this.folderNode.folder;
 152         if(isTrue(folder.shared()))
 153                 return alertId('oils_rpt_folder_already_shared');
 154         unHideMe(DOM.oils_rpt_folder_manager_share_div);
 155
 156
 157         var orgsel = new oilsRptMyOrgsWidget(
 158                 DOM.oils_rpt_folder_manager_share_lib_picker,
 159                 USER.ws_ou(), PERMS.SHARE_REPORT_FOLDER);
 160         orgsel.draw();
 161
 162         var type = this.type;
 163         DOM.oils_rpt_folder_manager_share_submit.onclick = function() {
 164                 folder.shared('t');
 165                 folder.share_with(orgsel.getValue());
 166                 oilsRptUpdateFolder( folder, type,
 167                         function(success) {
 168                                 if(success) {
 169                                         oilsRptAlertSuccess();
 170                                         oilsRptCurrentFolderManager.draw();
 171                                 }
 172                         }
 173                 );
 174         }
 175 }
 176
 177 oilsRptFolderWindow.prototype.unShareFolder = function() {
 178         var folder = this.folderNode.folder;
 179         if(!isTrue(folder.shared()))
 180                 return alertId('oils_rpt_folder_already_unshared');
 181         if(!confirmId('oils_rpt_folder_unshare_confirm')) return;
 182         folder.shared('f');
 183         var type = this.type;
 184         oilsRptUpdateFolder( folder, type,
 185                 function(success) {
 186                         if(success) {
 187                                 oilsRptAlertSuccess();
 188                                 oilsRptCurrentFolderManager.draw();
 189                         }
 190                 }
 191         );
 192 }
 193
 194
 195 oilsRptFolderWindow.prototype.hideFolderActions = function() {
 196         hideMe(DOM.oils_rpt_folder_manager_change_name_div);
 197         hideMe(DOM.oils_rpt_folder_manager_create_sub);
 198         hideMe(DOM.oils_rpt_folder_manager_share_div);
 199 }
 200
 201
 202 oilsRptFolderWindow.prototype.doFolderAction = function() {
 203         var objs = (this.fmTable) ? this.fmTable.getSelected() : [];
 204
 205         if( this.type == 'output' && this.fmTable2 )
 206                 objs = objs.concat( this.fmTable2.getSelected() );
 207
 208         if( objs.length == 0 )
 209                 return alert('Please select an item from the list');
 210         var action = getSelectorVal(DOM.oils_rpt_folder_contents_action_selector);
 211
 212         var obj = this;
 213         var successCallback = function(errid) {
 214                 if(errid) alertId(errid)
 215                 else oilsRptAlertSuccess();
 216                 obj.draw();
 217         };
 218
 219         var obj = this;
 220         switch(action) {
 221                 case 'create_report' :
 222                         hideMe(DOM.oils_rpt_folder_table_right_td);
 223                         unHideMe(DOM.oils_rpt_folder_table_alt_td);
 224                         unHideMe(DOM.oils_rpt_editor_div);
 225                         new oilsRptReportEditor(new oilsReport(objs[0]), this);
 226                         break;
 227                 case 'delete_report' :
 228                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 229                         this.deleteReports(objs, 0, successCallback);
 230                         break;
 231
 232                 case 'delete_template' :
 233                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 234                         this.deleteTemplates(objs, 0, successCallback);
 235                         break;
 236
 237                 case 'show_output':
 238                         this.showOutput(objs[0]);
 239                         break;
 240
 241                 case 'delete_output':
 242                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 243                         this.deleteOutputs(objs,0, successCallback);
 244                         break;
 245
 246                 case 'move_template':
 247                         this.changeBatchFolder(objs, 'template', successCallback);
 248                         break;
 249
 250                 case 'move_report':
 251                         this.changeBatchFolder(objs, 'report', successCallback);
 252                         break;
 253
 254                 case 'move_output':
 255                         this.changeBatchFolder(objs, 'output', successCallback);
 256                         break;
 257
 258                 case 'clone_template':
 259                         this.cloneTemplate(objs[0]);
 260         }
 261 }
 262
 263 oilsRptFolderWindow.prototype.changeBatchFolder = function(objs, type, callback) {
 264         hideMe(DOM.oils_rpt_folder_window_contents_table);
 265         unHideMe(DOM.oils_rpt_move_folder_div)
 266         var obj = this;
 267         this.drawFolderOptions(type,
 268                 function(folderid) {
 269                         obj.changeFolderList(objs, type, folderid, 0, callback);
 270                         hideMe(DOM.oils_rpt_move_folder_div)
 271                         unHideMe(DOM.oils_rpt_folder_window_contents_table);
 272                 }
 273         );
 274 }
 275
 276 oilsRptFolderWindow.prototype.cloneTemplate = function(template) {
 277         hideMe(DOM.oils_rpt_folder_window_contents_table);
 278         unHideMe(DOM.oils_rpt_move_folder_div)
 279         var obj = this;
 280         this.drawFolderOptions('template',
 281                 function(folderid) {
 282                         var s = location.search+'';
 283                         s = s.replace(/\&folder=\d+/g,'');
 284                         s = s.replace(/\&ct=\d+/g,'');
 285                         goTo('oils_rpt_builder.xhtml'+s+'&folder='+folderid+'&ct='+template.id());
 286                 }
 287         );
 288 }
 289
 290
 291 oilsRptFolderWindow.prototype.changeFolderList = function(list, type, folderid, idx, callback, errid) {
 292         if( idx >= list.length ) return callback(errid);
 293         var item = list[idx];
 294         var obj = this;
 295         var rcback = function(){obj.changeFolderList(list,type,folderid,++idx,callback,errid)};
 296
 297         item.folder(folderid);
 298
 299         switch(type) {
 300                 case 'template':
 301                         oilsRptUpdateTemplate(item,rcback);
 302                         break;
 303                 case 'report':
 304                         oilsRptUpdateReport(item,rcback);
 305                         break;
 306                 case 'output':
 307                         oilsRptUpdateSchedule(item,rcback);
 308                         break;
 309         }
 310 }
 311
 312 oilsRptFolderWindow.prototype.drawFolderOptions = function(type, callback) {
 313         //var oilsRptChangeFolderTree;
 314         var selectedFolder;
 315         oilsRptBuildFolder(
 316                 type,
 317                 DOM.oils_rpt_move_folder_picker,
 318                 'tree9807897',
 319                 'Change Folders',
 320                 function(node) {
 321                         appendClear(DOM.oils_rpt_move_folder_selected, node.folder.name());
 322                         selectedFolder = node.folder.id();
 323                 }
 324         );
 325
 326         DOM.oils_rpt_change_folder_submit.onclick = function() {
 327                 if(selectedFolder) callback(selectedFolder);
 328         }
 329
 330         DOM.oils_rpt_change_folder_cancel.onclick = function() {
 331                 hideMe(DOM.oils_rpt_move_folder_div)
 332                 unHideMe(DOM.oils_rpt_folder_window_contents_table);
 333         }
 334 }
 335
 336
 337 oilsRptFolderWindow.prototype.deleteOutputs = function(list, idx, callback, errid) {
 338         if( idx >= list.length ) return callback(errid);
 339         var output = list[idx];
 340
 341         if( output.runner().id()  != USER.id() ) {
 342                 this.deleteOutputs(list, ++idx,
 343                         callback, 'oils_rpt_folder_contents_no_delete');
 344
 345         } else {
 346                 _debug('deleting output ' + output.id());
 347                 var req = new Request(OILS_RPT_DELETE_SCHEDULE,SESSION,output.id());
 348                 var obj = this;
 349                 req.callback(function(){obj.deleteOutputs(list, ++idx, callback, errid);});
 350                 req.send();
 351         }
 352 }
 353
 354 oilsRptFolderWindow.prototype.showOutput = function(sched) {
 355         oilsRptFetchReport(sched.report().id(),
 356                 function(r) {
 357                         var url = oilsRptBuildOutputLink(r.template(), r.id(), sched.id());
 358                         _debug("launching report output view at URL: " + url);
 359                         if(isXUL())
 360                                 xulG.new_tab(url,{"tab_name":"Report Output: " + r.name()},{})
 361                         else {
 362                                 //goTo(url);
 363                                 var win = window.open(url,r.name(), 'resizable,width=800,height=600,scrollbars=1');
 364                         }
 365                 }
 366         );
 367 }
 368
 369
 370 oilsRptFolderWindow.prototype.deleteReports = function(list, idx, callback, errid) {
 371         if( idx >= list.length ) return callback(errid);
 372         var report = list[idx];
 373
 374         if( report.owner().id() != USER.id() ) {
 375                 this.deleteReports(list, ++idx,
 376                         callback, 'oils_rpt_folder_contents_no_delete');
 377
 378         } else {
 379
 380                 var obj = this;
 381                 var req0 = new Request(OILS_RPT_REPORT_HAS_OUTS, SESSION, report.id());
 382                 req0.callback(
 383                         function(r0) {
 384                                 var r0es = r0.getResultObject();
 385                                 if( r0es != '0' ) {
 386                                         obj.deleteReports(list, ++idx,
 387                                                 callback, 'oils_rpt_folder_contents_report_no_delete');
 388                                 } else {
 389                                         _debug('deleting report ' + report.id());
 390                                         var req = new Request(OILS_RPT_DELETE_REPORT, SESSION, report.id());
 391                                         req.callback(function(r) {
 392                                                 var res = r.getResultObject();
 393                                                 if( res != 1 ) return oilsRptAlertFailure();
 394                                                 obj.deleteReports(list, ++idx, callback, errid)
 395                                         });
 396                                         req.send();
 397                                 }
 398                         }
 399                 );
 400
 401                 req0.send();
 402         }
 403 }
 404
 405 oilsRptFolderWindow.prototype.deleteTemplates = function(list, idx, callback, errid) {
 406         if( idx >= list.length ) return callback(errid);
 407         var tmpl = list[idx];
 408
 409         var obj = this;
 410         if( tmpl.owner().id() != USER.id() ) {
 411                 this.deleteTemplates(list, ++idx,
 412                         callback, 'oils_rpt_folder_contents_no_delete');
 413
 414         } else {
 415
 416                 var req0 = new Request( OILS_RPT_TEMPLATE_HAS_RPTS, SESSION, tmpl.id() );
 417                 req0.callback(
 418                         function(r0) {
 419                                 var resp = r0.getResultObject();
 420
 421                                 if( resp != '0' ) {
 422                                         obj.deleteTemplates(list, ++idx,
 423                                                 callback, 'oils_rpt_folder_contents_template_no_delete');
 424
 425                                 } else {
 426                                         _debug('deleting template ' + tmpl.id());
 427                                         var req = new Request(OILS_RPT_DELETE_TEMPLATE, SESSION, tmpl.id());
 428                                         req.callback(function(r) {
 429                                                 var res = r.getResultObject();
 430                                                 if( res != 1 ) return oilsRptAlertFailure();
 431                                                 obj.deleteTemplates(list, ++idx, callback, errid)
 432                                         });
 433                                         req.send();
 434                                 }
 435                         }
 436                 );
 437                 req0.send();
 438         }
 439 }
 440
 441
 442
 443 oilsRptFolderWindow.prototype.drawFolderDetails = function() {
 444         appendClear(DOM.oils_rpt_folder_creator_label,
 445                 text(this.folderNode.folder.owner().usrname()));
 446         appendClear(DOM.oils_rpt_folder_name_label,
 447                 text(this.folderNode.folder.name()));
 448 }
 449
 450
 451 oilsRptFolderWindow.prototype.fetchFolderData = function(callback) {
 452
 453         hideMe(DOM.oils_rpt_content_count_row_2);
 454         hideMe(DOM.oils_rpt_content_row_2);
 455
 456         removeChildren(this.selector);
 457         var req = new Request(OILS_RPT_FETCH_FOLDER_DATA,
 458                 SESSION, this.type, this.folderNode.folder.id(), oilsRptOutputLimit);
 459
 460         hideMe(DOM.oils_rpt_pending_output);
 461
 462         if(this.type == 'output') {
 463                 unHideMe(DOM.oils_rpt_pending_output);
 464                 /* first fetch the non-complete schedules */
 465                 req = new Request(OILS_RPT_FETCH_OUTPUT,
 466                         SESSION, this.folderNode.folder.id(), oilsRptOutputLimit, 0);
 467         }
 468
 469         var obj = this;
 470         removeChildren(obj.selector);
 471         req.callback(
 472                 function(r) {
 473                         var res = r.getResultObject();
 474
 475                         if( res.length == 0 ) {
 476                                 hideMe(DOM.oils_rpt_content_count_row);
 477                                 hideMe(DOM.oils_rpt_content_row);
 478                                 unHideMe(DOM.oils_rpt_content_row_empty);
 479                         } else {
 480                                 unHideMe(DOM.oils_rpt_content_count_row);
 481                                 unHideMe(DOM.oils_rpt_content_row);
 482                                 hideMe(DOM.oils_rpt_content_row_empty);
 483                         }
 484
 485                         if( obj.type == 'output' ) {
 486                                 obj.fleshSchedules(res, 0, obj.selector);
 487                         } else {
 488
 489
 490                                 obj.fmTable = drawFMObjectTable(
 491                                         {
 492                                                 dest : obj.selector,
 493                                                 obj : res,
 494                                                 selectCol : true,
 495                                                 selectColName : 'Select',
 496                                                 selectAllName : 'All',
 497                                                 selectNoneName : 'None'
 498                                         }
 499                                 );
 500                         }
 501                 }
 502         );
 503         req.send();
 504
 505         if( this.type != 'output' ) return;
 506
 507         /*
 508         unHideMe(DOM.oils_rpt_content_count_row_2);
 509         unHideMe(DOM.oils_rpt_content_row_2);
 510         */
 511
 512         /* now fetch the completed schedules */
 513         req = new Request(OILS_RPT_FETCH_OUTPUT,
 514                 SESSION, this.folderNode.folder.id(), oilsRptOutputLimit2, 1);
 515
 516         _debug("TRYING: fleshing finished scheds with div: " + DOM.oils_rpt_folder_contents_selector_2);
 517         removeChildren(DOM.oils_rpt_folder_contents_selector_2);
 518         req.callback(
 519                 function(r) {
 520                         var res = r.getResultObject();
 521
 522                         if( res.length == 0 ) {
 523                                 hideMe(DOM.oils_rpt_content_count_row_2);
 524                                 hideMe(DOM.oils_rpt_content_row_2);
 525                         } else {
 526                                 unHideMe(DOM.oils_rpt_content_count_row_2);
 527                                 unHideMe(DOM.oils_rpt_content_row_2);
 528                         }
 529
 530                         _debug("fleshing finished scheds with div: " + DOM.oils_rpt_folder_contents_selector_2);
 531                         obj.fleshSchedules(res, 0, DOM.oils_rpt_folder_contents_selector_2, true);
 532                 }
 533         );
 534         req.send();
 535 }
 536
 537
 538 oilsRptFolderWindow.prototype.fleshSchedules = function(list, idx, selector, isSecond) {
 539
 540         if( idx >= list.length ) return;
 541
 542         var sched = list[idx];
 543         var obj = this;
 544
 545         oilsRptFetchUser(sched.runner(),
 546
 547                 function(user) {
 548                         sched.runner(user);
 549                         oilsRptFetchTemplate(sched.report().template(),
 550
 551                                 function(template) {
 552                                         sched.report().template(template);
 553                                         if( idx == 0 ) {
 554                                                 _debug("drawing schedule with output: "+selector);
 555                                                 var t = drawFMObjectTable(
 556                                                         {
 557                                                                 dest : selector,
 558                                                                 obj : [sched],
 559                                                                 selectCol : true,
 560                                                                 selectColName : 'Select',
 561                                                                 selectAllName : 'All',
 562                                                                 selectNoneName : 'None'
 563                                                         }
 564                                                 );
 565
 566                                                 if( isSecond ) obj.fmTable2 = t;
 567                                                 else obj.fmTable = t;
 568
 569                                         } else {
 570                                                 //obj.fmTable.add(sched);
 571                                                 if( isSecond ) obj.fmTable2.add(sched);
 572                                                 else obj.fmTable.add(sched);
 573                                         }
 574
 575                                         obj.fleshSchedules(list, ++idx, selector, isSecond);
 576                                 }
 577                         );
 578                 }
 579         );
 580 }
 581
 582
 583 oilsRptFolderWindow.prototype.setSelected = function(folderNode) {
 584         this.selectedFolder = folderNode;
 585 }
 586
 587 oilsRptFolderWindow.prototype.setFolderEditActions = function() {
 588         var folder = this.folderNode.folder;
 589
 590         var obj = this;
 591         DOM.oils_rpt_folder_manager_name_input.value = folder.name();
 592         DOM.oils_rpt_folder_manager_change_name_submit.onclick = function() {
 593                 var name = DOM.oils_rpt_folder_manager_name_input.value;
 594                 if(name) {
 595                         folder.name( name );
 596                         if(confirmId('oils_rpt_folder_manager_change_name_confirm')) {
 597                                 oilsRptUpdateFolder(folder, obj.type,
 598                                         function(success) {
 599                                                 if(success) {
 600                                                         oilsRptAlertSuccess();
 601                                                         oilsRptCurrentFolderManager.draw();
 602                                                 }
 603                                         }
 604                                 );
 605                         }
 606                 }
 607         }
 608
 609         DOM.oils_rpt_folder_manager_sub_lib_create.onclick = function() {
 610                 var folder;
 611
 612                 if( obj.type == 'report' ) folder = new rrf();
 613                 if( obj.type == 'template' ) folder = new rtf();
 614                 if( obj.type == 'output' ) folder = new rof();
 615
 616                 folder.owner(USER.id());
 617                 folder.parent(obj.folderNode.folder.id());
 618                 folder.name(DOM.oils_rpt_folder_manager_sub_name.value);
 619                 var shared = getSelectorVal(DOM.oils_rpt_folder_manager_sub_shared);
 620                 folder.shared( (shared == 'yes') ? 't' : 'f');
 621                 if( folder.shared() == 't' )
 622                         folder.share_with( obj.myOrgSelector.getValue() );
 623
 624                 oilsRptCreateFolder(folder, obj.type,
 625                         function(success) {
 626                                 if(success) {
 627                                         oilsRptAlertSuccess();
 628                                         oilsRptCurrentFolderManager.draw();
 629                                 }
 630                         }
 631                 );
 632         }
 633 }
 634
 635
 636 oilsRptFolderWindow.prototype.doFolderDelete = function() {
 637
 638         var cache = oilsRptFolderNodeCache[this.type];
 639         /* let's see if this folder has any children */
 640         for( var c in cache )
 641                 if( cache[c].folder.parent() == this.folderNode.folder.id() )
 642                         return alertId('oils_rpt_folder_cannot_delete');
 643
 644         /* lets see if the folder has contents */
 645         var req = new Request(OILS_RPT_FETCH_FOLDER_DATA,
 646                 SESSION, this.type, this.folderNode.folder.id(), 1);
 647
 648         if(this.type == 'output') {
 649                 req = new Request(OILS_RPT_FETCH_OUTPUT,
 650                         SESSION, this.folderNode.folder.id(), 1);
 651         }
 652
 653         var obj = this;
 654         req.send();
 655
 656         req.callback(
 657                 function(r) {
 658
 659                         var contents = r.getResultObject();
 660                         if( contents.length > 0 )
 661                                 return alertId('oils_rpt_folder_cannot_delete');
 662
 663                         if( confirmId('oils_rpt_folder_manager_delete_confirm') ) {
 664                                 var req2 = new Request(OILS_RPT_DELETE_FOLDER,
 665                                         SESSION, obj.type, obj.folderNode.folder.id());
 666
 667                                 req2.callback(
 668                                         function(r2) {
 669                                                 var res = r2.getResultObject();
 670                                                 if( res == 1 ) {
 671                                                         oilsRptAlertSuccess();
 672                                                         oilsRptCurrentFolderManager.draw();
 673                                                 }
 674                                                 else alert('error: '+js2JSON(res));
 675                                         }
 676                                 );
 677
 678                                 req2.send();
 679                         }
 680                 }
 681         );
 682 }
 683
 684