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