groupbasedpolicy-old-ui/module/src/main/resources/gbp/gbp.services.js

   1 define(['app/gbp/gbp.module', 'app/gbp/js/joint.clean.build'], function(gbp, joint) {
   2
   3     gbp.register.factory('GBPRestangular', function(Restangular, ENV) {
   4         return Restangular.withConfig(function(RestangularConfig) {
   5             RestangularConfig.setBaseUrl(ENV.getBaseURL("MD_SAL"));
   6         });
   7     });
   8
   9     gbp.register.factory('GBPConstants', function() {
  10         var c = { colors: {'graph' : {}}, strings: {}, jointElements: {}, objType: {}, numbers: {}};
  11
  12         c.strings.flood = 'flood';
  13         c.strings.bridge = 'bridge';
  14         c.strings.l3ctx = 'l3ctx';
  15         c.strings.subnet = 'subnet';
  16         c.strings.linklabel = 'linklabel';
  17         c.strings.in = 'in';
  18         c.strings.out = 'out';
  19         c.strings.bi = 'bidirectional';
  20
  21         c.strings.config = 'CONFIG';
  22         c.strings.oper = 'OPERATIONAL';
  23         c.strings.l2l3 = 'L2L3';
  24         c.strings.mock = 'MOCK';
  25         c.strings.sigmaTopoDefaultText = 'SIGMATOPODEFAULTTEXT';
  26         c.strings.sigmaTopoDefault = 'SIGMATOPODEFAULTTEXT';
  27
  28         c.colors[c.strings.flood] = '#DF0101';
  29         c.colors[c.strings.bridge] = '#0080FF';
  30         c.colors[c.strings.l3ctx] = '#3ADF00';
  31         c.colors[c.strings.subnet] = '#FF9933';
  32         c.colors[c.strings.sigmaTopoDefaultText] = '#fff';
  33         c.colors[c.strings.epg] = '#8fde70';
  34         c.colors[c.strings.linklabel] = '#3366CC';
  35
  36         c.colors[c.strings.flood+'-'+c.strings.bridge] = '#6666FF';
  37         c.colors[c.strings.bridge+'-'+c.strings.l3ctx] = '#6666FF';
  38
  39         c.colors[c.strings.subnet+'-'] = '#6666FF';
  40
  41         c.colors['graph']['subject'] = '#FFFFD4';
  42         c.colors['graph']['cns'] = '#8EEDFF';
  43         c.colors['graph']['pns'] = '#FF9C9C';
  44
  45         c.jointElements.minWidth = 100;
  46         c.jointElements.maxWidth = 300;
  47         c.jointElements.minHeight = 50;
  48         c.jointElements.maxHeight = 300;
  49
  50         c.objType.contract = 'contract';
  51         c.objType.epg = 'epg';
  52         c.objType.consumer = 'consumer';
  53         c.objType.provider = 'provider';
  54         c.objType.subject = 'subject';
  55         c.objType.rule = 'rule';
  56
  57         c.numbers.displayLabelLength = 40;
  58
  59         return c;
  60     });
  61
  62     gbp.register.factory('MockServices', function() {
  63
  64         var ms = {};
  65
  66         ms.mockTopoData = function() {
  67             var lid = 0,
  68                 nodeRaw = [0, 1, 2, 3],
  69                 linkRaw = [[0, 1], [2, 3], [3, 0], [0, 3]],
  70                 nodes = nodeRaw.map(function(data) {
  71                     return {
  72                                 'id': 'n' + data,
  73                                 'label': 'LABEL'+data,
  74                                 'size': 3,
  75                                 'x': Math.random(),
  76                                 'y': Math.random(),
  77                                 'color': GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault]
  78                             };
  79                 }),
  80                 links = linkRaw.map(function(data) {
  81                     var obj = {
  82                                 id: 'e' + lid,
  83                                 source: 'n' + data[0],
  84                                 target: 'n' + data[1],
  85                                 color: GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault]
  86                             };
  87                     lid = lid + 1;
  88                     return obj;
  89                 });
  90
  91             return {nodes: nodes, links: links};
  92         };
  93
  94         return ms;
  95     });
  96
  97     gbp.register.factory('TopologyDataLoaders', function(GBPRestangular, GBPConstants) {
  98         var tdl = {};
  99
 100         tdl.getSubjectsBetweenEndpointGroups = function(storage, tenantId, successCbk, errorCbk) {
 101             var restObj = GBPRestangular.one('restconf').one('operations'),
 102                 rpcRes = 'ui-backend:get-subjects-between-endpoint-groups',
 103                 reqData = { "input": { "tenant-id": tenantId }};
 104
 105             if(storage) {
 106                 reqData.input['from-oper-data'] = {};
 107             }
 108
 109             restObj.post(rpcRes, reqData).then(function(data) {
 110                 // console.info('got data', data.output);
 111                 successCbk(data);
 112             }, function(res) {
 113                 errorCbk(res);
 114             });
 115         };
 116
 117         //Policies are representing links in PGN topology
 118         tdl.getGroupRulesBetweenEndpointGroups = function(successCbk, errorCbk) {
 119             var restObj = GBPRestangular.one('restconf').one('operations'),
 120                 rpcRes = 'pgn-application:get-group-rules-between-endpoint-groups',
 121                 reqData = { "input": { "endpoint-group-pair":[] }};
 122
 123             restObj.post(rpcRes, reqData).then(function(data) {
 124                 successCbk(data); //set topology links
 125             }, function(res) {
 126                 errorCbk(res);
 127             });
 128         };
 129
 130         //Groups are representing nodes in PGN topology
 131         tdl.getEndpointGroups = function(successCbk, errorCbk) {
 132             var tenantId = getId(idTypes.tenant),
 133                 restObj = GBPRestangular.one('restconf').one('operations'),
 134                 rpcRes = 'pgn-application:get-endpoint-groups',
 135                 reqData = {
 136                             "input": {
 137                                 "endpoint-group-id":[
 138                                     {
 139                                         "pgn-application:tenant-id": tenantId
 140                                     }
 141                                 ]
 142                             }
 143                         };
 144
 145           restObj.post(rpcRes, reqData).then(function(data) {
 146               successCbk(data); //set topology nodes
 147           }, function(res) {
 148               errorCbk(res);
 149           });
 150
 151         };
 152
 153         tdl.getEndpointsFromEndpointGroup = function(tenantId, epgId, successCbk, errorCbk) {
 154             var restObj = GBPRestangular.one('restconf').one('operations'),
 155                 rpcRes = 'ui-backend:get-endpoints-from-endpoint-group',
 156                 reqData = {
 157                             "input": {
 158                                 "tenant-id": tenantId,
 159                                 "endpoint-group-id":epgId
 160                             }
 161                         };
 162
 163           restObj.post(rpcRes, reqData).then(function(data) {
 164               successCbk(data); //set topology nodes
 165           }, function(res) {
 166               errorCbk(res);
 167           });
 168
 169         };
 170
 171         tdl.getEpgTopo = function(data){
 172             var epgData = data.output['endpoint-group-pair-with-subject'],
 173                 nodes = [],
 174                 edges = [],
 175                 setNode = function(obj){
 176                     var nodeObj = {
 177                             'id': 'n' + nodes.length,
 178                             'label': obj.name || obj.id,
 179                             'name': obj.name,
 180                             'size': 1,
 181                             'x': Math.random(),
 182                             'y': Math.random(),
 183                             'color': GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault],
 184                             'type': obj.type
 185                         };
 186
 187                     nodes.push(nodeObj);
 188                     return nodeObj.id;
 189                 },
 190                 setEdge = function(sourceId, destId, data, direction) {
 191                     var obj = {
 192                             'id': 'e' + edges.length,
 193                             'source': sourceId,
 194                             'target': destId,
 195                             'color': GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault],
 196                             'data': data,
 197                             'direction' : direction
 198                             // 'type': 'curve',
 199                             // 'size' : 100
 200                         };
 201
 202                     edges.push(obj);
 203                 },
 204                 getObjByProp = function(val, prop, list) {
 205                     return list.filter(function(i){
 206                         return i[prop] === val;
 207                     });
 208                 },
 209                 getDirection = function(subjects){
 210                     var directions = [];
 211                     if ( subjects ) {
 212                         subjects.forEach(function(s){
 213                             if ( s['ui-rule'] ) {
 214                                 s['ui-rule'].forEach(function(rule){
 215                                     if ( rule['classifier-ref'] ) {
 216                                         rule['classifier-ref'].forEach(function(classifier){
 217                                             if ( classifier.direction && directions.indexOf(classifier.direction) === -1 ){
 218                                                 directions.push(classifier.direction);
 219                                             }
 220                                         });
 221                                     }
 222                                 });
 223                             }
 224                         });
 225                     }
 226                     return directions.length === 1 ? directions[0] : directions.length > 1 ? 'bidirectional' : null;
 227
 228                 };
 229
 230             if(epgData) {
 231                 epgData.forEach(function(e){
 232                     var cepgnId = null,
 233                         pepgnId = null;
 234
 235                     if ( !getObjByProp(e['consumer-endpoint-group-id'],'name', nodes).length ) {
 236                         var objCepg = {
 237                             type: 'epg',
 238                             name: e['consumer-endpoint-group-id']
 239                         };
 240                         cepgnId = setNode(objCepg);
 241                     } else {
 242                         cepgnId = getObjByProp(e['consumer-endpoint-group-id'],'name', nodes)[0].id;
 243                     }
 244                     if ( !getObjByProp(e['provider-endpoint-group-id'],'name', nodes).length ) {
 245                         var objPepg = {
 246                             type: 'epg',
 247                             name: e['provider-endpoint-group-id']
 248                         };
 249                         pepgnId = setNode(objPepg);
 250                     } else {
 251                         pepgnId = getObjByProp(e['provider-endpoint-group-id'],'name', nodes)[0].id;
 252                     }
 253
 254                     var direction = getDirection(e['ui-subject']);
 255
 256                     if ( cepgnId && pepgnId ) {
 257                         setEdge(cepgnId, pepgnId, e['ui-subject'], direction);
 258                     }
 259                 });
 260             }
 261
 262             return {
 263                 nodes: nodes,
 264                 links: edges
 265             };
 266         };
 267
 268
 269         tdl.getL2L3 = function(storage, tenantId, successCbk, errorCbk) {
 270             //l2-bridge-domain
 271             var lid = 0,
 272                 nid = 0,
 273                 getL2L3Label = function(node) {
 274                     return node.name || node.id;
 275                 },
 276                 getSubnetLabel = function(node) {
 277                     return node['ip-prefix'] || node.id;
 278                 },
 279                 getNodeColor = function(src) {
 280                     return GBPConstants.colors[src] || GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault];
 281                 },
 282                 getLinkColor = function(from, to) {
 283                     return GBPConstants.colors[from+'-'+to] || GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault];
 284                 },
 285                 getNodes = function(data, srcDesc, getLabelCbk) {
 286                     var nodes = data.map(function(elem) {
 287                         var obj = {
 288                             'id': 'n' + nid,
 289                             'label': getLabelCbk(elem),
 290                             'uuid': elem.id,
 291                             'size': 3,
 292                             'x': Math.random(),
 293                             'y': Math.random(),
 294                             'color': getNodeColor(srcDesc),
 295                             'elemType': srcDesc
 296                         };
 297
 298                         nid += 1;
 299                         return obj;
 300                     });
 301
 302                     return nodes;
 303                 },
 304                 getLinks = function(data, srcNodes, targetNodes, fromDesc, toDesc) {
 305                     var findByUUID = function(array, uuid) {
 306                         return array.filter(function(elem) {
 307                             return elem.uuid === uuid;
 308                         })[0];
 309                     };
 310
 311                     var links = data.map(function(elem) {
 312                         var obj = null,
 313                             src = findByUUID(srcNodes, elem.id),
 314                             trg = findByUUID(targetNodes, elem.parent);
 315
 316                         if(src && trg) {
 317                             obj = {
 318                                 'id': 'e' + lid,
 319                                 'source': src.id,
 320                                 'target': trg.id,
 321                                 'color': getLinkColor(fromDesc, toDesc)
 322                             };
 323                             lid += 1;
 324                         }
 325
 326                         return obj;
 327                     }).filter(function(elem) {
 328                         return elem !== null;
 329                     });
 330
 331                     return links;
 332                 };
 333
 334             restObj = GBPRestangular.one('restconf').one(storage).one('policy:tenants').one('tenant').one(tenantId);
 335
 336             restObj.get().then(function(data) {
 337                 var l2FloodNodes = getNodes(data.tenant[0]['l2-flood-domain'] || [], GBPConstants.strings.flood, getL2L3Label),
 338                     l2BridgeNodes = getNodes(data.tenant[0]['l2-bridge-domain'] || [], GBPConstants.strings.bridge, getL2L3Label),
 339                     l3ContextNodes = getNodes(data.tenant[0]['l3-context'] || [], GBPConstants.strings.l3ctx, getL2L3Label),
 340                     subnetNodes = getNodes(data.tenant[0]['subnet'] || [], GBPConstants.strings.subnet, getSubnetLabel),
 341                     l2FloodLinks = getLinks(data.tenant[0]['l2-flood-domain'] || [], l2FloodNodes, l2BridgeNodes, GBPConstants.strings.flood, GBPConstants.strings.bridge),
 342                     l2BridgeLinks = getLinks(data.tenant[0]['l2-bridge-domain'] || [], l2BridgeNodes, l3ContextNodes, GBPConstants.strings.bridge, GBPConstants.strings.l3ctx),
 343                     subnetLinks = getLinks(data.tenant[0]['subnet'] || [], subnetNodes, l2BridgeNodes.concat(l2FloodNodes).concat(l3ContextNodes), GBPConstants.strings.subnet, ''),
 344                     allNodes = l2BridgeNodes.concat(l2FloodNodes).concat(l3ContextNodes).concat(subnetNodes),
 345                     allLinks = l2BridgeLinks.concat(l2FloodLinks).concat(subnetLinks);
 346
 347                 successCbk(allNodes, allLinks);
 348             }, function(res) {
 349                 errorCbk(res.data, res.status);
 350             });
 351         };
 352
 353         tdl.getClassifierInstances = function() {
 354
 355         };
 356
 357         return tdl;
 358     });
 359
 360     gbp.register.factory('TopoServices', function(TopologyDataLoaders, MockServices, GBPConstants) {
 361
 362         var ts = {};
 363
 364         var loaders = {};
 365
 366         var legends = {};
 367
 368         var transformPGNTopoNodes = function(data) {
 369             return data.output['endpoint-group'].map(function(d) {
 370                 return {
 371                     id: d.id,
 372                     group: d.name,
 373                     sgt: d['security-group-tag']
 374                 };
 375             });
 376         };
 377
 378         var transformPGNTopoLinks = function(data) {
 379             return data.output['endpoint-group-pair-with-rules'].map(function(d) {
 380                 return {
 381                     source: d['provider-group-id'],
 382                     target: d['consumer-group-id'],
 383                     policy: d['group-rule'][0]['action-ref'].map(function(r) {
 384                         return r.name;
 385                     })
 386                 };
 387             });
 388         };
 389
 390         var gbpLegend = {
 391             'epg' : GBPConstants.colors[GBPConstants.strings.sigmaTopoDefault]
 392         };
 393
 394         legends[GBPConstants.strings.empty] = {};
 395         legends[GBPConstants.strings.config] = gbpLegend;
 396         legends[GBPConstants.strings.oper] = gbpLegend;
 397         legends[GBPConstants.strings.mock] = gbpLegend;
 398         legends[GBPConstants.strings.l2l3] = {
 399             'l2-flood': GBPConstants.colors[GBPConstants.strings.flood],
 400             'l2-bridge': GBPConstants.colors[GBPConstants.strings.bridge],
 401             'l3-context': GBPConstants.colors[GBPConstants.strings.l3ctx],
 402             'subnet': GBPConstants.colors[GBPConstants.strings.subnet],
 403             'link': GBPConstants.colors[GBPConstants.strings.subnet+'-']
 404         };
 405
 406         loaders[GBPConstants.strings.empty] = function(successCbk, errorCbk) {
 407             successCbk([], []);
 408         };
 409
 410         loaders[GBPConstants.strings.config] = function(successCbk, errorCbk, args) {
 411             var storage = args.storage || 'config',
 412                 tenantId = args.tenantId;
 413
 414
 415             TopologyDataLoaders.getSubjectsBetweenEndpointGroups(false, tenantId, function(data){
 416                 var topo = TopologyDataLoaders.getEpgTopo(data);
 417                 successCbk(topo.nodes, topo.links);
 418                 //successCbk
 419             }, errorCbk);
 420         };
 421
 422         loaders[GBPConstants.strings.oper] = function(successCbk, errorCbk, args) {
 423             var storage = args.storage || 'config',
 424                 tenantId = args.tenantId;
 425
 426             TopologyDataLoaders.getSubjectsBetweenEndpointGroups(true, tenantId, function(data){
 427                 var topo = TopologyDataLoaders.getEpgTopo(data);
 428                 successCbk(topo.nodes, topo.links);
 429                 //successCbk
 430             }, errorCbk);
 431         };
 432
 433         loaders[GBPConstants.strings.l2l3] = function(successCbk, errorCbk, args) {
 434             var storage = args.storage || 'config',
 435                 tenantId = args.tenantId;
 436
 437             if(storage && tenantId) {
 438                 TopologyDataLoaders.getL2L3(storage, tenantId, successCbk, errorCbk);
 439             } else {
 440                 //different kind of error
 441                 errorCbk();
 442             }
 443         };
 444
 445         loaders[GBPConstants.strings.mock] = function(successCbk, errorCbk) {
 446             var data = MockServices.mockTopoData();
 447             successCbk(data.nodes, data.links);
 448         };
 449
 450         ts.getConsProvLabel = function(edge, topo){
 451             var provName = '',
 452                 conName = '';
 453
 454             topo.nodes.forEach(function(n){
 455
 456                 if ( edge.source === n.id ) {
 457                     provName = n.name;
 458                 }
 459
 460                 if ( edge.target === n.id ) {
 461                     conName = n.name;
 462                 }
 463             });
 464
 465             return provName + ':' + conName;
 466         };
 467
 468         ts.getLegend = function(type) {
 469             if(type === null || legends.hasOwnProperty(type) === false) {
 470                 type = GBPConstants.strings.empty;
 471             }
 472
 473             return legends[type];
 474         };
 475
 476         ts.loadTopology = function(type, successCbk, errorCbk, args) {
 477             if(type === null || loaders.hasOwnProperty(type) === false) {
 478                 type = GBPConstants.strings.empty;
 479             }
 480
 481             loaders[type](successCbk, errorCbk, args);
 482         };
 483
 484         return ts;
 485     });
 486
 487     gbp.register.factory('GPBServices', function(GBPRestangular) {
 488
 489         var s = {};
 490
 491         s.getDefinitions = function(successCbk, errorCbk) {
 492             var restObj = GBPRestangular.one('restconf').one('operational').one('policy:subject-feature-definitions');
 493
 494             restObj.get().then(function(data) {
 495                 if(data['subject-feature-definitions']) {
 496                     var classifiersDefs = data['subject-feature-definitions']['classifier-definition'] || [],
 497                         actionsDefs = data['subject-feature-definitions']['action-definition'] || [];
 498                         successCbk(classifiersDefs, actionsDefs);
 499                 } else {
 500                     //TODO log error
 501                 }
 502             }, function(res) {
 503                 // errorCbk(res);
 504             });
 505         };
 506
 507         s.getServiceFunctionChains = function(successCbk, errorCbk) {
 508             var restObj = GBPRestangular.one('restconf').one('config').one('service-function-chain:service-function-chains');
 509
 510             restObj.get().then(function(data) {
 511                 if(data['service-function-chains']) {
 512                     successCbk(data['service-function-chains']['service-function-chain']);
 513                 } else {
 514                     //TODO log error
 515                 }
 516             }, function(res) {
 517                 // errorCbk(res);
 518             });
 519         };
 520
 521         s.getUUIDnumber = function() {
 522             var d = new Date().getTime();
 523             return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
 524                         var r = (d + Math.random()*16)%16 | 0;
 525                         d = Math.floor(d/16);
 526                         return (c=='x' ? r : (r&0x3|0x8)).toString(16);
 527                     });
 528         };
 529
 530         s.createRestObj = function(storage) {
 531             storage = storage || 'config';
 532             restObj = GBPRestangular.one('restconf').one(storage);
 533
 534             return restObj;
 535         };
 536
 537         s.send = function(restObj, reqData, successCbk, errorCbk) {
 538             restObj.customPUT(reqData).then(function(data) {
 539                 successCbk(data);
 540             }, function(res) {
 541                 errorCbk(res.data, res.status);
 542             });
 543         };
 544
 545         s.post = function(restObj, reqData, successCbk, errorCbk) {
 546             restObj.customPOST(reqData).then(function(data) {
 547                 successCbk(data);
 548             }, function(res) {
 549                 errorCbk(res.data, res.status);
 550             });
 551         };
 552
 553         s.delete = function(restObj, successCbk, errorCbk) {
 554             restObj.remove().then(function(data) {
 555                 successCbk(data);
 556             }, function(res) {
 557                 errorCbk(res.data, res.status);
 558             });
 559         };
 560
 561         s.load = function(restObj, transformCallback, successCbk, errorCbk) {
 562             restObj.get().then(function(data) {
 563                 var objs = transformCallback(data) || [];
 564                 successCbk(objs);
 565             }, function(res) {
 566                 errorCbk(res.data, res.status);
 567             });
 568         };
 569
 570         s.stripNullValues = function(obj) {
 571             Object.keys(obj).forEach(function(k) {
 572                 if(obj[k] === null) {
 573                     delete obj[k];
 574                 }
 575             });
 576
 577             return obj;
 578         };
 579
 580         s.removeEmptyElementsFromList = function(list) {
 581             return list.filter(function(e) {
 582                 return e !== "";
 583             });
 584         };
 585
 586         s.createParamObj = function(name, type, value) {
 587             var obj = { name: name };
 588
 589             obj[type+'-value'] = value;
 590
 591             return obj;
 592         };
 593
 594         s.getInstanceParamValue = function(param) {
 595             return param['int-value'] || param['string-value'] || param['range-value'];
 596         };
 597
 598         s.getDefinitionObjParams = function(defObj, id) {
 599             var obj = defObj.filter(function(def) {
 600                     return def.id === id;
 601                 })[0],
 602                 params = (obj && obj.parameter) ? obj.parameter : [];
 603
 604             return params;
 605
 606         };
 607
 608         s.getPropFromListByProp = function(list, propSrc, targetValue, propDst) {
 609             var output = null,
 610                 selectedObj = list.filter(function(e) {
 611                     return e[propSrc] === targetValue;
 612                 })[0];
 613
 614             if(selectedObj) {
 615                 if(propDst) {
 616                     output = selectedObj[propDst];
 617                 } else {
 618                     output = selectedObj;
 619                 }
 620             }
 621
 622             return output;
 623         };
 624
 625         return s;
 626
 627     });
 628
 629     gbp.register.factory('GBPGovernanceServices', function(TopologyDataLoaders) {
 630         var s = {};
 631
 632         var subjectInList = function(subjectName, subjectList) {
 633             return subjectList.some(function(s) {
 634                 return s.name === subjectName;
 635             });
 636         };
 637
 638         var EPG = function(epgId, tenantId) {
 639             this.id = epgId;
 640             this.tenantId = tenantId;
 641         };
 642
 643         var Subject = function(name) {
 644             this.name = name;
 645             this.rules = [];
 646             this.providers = [];
 647             this.consumers = [];
 648
 649             this.addProvider = function(providingEpg) {
 650                 if(this.providers.indexOf(providingEpg) === -1) {
 651                     this.providers.push(providingEpg);
 652                 }
 653             };
 654
 655             this.addConsumer = function(consumingEpg) {
 656                 if(this.consumers.indexOf(consumingEpg) === -1) {
 657                     this.consumers.push(consumingEpg);
 658                 }
 659             };
 660
 661             this.addRule = function(rule, classifierInstances) {
 662                 if(rule['classifier-ref'] && rule['classifier-ref'].length > 0) {
 663
 664                     rule['classifier-ref'].forEach(function(cr) {
 665                         //cr['parameters'] = [];
 666                         classifierInstances.forEach(function(ci) {
 667                             if(ci['name'] === cr['instance-name']) {
 668                                 cr['parameters'] = ci['parameter-value'];
 669                             }
 670                         });
 671                     });
 672                 }
 673
 674                 this.rules.push(rule);
 675             };
 676         };
 677
 678         var addEpg = function(epgList, epgId, tenantId) {
 679                 var addedEpg = null;
 680
 681                 if(epgList.some(function(epg) {
 682                     return epg.id === epgId && epg.tenantId === tenantId;
 683                 }) === false) {
 684                     addedEpg = new EPG(epgId, tenantId);
 685                 }
 686
 687                 if(addedEpg !== null) {
 688                     epgList.push(addedEpg);
 689                 }
 690
 691                 return addedEpg;
 692             },
 693             addSubject = function(subject, subjects, providerEpg, consumerEpg, classifierInstances) {
 694                 //console.log('classifierInstances:', classifierInstances);
 695                 var existingSubject = subjects.filter(function(s) {
 696                         return s.name === subject.name;
 697                     })[0],
 698                     newSubject = (existingSubject === undefined);
 699
 700                 if(newSubject) {
 701                     existingSubject = new Subject(subject.name);
 702                 }
 703
 704                 existingSubject.addProvider(providerEpg);
 705                 existingSubject.addConsumer(consumerEpg);
 706
 707                 if(subject['ui-rule'] && subject['ui-rule'].length > 0) {
 708                     subject['ui-rule'].forEach(function(r) {
 709                         existingSubject.addRule(r, classifierInstances);
 710                     });
 711                 }
 712
 713                 if(newSubject) {
 714                     subjects.push(existingSubject);
 715                 }
 716             },
 717             processPairData = function(providers, consumers, subjects, pairData, classifierInstances) {
 718                 addEpg(providers, pairData['provider-endpoint-group-id'], pairData['provider-tenant-id']);
 719                 addEpg(consumers, pairData['consumer-endpoint-group-id'], pairData['consumer-tenant-id']);
 720
 721                 pairData['ui-subject'].forEach(function(s) {
 722                     addSubject(s, subjects, pairData['provider-endpoint-group-id'], pairData['consumer-endpoint-group-id'], classifierInstances);
 723                 });
 724             };
 725
 726         s.getEPGsAndSubjects = function(tenantId, classifierInstances, successCbk, errorCbk) {
 727             TopologyDataLoaders.getSubjectsBetweenEndpointGroups(false, tenantId,
 728                 function(data) {
 729                     var epgPairs = data.output['endpoint-group-pair-with-subject'],
 730                         consumers = [],
 731                         providers = [],
 732                         subjects = [];
 733
 734                     if(epgPairs) {
 735                         epgPairs.forEach(function(p) {
 736                             processPairData(providers, consumers, subjects, p, classifierInstances);
 737                         });
 738                     }
 739
 740                     successCbk({providers: providers, consumers: consumers, subjects: subjects});
 741                 },
 742                 function() {
 743                     //TODO log error
 744             });
 745         };
 746
 747         return s;
 748     });
 749
 750     gbp.register.factory('GBPTenantServices', function(GPBServices) {
 751
 752         var s = {};
 753
 754         var Tenant = function(id, name, description) {
 755             this.id = id || GPBServices.getUUIDnumber();
 756             this.name = name || null;
 757             this.description = description || null;
 758         };
 759
 760         var createBaseRestObj = function() {
 761             return GPBServices
 762                 .createRestObj().one('policy:tenants');
 763         };
 764
 765         var createRestObj = function(pathObj) {
 766             return createBaseRestObj().one('tenant').one(pathObj.tenantId);
 767         };
 768
 769         var transformCallback = function(rawData) {
 770             // return rawData.map(function(rawObj){
 771             //     return new Tenant(rawObj.id, rawObj.name, rawObj.description);
 772             // });
 773             return rawData.tenants.tenant;
 774         };
 775
 776         var createData = function(obj) {
 777             return { tenant : [ GPBServices.stripNullValues(obj) ] };
 778         };
 779
 780         s.createPathObj = function(tenantId) {
 781             return {
 782                 tenantId: tenantId
 783             };
 784         };
 785
 786         s.createObj = function() {
 787             return new Tenant();
 788         };
 789
 790         s.send = function(path, obj, successCbk, errorCbk) {
 791             var restObj = createRestObj(path),
 792                 reqData = createData(obj);
 793
 794             GPBServices.send(restObj, reqData, successCbk, errorCbk);
 795         };
 796
 797         s.modify = function(path, obj, successCbk, errorCbk) {
 798             var restObj = createRestObj(path),
 799                 reqData = createData(obj);
 800
 801             GPBServices.send(restObj, reqData, successCbk, errorCbk);
 802         };
 803
 804         s.delete = function(path, successCbk, errorCbk) {
 805             var restObj = createRestObj(path);
 806
 807             GPBServices.delete(restObj, successCbk, errorCbk);
 808         };
 809
 810         s.load = function(successCbk, errorCbk) {
 811             var restObj = createBaseRestObj();
 812             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
 813         };
 814
 815         return s;
 816
 817     });
 818
 819     gbp.register.factory('GBPContractServices', function(GPBServices) {
 820
 821         var s = {};
 822
 823         var Contract = function(id, description, parent) {
 824             this.id = id || GPBServices.getUUIDnumber();
 825             this.description = description || null;
 826             this.parent = parent || null;
 827         };
 828
 829         var createBaseRestObj = function(pathObj) {
 830             return GPBServices.createRestObj().one('policy:tenants').one('tenant').one(pathObj.tenantId);
 831         };
 832
 833         var createRestObj = function(pathObj) {
 834             return createBaseRestObj(pathObj).one('contract').one(pathObj.contractId);
 835         };
 836
 837         var transformCallback = function(rawData) {
 838             // return rawData.map(function(rawObj){
 839             //     return new Contract(rawObj.id, rawObj.description);
 840             // });
 841             return rawData.tenant[0].contract;
 842         };
 843
 844         var createData = function(obj) {
 845             return { contract : [ GPBServices.stripNullValues(obj) ] };
 846         };
 847
 848         s.createPathObj = function(tenantId, contractId) {
 849             return {
 850                 tenantId: tenantId,
 851                 contractId: contractId
 852             };
 853         };
 854
 855         s.createObj = function() {
 856             return new Contract();
 857         };
 858
 859         s.send = function(path, obj, successCbk, errorCbk) {
 860             var restObj = createRestObj(path),
 861                 reqData = createData(obj);
 862
 863             GPBServices.send(restObj, reqData, successCbk, errorCbk);
 864         };
 865
 866         s.delete = function(path, successCbk, errorCbk) {
 867             var restObj = createRestObj(path);
 868
 869             GPBServices.delete(restObj, successCbk, errorCbk);
 870         };
 871
 872         s.load = function(path, successCbk, errorCbk) {
 873             var restObj = createBaseRestObj(path);
 874
 875             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
 876         };
 877
 878         return s;
 879
 880     });
 881
 882     gbp.register.factory('GBPClauseServices', function(GPBServices) {
 883
 884         var s = {};
 885
 886         var Clause = function(name, subjectRefs) {
 887             this.name = name || null;
 888             this['subject-refs'] = subjectRefs || [];
 889         };
 890
 891         var createBaseRestObj = function(pathObj) {
 892             return GPBServices.createRestObj()
 893                 .one('policy:tenants').one('tenant').one(pathObj.tenantId)
 894                 .one('contract').one(pathObj.contractId);
 895         };
 896
 897         var createRestObj = function(pathObj) {
 898             return createBaseRestObj(pathObj).one('clause').one(pathObj.clauseId);
 899         };
 900
 901         var transformCallback = function(rawData) {
 902             var data = null,
 903                 clauseData = rawData.contract[0].clause;
 904
 905             if(clauseData) {
 906                 data = clauseData.map(function(elem) {
 907                     if(elem.hasOwnProperty('subject-refs') === false) {
 908                         elem['subject-refs'] = [];
 909                     }
 910                     return elem;
 911                 });
 912             }
 913
 914             return data;
 915         };
 916
 917         var createData = function(obj) {
 918             var o = GPBServices.stripNullValues(obj);
 919
 920             if(o['subject-refs']) {
 921                 o['subject-refs'] = GPBServices.removeEmptyElementsFromList(o['subject-refs']);
 922             }
 923
 924             return { clause : [ o ] };
 925         };
 926
 927         s.createPathObj = function(tenantId, contractId, clauseId) {
 928             return {
 929                 tenantId: tenantId,
 930                 contractId: contractId,
 931                 clauseId: clauseId
 932             };
 933         };
 934
 935         s.createObj = function() {
 936             return new Clause();
 937         };
 938
 939         s.send = function(path, obj, successCbk, errorCbk) {
 940             var restObj = createRestObj(path),
 941                 reqData = createData(obj);
 942
 943             GPBServices.send(restObj, reqData, successCbk, errorCbk);
 944         };
 945
 946         s.delete = function(path, successCbk, errorCbk) {
 947             var restObj = createRestObj(path);
 948
 949             GPBServices.delete(restObj, successCbk, errorCbk);
 950         };
 951
 952         s.load = function(path, successCbk, errorCbk) {
 953             var restObj = createBaseRestObj(path);
 954
 955             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
 956         };
 957
 958         return s;
 959
 960     });
 961
 962     gbp.register.factory('GBPSubjectServices', function(GPBServices) {
 963
 964         var s = {};
 965
 966         var Subject = function(name, order) {
 967             this.name = name || null;
 968             this.order = order || null;
 969         };
 970
 971         var createBaseRestObj = function(pathObj) {
 972             return GPBServices.createRestObj()
 973                 .one('policy:tenants').one('tenant').one(pathObj.tenantId)
 974                 .one('contract').one(pathObj.contractId);
 975         };
 976
 977         var createRestObj = function(pathObj) {
 978             return createBaseRestObj(pathObj).one('subject').one(pathObj.subjectId);
 979         };
 980
 981         var transformCallback = function(rawData) {
 982             // return rawData.map(function(rawObj){
 983             //     return new Subject(rawObj.name, rawObj.order);
 984             // });
 985             return rawData.contract[0].subject;
 986         };
 987
 988         var createData = function(obj) {
 989             return { subject : [ GPBServices.stripNullValues(obj) ] };
 990         };
 991
 992         s.createPathObj = function(tenantId, contractId, subjectId) {
 993             return {
 994                 tenantId: tenantId,
 995                 contractId: contractId,
 996                 subjectId: subjectId
 997             };
 998         };
 999
1000         s.createObj = function() {
1001             return new Subject();
1002         };
1003
1004         s.send = function(path, obj, successCbk, errorCbk) {
1005             var restObj = createRestObj(path),
1006                 reqData = createData(obj);
1007
1008             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1009         };
1010
1011         s.delete = function(path, successCbk, errorCbk) {
1012             var restObj = createRestObj(path);
1013
1014             GPBServices.delete(restObj, successCbk, errorCbk);
1015         };
1016
1017         s.load = function(path, successCbk, errorCbk) {
1018             var restObj = createBaseRestObj(path);
1019
1020             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1021         };
1022
1023         return s;
1024
1025     });
1026
1027     gbp.register.factory('GBPRuleServices', function(GPBServices) {
1028
1029         var s = {};
1030
1031         var Rule = function(name, order) {
1032             this.name = name || null;
1033             this.order = order || null;
1034         };
1035
1036         var createBaseRestObj = function(pathObj) {
1037             return GPBServices.createRestObj()
1038                 .one('policy:tenants').one('tenant')
1039                 .one(pathObj.tenantId).one('contract').one(pathObj.contractId)
1040                 .one('subject').one(pathObj.subjectId);
1041         };
1042
1043         var createRestObj = function(pathObj) {
1044             return createBaseRestObj(pathObj).one('rule').one(pathObj.ruleId);
1045         };
1046
1047         var transformCallback = function(rawData) {
1048             // return rawData.map(function(rawObj){
1049             //     return new Rule(rawObj.name, rawObj.order);
1050             // });
1051             return rawData.subject[0].rule;
1052         };
1053
1054         var createData = function(obj) {
1055             return { rule : [ GPBServices.stripNullValues(obj) ] };
1056         };
1057
1058         s.createPathObj = function(tenantId, contractId, subjectId, ruleId) {
1059             return {
1060                 tenantId: tenantId,
1061                 contractId: contractId,
1062                 subjectId: subjectId,
1063                 ruleId: ruleId
1064             };
1065         };
1066
1067         s.createObj = function() {
1068             return new Rule();
1069         };
1070
1071         s.send = function(path, obj, successCbk, errorCbk) {
1072             var restObj = createRestObj(path),
1073                 reqData = createData(obj);
1074
1075             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1076         };
1077
1078         s.delete = function(path, successCbk, errorCbk) {
1079             var restObj = createRestObj(path);
1080
1081             GPBServices.delete(restObj, successCbk, errorCbk);
1082         };
1083
1084         s.load = function(path, successCbk, errorCbk) {
1085             var restObj = createBaseRestObj(path);
1086
1087             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1088         };
1089
1090         return s;
1091
1092     });
1093
1094     gbp.register.factory('GBPClassifierRefsServices', function(GPBServices) {
1095
1096         var s = {};
1097
1098         var ClassifierRef = function(name, direction, instanceName, connectionTracking) {
1099             this.name = name || null;
1100             this.direction = direction || null;
1101             this['instance-name'] = instanceName || null;
1102             this['connection-tracking'] = connectionTracking || null;
1103         };
1104
1105         var createBaseRestObj = function(pathObj) {
1106             return GPBServices.createRestObj()
1107                 .one('policy:tenants').one('tenant')
1108                 .one(pathObj.tenantId).one('contract').one(pathObj.contractId)
1109                 .one('subject').one(pathObj.subjectId)
1110                 .one('rule').one(pathObj.ruleId);
1111         };
1112
1113         var createRestObj = function(pathObj) {
1114             return createBaseRestObj(pathObj).one('classifier-ref').one(pathObj.classifierRefId);
1115         };
1116
1117         var transformCallback = function(rawData) {
1118             // return rawData.map(function(rawObj){
1119             //     return new ClassifierRef(rawObj.name, rawObj.direction, rawObj['instance-name']);
1120             // });
1121             return rawData.rule[0]['classifier-ref'];
1122         };
1123
1124         var createData = function(obj) {
1125             return { 'classifier-ref' : [ GPBServices.stripNullValues(obj) ] };
1126         };
1127
1128         s.createPathObj = function(tenantId, contractId, subjectId, ruleId, classifierRefId) {
1129             return {
1130                 tenantId: tenantId,
1131                 contractId: contractId,
1132                 subjectId: subjectId,
1133                 ruleId: ruleId,
1134                 classifierRefId: classifierRefId
1135             };
1136         };
1137
1138         s.createObj = function() {
1139             return new ClassifierRef();
1140         };
1141
1142         s.send = function(path, obj, successCbk, errorCbk) {
1143             var restObj = createRestObj(path),
1144                 reqData = createData(obj);
1145
1146             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1147         };
1148
1149         s.delete = function(path, successCbk, errorCbk) {
1150             var restObj = createRestObj(path);
1151
1152             GPBServices.delete(restObj, successCbk, errorCbk);
1153         };
1154
1155         s.load = function(path, successCbk, errorCbk) {
1156             var restObj = createBaseRestObj(path);
1157
1158             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1159         };
1160
1161         return s;
1162
1163     });
1164
1165     gbp.register.factory('GBPActionRefsServices', function(GPBServices) {
1166
1167         var s = {};
1168
1169         var ActionRef = function(name, order, instanceName) {
1170             this.name = name || null;
1171             this.order = order || null;
1172         };
1173
1174         var createBaseRestObj = function(pathObj) {
1175             return GPBServices.createRestObj()
1176                 .one('policy:tenants').one('tenant')
1177                 .one(pathObj.tenantId).one('contract').one(pathObj.contractId)
1178                 .one('subject').one(pathObj.subjectId)
1179                 .one('rule').one(pathObj.ruleId);
1180         };
1181
1182         var createRestObj = function(pathObj) {
1183             return createBaseRestObj(pathObj).one('action-ref').one(pathObj.actionRefId);
1184         };
1185
1186         var transformCallback = function(rawData) {
1187             // return rawData.map(function(rawObj){
1188             //     return new ActionRef(rawObj.name, rawObj.order);
1189             // });
1190             return rawData.rule[0]['action-ref'];
1191         };
1192
1193         var createData = function(obj) {
1194             return { 'action-ref' : [ GPBServices.stripNullValues(obj) ] };
1195         };
1196
1197         s.createPathObj = function(tenantId, contractId, subjectId, ruleId, actionRefId) {
1198             return {
1199                 tenantId: tenantId,
1200                 contractId: contractId,
1201                 subjectId: subjectId,
1202                 ruleId: ruleId,
1203                 actionRefId: actionRefId
1204             };
1205         };
1206
1207         s.createObj = function() {
1208             return new ActionRef();
1209         };
1210
1211         s.send = function(path, obj, successCbk, errorCbk) {
1212             var restObj = createRestObj(path),
1213                 reqData = createData(obj);
1214
1215             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1216         };
1217
1218         s.delete = function(path, successCbk, errorCbk) {
1219             var restObj = createRestObj(path);
1220
1221             GPBServices.delete(restObj, successCbk, errorCbk);
1222         };
1223
1224         s.load = function(path, successCbk, errorCbk) {
1225             var restObj = createBaseRestObj(path);
1226
1227             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1228         };
1229
1230         return s;
1231
1232     });
1233
1234     gbp.register.factory('GBPL2FloodDomainServices', function(GPBServices) {
1235
1236         var s = {};
1237
1238         var L2FloodDomain = function(id, name, description, parent) {
1239             this.id = id || GPBServices.getUUIDnumber();
1240             this.name = name || null;
1241             this.description = description || null;
1242             this.parent = parent || null;
1243         };
1244
1245         var createBaseRestObj = function(pathObj) {
1246             return GPBServices.createRestObj()
1247                 .one('policy:tenants').one('tenant').one(pathObj.tenantId);
1248         };
1249
1250         var createRestObj = function(pathObj) {
1251             return createBaseRestObj(pathObj).one('l2-flood-domain').one(pathObj.l2FloodDomain);
1252         };
1253
1254         var transformCallback = function(rawData) {
1255             // return rawData.map(function(rawObj){
1256             //     return new L2FloodDomain(rawObj.id, rawObj.name, rawObj.description, rawObj.parent);
1257             // });
1258             return rawData.tenant[0]['l2-flood-domain'];
1259         };
1260
1261         var createData = function(obj) {
1262             return { 'l2-flood-domain' : [ GPBServices.stripNullValues(obj) ] };
1263         };
1264
1265         s.createPathObj = function(tenantId, l2FloodDomain) {
1266             return {
1267                 tenantId: tenantId,
1268                 l2FloodDomain: l2FloodDomain
1269             };
1270         };
1271
1272         s.createObj = function() {
1273             return new L2FloodDomain();
1274         };
1275
1276         s.send = function(path, obj, successCbk, errorCbk) {
1277             var restObj = createRestObj(path),
1278                 reqData = createData(obj);
1279
1280             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1281         };
1282
1283         s.delete = function(path, successCbk, errorCbk) {
1284             var restObj = createRestObj(path);
1285
1286             GPBServices.delete(restObj, successCbk, errorCbk);
1287         };
1288
1289         s.load = function(path, successCbk, errorCbk) {
1290             var restObj = createBaseRestObj(path);
1291
1292             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1293         };
1294
1295         return s;
1296
1297     });
1298
1299     gbp.register.factory('GBPL2BridgeDomainServices', function(GPBServices) {
1300
1301         var s = {};
1302
1303         var L2BridgeDomain = function(id, name, description, parent) {
1304             this.id = id || GPBServices.getUUIDnumber();
1305             this.name = name || null;
1306             this.description = description || null;
1307             this.parent = parent || null;
1308         };
1309
1310         var createBaseRestObj = function(pathObj) {
1311             return GPBServices.createRestObj()
1312                 .one('policy:tenants').one('tenant')
1313                 .one(pathObj.tenantId);
1314         };
1315
1316         var createRestObj = function(pathObj) {
1317             return createBaseRestObj(pathObj).one('l2-bridge-domain').one(pathObj.l2BridgeDomain);
1318         };
1319
1320         var transformCallback = function(rawData) {
1321             // return rawData.map(function(rawObj){
1322             //     return new L2BridgeDomain(rawObj.id, rawObj.name, rawObj.description, rawObj.parent);
1323             // });
1324             return rawData.tenant[0]['l2-bridge-domain'];
1325         };
1326
1327         var createData = function(obj) {
1328             return { 'l2-bridge-domain' : [ GPBServices.stripNullValues(obj) ] };
1329         };
1330
1331         s.createPathObj = function(tenantId, l2BridgeDomain) {
1332             return {
1333                 tenantId: tenantId,
1334                 l2BridgeDomain: l2BridgeDomain
1335             };
1336         };
1337
1338         s.createObj = function() {
1339             return new L2BridgeDomain();
1340         };
1341
1342         s.send = function(path, obj, successCbk, errorCbk) {
1343             var restObj = createRestObj(path),
1344                 reqData = createData(obj);
1345
1346             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1347         };
1348
1349         s.delete = function(path, successCbk, errorCbk) {
1350             var restObj = createRestObj(path);
1351
1352             GPBServices.delete(restObj, successCbk, errorCbk);
1353         };
1354
1355         s.load = function(path, successCbk, errorCbk) {
1356             var restObj = createBaseRestObj(path);
1357
1358             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1359         };
1360
1361         return s;
1362
1363     });
1364
1365     gbp.register.factory('GBPL3ContextServices', function(GPBServices) {
1366
1367         var s = {};
1368
1369         var L3Context = function(id, name, description) {
1370             this.id = id || GPBServices.getUUIDnumber();
1371             this.name = name || null;
1372             this.description = description || null;
1373         };
1374
1375         var createBaseRestObj = function(pathObj) {
1376             return GPBServices.createRestObj()
1377                 .one('policy:tenants').one('tenant').one(pathObj.tenantId);
1378         };
1379
1380         var createRestObj = function(pathObj) {
1381             return createBaseRestObj(pathObj).one('l3-context').one(pathObj.l3Context);
1382         };
1383
1384         var transformCallback = function(rawData) {
1385             // return rawData.map(function(rawObj){
1386             //     return new L3Context(rawObj.id, rawObj.name, rawObj.description);
1387             // });
1388             return rawData.tenant[0]['l3-context'];
1389         };
1390
1391         var createData = function(obj) {
1392             return { 'l3-context' : [ GPBServices.stripNullValues(obj) ] };
1393         };
1394
1395         s.createPathObj = function(tenantId, l3Context) {
1396             return {
1397                 tenantId: tenantId,
1398                 l3Context: l3Context
1399             };
1400         };
1401
1402         s.createObj = function() {
1403             return new L3Context();
1404         };
1405
1406         s.send = function(path, obj, successCbk, errorCbk) {
1407             var restObj = createRestObj(path),
1408                 reqData = createData(obj);
1409
1410             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1411         };
1412
1413         s.delete = function(path, successCbk, errorCbk) {
1414             var restObj = createRestObj(path);
1415
1416             GPBServices.delete(restObj, successCbk, errorCbk);
1417         };
1418
1419         s.load = function(path, successCbk, errorCbk) {
1420             var restObj = createBaseRestObj(path);
1421
1422             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1423         };
1424
1425         return s;
1426
1427     });
1428
1429     gbp.register.factory('GBPSubnetServices', function(GPBServices) {
1430
1431         var s = {};
1432
1433         var Subnet = function(id, name, description, parent, ipPrefix, virtualRouterIp) {
1434             this.id = id || GPBServices.getUUIDnumber();
1435             this.name = name || null;
1436             this.description = description || null;
1437             this.parent = parent || null;
1438             this['ip-prefix'] = ipPrefix || null;
1439             this['virtual-router-ip'] = virtualRouterIp || null;
1440         };
1441
1442         var createBaseRestObj = function(pathObj) {
1443             return GPBServices.createRestObj()
1444                 .one('policy:tenants').one('tenant').one(pathObj.tenantId);
1445         };
1446
1447         var createRestObj = function(pathObj) {
1448             return createBaseRestObj(pathObj).one('subnet').one(pathObj.subnet);
1449         };
1450
1451         var transformCallback = function(rawData) {
1452             // return rawData.map(function(rawObj){
1453             //     return new L3Context(rawObj.id, rawObj.name, rawObj.description);
1454             // });
1455             return rawData.tenant[0]['subnet'];
1456         };
1457
1458         var createData = function(obj) {
1459             return { 'subnet' : [ GPBServices.stripNullValues(obj) ] };
1460         };
1461
1462         s.createPathObj = function(tenantId, subnet) {
1463             return {
1464                 tenantId: tenantId,
1465                 subnet: subnet
1466             };
1467         };
1468
1469         s.createObj = function() {
1470             return new Subnet();
1471         };
1472
1473         s.send = function(path, obj, successCbk, errorCbk) {
1474             var restObj = createRestObj(path),
1475                 reqData = createData(obj);
1476
1477             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1478         };
1479
1480         s.delete = function(path, successCbk, errorCbk) {
1481             var restObj = createRestObj(path);
1482
1483             GPBServices.delete(restObj, successCbk, errorCbk);
1484         };
1485
1486         s.load = function(path, successCbk, errorCbk) {
1487             var restObj = createBaseRestObj(path);
1488
1489             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1490         };
1491
1492         return s;
1493
1494     });
1495
1496     gbp.register.factory('GBPGatewayServices', function(GPBServices) {
1497
1498         var s = {};
1499
1500         var Gateway = function(gateway) {
1501             this.gateway = gateway || null;
1502         };
1503
1504         var createBaseRestObj = function(pathObj) {
1505             return GPBServices.createRestObj()
1506                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('subnet').one(pathObj.subnetId);
1507         };
1508
1509         var createRestObj = function(pathObj) {
1510             return createBaseRestObj(pathObj).one('gateways').one(pathObj.gateway);
1511         };
1512
1513         var transformCallback = function(rawData) {
1514             // return rawData.map(function(rawObj){
1515             //     return new L3Context(rawObj.id, rawObj.name, rawObj.description);
1516             // });
1517             return rawData.subnet[0]['gateways'];
1518         };
1519
1520         var createData = function(obj) {
1521             return { 'gateways' : [ GPBServices.stripNullValues(obj) ] };
1522         };
1523
1524         s.createPathObj = function(tenantId, subnetId, gateway) {
1525             return {
1526                 tenantId: tenantId,
1527                 subnetId: subnetId,
1528                 gateway: gateway
1529             };
1530         };
1531
1532         s.createObj = function() {
1533             return new Gateway();
1534         };
1535
1536         s.send = function(path, obj, successCbk, errorCbk) {
1537             var restObj = createRestObj(path),
1538                 reqData = createData(obj);
1539
1540             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1541         };
1542
1543         s.delete = function(path, successCbk, errorCbk) {
1544             var restObj = createRestObj(path);
1545
1546             GPBServices.delete(restObj, successCbk, errorCbk);
1547         };
1548
1549         s.load = function(path, successCbk, errorCbk) {
1550             var restObj = createBaseRestObj(path);
1551
1552             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1553         };
1554
1555         return s;
1556
1557     });
1558
1559     gbp.register.factory('GBPPrefixServices', function(GPBServices) {
1560
1561         var s = {};
1562
1563         var Prefix = function(prefix) {
1564             this.prefix = prefix || null;
1565         };
1566
1567         var createBaseRestObj = function(pathObj) {
1568             return GPBServices.createRestObj()
1569                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('subnet').one(pathObj.subnetId).one('gateways').one(pathObj.gatewayId);
1570         };
1571
1572         var createRestObj = function(pathObj) {
1573             return createBaseRestObj(pathObj).one('prefixes').one(pathObj.prefixId);
1574         };
1575
1576         var transformCallback = function(rawData) {
1577             // return rawData.map(function(rawObj){
1578             //     return new L3Context(rawObj.id, rawObj.name, rawObj.description);
1579             // });
1580             return rawData.gateways[0].prefixes;
1581         };
1582
1583         var createData = function(obj) {
1584             return { 'prefixes' : [ GPBServices.stripNullValues(obj) ] };
1585         };
1586
1587         s.createPathObj = function(tenantId, subnetId, gatewayId, prefixId) {
1588             return {
1589                 tenantId: tenantId,
1590                 subnetId: subnetId,
1591                 gatewayId: gatewayId,
1592                 prefixId: prefixId ? prefixId.replace("/", "%2F") : prefixId
1593             };
1594         };
1595
1596         s.createObj = function() {
1597             return new Prefix();
1598         };
1599
1600         s.send = function(path, obj, successCbk, errorCbk) {
1601             var restObj = createRestObj(path),
1602                 reqData = createData(obj);
1603
1604             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1605         };
1606
1607         s.delete = function(path, successCbk, errorCbk) {
1608             var restObj = createRestObj(path);
1609
1610             GPBServices.delete(restObj, successCbk, errorCbk);
1611         };
1612
1613         s.load = function(path, successCbk, errorCbk) {
1614             var restObj = createBaseRestObj(path);
1615
1616             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1617         };
1618
1619         return s;
1620
1621     });
1622
1623     gbp.register.factory('GBPClassifierInstanceServices', function(GPBServices) {
1624
1625         var s = {};
1626
1627         var ClassifierService = function(name, classifierDefId) {
1628             this.name = name || null;
1629             this['classifier-definition-id'] = classifierDefId || null;
1630             this['parameter-value'] = [];
1631         };
1632
1633         var createBaseRestObj = function(pathObj) {
1634             return GPBServices.createRestObj()
1635                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('subject-feature-instances');
1636         };
1637
1638         var createRestObj = function(pathObj) {
1639             return createBaseRestObj(pathObj).one('classifier-instance').one(pathObj.classfierInstanceId);
1640         };
1641
1642         var transformCallback = function(rawData) {
1643             return rawData['subject-feature-instances']['classifier-instance'];
1644         };
1645
1646         var createData = function(obj) {
1647             return { 'classifier-instance' : [ GPBServices.stripNullValues(obj) ] };
1648         };
1649
1650         s.createPathObj = function(tenantId, classfierInstanceId) {
1651             return {
1652                 tenantId: tenantId,
1653                 classfierInstanceId: classfierInstanceId
1654             };
1655         };
1656
1657         s.createObj = function() {
1658             return new ClassifierService();
1659         };
1660
1661         s.send = function(path, obj, successCbk, errorCbk) {
1662             var restObj = createRestObj(path),
1663                 reqData = createData(obj);
1664
1665             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1666         };
1667
1668         s.delete = function(path, successCbk, errorCbk) {
1669             var restObj = createRestObj(path);
1670
1671             GPBServices.delete(restObj, successCbk, errorCbk);
1672         };
1673
1674         s.load = function(path, successCbk, errorCbk) {
1675             var restObj = createBaseRestObj(path);
1676
1677             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1678         };
1679
1680         return s;
1681
1682     });
1683
1684     gbp.register.factory('GBPActionInstanceServices', function(GPBServices) {
1685
1686         var s = {};
1687
1688         var ActionService = function(name, actionDefId) {
1689             this.name = name || null;
1690             this['action-definition-id'] = actionDefId || null;
1691             this['parameter-value'] = [];
1692         };
1693
1694         var createBaseRestObj = function(pathObj) {
1695             return GPBServices.createRestObj()
1696                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('subject-feature-instances');
1697         };
1698
1699         var createRestObj = function(pathObj) {
1700             return createBaseRestObj(pathObj).one('action-instance').one(pathObj.actionInstanceId);
1701         };
1702
1703         var transformCallback = function(rawData) {
1704             return rawData['subject-feature-instances']['action-instance'];
1705         };
1706
1707         var createData = function(obj) {
1708             return { 'action-instance' : [ GPBServices.stripNullValues(obj) ] };
1709         };
1710
1711         s.createPathObj = function(tenantId, actionInstanceId) {
1712             return {
1713                 tenantId: tenantId,
1714                 actionInstanceId: actionInstanceId
1715             };
1716         };
1717
1718         s.createObj = function() {
1719             return new ActionService();
1720         };
1721
1722         s.send = function(path, obj, successCbk, errorCbk) {
1723             var restObj = createRestObj(path),
1724                 reqData = createData(obj);
1725
1726             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1727         };
1728
1729         s.delete = function(path, successCbk, errorCbk) {
1730             var restObj = createRestObj(path);
1731
1732             GPBServices.delete(restObj, successCbk, errorCbk);
1733         };
1734
1735         s.load = function(path, successCbk, errorCbk) {
1736             var restObj = createBaseRestObj(path);
1737
1738             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1739         };
1740
1741         s.getDefinitions = function(successCbk, errorCbk) {
1742             var restObj = GBPRestangular.one('restconf').one('operational').one('policy:subject-feature-definitions');
1743
1744             restObj.get().then(function(data) {
1745                 successCbk(data['subject-feature-definitions']['action-definition']);
1746             }, function(res) {
1747                 // errorCbk(res);
1748             });
1749         };
1750
1751         return s;
1752
1753     });
1754
1755     gbp.register.factory('GBPEpgServices', function(GPBServices) {
1756
1757         var s = {};
1758
1759         var EPG = function(name, description, intraGroupPolicy, networkDomain, id, parent) {
1760             this.id = id || GPBServices.getUUIDnumber();
1761             this.name = name || null;
1762             this.description = description || null;
1763             this['intra-group-policy'] = intraGroupPolicy || null;
1764             this['network-domain'] = networkDomain || null;
1765             this.parent = parent || null;
1766         };
1767
1768         var createBaseRestObj = function(pathObj) {
1769             return GPBServices.createRestObj()
1770                 .one('policy:tenants').one('tenant').one(pathObj.tenantId);
1771         };
1772
1773         var createRestObj = function(pathObj) {
1774             return createBaseRestObj(pathObj).one('endpoint-group').one(pathObj.epgId);
1775         };
1776
1777         var transformCallback = function(rawData) {
1778             return rawData.tenant[0]['endpoint-group'];
1779         };
1780
1781         var createData = function(obj) {
1782             return { 'endpoint-group' : [ GPBServices.stripNullValues(obj) ] };
1783         };
1784
1785         s.createPathObj = function(tenantId, epgId) {
1786             return {
1787                 tenantId: tenantId,
1788                 epgId: epgId
1789             };
1790         };
1791
1792         s.createObj = function() {
1793             return new EPG();
1794         };
1795
1796         s.send = function(path, obj, successCbk, errorCbk) {
1797             var restObj = createRestObj(path),
1798                 reqData = createData(obj);
1799
1800             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1801         };
1802
1803         s.delete = function(path, successCbk, errorCbk) {
1804             var restObj = createRestObj(path);
1805
1806             GPBServices.delete(restObj, successCbk, errorCbk);
1807         };
1808
1809         s.load = function(path, successCbk, errorCbk) {
1810             var restObj = createBaseRestObj(path);
1811
1812             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1813         };
1814
1815         return s;
1816
1817     });
1818
1819     gbp.register.factory('GBPConNamedSelServices', function(GPBServices) {
1820
1821         var s = {};
1822
1823         var ConsumerNamedSelector = function(name, contract) {
1824             this.name = name || null;
1825             this.contract = contract || [];
1826         };
1827
1828         var createBaseRestObj = function(pathObj) {
1829             return GPBServices.createRestObj()
1830                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('endpoint-group').one(pathObj.epgId);
1831         };
1832
1833         var createRestObj = function(pathObj) {
1834             return createBaseRestObj(pathObj).one('consumer-named-selector').one(pathObj.cnsId);
1835         };
1836
1837         var transformCallback = function(rawData) {
1838             var data = null,
1839                 consumerData = rawData['endpoint-group'][0]['consumer-named-selector'];
1840
1841             if(consumerData) {
1842                 data = consumerData.map(function(elem) {
1843                     if(elem.hasOwnProperty('contract') === false) {
1844                         elem.contract = [];
1845                     }
1846                     return elem;
1847                 });
1848             }
1849
1850             return data;
1851         };
1852
1853         var createData = function(obj) {
1854             var o = GPBServices.stripNullValues(obj);
1855
1856             if(o.contract) {
1857                 o.contract = GPBServices.removeEmptyElementsFromList(o.contract);
1858             }
1859
1860             return { 'consumer-named-selector' : [ o ] };
1861         };
1862
1863         s.createPathObj = function(tenantId, epgId, cnsId) {
1864             return {
1865                 tenantId: tenantId,
1866                 epgId: epgId,
1867                 cnsId: cnsId
1868             };
1869         };
1870
1871         s.createObj = function() {
1872             return new ConsumerNamedSelector();
1873         };
1874
1875         s.send = function(path, obj, successCbk, errorCbk) {
1876             var restObj = createRestObj(path),
1877                 reqData = createData(obj);
1878
1879             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1880         };
1881
1882         s.delete = function(path, successCbk, errorCbk) {
1883             var restObj = createRestObj(path);
1884
1885             GPBServices.delete(restObj, successCbk, errorCbk);
1886         };
1887
1888         s.load = function(path, successCbk, errorCbk) {
1889             var restObj = createBaseRestObj(path);
1890
1891             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1892         };
1893
1894         return s;
1895
1896     });
1897
1898
1899     gbp.register.factory('GBPProNamedSelServices', function(GPBServices) {
1900
1901         var s = {};
1902
1903         var ProviderNamedSelector = function(name, contract) {
1904             this.name = name || null;
1905             this.contract = contract || [];
1906         };
1907
1908         var createBaseRestObj = function(pathObj) {
1909             return GPBServices.createRestObj()
1910                 .one('policy:tenants').one('tenant').one(pathObj.tenantId).one('endpoint-group').one(pathObj.epgId);
1911         };
1912
1913         var createRestObj = function(pathObj) {
1914             return createBaseRestObj(pathObj).one('provider-named-selector').one(pathObj.cnsId);
1915         };
1916
1917         var transformCallback = function(rawData) {
1918             var data = null,
1919                 provderData = rawData['endpoint-group'][0]['provider-named-selector'];
1920
1921             if(provderData) {
1922                 data = provderData.map(function(elem) {
1923                     if(elem.hasOwnProperty('contract') === false) {
1924                         elem.contract = [];
1925                     }
1926                     return elem;
1927                 });
1928             }
1929
1930             return data;
1931         };
1932
1933         var createData = function(obj) {
1934             var o = GPBServices.stripNullValues(obj);
1935
1936             if(o.contract) {
1937                 o.contract = GPBServices.removeEmptyElementsFromList(o.contract);
1938             }
1939
1940             return { 'provider-named-selector' : [ o ] };
1941         };
1942
1943         s.createPathObj = function(tenantId, epgId, cnsId) {
1944             return {
1945                 tenantId: tenantId,
1946                 epgId: epgId,
1947                 cnsId: cnsId
1948             };
1949         };
1950
1951         s.createObj = function() {
1952             return new ProviderNamedSelector();
1953         };
1954
1955         s.send = function(path, obj, successCbk, errorCbk) {
1956             var restObj = createRestObj(path),
1957                 reqData = createData(obj);
1958
1959             GPBServices.send(restObj, reqData, successCbk, errorCbk);
1960         };
1961
1962         s.delete = function(path, successCbk, errorCbk) {
1963             var restObj = createRestObj(path);
1964
1965             GPBServices.delete(restObj, successCbk, errorCbk);
1966         };
1967
1968         s.load = function(path, successCbk, errorCbk) {
1969             var restObj = createBaseRestObj(path);
1970
1971             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
1972         };
1973
1974         return s;
1975
1976     });
1977
1978     gbp.register.factory('GBPEndpointServices', function(GPBServices) {
1979
1980         var s = {};
1981
1982         var Endpoint = function(tenantId) {
1983             this.tenant = tenantId || null;
1984             this['network-containment'] = null;
1985             this['endpoint-group'] = null;
1986             this['endpoint-groups'] = [];
1987             this.condition = [];
1988             this['l2-context'] = null;
1989             this['mac-address'] = null;
1990             this['l3-address'] = [];
1991         };
1992
1993         var createRestObj = function() {
1994             return GPBServices.createRestObj('operations');
1995         };
1996
1997         var transformCallback = function(rawData) {
1998             return rawData.endpoints.endpoint;
1999         };
2000
2001         var createBaseData = function(obj) {
2002             var o = GPBServices.stripNullValues(obj);
2003
2004             if(o.condition) {
2005                 o.condition = GPBServices.removeEmptyElementsFromList(o.condition);
2006             }
2007
2008             if(o['endpoint-groups']) {
2009                 o['endpoint-groups'] = GPBServices.removeEmptyElementsFromList(o['endpoint-groups']);
2010             }
2011
2012             if(o['l3-address']) {
2013                 o['l3-address'] = GPBServices.removeEmptyElementsFromList(o['l3-address']);
2014             }
2015
2016             return o;
2017         };
2018
2019         var createSendData = function(obj) {
2020             var o = createBaseData(obj);
2021             return { 'input': o };
2022         };
2023
2024         var createDeleteData = function(obj) {
2025             var o = {
2026                 'input': {
2027                     'l3': obj['l3-address'],
2028                     'l2': [
2029                         {
2030                             'l2-context': obj['l2-context'],
2031                             'mac-address': obj['mac-address']
2032                         }
2033                     ]
2034                 }
2035             };
2036
2037             return o;
2038         };
2039
2040         s.createObj = function(tenantId) {
2041             return new Endpoint(tenantId);
2042         };
2043
2044         s.send = function(path, obj, successCbk, errorCbk) {
2045             var restObj = createRestObj().one('endpoint:register-endpoint'),
2046                 reqData = createSendData(obj);
2047
2048             GPBServices.post(restObj, reqData, successCbk, errorCbk);
2049         };
2050
2051         s.delete = function(path, obj, successCbk, errorCbk) {
2052             var restObj = createRestObj(path).one('endpoint:unregister-endpoint'),
2053                 reqData = createDeleteData(obj);
2054             GPBServices.post(restObj, reqData, successCbk, errorCbk);
2055         };
2056
2057         s.load = function(path, successCbk, errorCbk) {
2058             var restObj = GPBServices.createRestObj('operational').one('endpoint:endpoints');
2059
2060             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
2061         };
2062
2063         return s;
2064
2065     });
2066
2067     gbp.register.factory('GBPEndpointL3Services', function(GPBServices) {
2068
2069         var s = {};
2070
2071         var EndpointL3 = function(tenantId) {
2072             this.tenant = tenantId || null;
2073             this['endpoint-group'] = null;
2074             this['endpoint-groups'] = [];
2075             this.condition = [];
2076             this['l3-context'] = null;
2077             this['ip-prefix'] = null;
2078             this['endpoint-l2-gateways'] = [];
2079             this['endpoint-l3-gateways'] = [];
2080         };
2081
2082         var createRestObj = function() {
2083             return GPBServices.createRestObj('operations');
2084         };
2085
2086         var transformCallback = function(rawData) {
2087             return rawData.endpoints['endpoint-l3-prefix'];
2088         };
2089
2090         var createBaseData = function(obj) {
2091             var o = GPBServices.stripNullValues(obj);
2092
2093             if(o.condition) {
2094                 o.condition = GPBServices.removeEmptyElementsFromList(o.condition);
2095             }
2096
2097             if(o['endpoint-groups']) {
2098                 o['endpoint-groups'] = GPBServices.removeEmptyElementsFromList(o['endpoint-groups']);
2099             }
2100
2101             if(o['endpoint-l2-gateways']) {
2102                 o['endpoint-l2-gateways'] = GPBServices.removeEmptyElementsFromList(o['endpoint-l2-gateways']);
2103             }
2104
2105             if(o['endpoint-l3-gateways']) {
2106                 o['endpoint-l3-gateways'] = GPBServices.removeEmptyElementsFromList(o['endpoint-l3-gateways']);
2107             }
2108
2109             return o;
2110         };
2111
2112         var createSendData = function(obj) {
2113             var o = createBaseData(obj);
2114             return { 'input': o };
2115         };
2116
2117         var createDeleteData = function(obj) {
2118             var o = {
2119                 'input': {
2120                     'l3-prefix': [
2121                         {
2122                             'l3-context': obj['l3-context'],
2123                             'ip-prefix': obj['ip-prefix']
2124                         }
2125                     ],
2126                     'l2': obj['endpoint-l2-gateways'],
2127                     'l3': obj['endpoint-l3-gateways']
2128                 }
2129             };
2130
2131             return o;
2132         };
2133
2134         s.createObj = function(tenantId) {
2135             return new EndpointL3(tenantId);
2136         };
2137
2138         s.send = function(path, obj, successCbk, errorCbk) {
2139             var restObj = createRestObj().one('endpoint:register-l3-prefix-endpoint'),
2140                 reqData = createSendData(obj);
2141
2142             GPBServices.post(restObj, reqData, successCbk, errorCbk);
2143         };
2144
2145         s.delete = function(path, obj, successCbk, errorCbk) {
2146             var restObj = createRestObj(path).one('endpoint:unregister-endpoint'),
2147                 reqData = createDeleteData(obj);
2148
2149             GPBServices.post(restObj, reqData, successCbk, errorCbk);
2150         };
2151
2152         s.load = function(path, successCbk, errorCbk) {
2153             var restObj = GPBServices.createRestObj('operational').one('endpoint:endpoints');
2154
2155             GPBServices.load(restObj, transformCallback, successCbk, errorCbk);
2156         };
2157
2158         return s;
2159
2160     });
2161
2162     gbp.register.factory('PGNServices', function(GBPRestangular) {
2163
2164         var s = {};
2165
2166         var idGetter = {};
2167
2168         var idTypes = {
2169             tenant: 'TENANT',
2170             uuid: 'UUID',
2171             l3ctx: 'L3CTX',
2172             pathAction: 'PATHACTION',
2173             accessAction: 'ACCESSACTION'
2174         };
2175
2176         idGetter[idTypes.tenant] = function() {
2177             return 1;
2178         };
2179
2180         idGetter[idTypes.uuid] = function() {
2181             return 2;
2182         };
2183
2184         idGetter[idTypes.l3ctx] = function() {
2185             return 3;
2186         };
2187
2188         idGetter[idTypes.pathAction] = function() {
2189             return 4;
2190         };
2191
2192         idGetter[idTypes.accessAction] = function() {
2193             return 5;
2194         };
2195
2196         var getId = function(type) {
2197             if(idGetter.hasOwnProperty(type)) {
2198                 return id = idGetter[type]();
2199             } else {
2200                 throw "Cannot get idGetter for type " + type;
2201             }
2202         };
2203
2204         s.addReplaceEndpointGroup = function(successCbk, errorCbk, groupName, sgt, description) {
2205             var tenantId = getId(idTypes.tenant),
2206                 uuid = getId(idTypes.uuid),
2207                 restObj = GBPRestangular.one('restconf').one('operations'),
2208                 rpcRes = 'pgn-application:create-or-replace-endpoint-groups',
2209                 reqData = {
2210                                "input":
2211                                 {
2212                                     "endpoint-group":[
2213                                     {
2214                                         "pgn-application:tenant-id": tenantID,
2215                                         "pgn-application:id":uuid,
2216                                         "pgn-application:security-group-tag":sgt,
2217                                         "pgn-application:name":groupName,
2218                                         "pgn-application:description":description
2219                                     }
2220                                 ]
2221                             }
2222                         };
2223
2224             restObj.post(rpcRes, reqData).then(function(data) {
2225                 successCbk(data);
2226             }, function(res) {
2227                 errorCbk(res);
2228             });
2229         };
2230
2231         s.deleteEndpointGroup = function(successCbk, errorCbk, uuid) {
2232             var tenantId = getId(idTypes.tenant),
2233                 restObj = GBPRestangular.one('restconf').one('operations'),
2234                 rpcRes = 'pgn-application:delete-endpoint-groups',
2235                 reqData = {
2236                             "input": {
2237                                 "endpoint-group":[
2238                                     {
2239                                         "pgn-application:tenant-id": tenantId,
2240                                         "pgn-application:id":uuid
2241                                     }
2242                                 ]
2243                             }
2244                         };
2245
2246             restObj.post(rpcRes, reqData).then(function(data) {
2247                 successCbk(data);
2248             }, function(res) {
2249                 errorCbk(res);
2250             });
2251         };
2252
2253         s.getActions = function(successCbk, errorCbk) {
2254             var tenantId = getId(idTypes.tenant),
2255                 pathActionId = getId(idTypes.pathAction),
2256                 accessActionId = getId(idTypes.accessAction),
2257                 restObj = GBPRestangular.one('restconf').one('config').one('policy:tenants',  tenantId).one('subject-feature-instances');
2258
2259             restObj.get().then(function(data) {
2260                 successCbk(data); //TODO fill actions
2261             }, function(res) {
2262                 errorCbk(res);
2263             });
2264         };
2265
2266         s.applyPolicy = function(successCbk, errorCbk, providerId, consumerId, pathSelRule, accessCtrlRule) {
2267             var restObj = GBPRestangular.one('restconf').one('operations'),
2268                 rpcRes = 'pgn-application:wire-endpoint-groups',
2269                 actionRefName = (pathSelRule ? pathSelRule : '') + (accessCtrlRule ? accessCtrlRule : ''),
2270                 reqData = {
2271                                "input": {
2272                                     "endpoint-group-pair-with-rules": {
2273                                         "pgn-application:provider-tenant-id": tenantID,
2274                                         "pgn-application:consumer-tenant-id": tenantID,
2275                                         "pgn-application:provider-group-id":providerId,
2276                                         "pgn-application:consumer-group-id":consumerId,
2277                                         "pgn-application:group-rule": [
2278                                             {
2279                                                 "action-ref": [pathSelRule, accessCtrlRule].map(function(r) {
2280                                                     return { "name":r };
2281                                                 }),
2282                                                 "name":actionRefName
2283                                             }
2284                                         ]
2285                                     }
2286                                 }
2287                             };
2288
2289             restObj.post(rpcRes, reqData).then(function(data) {
2290                 successCbk(data); //TODO reload policies
2291             }, function(res) {
2292                 errorCbk(res);
2293             });
2294         };
2295
2296         s.deletePolicy = function(successCbk, errorCbk, providerId, consumerId) {
2297             var tenantId = getId(idTypes.tenant),
2298                 restObj = GBPRestangular.one('restconf').one('operations'),
2299                 rpcRes = 'pgn-application:unwire-endpoint-groups',
2300                 reqData = {
2301                            "input":
2302                             {
2303                                 "endpoint-group-pair":[
2304                                     {
2305                                         "pgn-application:provider-tenant-id": tenantId,
2306                                         "pgn-application:consumer-tenant-id": tenantId,
2307                                         "pgn-application:provider-group-id":providerId,
2308                                         "pgn-application:consumer-group-id":consumerId
2309                                     }
2310                                 ]
2311                             }
2312                         };
2313
2314             restObj.post(rpcRes, reqData).then(function(data) {
2315                 successCbk(data); //TODO reload policies
2316             }, function(res) {
2317                 errorCbk(res);
2318             });
2319         };
2320
2321         s.addEndPoint = function(successCbk, errorCbk, ipAddress, groupId) {
2322             var l3ctxId = getId(idTypes.l3ctx),
2323                 tenantId = getId(idTypes.tenant),
2324                 restObj = GBPRestangular.one('restconf').one('operations'),
2325                 rpcRes = 'endpoint:register-endpoint',
2326                 reqData = {
2327                             "input": {
2328                                 "endpoint-group": groupId,
2329                                 "l3-address": [
2330                                     {
2331                                         "ip-address": ipAddress,
2332                                         "l3-context": l3ctxId
2333                                     }
2334                                 ],
2335                                 "tenant": tenantId
2336                             }
2337                         };
2338
2339             restObj.post(rpcRes, reqData).then(function(data) {
2340                 successCbk(data);
2341             }, function(res) {
2342                 errorCbk(res);
2343             });
2344         };
2345
2346         s.getUUIDnumber = function() {
2347             var d = new Date().getTime();
2348             return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
2349                         var r = (d + Math.random()*16)%16 | 0;
2350                         d = Math.floor(d/16);
2351                         return (c=='x' ? r : (r&0x3|0x8)).toString(16);
2352                     });
2353         };
2354
2355         return s;
2356     });
2357
2358     gbp.register.factory('DesignGbpFactory', function(){
2359
2360         var dvf = {};
2361
2362         dvf.setMainClass = function(){
2363             if ( $('.gbpWrapper').length ) {
2364                 $('.gbpWrapper').closest('.col-xs-12').addClass('gbpGlobalWrapper');
2365               }
2366         };
2367
2368         return dvf;
2369
2370     });
2371
2372     gbp.register.factory('JointGraphOffsetFactory', function(GBPConstants){
2373         var jgof = {};
2374
2375         jgof.createWHObj = function(w, h) {
2376             return {w: w || 0, h: h || 0};
2377         };
2378
2379         jgof.updateOffsets = function(delta, offset, margin, maximums, paper) {
2380             offset.w = offset.w + delta.w + margin.w;
2381
2382             if(offset.w >= maximums.w) {
2383                 paper.setDimensions(offset.w + 30, paper.options.height);
2384                 offset.w = offset.ow;
2385                 offset.h = offset.h + margin.h;
2386             }
2387
2388         };
2389
2390         jgof.resetOffsets = function(offset, w, h) {
2391             offset.w = w;
2392             offset.h = h;
2393         };
2394
2395         jgof.getCurrentOffset = function(array, type) {
2396             var max = 0;
2397             array.forEach(function(item){
2398                 max = item.attributes.position[type] > max ? item.attributes.position[type] : max;
2399             });
2400
2401             return max;
2402         };
2403
2404         jgof.checkObjsHoffsets = function(array, size, paper) {
2405             var lastPosY = 0,
2406                 addOffset = false,
2407                 cellBottomOffset = 80,
2408                 setItemPosition = function(item, type) {
2409                     while (item.attributes.position[type] < size + cellBottomOffset) {
2410                         item.translate(null, cellBottomOffset);
2411                     }
2412                 };
2413
2414             array.forEach(function(item){
2415                 addOffset = (size + cellBottomOffset) >= item.attributes.position.y;
2416
2417                 if ( addOffset ) {
2418                     setItemPosition(item, 'y');
2419                 }
2420
2421                 if ( item.attributes.position.y + cellBottomOffset > paper.options.height ) {
2422                     paper.setDimensions(paper.options.width, paper.options.height + cellBottomOffset);
2423                 }
2424             });
2425         };
2426
2427         return jgof;
2428     });
2429
2430     gbp.register.factory('JointGraphFactory', function(GBPConstants){
2431         var defaulColor = 'blue';
2432
2433         var jgf = {};
2434
2435         jgf.getLabelLength = function(length) {
2436             return length * 10 > 200 ? 200 : length * 10;
2437         };
2438
2439         jgf.createGraph = function() {
2440             var graph = new joint.dia.Graph();
2441
2442             var paper = new joint.dia.Paper({
2443                 el: $('#graph'),
2444                 width: 1300,
2445                 height: 650,
2446                 model: graph,
2447                 gridSize: 1,
2448                 interactive: { vertexAdd: false }
2449             });
2450
2451             return paper;
2452         };
2453
2454         jgf.resetGraphDimension = function(paper, element, paddingT, paddingL){
2455             paddingT = paddingT ? paddingT : 0;
2456             paddingL = paddingL ? paddingL : paddingT;
2457
2458             var paperWidth = element.width() - paddingL,
2459                 paperHeight = element.height() - paddingT - 5;
2460
2461             paper.setDimensions(paperWidth, paperHeight);
2462         };
2463
2464         jgf.reloadGraph = function(graph) {
2465             graph.clear();
2466         };
2467
2468         jgf.createElement = function(elementName, posx, posy, width, height, objectType, object, tooltip, bgcolor, titleName) {
2469             var setWidth = function(width) {
2470                 return width < GBPConstants.jointElements.minWidth ? GBPConstants.jointElements.minWidth :
2471                        width > GBPConstants.jointElements.maxWidth ? GBPConstants.jointElements.maxWidth : width;
2472             };
2473
2474             var setHeight = function(height) {
2475                 return height < GBPConstants.jointElements.minHeight ? GBPConstants.jointElements.minHeight :
2476                        height > GBPConstants.jointElements.maxHeight ? GBPConstants.jointElements.maxHeight : height;
2477             };
2478
2479             // joint.shapes.basic.Rect = joint.shapes.basic.Generic.extend({
2480             joint.shapes.html = {};
2481             joint.shapes.html.Element = joint.shapes.basic.Generic.extend({
2482
2483                 markup: '<g class="rotatable"><g class="scalable"><rect/><title /></g><text class="text1"></text><text class="text2"></text><title /></g>',
2484
2485                 defaults: joint.util.deepSupplement({
2486                     type: 'html.Element',
2487                     attrs: {
2488                         'rect': { fill: bgcolor, stroke: 'black', 'follow-scale': true, width: 80, height: 40, cursor: 'pointer' },
2489                         '.text1': { ref: 'rect', 'ref-x': 0.5, 'ref-y': 0.3, 'y-alignment': 'middle', 'x-alignment': 'middle', cursor: 'pointer', 'font-weight' : 'bold'},
2490                         '.text2': { ref: 'rect', 'ref-x': 0.5, 'ref-y': 0.7, 'y-alignment': 'middle', 'x-alignment': 'middle', cursor: 'pointer'},
2491                         'title': {text: tooltip},
2492                     }
2493
2494                 }, joint.shapes.basic.Generic.prototype.defaults)
2495             });
2496
2497             // joint.shapes.html.ElementView = joint.dia.ElementView.extend({
2498
2499             //     template: [
2500             //         '<input class="html-element" type="text" value="'+elementName+'"/>',
2501             //         ''
2502             //     ].join(''),
2503
2504             //     initialize: function() {
2505             //         _.bindAll(this, 'updateBox');
2506             //         joint.dia.ElementView.prototype.initialize.apply(this, arguments);
2507
2508             //         this.$box = $(_.template(this.template)());
2509             //         // Prevent paper from handling pointerdown.
2510             //         this.$box.find('input,select').on('mousedown click', function(evt) { evt.stopPropagation(); });
2511             //         // This is an example of reacting on the input change and storing the input data in the cell model.
2512             //         this.$box.find('input').on('change', _.bind(function(evt) {
2513             //             this.model.set('input', $(evt.target).val());
2514             //         }, this));
2515             //         this.$box.find('button').on('click', _.bind(function(evt) {
2516             //             this.model.set('button', $('.divc').css('display','block'));
2517             //         }, this));
2518             //         // Update the box position whenever the underlying model changes.
2519             //         this.model.on('change', this.updateBox, this);
2520
2521             //         this.updateBox();
2522             //     },
2523             //     render: function() {
2524             //         joint.dia.ElementView.prototype.render.apply(this, arguments);
2525             //         this.paper.$el.prepend(this.$box);
2526             //         this.updateBox();
2527             //         return this;
2528             //     },
2529             //     updateBox: function() {
2530             //         // Set the position and dimension of the box so that it covers the JointJS element.
2531             //         var bbox = this.model.getBBox();
2532             //         // Example of updating the HTML with a data stored in the cell model.
2533             //         this.$box.css({ width: bbox.width, height: bbox.height, left: bbox.x, top: bbox.y, transform: 'rotate(' + (this.model.get('angle') || 0) + 'deg)' });
2534             //     },
2535             //     removeBox: function(evt) {
2536             //         this.$box.remove();
2537             //     }
2538             // });
2539
2540             elementName = elementName.length > 20 ? elementName.slice(0,20) + '...' : elementName;
2541             // width = width > 200 ? 200 : width;
2542
2543             // return new joint.shapes.basic.Rect({
2544             return new joint.shapes.html.Element({
2545                 position: { x: posx || 0, y: posy || 0 },
2546                 size: { width: width ||  GBPConstants.jointElements.minWidth, height: height || GBPConstants.jointElements.minHeight },
2547                 attrs: { rect: { fill: bgcolor }, '.text1': { fill: 'black', text: titleName}, '.text2': { fill: 'black', text: elementName }},
2548                 objType: objectType,
2549                 objData: object
2550             });
2551         };
2552
2553         jgf.transformElement = function(element, transformX, transformY) {
2554             return element.translate(transformX, transformY);
2555         };
2556
2557         jgf.addItem = function(graph, item) {
2558             graph.addCells([item]);
2559         };
2560
2561         jgf.addItemList = function(graph, listItem) {
2562             graph.addCells(listItem);
2563         };
2564
2565         jgf.createLink = function(srcId, targetId, colorIn, colorOut, direction, objData) {
2566             colorIn = colorIn || defaulColor;
2567             colorOut = colorOut || defaulColor;
2568
2569             var labelTextColor = GBPConstants.colors[GBPConstants.strings.sigmaTopoDefaultText],
2570                 labelBckColor = GBPConstants.colors[GBPConstants.strings.linklabel];
2571
2572             var linkObj = {
2573                 source: { id: srcId },
2574                 target: { id: targetId },
2575                 attrs: {
2576                     '.connection': { stroke: colorIn, 'stroke-width': 2, name: 'normal' },
2577                     '.connection-wrap': { 'stroke-width': 10 }
2578                 },
2579                 objData: objData
2580             };
2581
2582             if(direction === 'in' || direction == 'bidirectional' || direction === undefined || direction === null) {
2583                 linkObj.attrs['.marker-target'] = { fill: colorIn, d: 'M 10 0 L 0 5 L 10 10 z' };
2584             }
2585
2586             if(direction === 'out' || direction == 'bidirectional') {
2587                 linkObj.attrs['.marker-source'] = { fill: colorOut, d: 'M 10 0 L 0 5 L 10 10 z' };
2588             }
2589
2590             var link = new joint.dia.Link(linkObj);
2591
2592             // if(labelText) {
2593             //     link.label(0, { position: 0.3, attrs: { text: { text: labelText, fill: labelTextColor }, rect: { stroke: labelBckColor, 'stroke-width': 20 }}});
2594             // }
2595
2596
2597             return link;
2598         };
2599
2600         return jgf;
2601     });
2602
2603     gbp.register.factory('GBPJointGraphBuilder', function(GBPRestangular, GBPConstants, JointGraphFactory, JointGraphOffsetFactory, TopologyDataLoaders){
2604         var jgb = {};
2605
2606         var builders = {};
2607
2608         var buildJointData = function(paper, nodes, links) {
2609
2610         };
2611
2612         var setOperConfigTopoData = function(paper, data){
2613             var topo = TopologyDataLoaders.getEpgTopo(data);
2614
2615             var offsetObj = {
2616                     ow: 100,
2617                     oh: 100,
2618                     w: 100,
2619                     h: 100
2620                 },
2621                 marginObj = {
2622                     w: 50,
2623                     h: 80
2624                 },
2625                 offsetHobj = {
2626                     pEpg: 0,
2627                     cEpg: 0,
2628                     subject: 0
2629                 },
2630                 itemsArray = {
2631                     epg: []
2632                 },
2633                 linksArray = [];
2634
2635             JointGraphFactory.resetGraphDimension(paper, $('.policyGraphWrapper'));
2636             JointGraphFactory.reloadGraph(paper.model);
2637
2638             var deg2rad = function(deg){
2639                 return deg * Math.PI / 180;
2640             };
2641
2642             var getXYInCircle = function(elementIndex, elementsCount, paperCenterX, paperCenterY, elementWidth, elementHeight){
2643                 var result = {x:0, y:0};
2644                     circleMargin = 100;
2645                     r = (paperCenterX < paperCenterY ? paperCenterX : paperCenterY ) - circleMargin;
2646                     degs = 360 / elementsCount * (elementIndex+1) + 180;
2647                     rads = deg2rad(degs);
2648
2649                 elementWidth = elementWidth ? elementWidth : GBPConstants.jointElements.minWidth;
2650                 elementHeight = elementHeight ? elementHeight : GBPConstants.jointElements.minHeight;
2651
2652                 if(elementWidth < GBPConstants.jointElements.minWidth){elementWidth = GBPConstants.jointElements.minWidth;}
2653                 if(elementWidth > GBPConstants.jointElements.maxWidth){elementWidth = GBPConstants.jointElements.maxWidth;}
2654                 if(elementHeight < GBPConstants.jointElements.minHeight){elementHeight = GBPConstants.jointElements.minHeight;}
2655                 if(elementHeight > GBPConstants.jointElements.maxHeight){elementHeight = GBPConstants.jointElements.maxHeight;}
2656
2657                 result.x = paperCenterX + r * Math.cos(rads);
2658                 result.y = paperCenterY + r * Math.sin(rads);
2659
2660                 degs = degs % 360;
2661                 if(degs > 90 && degs < 270){
2662                     result.x = result.x - elementWidth;
2663                 }
2664                 if(degs == 90 || degs == 270){
2665                     result.x = result.x - elementWidth / 2;
2666                 }
2667                 if(degs > 180 && degs < 360){
2668                     result.y = result.y - elementHeight;
2669                 }
2670                 if(degs === 0 || degs == 180){
2671                     result.y = result.y - elementHeight / 2;
2672                 }
2673                 return result;
2674             };
2675
2676             var paperCenterX = (paper.options.width) / 2;
2677             var paperCenterY = (paper.options.height) / 2;
2678             topo.nodes.forEach(function(i, index){
2679                 var label = i.label,
2680                     header = 'Epg',
2681                     width =  Math.max(JointGraphFactory.getLabelLength(label.length), JointGraphFactory.getLabelLength(header.length)),
2682                     color = GBPConstants.colors[GBPConstants.strings.epg];
2683
2684                 var itemPos = getXYInCircle(index, topo.nodes.length, paperCenterX, paperCenterY, width, null);
2685                 var item = JointGraphFactory.createElement(label, itemPos.x, itemPos.y, width, null, GBPConstants.strings.epg , i, label, color, header);
2686
2687                 itemsArray.epg.push(item);
2688
2689                 // JointGraphOffsetFactory.updateOffsets(JointGraphOffsetFactory.createWHObj(width), offsetObj, marginObj, JointGraphOffsetFactory.createWHObj(paper.options.width, paper.options.height), paper);
2690                 JointGraphFactory.addItem(paper.model, item);
2691             });
2692
2693             var getItemById = function(id, array){
2694                 var item = array.filter(function(i){
2695                     return i.attributes.objData.id === id;
2696                 });
2697
2698                 return item.length ? item[0] : null;
2699             };
2700
2701             topo.links.forEach(function(l){
2702                 var sourceItem = getItemById(l.source, itemsArray.epg),
2703                     targetItem = getItemById(l.target, itemsArray.epg);
2704
2705                 if (sourceItem && targetItem) {
2706                     var link = JointGraphFactory.createLink(sourceItem.id, targetItem.id, 'blue', 'green', l.direction, l.data);
2707                     linksArray.push(link);
2708                 }
2709             });
2710
2711             JointGraphFactory.addItemList(paper.model, linksArray);
2712         };
2713
2714         jgb.loadTopology = function(args, paper, type) {
2715             if(type === null || builders.hasOwnProperty(type) === false) {
2716                 type = GBPConstants.strings.empty;
2717             }
2718
2719             builders[type](args, paper);
2720         };
2721
2722         builders[GBPConstants.strings.empty] = function(args, paper) {
2723             JointGraphFactory.reloadGraph(paper.model);
2724         };
2725
2726         builders[GBPConstants.strings.config] = function(args, paper) {
2727             var storage = args.storage || 'config',
2728                 tenantId = args.tenantId;
2729
2730
2731             TopologyDataLoaders.getSubjectsBetweenEndpointGroups(false, tenantId, function(data){
2732                 setOperConfigTopoData(paper, data);
2733             }, function(){});
2734         };
2735
2736         builders[GBPConstants.strings.oper] = function(args, paper) {
2737             var storage = args.storage || 'config',
2738                 tenantId = args.tenantId;
2739
2740             TopologyDataLoaders.getSubjectsBetweenEndpointGroups(true, tenantId, function(data){
2741                 setOperConfigTopoData(paper, data);
2742             }, function(){});
2743         };
2744
2745         builders[GBPConstants.strings.l2l3] = function(args, paper) {
2746             var storage = args.storage || 'config',
2747                 tenantId = args.tenantId;
2748
2749             if(storage && tenantId) {
2750                 restObj = GBPRestangular.one('restconf').one(storage).one('policy:tenants').one('tenant').one(tenantId);
2751
2752                 restObj.get().then(function(data) {
2753                     var createLinks = function(srcList, srcItems, dstItems) {
2754                         var linkItems = srcList.map(function(srcObj) {
2755                             var linkItem = null;
2756                             if(srcObj.parent && dstItems[srcObj.parent]) {
2757                                 linkItem = JointGraphFactory.createLink(srcItems[srcObj.id].id, dstItems[srcObj.parent].id, 'blue');
2758                             }
2759                             return linkItem;
2760                         }).filter(function(linkObj) {
2761                             return linkObj !== null;
2762                         });
2763
2764                         return linkItems;
2765                     };
2766
2767                     var offsetObj = {
2768                         ow: 100,
2769                         oh: 100,
2770                         w: 100,
2771                         h: 100
2772                     },
2773                     marginObj = {
2774                         w: 50,
2775                         h: 80
2776                     },
2777                     itemsArray = {
2778                         l3: {},
2779                         l2bridge: {},
2780                         l2flood: {},
2781                         subnets: {}
2782                     };
2783
2784                     JointGraphFactory.reloadGraph(paper.model);
2785
2786                     data.tenant[0]['l3-context'].forEach(function(c, i) {
2787                         var label = c.name || c.id,
2788                             header = 'L3 context',
2789                             color = GBPConstants.colors[GBPConstants.strings.l3ctx],
2790                             width = Math.max(JointGraphFactory.getLabelLength(label.length), JointGraphFactory.getLabelLength(header.length));
2791                             item = JointGraphFactory.createElement(label, offsetObj.w, offsetObj.h, width, null, GBPConstants.strings.l3ctx , c, null, color, header);
2792
2793                         itemsArray.l3[c.id] = item;
2794
2795                         JointGraphOffsetFactory.updateOffsets(JointGraphOffsetFactory.createWHObj(width), offsetObj, marginObj, JointGraphOffsetFactory.createWHObj(paper.options.width, paper.options.height), paper);
2796                         JointGraphFactory.addItem(paper.model, item);
2797                     });
2798
2799                     JointGraphOffsetFactory.resetOffsets(offsetObj, offsetObj.ow, offsetObj.h + 100);
2800
2801                     data.tenant[0]['l2-bridge-domain'].forEach(function(c, i) {
2802                         var label = c.name || c.id,
2803                             header = 'L2 bridge domain',
2804                             color = GBPConstants.colors[GBPConstants.strings.bridge],
2805                             width = Math.max(JointGraphFactory.getLabelLength(label.length), JointGraphFactory.getLabelLength(header.length));
2806                             item = JointGraphFactory.createElement(label, offsetObj.w, offsetObj.h, width, null, GBPConstants.strings.bridge , c, null, color, header);
2807
2808                         itemsArray.l2bridge[c.id] = item;
2809
2810                         JointGraphOffsetFactory.updateOffsets(JointGraphOffsetFactory.createWHObj(width), offsetObj, marginObj, JointGraphOffsetFactory.createWHObj(paper.options.width, paper.options.height), paper);
2811                         JointGraphFactory.addItem(paper.model, item);
2812                     });
2813
2814                     JointGraphOffsetFactory.resetOffsets(offsetObj, offsetObj.ow, offsetObj.h + 100);
2815
2816                     data.tenant[0]['l2-flood-domain'].forEach(function(c, i) {
2817                         var label = c.name || c.id,
2818                             header = 'L2 flood domain',
2819                             color = GBPConstants.colors[GBPConstants.strings.flood],
2820                             width = Math.max(JointGraphFactory.getLabelLength(label.length), JointGraphFactory.getLabelLength(header.length));
2821                             item = JointGraphFactory.createElement(label, offsetObj.w, offsetObj.h, width, null, GBPConstants.strings.flood , c, null, color, header);
2822
2823                         itemsArray.l2flood[c.id] = item;
2824
2825                         JointGraphOffsetFactory.updateOffsets(JointGraphOffsetFactory.createWHObj(width), offsetObj, marginObj, JointGraphOffsetFactory.createWHObj(paper.options.width, paper.options.height), paper);
2826                         JointGraphFactory.addItem(paper.model, item);
2827                     });
2828
2829                     JointGraphOffsetFactory.resetOffsets(offsetObj, offsetObj.ow, offsetObj.h + 100);
2830
2831                     data.tenant[0]['subnet'].forEach(function(c, i) {
2832                         var label = c.name || c.id,
2833                             header = 'Subnet',
2834                             color = GBPConstants.colors[GBPConstants.strings.subnet],
2835                             width = Math.max(JointGraphFactory.getLabelLength(label.length), JointGraphFactory.getLabelLength(header.length));
2836                             item = JointGraphFactory.createElement(label, offsetObj.w, offsetObj.h, width, null, GBPConstants.strings.subnet , c, null, color, header);
2837
2838                         itemsArray.subnets[c.id] = item;
2839
2840                         JointGraphOffsetFactory.updateOffsets(JointGraphOffsetFactory.createWHObj(width), offsetObj, marginObj, JointGraphOffsetFactory.createWHObj(paper.options.width, paper.options.height), paper);
2841                         JointGraphFactory.addItem(paper.model, item);
2842                     });
2843
2844                     JointGraphOffsetFactory.resetOffsets(offsetObj, offsetObj.ow, offsetObj.oh);
2845
2846                     var l2bridgeL3 = createLinks(data.tenant[0]['l2-bridge-domain'], itemsArray.l2bridge, itemsArray.l3);
2847                     JointGraphFactory.addItemList(paper.model, l2bridgeL3);
2848
2849                     var l2floodL2bridge = createLinks(data.tenant[0]['l2-flood-domain'], itemsArray.l2flood, itemsArray.l2bridge);
2850                     JointGraphFactory.addItemList(paper.model, l2floodL2bridge);
2851
2852                     var l2floodSubnet = createLinks(data.tenant[0]['subnet'], itemsArray.subnets, itemsArray.l2flood);
2853                     JointGraphFactory.addItemList(paper.model, l2floodSubnet);
2854
2855                     var l2bridgeSubnet = createLinks(data.tenant[0]['subnet'], itemsArray.subnets, itemsArray.l2bridge);
2856                     JointGraphFactory.addItemList(paper.model, l2bridgeSubnet);
2857
2858                     var l3Subnet = createLinks(data.tenant[0]['subnet'], itemsArray.subnets, itemsArray.l3);
2859                     JointGraphFactory.addItemList(paper.model, l3Subnet);
2860
2861                 }, function() {
2862
2863                 });
2864             }
2865         };
2866
2867
2868         return jgb;
2869     });
2870 });