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
 126         /**
 127          * Change displayed data type to json or form, after switching set current data to be displayed
 128          */
 129         function changeDataType(){
 130             $scope.switchSection('rightPanelSection', requestHeader.selectedShownDataType);
 131
 132             if(!$scope.node || requestHeader.urlChanged) {
 133                 requestHeader.setRequestUrl();
 134                 requestHeader.urlChanged = false;
 135             }
 136
 137             // if changing to json, fill codemirror data
 138             if ( requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA && $scope.node ){
 139                 setJsonView();
 140                 sendRequestData($scope.buildRootRequest(), 'SENT');
 141             }
 142
 143             // if changing to form, try to fill node data
 144             if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM) {
 145                 var reqData = {};
 146
 147                 reqData = getDataForForm();
 148                 setNodeDataFromRequestData(requestHeader.requestUrl);
 149
 150                 if ( $scope.node ) {
 151
 152                     YangmanService.fillNodeFromResponse($scope.node, reqData);
 153                     $scope.node.expanded = true;
 154                 }
 155             }
 156         }
 157
 158         /**
 159          * Helper method for building correct json data for form, rpc included
 160          * @returns {*}
 161          */
 162         function getDataForForm(){
 163             var params = {
 164                     reqData: null,
 165                 },
 166                 dataTypeFunc = {
 167                     rpc: function () {
 168                         var sentData = { reqData: null },
 169                             allData = { sent: null, received: null };
 170
 171                         $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_RECEIVED', params);
 172                         $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_SENT', sentData);
 173
 174                         allData.sent = sentData.reqData ? angular.fromJson(sentData.reqData) : {};
 175                         allData.received = params.reqData ? angular.fromJson(params.reqData) : {};
 176
 177                         return YangmanService.prepareReceivedData(
 178                             $scope.node,
 179                             requestHeader.selectedOperation,
 180                             allData.received,
 181                             allData.sent,
 182                             requestHeader.selectedShownDataType
 183                         );
 184                     },
 185                     default: function (){
 186                         var dataType;
 187                         if(requestHeader.executedOperation) {
 188                             dataType = requestHeader.executedOperation === constants.OPERATION_GET ? constants.REQUEST_DATA_TYPE_RECEIVED : 'SENT';
 189                         }
 190                         else {
 191                             dataType = requestHeader.selectedOperation === constants.OPERATION_GET ? constants.REQUEST_DATA_TYPE_RECEIVED : 'SENT';
 192                         }
 193
 194                         $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_' + dataType, params);
 195                         return params.reqData ? angular.fromJson(params.reqData) : {};
 196                     },
 197                 };
 198
 199             return $scope.node ? (dataTypeFunc[$scope.node.type] || dataTypeFunc.default)() : {};
 200         }
 201
 202         /**
 203          * Send data to codemirror
 204          * @param data
 205          */
 206         function sendRequestData(data, type){
 207             $scope.rootBroadcast(
 208                 'YANGMAN_SET_CODEMIRROR_DATA_' + type,
 209                 { data: data instanceof Object ? JSON.stringify(data, null, 4) : data }
 210             );
 211         }
 212
 213         function sendErrorData(response) {
 214             $scope.rootBroadcast('YANGMAN_SET_ERROR_DATA', response);
 215         }
 216
 217         /**
 218          * Create empty parameters list, load from local storage and set to $scope
 219          */
 220         function initParams(){
 221             $scope.parametersList.loadListFromStorage();
 222         }
 223
 224         /**
 225          * Initialization
 226          */
 227         function init(){
 228             setAllowedMethods(requestHeader.allOperations);
 229             initParams();
 230             requestHeader.selectedShownDataType = $scope.rightPanelSection;
 231         }
 232
 233         /**
 234          * Set allowed operations for request
 235          * @param operations
 236          */
 237         function setAllowedMethods(operations){
 238             requestHeader.selectedOperationsList = operations.length ? operations : requestHeader.allOperations;
 239             if (operations.indexOf(requestHeader.selectedOperation) === -1){
 240                 requestHeader.selectedOperation = requestHeader.selectedOperationsList[0];
 241             }
 242         }
 243
 244         /**
 245          * Set header request url if json selected
 246          */
 247         function setRequestUrl(path){
 248             requestHeader.requestUrl = path || ($scope.selectedSubApi ?
 249                     ENV.getBaseURL('MD_SAL') + '/restconf/' + $scope.selectedSubApi.buildApiRequestString() : '');
 250         }
 251
 252
 253         /**
 254          * Try to set api, module, dataStore and node, if api indexes for request url available
 255          * and set (or unset) module detail panel to be displayed
 256          * @param requestUrl url to try to find
 257          * @param leftpanel index of main left tabs to be displayed (we dont want to display module detail in all cases)
 258          */
 259         function setNodeDataFromRequestData(requestUrl, leftpanel){
 260
 261             setApiByUrl(requestUrl, function (treeApis) {
 262                 // set module
 263                 $scope.setModule($filter('filter')(treeApis, { label: $scope.selectedApi.module })[0]);
 264
 265                 // set datastore
 266                 $scope.setDataStore(
 267                     $filter('filter')(
 268                         $scope.selectedModule.children,
 269                         { label: $scope.selectedSubApi.storage })[0],
 270                     true,
 271                     leftpanel
 272                 );
 273
 274                 // set node
 275                 $scope.setNode($scope.selectedSubApi.node);
 276
 277                 // fill subapi path
 278                 PathUtilsService.fillPath($scope.selectedSubApi.pathArray, requestUrl);
 279                 setRequestUrl();
 280             });
 281         }
 282
 283         function setApiByUrl(url, cbk, fill){
 284             $scope.rootBroadcast('YANGMAN_GET_API_TREE_DATA', null, function (treeApis) {
 285                 var apisIndexes =
 286                     PathUtilsService.searchNodeByPath(url, treeApis, null, true, true);
 287
 288                 if ( apisIndexes ) {
 289
 290                     // set apis
 291                     $scope.setApi(
 292                         $scope.apis[apisIndexes.indexApi],
 293                         $scope.apis[apisIndexes.indexApi].subApis[apisIndexes.indexSubApi]
 294                     );
 295
 296                     if ( $scope.selectedSubApi && fill ) {
 297                         var updatedUrl = YangmanService.cutUrl(url);
 298                         PathUtilsService.fillPath($scope.selectedSubApi.pathArray, updatedUrl);
 299
 300                     }
 301
 302                     (cbk || angular.noop)(treeApis);
 303                 }
 304             });
 305         }
 306
 307         function saveRequestToCollection(event) {
 308             var historyReq = null,
 309                 sentData = { reqData: null },
 310                 receivedData = { reqData: null };
 311
 312             if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM) {
 313                 requestHeader.setRequestUrl();
 314             }
 315
 316             historyReq = RequestService.createHistoryRequest(
 317                 null, null, requestHeader.requestUrl, requestHeader.selectedOperation, '', '', ''
 318             );
 319
 320             $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_SENT', sentData);
 321             $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_RECEIVED', receivedData);
 322
 323             RequestService.fillRequestByMethod(
 324                 historyReq, sentData, receivedData, requestHeader.selectedOperation, $scope.node,
 325                 requestHeader.selectedShownDataType
 326             );
 327
 328             $scope.rootBroadcast('YANGMAN_SAVE_REQUEST_TO_COLLECTION', { event: event, reqObj: historyReq });
 329         }
 330
 331         function showRequestProgress(){
 332             $scope.rootBroadcast('YANGMAN_EXECUTING_REQUEST_PROGRESS_START');
 333         }
 334
 335
 336         function finishRequestProgress(message){
 337             $scope.rootBroadcast('YANGMAN_EXECUTING_REQUEST_PROGRESS_STOP');
 338         }
 339
 340         /**
 341          * Execute request operation
 342          */
 343         function executeOperation(requestData, executeCbk){
 344             var allowExecuteOperation =
 345                 requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_FORM && $scope.selectedSubApi ?
 346                     !PathUtilsService.checkEmptyIdentifiers($scope.selectedSubApi.pathArray) : true;
 347
 348             if ( allowExecuteOperation ) {
 349
 350                 showRequestProgress();
 351                 setRequestUrl(requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA ? requestHeader.requestUrl : null);
 352                 $scope.rootBroadcast('YANGMAN_SET_ERROR_MESSAGE', '');
 353
 354                 if ( requestHeader.selectedShownDataType !== constants.DISPLAY_TYPE_FORM ){
 355                     setApiByUrl(requestHeader.requestUrl, null, true);
 356                 }
 357
 358                 var historyReq = RequestService.createHistoryRequest(null, null, requestHeader.requestUrl,
 359                     requestHeader.selectedOperation, '', '', '');
 360
 361                 YangmanService.executeRequestOperation(
 362                     $scope.selectedApi,
 363                     $scope.selectedSubApi,
 364                     requestHeader.selectedOperation,
 365                     $scope.node,
 366                     requestHeader.selectedShownDataType,
 367                     requestHeader.requestUrl,
 368                     requestData,
 369                     $scope.parametersList,
 370                     executeReqSuccCbk,
 371                     executeReqErrCbk
 372                 );
 373                 requestHeader.executedOperation = requestHeader.selectedOperation;
 374             } else {
 375                 $scope.rootBroadcast(
 376                     'YANGMAN_SET_ERROR_MESSAGE',
 377                     $filter('translate')('YANGMAN_ERROR_EMPTY_IDENTIFIERS')
 378                 );
 379             }
 380
 381             /**
 382              * Success callback after executin operation
 383              * @param reqInfo
 384              * @param response
 385              */
 386             function executeReqSuccCbk(reqInfo, response) {
 387                 var preparedReceivedData = YangmanService.prepareReceivedData(
 388                     $scope.node,
 389                     requestHeader.selectedOperation,
 390                     response.data ? response.data.plain() : {},
 391                     reqInfo.requestSrcData,
 392                     requestHeader.selectedShownDataType
 393                 );
 394
 395                 finishRequestProgress();
 396
 397                 requestHeader.statusObj = reqInfo;
 398
 399                 sendErrorData({});
 400
 401                 if (requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA){
 402
 403                     setNodeDataFromRequestData(requestHeader.requestUrl);
 404                     sendRequestData(preparedReceivedData, constants.REQUEST_DATA_TYPE_RECEIVED);
 405                     sendRequestData(reqInfo.requestSrcData || {}, 'SENT');
 406                 } else {
 407
 408                     if ($scope.node){
 409
 410                         YangmanService.fillNodeFromResponse($scope.node, preparedReceivedData);
 411                         YangmanService.handleNodeIdentifier(
 412                             $scope.parametersList, $scope.selectedSubApi, $scope.node
 413                         );
 414                         $scope.node.expanded = true;
 415
 416                         $scope.rootBroadcast('YANGMAN_DISABLE_ADDING_LIST_ELEMENT');
 417                         preparedReceivedData = YangmanService.checkRpcReceivedData(preparedReceivedData, $scope.node);
 418                         sendRequestData(preparedReceivedData, constants.REQUEST_DATA_TYPE_RECEIVED);
 419                     }
 420                 }
 421
 422                 // create and set history request
 423                 historyReq.setExecutionData(
 424                     reqInfo.requestSrcData,
 425                     preparedReceivedData,
 426                     reqInfo.status,
 427                     reqInfo.status,
 428                     reqInfo.statusText,
 429                     reqInfo.time
 430                 );
 431
 432                 $scope.rootBroadcast('YANGMAN_SAVE_EXECUTED_REQUEST', historyReq, function (){
 433                     $scope.rootBroadcast('YANGMAN_SELECT_THE_NEWEST_REQUEST');
 434                 });
 435
 436                 (executeCbk || angular.noop)(historyReq);
 437
 438
 439             }
 440
 441             /**
 442              * Error callback after executin operation
 443              * @param reqInfo
 444              * @param response
 445              */
 446             function executeReqErrCbk(reqInfo, response) {
 447                 requestHeader.statusObj = reqInfo;
 448
 449                 finishRequestProgress();
 450
 451                 historyReq.setExecutionData(
 452                     reqInfo.requestSrcData,
 453                     response.data,
 454                     reqInfo.status,
 455                     reqInfo.status,
 456                     reqInfo.statusText,
 457                     reqInfo.time
 458                 );
 459                 $scope.rootBroadcast('YANGMAN_SAVE_EXECUTED_REQUEST', historyReq, function (){
 460                     $scope.rootBroadcast('YANGMAN_SELECT_THE_NEWEST_REQUEST');
 461                 });
 462
 463                 if (response.data) {
 464                     // try to fill code mirror editor
 465                     sendRequestData(response.data, constants.REQUEST_DATA_TYPE_RECEIVED);
 466                     sendErrorData(response.data);
 467                 }
 468
 469                 (executeCbk || angular.noop)(historyReq);
 470
 471
 472             }
 473
 474         }
 475
 476         /**
 477          * TODO :: description
 478          * @param pathElem
 479          * @param identifier
 480          */
 481         function fillNodeData(pathElem, identifier) {
 482             if ($scope.selectedSubApi && $scope.selectedSubApi.storage === constants.DATA_STORE_CONFIG &&
 483                 $scope.selectedSubApi.pathArray.indexOf(pathElem) === ($scope.selectedSubApi.pathArray.length - 1)) {
 484                 PathUtilsService.fillListNode($scope.node, identifier.label, identifier.value);
 485             }
 486
 487             requestHeader.urlChanged = true;
 488         }
 489
 490         /**
 491          * Check data before executin operations
 492          */
 493         function prepareDataAndExecute(cbk){
 494             if ( requestHeader.requestUrl.length ) {
 495
 496                 if ( requestHeader.selectedShownDataType === constants.DISPLAY_TYPE_REQ_DATA ) {
 497                     // get json data
 498                     var params = { reqData: null };
 499                     $scope.rootBroadcast('YANGMAN_GET_CODEMIRROR_DATA_SENT', params);
 500                     executeOperation(params.reqData ? angular.fromJson(params.reqData) : {}, cbk);
 501                 } else {
 502                     executeOperation({}, cbk);
 503                 }
 504             }
 505         }
 506
 507         /**
 508          * Mount point initialization
 509          * @param mountPointStructure
 510          * @param mountPointTreeApis
 511          * @param mountPointApis
 512          * @param augmentations
 513          */
 514         function initMountPoint(mountPointTreeApis, mountPointApis, augmentations, reqObj){
 515             DataBackupService.storeFromScope(
 516                 [
 517                     'selectedDatastore', 'node', 'apis',
 518                     'selectedApi', 'selectedSubApi', 'augmentations', 'selectedModule',
 519                 ],
 520                 $scope,
 521                 'MAIN_SCOPE'
 522             );
 523
 524             $scope.rootBroadcast('YANGMAN_GET_API_TREE_DATA', null, function (treeApis) {
 525                 DataBackupService.storeFromScope(
 526                     ['treeApis'],
 527                     { treeApis: treeApis },
 528                     'MODULES_LIST'
 529                 );
 530             });
 531
 532             $scope.setNode(null);
 533             $scope.setModule(null);
 534             $scope.setGlobalParams(mountPointApis, augmentations);
 535             $scope.setDataStore(null);
 536             requestHeader.statusObj = reqObj;
 537             $scope.rootBroadcast('YANGMAN_SET_API_TREE_DATA', mountPointTreeApis);
 538         }
 539
 540         /**
 541          * Executing custom plugin callback
 542          * @param customPlugin
 543          */
 544         function executePluginFunctionality(customPlugin){
 545             requestHeader.selectedPlugin = customPlugin;
 546             customPlugin.runCallback({ scope: $scope, controller: requestHeader });
 547         }
 548
 549         /**
 550          * Unset custom plugin functionality - get back major params from scope
 551          */
 552         function unsetPluginFunctionality(){
 553             if ( requestHeader.selectedPlugin ) {
 554                 $scope.unsetPlugin(requestHeader);
 555             }
 556
 557             requestHeader.selectedPlugin = null;
 558             requestHeader.selectedPluginsButtons = [];
 559         }
 560
 561     }
 562
 563 });