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
  23         DOM.oils_rpt_output_limit_selector.onchange = function() {
  24                 oilsRptOutputLimit = getSelectorVal(DOM.oils_rpt_output_limit_selector);
  25                 obj.draw();
  26         }
  27
  28
  29         if( this.folderNode.folder.owner().id() == USER.id() && this.type == 'template')
  30                 unHideMe(DOM.oils_rpt_folder_window_contents_new_template.parentNode);
  31         else hideMe(DOM.oils_rpt_folder_window_contents_new_template.parentNode);
  32
  33         unHideMe(DOM.oils_rpt_folder_window_contents_div);
  34         hideMe(DOM.oils_rpt_folder_manager_div);
  35         hideMe(DOM.oils_rpt_top_folder);
  36
  37         DOM.oils_rpt_folder_window_manage_tab.onclick = function() {
  38                 unHideMe(DOM.oils_rpt_folder_window_contents_div);
  39                 hideMe(DOM.oils_rpt_folder_manager_div);
  40         }
  41         DOM.oils_rpt_folder_window_edit_tab.onclick = function() {
  42                 hideMe(DOM.oils_rpt_folder_window_contents_div);
  43                 unHideMe(DOM.oils_rpt_folder_manager_div);
  44         }
  45
  46         this.setFolderEditActions();
  47
  48         hideMe(DOM.oils_rpt_template_folder_new_report);
  49         unHideMe(DOM.oils_rpt_folder_table_right_td);
  50         hideMe(DOM.oils_rpt_folder_table_alt_td);
  51         this.drawFolderDetails();
  52
  53         DOM.oils_rpt_folder_content_action_go.onclick =
  54                 function() {obj.doFolderAction()}
  55
  56         this.fetchFolderData();
  57
  58         var sel = DOM.oils_rpt_folder_contents_action_selector;
  59         var x = true;
  60         for( var i = 0; i < sel.options.length; i++ ) {
  61                 var opt = sel.options[i];
  62                 if( opt.getAttribute('type') == this.type ) {
  63                         if(x) opt.selected = true;
  64                         x = false;
  65                         unHideMe(opt);
  66                 }
  67                 else hideMe(opt);
  68         }
  69         sel.options[0].selected = true;
  70
  71         /*
  72         hideMe(DOM.oils_rpt_output_limit_selector.parentNode);
  73         if( this.type == 'output' )
  74                 unHideMe(DOM.oils_rpt_output_limit_selector.parentNode);
  75                 */
  76
  77         this.drawEditActions();
  78
  79
  80         var porg = PERMS.SHARE_REPORT_FOLDER;
  81         if( porg < 1 )
  82                 DOM.oils_rpt_folder_manager_share_opt.disabled = true;
  83 }
  84
  85 oilsRptFolderWindow.prototype.drawEditActions = function() {
  86
  87         DOM.oils_rpt_folder_window_contents_new_template.onclick = function() {
  88                 var s = location.search+'';
  89                 s = s.replace(/\&folder=\d+/,'');
  90                 goTo( 'oils_rpt_builder.xhtml'+s+'&folder='+obj.folderNode.folder.id());
  91         }
  92
  93
  94         if( this.folderNode.folder.owner().id() != USER.id() )
  95                 hideMe(DOM.oils_rpt_folder_manager_tab_table);
  96         else
  97                 unHideMe(DOM.oils_rpt_folder_manager_tab_table);
  98
  99         if( isTrue(this.folderNode.folder.shared())) {
 100                 DOM.oils_rpt_folder_manager_share_opt.disabled = true;
 101                 DOM.oils_rpt_folder_manager_unshare_opt.disabled = false;
 102         } else {
 103                 DOM.oils_rpt_folder_manager_share_opt.disabled = false;
 104                 DOM.oils_rpt_folder_manager_unshare_opt.disabled = true;
 105         }
 106
 107         this.hideFolderActions();
 108         var obj = this;
 109
 110         DOM.oils_rpt_folder_manager_actions_submit.onclick = function() {
 111                 var act = getSelectorVal(DOM.oils_rpt_folder_manager_actions);
 112                 _debug("doing folder action: " + act);
 113                 obj.hideFolderActions();
 114                 switch(act) {
 115                         case 'change_name':
 116                                 unHideMe(DOM.oils_rpt_folder_manager_change_name_div);
 117                                 break;
 118                         case 'create_sub_folder':
 119                                 var porg = PERMS.SHARE_REPORT_FOLDER;
 120                                 if( porg < 1 )
 121                                         DOM.oils_rpt_folder_manager_sub_shared.disabled = true;
 122                                 removeChildren(DOM.oils_rpt_folder_manager_sub_lib_picker);
 123                                 unHideMe(DOM.oils_rpt_folder_manager_create_sub);
 124                                 obj.myOrgSelector = new oilsRptMyOrgsWidget(
 125                                         DOM.oils_rpt_folder_manager_sub_lib_picker, USER.ws_ou(), porg)
 126                                 obj.myOrgSelector.draw();
 127                                 break;
 128                         case 'delete':
 129                                 obj.doFolderDelete();
 130                                 break;
 131                         case 'share':
 132                                 obj.shareFolder();
 133                                 break;
 134                         case 'unshare':
 135                                 obj.unShareFolder();
 136                                 break;
 137                 }
 138         }
 139
 140 }
 141
 142
 143 oilsRptFolderWindow.prototype.shareFolder = function() {
 144         var folder = this.folderNode.folder;
 145         if(isTrue(folder.shared()))
 146                 return alertId('oils_rpt_folder_already_shared');
 147         unHideMe(DOM.oils_rpt_folder_manager_share_div);
 148
 149
 150         var orgsel = new oilsRptMyOrgsWidget(
 151                 DOM.oils_rpt_folder_manager_share_lib_picker,
 152                 USER.ws_ou(), PERMS.SHARE_REPORT_FOLDER);
 153         orgsel.draw();
 154
 155         var type = this.type;
 156         DOM.oils_rpt_folder_manager_share_submit.onclick = function() {
 157                 folder.shared('t');
 158                 folder.share_with(orgsel.getValue());
 159                 oilsRptUpdateFolder( folder, type,
 160                         function(success) {
 161                                 if(success) {
 162                                         oilsRptAlertSuccess();
 163                                         oilsRptCurrentFolderManager.draw();
 164                                 }
 165                         }
 166                 );
 167         }
 168 }
 169
 170 oilsRptFolderWindow.prototype.unShareFolder = function() {
 171         var folder = this.folderNode.folder;
 172         if(!isTrue(folder.shared()))
 173                 return alertId('oils_rpt_folder_already_unshared');
 174         if(!confirmId('oils_rpt_folder_unshare_confirm')) return;
 175         folder.shared('f');
 176         var type = this.type;
 177         oilsRptUpdateFolder( folder, type,
 178                 function(success) {
 179                         if(success) {
 180                                 oilsRptAlertSuccess();
 181                                 oilsRptCurrentFolderManager.draw();
 182                         }
 183                 }
 184         );
 185 }
 186
 187
 188 oilsRptFolderWindow.prototype.hideFolderActions = function() {
 189         hideMe(DOM.oils_rpt_folder_manager_change_name_div);
 190         hideMe(DOM.oils_rpt_folder_manager_create_sub);
 191         hideMe(DOM.oils_rpt_folder_manager_share_div);
 192 }
 193
 194
 195 oilsRptFolderWindow.prototype.doFolderAction = function() {
 196         var objs = this.fmTable.getSelected();
 197         if( objs.length == 0 )
 198                 return alert('Please select an item from the list');
 199         var action = getSelectorVal(DOM.oils_rpt_folder_contents_action_selector);
 200
 201         var obj = this;
 202         var successCallback = function(errid) {
 203                 if(errid) alertId(errid)
 204                 else oilsRptAlertSuccess();
 205                 obj.draw();
 206         };
 207
 208         var obj = this;
 209         switch(action) {
 210                 case 'create_report' :
 211                         hideMe(DOM.oils_rpt_folder_table_right_td);
 212                         unHideMe(DOM.oils_rpt_folder_table_alt_td);
 213                         unHideMe(DOM.oils_rpt_editor_div);
 214                         new oilsRptReportEditor(new oilsReport(objs[0]), this);
 215                         break;
 216                 case 'delete_report' :
 217                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 218                         this.deleteReports(objs, 0, successCallback);
 219                         break;
 220
 221                 case 'delete_template' :
 222                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 223                         this.deleteTemplates(objs, 0, successCallback);
 224                         break;
 225
 226                 case 'show_output':
 227                         this.showOutput(objs[0]);
 228                         break;
 229
 230                 case 'delete_output':
 231                         if(!confirmId('oils_rpt_folder_contents_confirm_delete')) return;
 232                         this.deleteOutputs(objs,0, successCallback);
 233                         break;
 234
 235         }
 236 }
 237
 238
 239 oilsRptFolderWindow.prototype.deleteOutputs = function(list, idx, callback, errid) {
 240         if( idx >= list.length ) return callback(errid);
 241         var output = list[idx];
 242
 243         if( output.runner().id()  != USER.id() ) {
 244                 this.deleteOutputs(list, ++idx,
 245                         callback, 'oils_rpt_folder_contents_no_delete');
 246
 247         } else {
 248                 _debug('deleting output ' + output.id());
 249                 var req = new Request(OILS_RPT_DELETE_SCHEDULE,SESSION,output.id());
 250                 var obj = this;
 251                 req.callback(function(){obj.deleteOutputs(list, ++idx, callback, errid);});
 252                 req.send();
 253         }
 254 }
 255
 256 oilsRptFolderWindow.prototype.showOutput = function(sched) {
 257         oilsRptFetchReport(sched.report(),
 258                 function(r) {
 259                         var url = oilsRptBuildOutputLink(r.template(), r.id(), sched.id());
 260                         goTo(url);
 261                 }
 262         );
 263 }
 264
 265
 266 oilsRptFolderWindow.prototype.deleteReports = function(list, idx, callback, errid) {
 267         if( idx >= list.length ) return callback(errid);
 268         var report = list[idx];
 269
 270         if( report.owner().id() != USER.id() ) {
 271                 this.deleteReports(list, ++idx,
 272                         callback, 'oils_rpt_folder_contents_no_delete');
 273
 274         } else {
 275
 276                 var obj = this;
 277                 var req0 = new Request(OILS_RPT_REPORT_HAS_OUTS, SESSION, report.id());
 278                 req0.callback(
 279                         function(r0) {
 280                                 var r0es = r0.getResultObject();
 281                                 if( r0es != '0' ) {
 282                                         obj.deleteReports(list, ++idx,
 283                                                 callback, 'oils_rpt_folder_contents_report_no_delete');
 284                                 } else {
 285                                         _debug('deleting report ' + report.id());
 286                                         var req = new Request(OILS_RPT_DELETE_REPORT, SESSION, report.id());
 287                                         req.callback(function(r) {
 288                                                 var res = r.getResultObject();
 289                                                 if( res != 1 ) return oilsRptAlertFailure();
 290                                                 obj.deleteReports(list, ++idx, callback, errid)
 291                                         });
 292                                         req.send();
 293                                 }
 294                         }
 295                 );
 296
 297                 req0.send();
 298         }
 299 }
 300
 301 oilsRptFolderWindow.prototype.deleteTemplates = function(list, idx, callback, errid) {
 302         if( idx >= list.length ) return callback(errid);
 303         var tmpl = list[idx];
 304
 305         var obj = this;
 306         if( tmpl.owner().id() != USER.id() ) {
 307                 this.deleteTemplates(list, ++idx,
 308                         callback, 'oils_rpt_folder_contents_no_delete');
 309
 310         } else {
 311
 312                 var req0 = new Request( OILS_RPT_TEMPLATE_HAS_RPTS, SESSION, tmpl.id() );
 313                 req0.callback(
 314                         function(r0) {
 315                                 var resp = r0.getResultObject();
 316
 317                                 if( resp != '0' ) {
 318                                         obj.deleteTemplates(list, ++idx,
 319                                                 callback, 'oils_rpt_folder_contents_template_no_delete');
 320
 321                                 } else {
 322                                         _debug('deleting template ' + tmpl.id());
 323                                         var req = new Request(OILS_RPT_DELETE_TEMPLATE, SESSION, tmpl.id());
 324                                         req.callback(function(r) {
 325                                                 var res = r.getResultObject();
 326                                                 if( res != 1 ) return oilsRptAlertFailure();
 327                                                 obj.deleteTemplates(list, ++idx, callback, errid)
 328                                         });
 329                                         req.send();
 330                                 }
 331                         }
 332                 );
 333                 req0.send();
 334         }
 335 }
 336
 337
 338
 339 oilsRptFolderWindow.prototype.drawFolderDetails = function() {
 340         appendClear(DOM.oils_rpt_folder_creator_label,
 341                 text(this.folderNode.folder.owner().usrname()));
 342         appendClear(DOM.oils_rpt_folder_name_label,
 343                 text(this.folderNode.folder.name()));
 344 }
 345
 346
 347 oilsRptFolderWindow.prototype.fetchFolderData = function(callback) {
 348         removeChildren(this.selector);
 349         var req = new Request(OILS_RPT_FETCH_FOLDER_DATA,
 350                 SESSION, this.type, this.folderNode.folder.id(), oilsRptOutputLimit);
 351
 352         if(this.type == 'output') {
 353                 req = new Request(OILS_RPT_FETCH_OUTPUT,
 354                         SESSION, this.folderNode.folder.id(), oilsRptOutputLimit);
 355         }
 356
 357         var obj = this;
 358         removeChildren(obj.selector);
 359         req.callback(
 360                 function(r) {
 361                         var res = r.getResultObject();
 362                         if( obj.type == 'output' ) {
 363                                 obj.fleshSchedules(res, 0);
 364                         } else {
 365                                 obj.fmTable = drawFMObjectTable(
 366                                         {
 367                                                 dest : obj.selector,
 368                                                 obj : res,
 369                                                 selectCol : true,
 370                                                 selectColName : 'Select',
 371                                                 selectAllName : 'All',
 372                                                 selectNoneName : 'None'
 373                                         }
 374                                 );
 375                         }
 376                 }
 377         );
 378         req.send();
 379 }
 380
 381
 382 oilsRptFolderWindow.prototype.fleshSchedules = function(list, idx, table) {
 383
 384         if( idx >= list.length ) return;
 385
 386         var sched = list[idx];
 387         var obj = this;
 388
 389         oilsRptFetchUser(sched.runner(),
 390
 391                 function(user) {
 392                         sched.runner(user);
 393                         oilsRptFetchTemplate(sched.report().template(),
 394
 395                                 function(template) {
 396                                         sched.report().template(template);
 397                                         if( idx == 0 ) {
 398                                                 obj.fmTable = drawFMObjectTable(
 399                                                         {
 400                                                                 dest : obj.selector,
 401                                                                 obj : [sched],
 402                                                                 selectCol : true,
 403                                                                 selectColName : 'Select',
 404                                                                 selectAllName : 'All',
 405                                                                 selectNoneName : 'None'
 406                                                         }
 407                                                 );
 408                                         } else {
 409                                                 obj.fmTable.add(sched);
 410                                         }
 411                                         obj.fleshSchedules(list, ++idx);
 412                                 }
 413                         );
 414                 }
 415         );
 416 }
 417
 418
 419 oilsRptFolderWindow.prototype.setSelected = function(folderNode) {
 420         this.selectedFolder = folderNode;
 421 }
 422
 423 oilsRptFolderWindow.prototype.setFolderEditActions = function() {
 424         var folder = this.folderNode.folder;
 425
 426         var obj = this;
 427         DOM.oils_rpt_folder_manager_name_input.value = folder.name();
 428         DOM.oils_rpt_folder_manager_change_name_submit.onclick = function() {
 429                 var name = DOM.oils_rpt_folder_manager_name_input.value;
 430                 if(name) {
 431                         folder.name( name );
 432                         if(confirmId('oils_rpt_folder_manager_change_name_confirm')) {
 433                                 oilsRptUpdateFolder(folder, obj.type,
 434                                         function(success) {
 435                                                 if(success) {
 436                                                         oilsRptAlertSuccess();
 437                                                         oilsRptCurrentFolderManager.draw();
 438                                                 }
 439                                         }
 440                                 );
 441                         }
 442                 }
 443         }
 444
 445         DOM.oils_rpt_folder_manager_sub_lib_create.onclick = function() {
 446                 var folder;
 447
 448                 if( obj.type == 'report' ) folder = new rrf();
 449                 if( obj.type == 'template' ) folder = new rtf();
 450                 if( obj.type == 'output' ) folder = new rof();
 451
 452                 folder.owner(USER.id());
 453                 folder.parent(obj.folderNode.folder.id());
 454                 folder.name(DOM.oils_rpt_folder_manager_sub_name.value);
 455                 var shared = getSelectorVal(DOM.oils_rpt_folder_manager_sub_shared);
 456                 folder.shared( (shared == 'yes') ? 't' : 'f');
 457                 if( folder.shared() == 't' )
 458                         folder.share_with( obj.myOrgSelector.getValue() );
 459
 460                 oilsRptCreateFolder(folder, obj.type,
 461                         function(success) {
 462                                 if(success) {
 463                                         oilsRptAlertSuccess();
 464                                         oilsRptCurrentFolderManager.draw();
 465                                 }
 466                         }
 467                 );
 468         }
 469 }
 470
 471
 472 oilsRptFolderWindow.prototype.doFolderDelete = function() {
 473
 474         var cache = oilsRptFolderNodeCache[this.type];
 475         /* let's see if this folder has any children */
 476         for( var c in cache )
 477                 if( cache[c].folder.parent() == this.folderNode.folder.id() )
 478                         return alertId('oils_rpt_folder_cannot_delete');
 479
 480         /* lets see if the folder has contents */
 481         var req = new Request(OILS_RPT_FETCH_FOLDER_DATA,
 482                 SESSION, this.type, this.folderNode.folder.id(), 1);
 483
 484         if(this.type == 'output') {
 485                 req = new Request(OILS_RPT_FETCH_OUTPUT,
 486                         SESSION, this.folderNode.folder.id(), 1);
 487         }
 488
 489         var obj = this;
 490         req.send();
 491
 492         req.callback(
 493                 function(r) {
 494
 495                         var contents = r.getResultObject();
 496                         if( contents.length > 0 )
 497                                 return alertId('oils_rpt_folder_cannot_delete');
 498
 499                         if( confirmId('oils_rpt_folder_manager_delete_confirm') ) {
 500                                 var req2 = new Request(OILS_RPT_DELETE_FOLDER,
 501                                         SESSION, obj.type, obj.folderNode.folder.id());
 502
 503                                 req2.callback(
 504                                         function(r2) {
 505                                                 var res = r2.getResultObject();
 506                                                 if( res == 1 ) {
 507                                                         oilsRptAlertSuccess();
 508                                                         oilsRptCurrentFolderManager.draw();
 509                                                 }
 510                                                 else alert('error: '+js2JSON(res));
 511                                         }
 512                                 );
 513
 514                                 req2.send();
 515                         }
 516                 }
 517         );
 518 }
 519
 520