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