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