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