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