modules/yangman-resources/src/main/resources/yangman/controllers/requests-list.controller.js

   1 define([
   2     'app/yangman/controllers/save-req-dialog.controller',
   3     'app/yangman/controllers/edit-collection-dialog.controller',
   4     'app/yangman/controllers/history-settings.controller',
   5     'app/yangman/services/handle-file.services',
   6 ], function (SaveReqDialogCtrl, EditCollectionDialogCtrl, HistorySettingsCtrl) {
   7     'use strict';
   8
   9     angular.module('app.yangman').controller('RequestsListCtrl', RequestsListCtrl);
  10
  11     RequestsListCtrl.$inject = [
  12         '$filter', '$mdDialog', '$scope', 'YMHandleFileService', 'PathUtilsService', 'RequestsService', 'YangmanService',
  13         'YangmanDesignService', 'constants',
  14     ];
  15
  16     /**
  17      * Controller for requests lists, means History requests and Collections requests
  18      * @param $filter
  19      * @param $mdDialog
  20      * @param $scope
  21      * @param YMHandleFileService
  22      * @param PathUtilsService
  23      * @param RequestsService
  24      * @param YangmanService
  25      * @param YangmanDesignService
  26      * @constructor
  27      */
  28     function RequestsListCtrl($filter, $mdDialog, $scope, YMHandleFileService, PathUtilsService, RequestsService,
  29                               YangmanService, YangmanDesignService, constants) {
  30         var vm = this;
  31
  32         vm.collectionList = null;
  33         vm.constants = constants;
  34
  35         vm.requestList = null;
  36         vm.mainList = null;
  37         vm.collectionsSortAsc = true;
  38         vm.search = '';
  39
  40         vm.clearCollectionList = clearCollectionList;
  41         vm.clearFilter = clearFilter;
  42         vm.clearHistoryList = clearHistoryList;
  43         vm.colMatchingReqsCount = colMatchingReqsCount;
  44         vm.deselectAllFilteredRequests = deselectAllFilteredReqs;
  45         vm.downloadCollection = downloadCollection;
  46         vm.executeRequest = executeRequest;
  47         vm.fakeFilter = fakeFilter;
  48         vm.filterCol = filterCol;
  49         vm.filterColName = filterColName;
  50         vm.filterReq = filterReq;
  51         vm.init = init;
  52         vm.readCollectionFromFile = readCollectionFromFile;
  53         vm.selectAllFilteredRequests = selectAllFilteredReqs;
  54         vm.selectRequest = selectRequest;
  55         vm.showData = showData;
  56         vm.showDgDeleteCollection = showDgDeleteCollection;
  57         vm.showDgDeleteRequests = showDgDeleteRequests;
  58         vm.showDgEditCollection = showDgEditCollection;
  59         vm.showDgSaveReq = showDgSaveReq;
  60         vm.showHistorySettings = showHistorySettings;
  61         vm.showForm = showForm;
  62         vm.toggleCollectionsSort = toggleCollectionsSort;
  63         vm.selectOnlyThisRequest = selectOnlyThisRequest;
  64         vm.deselectAllRequests = deselectAllRequests;
  65         vm.filterCollReq = filterCollReq;
  66
  67         /**
  68          * Save request obje to collection from other controller
  69          * @param reqObj
  70          */
  71         function saveRequestFromExt(event, args) {
  72             vm.showDgSaveReq(args.params.event, args.params.reqObj, false);
  73         }
  74
  75
  76         /**
  77          * Clear history requests list and save to storage
  78          */
  79         function clearHistoryList(event) {
  80
  81             YangmanDesignService.disableMdMenuItem(event);
  82
  83             var confirm = $mdDialog.confirm()
  84                 .title($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TITLE'))
  85                 .textContent($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TEXT'))
  86                 .ariaLabel($filter('translate')('YANGMAN_DELETE_HISTORY_CONFIRM_TITLE'))
  87                 .targetEvent(event)
  88                 .ok($filter('translate')('YANGMAN_OK'))
  89                 .cancel($filter('translate')('YANGMAN_CANCEL'));
  90
  91             $mdDialog.show(confirm)
  92             .then(function (){
  93                 vm.requestList.clear();
  94                 vm.requestList.saveToStorage();
  95                 loadHistoryList();
  96             })
  97             .then(YangmanDesignService.enableMdMenuItem(event));
  98         }
  99
 100         /**
 101          * Clear collections requests list and save to storage
 102          */
 103         function clearCollectionList(event) {
 104             var confirm = $mdDialog.confirm()
 105                 .title($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TITLE'))
 106                 .textContent($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TEXT'))
 107                 .ariaLabel($filter('translate')('YANGMAN_DELETE_COLLECTION_CONFIRM_TITLE'))
 108                 .targetEvent(event)
 109                 .ok($filter('translate')('YANGMAN_OK'))
 110                 .cancel($filter('translate')('YANGMAN_CANCEL'));
 111
 112             YangmanDesignService.disableMdMenuItem(event);
 113
 114             $mdDialog.show(confirm)
 115             .then(function (){
 116                 vm.collectionList.clear();
 117                 vm.collectionList.saveToStorage();
 118                 $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS);
 119             })
 120             .then(YangmanDesignService.enableMdMenuItem(event));
 121         }
 122
 123         /**
 124          * Create history request from other ctrl
 125          * @param broadcastEvent
 126          * @param params
 127          */
 128         function saveBcstedHistoryRequest(broadcastEvent, params) {
 129             vm.requestList.addItemToList(params.params);
 130             vm.requestList.saveToStorage();
 131             (params.cbk || angular.noop)();
 132         }
 133
 134         /**
 135          * Clear value of input file used to import collection
 136          */
 137         function clearFileInputValue(){
 138             angular.element(document).find('#importCollection').val('');
 139         }
 140
 141         /**
 142          * Importing collection from a file
 143          * @param $fileContent
 144          */
 145         function readCollectionFromFile($fileContent) {
 146             var data = $fileContent;
 147
 148             if (data && YangmanService.validateFile(data, constants.COLLECTION_CHECK_ARRAY)){
 149                 try {
 150                     vm.collectionList.loadListFromFile(data);
 151                     vm.collectionList.saveToStorage();
 152                     $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS);
 153                     clearFileInputValue();
 154                 }
 155                 catch (e) {
 156                     clearFileInputValue();
 157                     console.error('DataStorage error:', e);
 158                 }
 159             }
 160             else {
 161                 clearFileInputValue();
 162             }
 163             removeButtonBackground();
 164
 165             function removeButtonBackground() {
 166                 $('#importCollection').next().css({ 'background': 'transparent' });
 167             }
 168         }
 169
 170         function toggleCollectionsSort() {
 171             vm.collectionsSortAsc = !vm.collectionsSortAsc;
 172         }
 173
 174         /**
 175          * Export collection to json file
 176          * @param {Collection} collection
 177          */
 178         function downloadCollection(collection) {
 179
 180             var cListJSON = vm.collectionList.getCollectionInRawJSON(collection.name);
 181
 182             YMHandleFileService.downloadFile(collection.name + '.json', cListJSON, 'json', 'charset=utf-8',
 183                 function (){},
 184                 function (e){
 185                     console.error('ExportCollection error:', e);
 186                 }
 187             );
 188         }
 189
 190         /**
 191          * Fill request form in right panel with request data
 192          * @param reqObj
 193          * @param preventFillingWithReceived
 194          */
 195         function showForm(reqObj, preventFillingWithReceived) {
 196             var data = reqObj.sentData;
 197
 198             if ($scope.historySettings.data.fillWithReceived && !preventFillingWithReceived) {
 199                 data = reqObj.receivedData;
 200             }
 201
 202             $scope.rootBroadcast(
 203                 constants.YANGMAN_SET_CODEMIRROR_DATA_RECEIVED, { data: reqObj.setDataForView(reqObj.receivedData) }
 204             );
 205             $scope.rootBroadcast(
 206                 constants.YANGMAN_SET_CODEMIRROR_DATA_SENT, { data: reqObj.setDataForView(reqObj.sentData) }
 207             );
 208
 209             $scope.rootBroadcast(constants.YANGMAN_SET_ERROR_DATA,
 210                 reqObj.receivedData && reqObj.receivedData.hasOwnProperty('errors') ? reqObj.receivedData : {});
 211
 212             $scope.rootBroadcast(constants.YANGMAN_FILL_NODE_FROM_REQ, { requestUrl: reqObj.path, requestData: data },
 213                 function (){
 214                     $scope.setRightPanelSection(constants.DISPLAY_TYPE_FORM);
 215                     $scope.rootBroadcast(constants.YANGMAN_HEADER_INIT, {
 216                         path: reqObj.path,
 217                         method: reqObj.method,
 218                         statusObj: {
 219                             status: reqObj.responseStatus,
 220                             statusText: reqObj.responseStatusText,
 221                             time: reqObj.responseTime,
 222                         },
 223                     });
 224
 225                     if ( $scope.node ) {
 226                         // prepare data for filling form
 227                         if ($scope.node.type === constants.NODE_RPC && $scope.historySettings.data.fillWithReceived) {
 228                             data = YangmanService.prepareReceivedData(
 229                                 $scope.node,
 230                                 reqObj.method,
 231                                 reqObj.receivedData,
 232                                 reqObj.sentData,
 233                                 constants.DISPLAY_TYPE_FORM
 234                             );
 235                         }
 236
 237                         // try to fill node
 238                         YangmanService.fillNodeFromResponse($scope.node, data);
 239                         $scope.node.expanded = true;
 240                     }
 241
 242                 }
 243             );
 244
 245         }
 246
 247         /**
 248          * Force request header to execute request with data from reqObj
 249          * @param reqObj
 250          */
 251         function executeRequest(reqObj) {
 252             if ($scope.rightPanelSection === constants.DISPLAY_TYPE_FORM) {
 253                 showForm(reqObj, true);
 254             }
 255             else {
 256                 showData(reqObj);
 257             }
 258             $scope.rootBroadcast(constants.YANGMAN_EXECUTE_WITH_DATA,{ data: reqObj.sentData });
 259         }
 260
 261         /**
 262          * Method for setup data into CM, Header, find api, subapi, node
 263          * @param reqObj
 264          * @param status
 265          */
 266         function showData(reqObj, select){
 267             var headerObj = {
 268                 path: reqObj.path,
 269                 method: reqObj.method,
 270             };
 271
 272             // action select request
 273             if ( select ) {
 274                 headerObj.statusObj = {
 275                     status: reqObj.responseStatus,
 276                     statusText: reqObj.responseStatusText,
 277                     time: reqObj.responseTime,
 278                 };
 279
 280                 $scope.rootBroadcast(
 281                     constants.YANGMAN_SET_ERROR_DATA,
 282                     reqObj.receivedData && reqObj.receivedData.hasOwnProperty('errors') ? reqObj.receivedData : {}
 283                 );
 284             }
 285
 286             $scope.setRightPanelSection(constants.DISPLAY_TYPE_REQ_DATA);
 287             $scope.setJsonView(true, reqObj.method !== constants.OPERATION_GET);
 288
 289             $scope.rootBroadcast(constants.YANGMAN_HEADER_INIT, headerObj);
 290             $scope.rootBroadcast(constants.YANGMAN_FILL_NODE_FROM_REQ, { requestUrl: reqObj.path });
 291
 292             $scope.rootBroadcast(
 293                 constants.YANGMAN_SET_CODEMIRROR_DATA_RECEIVED,
 294                 { data: reqObj.setDataForView(reqObj.receivedData) }
 295             );
 296
 297             $scope.rootBroadcast(
 298                 constants.YANGMAN_SET_CODEMIRROR_DATA_SENT,
 299                 { data: reqObj.setDataForView(reqObj.sentData) }
 300             );
 301         }
 302
 303         /**
 304          * Clear current ctrl search value
 305          */
 306         function clearFilter(){
 307             vm.search = '';
 308         }
 309
 310         /**
 311          * Dialog for deleting either selected requests or reqObj
 312          *
 313          * @param event
 314          * @param reqObj
 315          */
 316         function showDgDeleteRequests(event, reqObj){
 317
 318             var confirm = $mdDialog.confirm()
 319                 .title($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TITLE'))
 320                 .textContent($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TEXT'))
 321                 .ariaLabel($filter('translate')('YANGMAN_DELETE_REQ_CONFIRM_TITLE'))
 322                 .targetEvent(event)
 323                 .ok($filter('translate')('YANGMAN_OK'))
 324                 .cancel($filter('translate')('YANGMAN_CANCEL'));
 325
 326             YangmanDesignService.disableMdMenuItem(event);
 327
 328             $mdDialog.show(confirm)
 329             .then(function (){
 330                     deleteRequestsAndReload(reqObj);
 331             })
 332             .then(YangmanDesignService.enableMdMenuItem(event));
 333         }
 334
 335
 336         /**
 337          * Dialog for deleting collection and refreshing collections
 338          * @param ev
 339          * @param collObj
 340          */
 341         function showDgDeleteCollection(ev, collObj){
 342             var confirm = $mdDialog.confirm()
 343                 .title($filter('translate')('YANGMAN_DELETE_COL_CONFIRM_TITLE') + ' ' + collObj.name + '?')
 344                 .textContent($filter('translate')('YANGMAN_DELETE_COL_CONFIRM_TEXT'))
 345                 .ariaLabel($filter('translate')('YANGMAN_DELETE_COL_CONFIRM_TITLE'))
 346                 .targetEvent(ev)
 347                 .ok($filter('translate')('YANGMAN_OK'))
 348                 .cancel($filter('translate')('YANGMAN_CANCEL'));
 349
 350             YangmanDesignService.disableMdMenuItem(ev);
 351
 352             $mdDialog.show(confirm)
 353             .then(function (){
 354                 vm.collectionList.deleteCollection(collObj);
 355                 vm.collectionList.saveToStorage();
 356                 refreshCollectionsWithExpansion();
 357             })
 358             .then(YangmanDesignService.enableMdMenuItem(ev));
 359         }
 360
 361         /**
 362          * Check if reqObj matches current search value
 363          * @param reqObj
 364          * @returns {boolean}
 365          */
 366         function filterReq(reqObj){
 367             var searchPhrase = vm.search.toLocaleLowerCase();
 368             return reqObj.path.toLowerCase().indexOf(searchPhrase) > -1 ||
 369                 reqObj.collection.toLowerCase().indexOf(searchPhrase) > -1 ||
 370                 reqObj.method.toLowerCase() === searchPhrase;
 371         }
 372
 373         /**
 374          * Check if collection name matches current search value or any collection req matches
 375          * @param colObj
 376          */
 377         function filterCol(colObj){
 378             return filterColName(colObj) || colObj.data.some(filterReq);
 379         }
 380
 381         /**
 382          * Get count of requests matching filter in collection colObj
 383          * @param colObj
 384          * @returns {*}
 385          */
 386         function colMatchingReqsCount(colObj){
 387             return colObj.data.filter(vm.filterReq).length;
 388         }
 389
 390         /**
 391          * Check if collection name matches current filter
 392          * @param colObj
 393          * @returns {boolean}
 394          */
 395         function filterColName(colObj){
 396             return colObj.name.toLowerCase().indexOf(vm.search.toLowerCase()) > -1;
 397         }
 398
 399         /**
 400          * Returns true
 401          * @returns {boolean}
 402          */
 403         function fakeFilter(){
 404             return true;
 405         }
 406
 407
 408         /**
 409          * Show dialog for saving reqObj to collection (used for duplicate req too)
 410          * @param ev
 411          * @param reqObj
 412          * @param duplicate
 413          */
 414         function showDgSaveReq(ev, reqObj, duplicate){
 415
 416             $mdDialog.show({
 417                 controller: SaveReqDialogCtrl,
 418                 controllerAs: 'dialog',
 419                 templateUrl: $scope.globalViewPath + 'leftpanel/save-req-dialog.tpl.html',
 420                 parent: angular.element('#yangmanModule'),
 421                 targetEvent: ev,
 422                 clickOutsideToClose: true,
 423                 locals: {
 424                     requests: reqObj ? [reqObj] : vm.mainList.getSelectedItems(
 425                         vm.mainList === vm.collectionList ? filterCollReq : filterReq
 426                     ),
 427                     collectionNames: vm.collectionList.getCollectionNames(),
 428                     duplicate: duplicate || false,
 429                 },
 430             }).then(saveRequests);
 431         }
 432
 433         /**
 434          * Show popup window for history requests settings
 435          * @param ev
 436          */
 437         function showHistorySettings(ev){
 438
 439             $mdDialog.show({
 440                 controller: HistorySettingsCtrl,
 441                 controllerAs: 'settingsCtrl',
 442                 templateUrl: $scope.globalViewPath + 'leftpanel/history-settings.tpl.html',
 443                 parent: angular.element('#yangmanModule'),
 444                 targetEvent: ev,
 445                 clickOutsideToClose: true,
 446                 locals: {
 447                     settingsObj: $scope.historySettings,
 448                 },
 449             }).then(function (changedSettings){
 450                 $scope.historySettings.setData(changedSettings.data);
 451                 $scope.rootBroadcast(constants.YANGMAN_RESET_HISTORY_SETTINGS);
 452             });
 453         }
 454
 455         /**
 456          * Add each request from requests array to collectionList and save
 457          * @param requests
 458          */
 459         function saveRequests(requests){
 460             requests.forEach(function (reqObj){
 461                 vm.collectionList.addItemToList(RequestsService.clearUnnecessaryProperties(reqObj.clone()));
 462                 vm.collectionList.saveToStorage();
 463                 refreshCollectionsWithExpansion();
 464             });
 465         }
 466
 467
 468         /**
 469          * Dialog for editing collection name (used for duplicating collection too)
 470          * @param ev
 471          * @param collection
 472          * @param {boolean} duplicate
 473          */
 474         function showDgEditCollection(ev, collection, duplicate){
 475             $mdDialog.show({
 476                 controller: EditCollectionDialogCtrl,
 477                 controllerAs: 'dialog',
 478                 templateUrl: $scope.globalViewPath + 'leftpanel/edit-collection-dialog.tpl.html',
 479                 parent: angular.element('#yangmanModule'),
 480                 targetEvent: ev,
 481                 clickOutsideToClose: true,
 482                 locals: {
 483                     collection: collection,
 484                     allCollections: vm.collectionList.collections,
 485                     duplicate: duplicate,
 486                 },
 487             }).then(duplicate ? duplicateCollection : changeCollectionName);
 488         }
 489
 490         /**
 491          * Rename collection
 492          * @param {array} names 0. element is old name, 1. element is new name
 493          */
 494         function changeCollectionName(names){
 495             vm.collectionList.renameCollection(names[0], names[1]);
 496             vm.collectionList.saveToStorage();
 497             refreshCollectionsWithExpansion();
 498         }
 499
 500         /**
 501          * Create collection duplicate, save and refresh collections
 502          * @param {array} names 0. element is old name, 1. element is new name
 503          */
 504         function duplicateCollection(names){
 505             vm.collectionList.duplicateCollection(names[0], names[1]);
 506             vm.collectionList.saveToStorage();
 507             refreshCollectionsWithExpansion();
 508         }
 509
 510
 511         function selectNewestRequest() {
 512             vm.mainList.toggleReqSelection(true, vm.mainList.getNewestRequest());
 513         }
 514
 515         function loadCollectionsList() {
 516             vm.collectionList.loadListFromStorage();
 517         }
 518
 519         function loadHistoryList() {
 520             vm.requestList.loadListFromStorage();
 521         }
 522
 523         /**
 524          *
 525          * @param mainList collectionList or requestList object
 526          */
 527         function init(mainList){
 528
 529             vm.collectionList = RequestsService.createEmptyCollectionList('yangman_collectionsList');
 530             // collections are loaded for both history and collections tab
 531             loadCollectionsList();
 532
 533             vm.requestList = RequestsService.createEmptyHistoryList('yangman_requestsList', $scope.historySettings);
 534
 535             $scope.$on(constants.YANGMAN_RESET_HISTORY_SETTINGS, function () {
 536                 vm.requestList.setSettings($scope.historySettings);
 537             });
 538
 539             // if request was selected, deselect requests in all other instances of RequestsListCtrl
 540             $scope.$on(constants.YANGMAN_DESELECT_REQUESTS, function (event, params) {
 541                 if (params.params.broadcastingCtrl !== vm) {
 542                     deselectAllRequests();
 543                 }
 544             });
 545
 546             $scope.$on(constants.YANGMAN_REFRESH_COLLECTIONS, function (event, params){
 547                 loadCollectionsList();
 548                 (params.cbk || angular.noop)();
 549             });
 550
 551             // list type dependend operations
 552             if (mainList === 'history') {
 553
 554                 vm.mainList = vm.requestList;
 555                 loadHistoryList();
 556
 557                 $scope.$on(constants.YANGMAN_REFRESH_HISTORY, loadHistoryList);
 558                 // saving from request header after execution
 559                 $scope.$on(constants.YANGMAN_SAVE_EXECUTED_REQUEST, saveBcstedHistoryRequest);
 560                 // select newest request
 561                 $scope.$on(constants.YANGMAN_SELECT_THE_NEWEST_REQUEST, selectNewestRequest);
 562             }
 563             else {
 564                 vm.mainList = vm.collectionList;
 565                 // saving from request header
 566                 $scope.$on(constants.YANGMAN_SAVE_REQUEST_TO_COLLECTION, saveRequestFromExt);
 567                 // saving collections expanded status on refresh
 568                 $scope.$on(constants.YANGMAN_REFRESH_AND_EXPAND_COLLECTIONS, function(){
 569                     var expandedColNames = vm.collectionList.getExpandedCollectionNames();
 570                     $scope.rootBroadcast(constants.YANGMAN_REFRESH_COLLECTIONS, {}, function (){
 571                         vm.collectionList.expandCollectionByNames(expandedColNames);
 572                     });
 573                 });
 574             }
 575
 576         }
 577
 578
 579         /**
 580          * Request in list selection
 581          * For history reqs it is possible multiselect, thats why event.ctrlKey is used
 582          * @param event
 583          * @param requestObj
 584          */
 585         function selectRequest(event, requestObj){
 586             console.debug('selected', requestObj);
 587
 588             $scope.rootBroadcast(constants.YANGMAN_DESELECT_REQUESTS, { broadcastingCtrl: vm });
 589             vm.mainList.toggleReqSelection(!event.ctrlKey, requestObj);
 590             if (!event.ctrlKey){
 591                 if ($scope.rightPanelSection === constants.DISPLAY_TYPE_FORM) {
 592                     vm.showForm(requestObj);
 593                 }
 594                 else {
 595                     vm.showData(requestObj, true);
 596                 }
 597             }
 598         }
 599
 600         /**
 601          * Mark only requestObj in current list as selected
 602          * Used for example when user clicks on request submenu
 603          * @param requestObj
 604          */
 605         function selectOnlyThisRequest(requestObj){
 606             vm.mainList.toggleReqSelection(true, requestObj);
 607         }
 608
 609         /**
 610          * Deselect history requests
 611          */
 612         function deselectAllFilteredReqs(){
 613             vm.mainList.deselectAllFilteredItems(vm.mainList === vm.collectionList ? filterCollReq : vm.filterReq);
 614         }
 615
 616         function deselectAllRequests() {
 617             vm.mainList.deselectAllItems();
 618         }
 619
 620         /**
 621          * Select history requests
 622          */
 623         function selectAllFilteredReqs(){
 624             vm.mainList.selectAllFilteredItems(vm.mainList === vm.collectionList ? filterCollReq : vm.filterReq);
 625         }
 626
 627         /**
 628          * Use when selecting filtered requests if they are saved to some collection
 629          * Additional filter is if the collection of the request is expanded
 630          * @param request
 631          * @returns {*|boolean}
 632          */
 633         function filterCollReq(request) {
 634             return vm.collectionList.getCollection(request.collection).expanded && vm.filterReq(request);
 635         }
 636
 637         /**
 638          * Refresh and expand collections
 639          */
 640         function refreshCollectionsWithExpansion(){
 641             $scope.rootBroadcast(constants.YANGMAN_REFRESH_AND_EXPAND_COLLECTIONS);
 642         }
 643
 644         function deleteRequestsAndReload(reqObj) {
 645             if (reqObj){
 646                 vm.mainList.deleteRequestItem(reqObj);
 647             }
 648             else {
 649                 vm.mainList.getSelectedItems(
 650                     vm.mainList === vm.collectionList ? filterCollReq : filterReq
 651                 ).forEach(function (elem){
 652                     vm.mainList.deleteRequestItem(elem);
 653                 });
 654             }
 655             vm.mainList.saveToStorage();
 656
 657             if (vm.mainList === vm.requestList) {
 658                 loadHistoryList();
 659             }
 660             else {
 661                 refreshCollectionsWithExpansion();
 662             }
 663         }
 664     }
 665
 666 });