modules/yangman-resources/src/main/resources/yangman/controllers/request-header.controller.js

   1 define([
   2     'app/yangman/controllers/params-admin.controller',
   3     'app/yangman/services/time-tracking.services',
   4 ], function (ParamsAdminCtrl) {
   5     'use strict';
   6
   7     angular.module('app.yangman').controller('RequestHeaderCtrl', RequestHeaderCtrl);
   8
   9     RequestHeaderCtrl.$inject = [
  10         '$mdDialog', '$mdToast', '$scope', '$rootScope', 'ENV', 'YangmanService', 'ParametersService',
  11         'PathUtilsService', 'RequestsService', '$filter', 'DataBackupService', 'constants', 'TimeTrackingService'
  12     ];
  13
  14     function RequestHeaderCtrl($mdDialog, $mdToast, $scope, $rootScope, ENV, YangmanService, ParametersService,
  15                                PathUtilsService, RequestService, $filter, DataBackupService, constants,
  16                                TimeTrackingService) {
  17         var requestHeader = this;
  18
  19         requestHeader.allOperations = [constants.OPERATION_GET, constants.OPERATION_POST, constants.OPERATION_PUT, constants.OPERATION_DELETE];
  20         requestHeader.constants = constants;
  21         requestHeader.urlChanged = false;
  22         requestHeader.executedOperation = null;
  23         requestHeader.selectedOperationsList = [];
  24         requestHeader.selectedOperation = null;
  25         requestHeader.requestUrl = '';
  26         requestHeader.selectedPluginsButtons = [];
  27         requestHeader.selectedPlugin = null;
  28         requestHeader.statusObj = null;
  29
  30         // methods
  31         requestHeader.executeOperation = executeOperation;
  32         requestHeader.executePluginFunctionality = executePluginFunctionality;
  33         requestHeader.fillNodeData = fillNodeData;
  34         requestHeader.changeDataType = changeDataType;
  35         requestHeader.prepareDataAndExecute = prepareDataAndExecute;
  36         requestHeader.initMountPoint = initMountPoint;
  37         requestHeader.setJsonView = setJsonView;
  38         requestHeader.setRequestUrl = setRequestUrl;
  39         requestHeader.showParamsAdmin = showParamsAdmin;
  40         requestHeader.saveRequestToCollection = saveRequestToCollection;
  41         requestHeader.unsetPluginFunctionality = unsetPluginFunctionality;
  42
  43         // watchers
  44         /**
  45          * Set selected operations based on data store
  46          */
  47         $scope.$on(constants.SET_SEL_OPERATIONS, function (event, operations, setUrl) {
  48             setAllowedMethods(operations);
  49
  50             if ( setUrl ) {
  51                 setRequestUrl();
  52             }
  53         });
  54
  55         /**
  56          * Watching for changes in shown detail data type (radio button)
  57          */
  58         $scope.$on(constants.YANGMAN_HEADER_INIT, function (event, args) {
  59             init();
  60             setRequestUrl(args.params.path);
  61             setRequestMethod(args.params.method);
  62             setRequestStatus(args.params.statusObj);
  63             setJsonView();
  64             (args.cbk || angular.noop)();
  65         });
  66
  67         $scope.$on(constants.YANGMAN_FILL_NODE_FROM_REQ, function (event, args) {
  68             setNodeDataFromRequestData(args.params.requestUrl, args.params.leftpanel);
  69             (args.cbk || angular.noop)();
  70         });
  71
  72         $scope.$on(constants.YANGMAN_EXECUTE_WITH_DATA, function (event, args) {
  73             executeOperation(args.params.data ? angular.fromJson(args.params.data) : {}, args.cbk);
  74         });
  75
  76         init();
  77
  78         /**
  79          * Setter for selected operation
  80          * @param method
  81          */
  82         function setRequestMethod(method){
  83             requestHeader.selectedOperation = method;
  84         }
  85
  86         /**
  87          * Setter for request status
  88          * @param statusObj
  89          */
  90         function setRequestStatus(statusObj){
  91             requestHeader.statusObj = statusObj;
  92         }
  93
  94         /**
  95          * Show popup for parameters administration
  96          * @param event
  97          */
  98         function showParamsAdmin(event) {
  99             $mdDialog.show({
 100                 controller: ParamsAdminCtrl,
 101                 controllerAs: 'paramsAdmin',
 102                 templateUrl: $scope.globalViewPath + 'popup/parameters-admin.tpl.html',
 103                 parent: angular.element('#yangmanModule'),
 104                 targetEvent: event,
 105                 clickOutsideToClose: true,
 106                 locals: {
 107                     parametersList: $scope.parametersList,
 108                 },
 109             }).then(
 110                 function (){
 111                     $scope.parametersList.loadListFromStorage();
 112                 },
 113                 function (){
 114                     $scope.parametersList.loadListFromStorage();
 115                 }
 116             );
 117         }
 118
 119         /**
 120          * Method for selecting correct json view by selected operation
 121          */
 122         function setJsonView(){
 123             var both = [constants.OPERATION_PUT, constants.OPERATION_POST];
 124
 125             if ( both.indexOf(requestHeader.selectedOperation) > -1 ){
 126                 $scope.setJsonView(true, true);
 127             } else {
 128                 $scope.setJsonView(true, false);
 129             }
 130         }
 131
 132         /**
 133          * Change displayed data type to json or form, after switching set current data to be displayed
 134          */
 135         function changeDataType(){
 136             $scope.switchSection('rightPanelSection', requestHeader.selectedShownDataType);
 137
 138             if(!$scope.node || requestHeader.urlChanged) {
 139                 requestHeader.setRequestUrl();
 140                 requestHeader.urlChanged = false;
 141             }
 142
 143             // if changing to json, fill codemirror data
 144             if ( requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA && $scope.node ){
 145                 setJsonView();
 146                 sendRequestData($scope.buildRootRequest(), 'SENT');
 147             }
 148
 149             // if changing to form, try to fill node data
 150             if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM) {
 151                 var reqData = {};
 152
 153                 reqData = getDataForForm();
 154                 setNodeDataFromRequestData(requestHeader.requestUrl);
 155
 156                 if ( $scope.node ) {
 157
 158                     YangmanService.fillNodeFromResponse($scope.node, reqData);
 159                     $scope.node.expanded = true;
 160                 }
 161             }
 162         }
 163
 164         /**
 165          * Helper method for building correct json data for form, rpc included
 166          * @returns {*}
 167          */
 168         function getDataForForm(){
 169             var params = {
 170                     reqData: null,
 171                 },
 172                 dataTypeFunc = {
 173                     rpc: function () {
 174                         var sentData = { reqData: null },
 175                             allData = { sent: null, received: null };
 176
 177                         $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA_RECEIVED, params);
 178                         $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA_SENT, sentData);
 179
 180                         allData.sent = sentData.reqData ? angular.fromJson(sentData.reqData) : {};
 181                         allData.received = params.reqData ? angular.fromJson(params.reqData) : {};
 182
 183                         return YangmanService.prepareReceivedData(
 184                             $scope.node,
 185                             requestHeader.selectedOperation,
 186                             allData.received,
 187                             allData.sent,
 188                             requestHeader.selectedShownDataType
 189                         );
 190                     },
 191                     default: function (){
 192                         var dataType;
 193                         if(requestHeader.executedOperation) {
 194                             dataType = requestHeader.executedOperation === constants.OPERATION_GET ? constants.REQUEST_DATA_TYPE_RECEIVED : 'SENT';
 195                         }
 196                         else {
 197                             dataType = requestHeader.selectedOperation === constants.OPERATION_GET ? constants.REQUEST_DATA_TYPE_RECEIVED : 'SENT';
 198                         }
 199
 200                         $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA + dataType, params);
 201                         return params.reqData ? angular.fromJson(params.reqData) : {};
 202                     },
 203                 };
 204
 205             return $scope.node ? (dataTypeFunc[$scope.node.type] || dataTypeFunc.default)() : {};
 206         }
 207
 208         /**
 209          * Send data to codemirror
 210          * @param data
 211          */
 212         function sendRequestData(data, type){
 213             $scope.rootBroadcast(
 214                 constants.YANGMAN_SET_CODEMIRROR_DATA + type,
 215                 { data: data instanceof Object ? JSON.stringify(data, null, 4) : data }
 216             );
 217         }
 218
 219         function sendErrorData(response) {
 220             $scope.rootBroadcast(constants.YANGMAN_SET_ERROR_DATA, response);
 221         }
 222
 223         /**
 224          * Create empty parameters list, load from local storage and set to $scope
 225          */
 226         function initParams(){
 227             $scope.parametersList.loadListFromStorage();
 228         }
 229
 230         /**
 231          * Initialization
 232          */
 233         function init(){
 234             setAllowedMethods(requestHeader.allOperations);
 235             initParams();
 236             requestHeader.selectedShownDataType = $scope.rightPanelSection;
 237         }
 238
 239         /**
 240          * Set allowed operations for request
 241          * @param operations
 242          */
 243         function setAllowedMethods(operations){
 244             requestHeader.selectedOperationsList = operations.length ? operations : requestHeader.allOperations;
 245             if (operations.indexOf(requestHeader.selectedOperation) === -1){
 246                 requestHeader.selectedOperation = requestHeader.selectedOperationsList[0];
 247             }
 248         }
 249
 250         /**
 251          * Set header request url if json selected
 252          */
 253         function setRequestUrl(path){
 254             requestHeader.requestUrl = path || ($scope.selectedSubApi ?
 255                     ENV.getBaseURL('MD_SAL') + '/restconf/' + $scope.selectedSubApi.buildApiRequestString() : '');
 256         }
 257
 258
 259         /**
 260          * Try to set api, module, dataStore and node, if api indexes for request url available
 261          * and set (or unset) module detail panel to be displayed
 262          * @param requestUrl url to try to find
 263          * @param leftpanel index of main left tabs to be displayed (we dont want to display module detail in all cases)
 264          */
 265         function setNodeDataFromRequestData(requestUrl, leftpanel){
 266
 267             setApiByUrl(requestUrl, function (treeApis) {
 268                 // set module
 269                 $scope.setModule($filter('filter')(treeApis, { label: $scope.selectedApi.module })[0]);
 270
 271                 // set datastore
 272                 $scope.setDataStore(
 273                     $filter('filter')(
 274                         $scope.selectedModule.children,
 275                         { label: $scope.selectedSubApi.storage })[0],
 276                     true,
 277                     leftpanel
 278                 );
 279
 280                 // set node
 281                 $scope.setNode($scope.selectedSubApi.node);
 282
 283                 // fill subapi path
 284                 PathUtilsService.fillPath($scope.selectedSubApi.pathArray, requestUrl);
 285                 setRequestUrl();
 286             });
 287         }
 288
 289         function setApiByUrl(url, cbk, fill){
 290             $scope.rootBroadcast(constants.YANGMAN_GET_API_TREE_DATA, null, function (treeApis) {
 291                 var apisIndexes =
 292                     PathUtilsService.searchNodeByPath(url, treeApis, null, true, true);
 293
 294                 if ( apisIndexes ) {
 295
 296                     // set apis
 297                     $scope.setApi(
 298                         $scope.apis[apisIndexes.indexApi],
 299                         $scope.apis[apisIndexes.indexApi].subApis[apisIndexes.indexSubApi]
 300                     );
 301
 302                     if ( $scope.selectedSubApi && fill ) {
 303                         var updatedUrl = YangmanService.cutUrl(url);
 304                         PathUtilsService.fillPath($scope.selectedSubApi.pathArray, updatedUrl);
 305
 306                     }
 307
 308                     (cbk || angular.noop)(treeApis);
 309                 }
 310             });
 311         }
 312
 313         function saveRequestToCollection(event) {
 314             var historyReq = null,
 315                 sentData = { reqData: null },
 316                 receivedData = { reqData: null };
 317
 318             if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM) {
 319                 requestHeader.setRequestUrl();
 320             }
 321
 322             historyReq = RequestService.createHistoryRequest(
 323                 null, null, requestHeader.requestUrl, requestHeader.selectedOperation, '', '', ''
 324             );
 325
 326             $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA_SENT, sentData);
 327             $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA_RECEIVED, receivedData);
 328
 329             RequestService.fillRequestByMethod(
 330                 historyReq, sentData, receivedData, requestHeader.selectedOperation, $scope.node,
 331                 requestHeader.selectedShownDataType
 332             );
 333
 334             $scope.rootBroadcast(constants.YANGMAN_SAVE_REQUEST_TO_COLLECTION, { event: event, reqObj: historyReq });
 335         }
 336
 337         function showRequestProgress(){
 338             $scope.rootBroadcast(constants.YANGMAN_EXECUTING_REQUEST_PROGRESS_START);
 339         }
 340
 341
 342         function finishRequestProgress(message){
 343             $scope.rootBroadcast(constants.YANGMAN_EXECUTING_REQUEST_PROGRESS_STOP);
 344         }
 345
 346         /**
 347          * Execute request operation
 348          */
 349         function executeOperation(requestData, executeCbk){
 350             TimeTrackingService.startTimer();
 351             var allowExecuteOperation =
 352                 requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM && $scope.selectedSubApi ?
 353                     !PathUtilsService.checkEmptyIdentifiers($scope.selectedSubApi.pathArray) : true;
 354
 355             if ( allowExecuteOperation ) {
 356
 357                 showRequestProgress();
 358                 setRequestUrl(requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA ? requestHeader.requestUrl : null);
 359                 $scope.rootBroadcast(constants.YANGMAN_SET_ERROR_MESSAGE, '');
 360
 361                 if ( requestHeader.selectedShownDataType !== constants.DISPLAY_TYPE_FORM ){
 362                     setApiByUrl(requestHeader.requestUrl, null, true);
 363                 }
 364
 365                 var historyReq = RequestService.createHistoryRequest(null, null, requestHeader.requestUrl,
 366                     requestHeader.selectedOperation, '', '', '');
 367
 368                 YangmanService.executeRequestOperation(
 369                     $scope.selectedApi,
 370                     $scope.selectedSubApi,
 371                     requestHeader.selectedOperation,
 372                     $scope.node,
 373                     requestHeader.selectedShownDataType,
 374                     requestHeader.requestUrl,
 375                     requestData,
 376                     $scope.parametersList,
 377                     executeReqSuccCbk,
 378                     executeReqErrCbk
 379                 );
 380                 requestHeader.executedOperation = requestHeader.selectedOperation;
 381             } else {
 382                 $scope.rootBroadcast(
 383                     constants.YANGMAN_SET_ERROR_MESSAGE,
 384                     $filter('translate')(constants.YANGMAN_ERROR_EMPTY_IDENTIFIERS)
 385                 );
 386             }
 387
 388             /**
 389              * Success callback after executin operation
 390              * @param reqInfo
 391              * @param response
 392              */
 393             function executeReqSuccCbk(reqInfo, response) {
 394                 var preparedReceivedData = YangmanService.prepareReceivedData(
 395                     $scope.node,
 396                     requestHeader.selectedOperation,
 397                     response.data ? response.data.plain() : {},
 398                     reqInfo.requestSrcData,
 399                     requestHeader.selectedShownDataType
 400                 );
 401
 402                 finishRequestProgress();
 403
 404                 requestHeader.statusObj = reqInfo;
 405
 406                 sendErrorData({});
 407
 408                 if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA){
 409
 410                     setNodeDataFromRequestData(requestHeader.requestUrl);
 411                     sendRequestData(preparedReceivedData, constants.REQUEST_DATA_TYPE_RECEIVED);
 412                     sendRequestData(reqInfo.requestSrcData || {}, 'SENT');
 413                 } else {
 414
 415                     if ($scope.node){
 416
 417                         YangmanService.fillNodeFromResponse($scope.node, preparedReceivedData);
 418                         YangmanService.handleNodeIdentifier(
 419                             $scope.parametersList, $scope.selectedSubApi, $scope.node
 420                         );
 421                         $scope.node.expanded = true;
 422
 423                         $scope.rootBroadcast(constants.YANGMAN_DISABLE_ADDING_LIST_ELEMENT);
 424                         preparedReceivedData = YangmanService.checkRpcReceivedData(preparedReceivedData, $scope.node);
 425                         sendRequestData(preparedReceivedData, constants.REQUEST_DATA_TYPE_RECEIVED);
 426                     }
 427                 }
 428
 429                 // create and set history request
 430                 requestHeader.statusObj.time = TimeTrackingService.returnTime();
 431
 432                 historyReq.setExecutionData(
 433                     reqInfo.requestSrcData,
 434                     preparedReceivedData,
 435                     reqInfo.status,
 436                     reqInfo.status,
 437                     reqInfo.statusText,
 438                     requestHeader.statusObj.time
 439                 );
 440
 441                 $scope.rootBroadcast(constants.YANGMAN_SAVE_EXECUTED_REQUEST, historyReq, function (){
 442                     $scope.rootBroadcast(constants.YANGMAN_SELECT_THE_NEWEST_REQUEST);
 443                 });
 444
 445                 (executeCbk || angular.noop)(historyReq);
 446
 447
 448             }
 449
 450             /**
 451              * Error callback after executin operation
 452              * @param reqInfo
 453              * @param response
 454              */
 455             function executeReqErrCbk(reqInfo, response) {
 456                 requestHeader.statusObj = reqInfo;
 457
 458                 finishRequestProgress();
 459
 460                 requestHeader.statusObj.time = TimeTrackingService.returnTime();
 461
 462                 historyReq.setExecutionData(
 463                     reqInfo.requestSrcData,
 464                     response.data,
 465                     reqInfo.status,
 466                     reqInfo.status,
 467                     reqInfo.statusText,
 468                     requestHeader.statusObj.time
 469                 );
 470                 $scope.rootBroadcast(constants.YANGMAN_SAVE_EXECUTED_REQUEST, historyReq, function (){
 471                     $scope.rootBroadcast(constants.YANGMAN_SELECT_THE_NEWEST_REQUEST);
 472                 });
 473
 474                 if (response.data) {
 475                     // try to fill code mirror editor
 476                     sendRequestData(response.data, constants.REQUEST_DATA_TYPE_RECEIVED);
 477                     sendErrorData(response.data);
 478                 }
 479
 480                 (executeCbk || angular.noop)(historyReq);
 481
 482
 483             }
 484
 485         }
 486
 487         /**
 488          * TODO :: description
 489          * @param pathElem
 490          * @param identifier
 491          */
 492         function fillNodeData(pathElem, identifier) {
 493             if ($scope.selectedSubApi && $scope.selectedSubApi.storage === constants.DATA_STORE_CONFIG &&
 494                 $scope.selectedSubApi.pathArray.indexOf(pathElem) === ($scope.selectedSubApi.pathArray.length - 1)) {
 495                 PathUtilsService.fillListNode($scope.node, identifier.label, identifier.value);
 496             }
 497
 498             requestHeader.urlChanged = true;
 499         }
 500
 501         /**
 502          * Check data before executin operations
 503          */
 504         function prepareDataAndExecute(cbk){
 505             if (requestHeader.statusObj) {
 506                 requestHeader.statusObj.statusText = null;
 507                 requestHeader.statusObj.time = null;
 508             }
 509
 510             if ( requestHeader.requestUrl.length ) {
 511
 512                 if ( requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA ) {
 513                     // get json data
 514                     var params = { reqData: null };
 515                     $scope.rootBroadcast(constants.YANGMAN_GET_CODEMIRROR_DATA_SENT, params);
 516                     executeOperation(params.reqData ? angular.fromJson(params.reqData) : {}, cbk);
 517                 } else {
 518                     executeOperation({}, cbk);
 519                 }
 520             }
 521         }
 522
 523         /**
 524          * Mount point initialization
 525          * @param mountPointStructure
 526          * @param mountPointTreeApis
 527          * @param mountPointApis
 528          * @param augmentations
 529          */
 530         function initMountPoint(mountPointTreeApis, mountPointApis, augmentations, reqObj){
 531             DataBackupService.storeFromScope(
 532                 [
 533                     'selectedDatastore', 'node', 'apis',
 534                     'selectedApi', 'selectedSubApi', 'augmentations', 'selectedModule',
 535                 ],
 536                 $scope,
 537                 'MAIN_SCOPE'
 538             );
 539
 540             $scope.rootBroadcast(constants.YANGMAN_GET_API_TREE_DATA, null, function (treeApis) {
 541                 DataBackupService.storeFromScope(
 542                     ['treeApis'],
 543                     { treeApis: treeApis },
 544                     'MODULES_LIST'
 545                 );
 546             });
 547
 548             $scope.setNode(null);
 549             $scope.setModule(null);
 550             $scope.setGlobalParams(mountPointApis, augmentations);
 551             $scope.setDataStore(null);
 552             requestHeader.statusObj = reqObj;
 553             $scope.rootBroadcast(constants.YANGMAN_SET_API_TREE_DATA, mountPointTreeApis);
 554         }
 555
 556         /**
 557          * Executing custom plugin callback
 558          * @param customPlugin
 559          */
 560         function executePluginFunctionality(customPlugin){
 561             requestHeader.selectedPlugin = customPlugin;
 562             customPlugin.runCallback({ scope: $scope, controller: requestHeader });
 563         }
 564
 565         /**
 566          * Unset custom plugin functionality - get back major params from scope
 567          */
 568         function unsetPluginFunctionality(){
 569             if ( requestHeader.selectedPlugin ) {
 570                 $scope.unsetPlugin(requestHeader);
 571             }
 572
 573             requestHeader.selectedPlugin = null;
 574             requestHeader.selectedPluginsButtons = [];
 575         }
 576
 577     }
 578
 579 });