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

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