groupbasedpolicy-ui/module/src/main/resources/gbp/resolved-policy/resolved-policy-list.service.js

   1 define(['app/gbp/resolved-policy/resolved-policy.service'], function () {
   2     'use strict';
   3
   4     angular.module('app.gbp').service('ResolvedPolicyListService', ResolvedPolicyListService);
   5
   6     ResolvedPolicyListService.$inject = ['$filter', 'Restangular', 'ResolvedPolicyService'];
   7
   8     function ResolvedPolicyListService($filter, Restangular, ResolvedPolicyService) {
   9         /* methods */
  10         this.createList = createList;
  11
  12
  13         function ResolvedPolicyList() {
  14             /* properties */
  15             this.data = [];
  16
  17             /* methods */
  18             this.aggregateResolvedPolicies = aggregateResolvedPolicies;
  19             this.get = get;
  20             this.clearData = clearData;
  21             this.setData = setData;
  22
  23             /* Implementation */
  24             /**
  25              * fills ResolvedPolicyList object with data
  26              * @param data
  27              */
  28             function setData(data) {
  29                 var self = this;
  30
  31                 if (data) {
  32                     data.forEach(function (dataElement) {
  33                         self.data.push(ResolvedPolicyService.createObject(dataElement));
  34                     });
  35                 }
  36             }
  37
  38             /**
  39              * Clears data property of ResolvedPolicyList object
  40              */
  41             function clearData() {
  42                 var self = this;
  43                 self.data = [];
  44             }
  45
  46             /**
  47              * Reads data from operational datastore and filters it by tenant property if available
  48              * @param tenant
  49              * @param successCallback
  50              */
  51             function get(tenant, successCallback) {
  52                 var self = this;
  53
  54                 var restObj = Restangular.one('restconf').one('operational').one('resolved-policy:resolved-policies');
  55
  56                 return restObj.get().then(function (data) {
  57                     if (tenant) {
  58                         self.data = $filter('filter')(data['resolved-policies']['resolved-policy'], {
  59                             'consumer-tenant-id': tenant,
  60                             'provider-tenant-id': tenant,
  61                         });
  62                     }
  63                     else {
  64                         self.data = data['resolved-policies']['resolved-policy'];
  65                     }
  66
  67                     successCallback();
  68                 });
  69             }
  70
  71             /**
  72              * Process resolved policies and returns object with epgs and contracts properties
  73              * @returns {{epgs: {}, contracts: {}}}
  74              */
  75             function aggregateResolvedPolicies() {
  76                 var self = this,
  77                     result = { epgs: {}, contracts: {} };
  78
  79                 self.data.forEach(function (rp) {
  80                     processEpg(result, rp, 'consumer');
  81                     processEpg(result, rp, 'provider');
  82
  83                     if (rp.hasOwnProperty('policy-rule-group-with-endpoint-constraints')) {
  84                         processConstraints(
  85                             result,
  86                             rp['policy-rule-group-with-endpoint-constraints'],
  87                             rp['provider-epg-id'],
  88                             rp['consumer-epg-id']
  89                         );
  90                     }
  91                 });
  92
  93                 return result;
  94
  95             }
  96
  97             /**
  98              * Checks if exists object in returnValue.epgs and if not, creates one
  99              * @param returnValue
 100              * @param resolvedPolicyItem
 101              * @param type
 102              */
 103             function processEpg(returnValue, resolvedPolicyItem, type) {
 104                 if (!returnValue.epgs.hasOwnProperty(resolvedPolicyItem[type + '-epg-id'])) {
 105                     returnValue.epgs[resolvedPolicyItem[type + '-epg-id']] = {
 106                         'provided-contracts': [],
 107                         'consumed-contracts': [],
 108                     };
 109                 }
 110
 111
 112
 113             }
 114
 115             /**
 116              * Process policy-rule-group-with-endpoint-constraints from resolved-policy.
 117              * Creates contracts and updates epgs with contract objects
 118              * @param returnValue
 119              * @param constraints
 120              * @param providerEpgId
 121              * @param consumerEpgId
 122              */
 123             function processConstraints(returnValue, constraints, providerEpgId, consumerEpgId) {
 124                 constraints.forEach(function (element) {
 125                     element['policy-rule-group'].forEach(function (el) {
 126                         var linkId = generateLinkId(el['contract-id'], providerEpgId, consumerEpgId);
 127
 128                         if (!returnValue.contracts.hasOwnProperty(linkId)) {
 129                             returnValue.contracts[linkId] = {
 130                                 'contract-id': el['contract-id'],
 131                                 'linkId': linkId,
 132                                 'subjects': {},
 133                                 'type': '',
 134                             };
 135                         }
 136
 137                         if (!returnValue.contracts[linkId].subjects.hasOwnProperty(el['subject-name'])) {
 138                             returnValue.contracts[linkId].subjects[el['subject-name']] = { 'resolved-rule': [] };
 139                         }
 140
 141                         returnValue.contracts[linkId].subjects[el['subject-name']]['resolved-rule'] =
 142                             returnValue.contracts[linkId].subjects[el['subject-name']]['resolved-rule'].concat(el['resolved-rule']);
 143
 144                         Object.keys(returnValue.contracts[linkId].subjects).forEach(function(key) {
 145                             returnValue.contracts[linkId].type =
 146                                 getContractType(returnValue.contracts[linkId].subjects[key]) ? 'chain' : 'allow';
 147                         })
 148
 149                         updateEpg(returnValue, returnValue.contracts[linkId], providerEpgId, 'provided');
 150                         updateEpg(returnValue, returnValue.contracts[linkId], consumerEpgId, 'consumed');
 151                     });
 152                 });
 153             }
 154
 155             /**
 156              * Updates epgobject with contract object
 157              * @param returnValue
 158              * @param contract
 159              * @param epgId
 160              * @param epgType
 161              */
 162             function updateEpg(returnValue, contract, epgId, epgType) {
 163                 returnValue.epgs[epgId][epgType + '-contracts'].push(contract);
 164             }
 165         }
 166
 167         /**
 168          * Creates ResolvedPolicyList object
 169          * @param data
 170          * @returns {ResolvedPolicyList}
 171          */
 172         function createList(data) {
 173             var obj = new ResolvedPolicyList();
 174
 175             if (data) {
 176                 obj.setData(data);
 177             }
 178
 179             return obj;
 180         }
 181
 182         /**
 183          * creates linkId string from input parameters
 184          * @param contractId
 185          * @param providerEpgId
 186          * @param consumerEpgId
 187          * @returns {string}
 188          */
 189         function generateLinkId(contractId, providerEpgId, consumerEpgId) {
 190             return contractId + '++' + providerEpgId + '++' + consumerEpgId;
 191         }
 192
 193         function getContractType(subject) {
 194             return subject['resolved-rule'].some(function(s) {
 195                 return s.action.some(function (a) {
 196                     return a['action-definition-id'] === 'Action-Chain';
 197                 });
 198             });
 199         }
 200     }
 201
 202     return ResolvedPolicyListService;
 203 });