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