Open-ILS/web/reports/oils_rpt_folder_window.js

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