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