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