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