groupbasedpolicy-ui/module/src/main/resources/gbp/common/gbp.controller.js

   1 define([
   2     'app/gbp/common/gbp.service',
   3     'app/gbp/resolved-policy/resolved-policy-list.service',
   4     'app/gbp/endpoints/sxp-mapping-list.service'
   5 ], function () {
   6     'use strict';
   7
   8     angular.module('app.gbp').controller('RootGbpCtrl', RootGbpCtrl);
   9
  10     RootGbpCtrl.$inject = ['$filter', '$mdDialog', '$rootScope', '$scope', '$state',
  11         'EndpointsListService', 'NextTopologyService', 'ResolvedPolicyListService', 'RootGbpService',
  12         'TenantListService', 'SxpMappingListService'];
  13
  14     function RootGbpCtrl($filter, $mdDialog, $rootScope, $scope, $state,
  15         EndpointsListService, NextTopologyService, ResolvedPolicyListService, RootGbpService,
  16         TenantListService, SxpMappingListService) {
  17         /* properties */
  18         $scope.apiType = 'operational';
  19         $scope.activeObject = null;
  20         $scope.endpoints = EndpointsListService.createList();
  21         $scope.endpointSgtList = SxpMappingListService.createList();
  22         $scope.rootTenant = null;
  23         $scope.rootTenants = TenantListService.createList();
  24         $scope.resolvedPolicy = {};
  25         $scope.selectedNode = {};
  26         $scope.sidePanelObject = {};
  27         $scope.sidePanelPage = false;
  28         $scope.sidePanelPageEndpoint = false;
  29         $scope.stateUrl = null;
  30         $scope.topologyData = { nodes: [], links: [] };
  31         $scope.viewPath = 'src/app/gbp/';
  32
  33         var resolvedPolicies = ResolvedPolicyListService.createList();
  34         getResolvedPolicies();
  35
  36         /* methods */
  37         $scope.broadcastFromRoot = broadcastFromRoot;
  38         $scope.closeSidePanel = closeSidePanel;
  39         $scope.openSfcDialog = openSfcDialog;
  40         $scope.openSidePanel = openSidePanel;
  41         $scope.setRootTenant = setRootTenant;
  42         $scope.toggleExpanded = toggleExpanded;
  43         $scope.openSidePanelContract = openSidePanelContract;
  44         $scope.openSidePanelChild = openSidePanelChild;
  45         $scope.deselectEpg = deselectEpg;
  46         $scope.deselectContract = deselectContract;
  47         $scope.openSidePanelTpl = openSidePanelTpl;
  48         $scope.getObjectsCount = getObjectsCount;
  49         $scope.expandAll = expandAll;
  50         $scope.collapseAll = collapseAll;
  51         $scope.highlightNode = highlightNode;
  52         $scope.highlightLink = highlightLink;
  53         $scope.fadeAll = fadeAll;
  54         $scope.rootOpenEndpointDialog = rootOpenEndpointDialog;
  55         $scope.rootDeleteEndpointDialog = rootDeleteEndpointDialog;
  56         $scope.getEndpointsList = getEndpointsList;
  57
  58         RootGbpService.setMainClass();
  59         init();
  60
  61         /* implementations */
  62
  63         /**
  64          *
  65          * @param eventName
  66          * @param val
  67          */
  68         function broadcastFromRoot(eventName, val) {
  69             $scope.$broadcast(eventName, val);
  70         }
  71
  72         /**
  73          *
  74          */
  75         function closeSidePanel() {
  76             if($scope.sidePanelPage) {
  77                 $scope.sidePanelPage = false;
  78                 $scope.fadeAll();
  79             }
  80         }
  81
  82         /**
  83          *
  84          * @param arr
  85          */
  86         function collapseAll(arr) {
  87             arr.forEach(function (element) {
  88                 element.expanded = false;
  89             });
  90         }
  91
  92         /**
  93          *
  94          * @param source
  95          * @param target
  96          * @param contract
  97          * @param tenant
  98          * @returns {{id: string, source: *, target: *, tenant: *}}
  99          */
 100         function createLink( linkId) {
 101             var linkIdParts = linkId.split('_');
 102             return {
 103                 'id': linkId,
 104                 'source': linkIdParts[1],
 105                 'target': linkIdParts[2],
 106                 'tenant': $scope.rootTenant
 107             };
 108         }
 109
 110         /**
 111          *
 112          * @param nodeName
 113          * @param tenantId
 114          * @returns {Object}
 115          */
 116         function createNode(nodeName) {
 117             return {
 118                 'id': nodeName,
 119                 'tenantId': $scope.rootTenant,
 120                 'node-id': nodeName,
 121                 'label': nodeName
 122             };
 123         }
 124
 125         /**
 126          *
 127          */
 128         function deselectContract() {
 129             $scope.fadeAll();
 130             $scope.sidePanelPage = 'resolved-policy/contract-sidepanel';
 131
 132             $scope.sidePanelObject = Object.keys($scope.resolvedPolicy.contracts).map(function (k) {
 133                 var ob = $scope.resolvedPolicy.contracts[k];
 134                 ob.linkId = k;
 135
 136                 return ob;
 137             });
 138
 139             $scope.selectedNode = null;
 140             $scope.activeObject = 'contract';
 141         }
 142
 143         /**
 144          *
 145          */
 146         function deselectEpg() {
 147             $scope.fadeAll();
 148             $scope.sidePanelPage = 'resolved-policy/epg-sidepanel';
 149
 150             $scope.sidePanelObject = Object.keys($scope.resolvedPolicy.epgs).map(function (k) {
 151                 var ob = $scope.resolvedPolicy.epgs[k];
 152                 ob.id = k;
 153
 154                 return ob;
 155             });
 156             $scope.selectedNode = null;
 157             $scope.activeObject = 'epg';
 158         }
 159
 160         /**
 161          *
 162          * @param arr
 163          */
 164         function expandAll(arr) {
 165             arr.forEach(function (element) {
 166                 element.expanded = true;
 167             });
 168         }
 169
 170         /**
 171          *
 172          */
 173         function fadeAll() {
 174             $rootScope.nxTopology && NextTopologyService.fadeInAllLayers($rootScope.nxTopology);
 175         }
 176
 177         /**
 178          * reads resolvedPolicies list, prepares nodes and links for topology and fills them
 179          */
 180         function fillTopologyData() {
 181             var tempTopoData = {nodes: [], links: []};
 182
 183             $scope.resolvedPolicy = resolvedPolicies.aggregateResolvedPolicies();
 184             console.log('resolved and aggregated', $scope.resolvedPolicy);
 185
 186             tempTopoData.nodes = Object.keys($scope.resolvedPolicy.epgs).map(function (key) {
 187                 return createNode(key);
 188             });
 189
 190             tempTopoData.links = Object.keys($scope.resolvedPolicy.contracts).map(function (key) {
 191                 return createLink(key);
 192             });
 193
 194             $scope.topologyData = tempTopoData;
 195             $scope.topologyLoaded = true;
 196         }
 197
 198         /**
 199          *
 200          * @param obj
 201          * @returns {*}
 202          */
 203         function getObjectsCount(obj) {
 204             if(obj)
 205                 return Object.keys(obj).length;
 206             else
 207                 return 0;
 208         }
 209
 210         function getResolvedPolicies() {
 211             if($scope.rootTenant) {
 212                 resolvedPolicies.get($scope.rootTenant, fillTopologyData);
 213             }
 214         }
 215
 216         /**
 217          *
 218          * @param node
 219          */
 220         function highlightNode(node) {
 221             NextTopologyService.highlightNode($rootScope.nxTopology, node);
 222         }
 223
 224         /**
 225          *
 226          * @param link
 227          */
 228         function highlightLink(link) {
 229             NextTopologyService.highlightLink($rootScope.nxTopology, link);
 230         }
 231
 232         /**
 233          *
 234          */
 235         function init() {
 236             $scope.rootTenants.clearData();
 237             $scope.rootTenants.get('config');
 238             $state.go('main.gbp.index.resolvedPolicy');
 239             $scope.endpointSgtList.get();
 240         }
 241
 242         /**
 243          *
 244          * @param chainName
 245          */
 246         function openSfcDialog(chainName) {
 247             $mdDialog.show({
 248                 clickOutsideToClose: true,
 249                 controller: 'SfcTopologyController',
 250                 preserveScope: true,
 251                 templateUrl: $scope.viewPath + 'sfc/dialog-sfc-topology.tpl.html',
 252                 parent: angular.element(document.body),
 253                 scope: $scope,
 254                 locals: {
 255                     chainName: chainName
 256                 }
 257             });
 258         }
 259
 260
 261         /**
 262          * Sets '$scope.sidePanelPage' to true. This variable is watched in index.tpl.html template
 263          * and opens/closes side panel
 264          */
 265         function openSidePanel(page, object, cbk) {
 266             var samePage = page === $scope.sidePanelPage;
 267
 268             $scope.selectedNode = object;
 269
 270             $scope.sidePanelCbk = cbk;
 271             $scope.sidePanelPage = page;
 272             $scope.sidePanelObject = object;
 273
 274             if ( samePage &&  $scope.sidePanelCbk) {
 275                 $scope.sidePanelCbk();
 276             }
 277         }
 278
 279         /**
 280          *
 281          * @param idElement
 282          */
 283         function openSidePanelContract(idElement) {
 284             var obj = $filter('filter')(Object.keys($scope.resolvedPolicy.contracts).map(function (k) {
 285                 var obj = $scope.resolvedPolicy.contracts[k];
 286                 obj.linkId = k;
 287
 288                 return obj;
 289             }), { 'contract-id': idElement });
 290
 291             $scope.sidePanelPage = 'resolved-policy/contract-sidepanel';
 292             $scope.sidePanelObject = obj[0];
 293             $scope.selectedNode = obj[0];
 294             $scope.activeObject = 'contract';
 295
 296             NextTopologyService.highlightLink($rootScope.nxTopology, obj[0].linkId);
 297         }
 298
 299         /**
 300          * .
 301          * @param index
 302          * @param type
 303          */
 304         function openSidePanelChild(index, type) {
 305             switch (type) {
 306             case 'subject':
 307                 $scope.sidePanelPage = 'resolved-policy/subject-sidepanel';
 308                 $scope.subjectIndex = index;
 309                 break;
 310             case 'clause':
 311                 $scope.sidePanelPage = 'resolved-policy/clause-sidepanel';
 312                 $scope.clauseIndex = index;
 313                 break;
 314             case 'rule':
 315                 $scope.sidePanelPage = 'resolved-policy/rule-sidepanel';
 316                 $scope.ruleIndex = index;
 317                 break;
 318             }
 319         }
 320
 321         /**
 322          *
 323          * @param tpl
 324          */
 325         function openSidePanelTpl(tpl) {
 326             switch (tpl) {
 327             case 'contract':
 328                 $scope.sidePanelPage = 'resolved-policy/contract-sidepanel';
 329                 break;
 330             case 'subject':
 331                 $scope.sidePanelPage = 'resolved-policy/subject-sidepanel';
 332                 break;
 333             case 'clause':
 334                 $scope.sidePanelPage = 'resolved-policy/clause-sidepanel';
 335                 break;
 336             case 'rule':
 337                 $scope.sidePanelPage = 'resolved-policy/rule-sidepanel';
 338                 break;
 339             }
 340         }
 341
 342         /**
 343          *
 344          */
 345         function setRootTenant() {
 346             $scope.broadcastFromRoot('ROOT_TENANT_CHANGED');
 347
 348             if ($scope.stateUrl.startsWith('/resolved-policy')) {
 349                 getResolvedPolicies()
 350                 if($scope.sidePanelPage) {
 351                     if($scope.activeObject == 'epg')
 352                         deselectEpg();
 353                     else if($scope.activeObject == 'contract')
 354                         deselectContract();
 355                 }
 356             }
 357         }
 358
 359         /**
 360          * fills $scope.stateUrl with loaded url
 361          * It's called on $viewContentLoaded event
 362          */
 363         function setStateUrl() {
 364             $scope.stateUrl = $state.current.url;
 365             closeSidePanel();
 366
 367             if ($scope.stateUrl.startsWith('/resolved-policy')) {
 368                 getResolvedPolicies()
 369             }
 370         }
 371
 372         /**
 373          *
 374          * @param element
 375          */
 376         function toggleExpanded(element) {
 377             if (typeof element !== 'string') {
 378                 element.expanded = !element.expanded;
 379             }
 380         }
 381
 382         function rootOpenEndpointDialog(operation, endpointData) {
 383             $scope.disableKeyFieldsEditing = operation === 'edit';
 384             $mdDialog.show({
 385                 clickOutsideToClose: true,
 386                 controller: 'AddEndpointController',
 387                 preserveScope: true,
 388                 templateUrl: $scope.viewPath + 'endpoints/dialog-add-endpoint.tpl.html',
 389                 parent: angular.element(document.body),
 390                 scope: $scope,
 391                 locals: {
 392                     endpoint: endpointData
 393                 }
 394             });
 395         }
 396
 397         function rootDeleteEndpointDialog(endpointData) {
 398             var confirm = $mdDialog.confirm()
 399                 .title('Delete endpoint')
 400                 .textContent('Do you want to delete endpoint?')
 401                 .ok('Delete')
 402                 .cancel('Cancel');
 403
 404             $mdDialog.show(confirm).then(function () {
 405                 endpointData.deleteEndpoint(function () {
 406                     getEndpointsList();
 407                 });
 408             }, function () {
 409
 410             });
 411         }
 412
 413         function getEndpointsList() {
 414             $scope.endpoints.clearData();
 415             $scope.endpoints.getByEpg($scope.selectedNode.data.id);
 416         }
 417         /* event listeners */
 418         /**
 419          * Event fired after content loaded, setStateUrl function is called to fill stateUrl method
 420          */
 421         $scope.$on('$viewContentLoaded', setStateUrl);
 422     }
 423 });