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