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