vid-webpack-master/src/app/shared/services/aaiService/aai.service.ts

   1 import {NgRedux} from "@angular-redux/store";
   2 import {HttpClient} from '@angular/common/http';
   3 import {Injectable} from '@angular/core';
   4 import * as _ from 'lodash';
   5 import 'rxjs/add/operator/catch';
   6 import 'rxjs/add/operator/do';
   7 import {Observable, of} from "rxjs";
   8
   9 import {AicZone} from "../../models/aicZone";
  10 import {CategoryParams} from "../../models/categoryParams";
  11 import {LcpRegion} from "../../models/lcpRegion";
  12 import {LcpRegionsAndTenants} from "../../models/lcpRegionsAndTenants";
  13 import {OwningEntity} from "../../models/owningEntity";
  14 import {ProductFamily} from "../../models/productFamily";
  15 import {Project} from "../../models/project";
  16 import {SelectOption} from '../../models/selectOption';
  17 import {ServiceType} from "../../models/serviceType";
  18 import {Subscriber} from "../../models/subscriber";
  19 import {Tenant} from "../../models/tenant";
  20 import {Constants} from '../../utils/constants';
  21 import {AppState} from "../../store/reducers";
  22 import {GetAicZonesResponse} from "./responseInterfaces/getAicZonesResponseInterface";
  23 import {GetCategoryParamsResponseInterface} from "./responseInterfaces/getCategoryParamsResponseInterface";
  24 import {GetServicesResponseInterface} from "./responseInterfaces/getServicesResponseInterface";
  25 import {GetSubDetailsResponse} from "./responseInterfaces/getSubDetailsResponseInterface";
  26 import {GetSubscribersResponse} from "./responseInterfaces/getSubscribersResponseInterface";
  27 import {Root} from "./model/crawledAaiService";
  28 import {VnfInstance} from "../../models/vnfInstance";
  29 import {VfModuleInstance} from "../../models/vfModuleInstance";
  30 import {ServiceInstance} from "../../models/serviceInstance";
  31 import {VfModuleMap} from "../../models/vfModulesMap";
  32 import {updateAicZones, updateCategoryParameters, updateLcpRegionsAndTenants, updateServiceTypes, updateSubscribers, updateUserId} from "../../storeUtil/utils/general/general.actions";
  33 import {createServiceInstance, updateModel,} from "../../storeUtil/utils/service/service.actions";
  34 import {FeatureFlagsService, Features} from "../featureFlag/feature-flags.service";
  35 import {VnfMember} from "../../models/VnfMember";
  36 import {setOptionalMembersVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
  37 import {NetworkModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/networkStep/network.step.model";
  38 import {VPNModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/vpnStep/vpn.step.model";
  39 import {ModelInfo} from "../../models/modelInfo";
  40
  41 @Injectable()
  42 export class AaiService {
  43   constructor(private http: HttpClient, private store: NgRedux<AppState>, private featureFlagsService:FeatureFlagsService) {
  44
  45   }
  46
  47   sdncPreload(): Observable<boolean> {
  48     let pathQuery: string = Constants.Path.PRE_LOAD;
  49     return this.http.post<boolean>(pathQuery, {})
  50   }
  51
  52   getServiceModelById = (serviceModelId: string): Observable<any> => {
  53     if (_.has(this.store.getState().service.serviceHierarchy, serviceModelId)) {
  54       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.serviceHierarchy[serviceModelId])));
  55     }
  56     let pathQuery: string = Constants.Path.SERVICES_PATH + serviceModelId;
  57     return this.http.get(pathQuery).map(res => res)
  58       .do((res) => {
  59         this.store.dispatch(updateModel(res));
  60       });
  61   };
  62
  63   retrieveServiceLatestUpdateableVersion = (modelInvariantId: string): Observable<ModelInfo> => {
  64     let pathQuery: string = Constants.Path.SERVICE_LATEST_VERSION + modelInvariantId;
  65     return this.http.get<ModelInfo>(pathQuery)
  66   };
  67
  68   getUserId = (): Observable<any> => {
  69     return this.http.get("../../getuserID", {responseType: 'text'}).do((res) => this.store.dispatch(updateUserId(res)));
  70   };
  71
  72
  73   resolve = (root: Root, serviceInstance: ServiceInstance) => {
  74     if (root.type === 'service-instance') {
  75       serviceInstance.instanceName = root.name;
  76       serviceInstance.orchStatus = root.orchestrationStatus;
  77       serviceInstance.modelInavariantId = root.modelInvariantId;
  78       for (let i = 0; i < root.children.length; i++) {
  79         let child = root.children[i];
  80         if (child.type === 'generic-vnf') {
  81           let vnf = new VnfInstance();
  82           vnf.originalName = child.name;
  83           vnf.orchStatus = child.orchestrationStatus
  84           if (child.children.length > 0) {
  85             let vfModuleMap = new VfModuleMap();
  86             for (let j = 0; j < child.children.length; j++) {
  87               let child = root.children[i];
  88               if (child.type === 'vf-module') {
  89                 let vfModule = new VfModuleInstance();
  90                 vfModule.instanceName = child.name;
  91                 vfModule.orchStatus = child.orchestrationStatus;
  92                 vfModuleMap.vfModules[child.name] = vfModule;
  93               }
  94             }
  95             vnf.vfModules = {"a": vfModuleMap};
  96           }
  97           serviceInstance.vnfs[child.name] = vnf;
  98
  99         }
 100       }
 101
 102     }
 103   };
 104
 105
 106   getCRAccordingToNetworkFunctionId = (networkCollectionFunction, cloudOwner, cloudRegionId) => {
 107     return this.http.get('../../aai_get_instance_groups_by_cloudregion/' + cloudOwner + '/' + cloudRegionId + '/' + networkCollectionFunction)
 108       .map(res => res).do((res) => console.log(res));
 109   };
 110
 111   getCategoryParameters = (familyName): Observable<CategoryParams> => {
 112     familyName = familyName || Constants.Path.PARAMETER_STANDARDIZATION_FAMILY;
 113     let pathQuery: string = Constants.Path.GET_CATEGORY_PARAMETERS + "?familyName=" + familyName + "&r=" + Math.random();
 114
 115     return this.http.get<GetCategoryParamsResponseInterface>(pathQuery)
 116       .map(this.categoryParametersResponseToProductAndOwningEntity)
 117       .do(res => {
 118         this.store.dispatch(updateCategoryParameters(res))
 119       });
 120   };
 121
 122
 123   categoryParametersResponseToProductAndOwningEntity = (res: GetCategoryParamsResponseInterface): CategoryParams => {
 124     if (res && res.categoryParameters) {
 125       const owningEntityList = res.categoryParameters.owningEntity.map(owningEntity => new OwningEntity(owningEntity));
 126       const projectList = res.categoryParameters.project.map(project => new Project(project));
 127       const lineOfBusinessList = res.categoryParameters.lineOfBusiness.map(owningEntity => new SelectOption(owningEntity));
 128       const platformList = res.categoryParameters.platform.map(platform => new SelectOption(platform));
 129
 130       return new CategoryParams(owningEntityList, projectList, lineOfBusinessList, platformList);
 131     } else {
 132       return new CategoryParams();
 133     }
 134   };
 135
 136   getProductFamilies = (): Observable<ProductFamily[]> => {
 137
 138     let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();
 139
 140     return this.http.get<GetServicesResponseInterface>(pathQuery).map(res => res.service.map(service => new ProductFamily(service)));
 141   };
 142
 143   getServices = (): Observable<GetServicesResponseInterface> => {
 144     let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();
 145
 146     return this.http.get<GetServicesResponseInterface>(pathQuery);
 147   };
 148
 149   getSubscribers = (): Observable<Subscriber[]> => {
 150
 151     if (this.store.getState().service.subscribers) {
 152       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.subscribers)));
 153     }
 154
 155     let pathQuery: string = Constants.Path.AAI_GET_SUBSCRIBERS + Constants.Path.ASSIGN + Math.random();
 156
 157     return this.http.get<GetSubscribersResponse>(pathQuery).map(res =>
 158       res.customer.map(subscriber => new Subscriber(subscriber))).do((res) => {
 159       this.store.dispatch(updateSubscribers(res));
 160     });
 161   };
 162
 163   getAicZones = (): Observable<AicZone[]> => {
 164     if (this.store.getState().service.aicZones) {
 165       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.aicZones)));
 166     }
 167
 168     let pathQuery: string = Constants.Path.AAI_GET_AIC_ZONES + Constants.Path.ASSIGN + Math.random();
 169
 170     return this.http.get<GetAicZonesResponse>(pathQuery).map(res =>
 171       res.zone.map(aicZone => new AicZone(aicZone))).do((res) => {
 172       this.store.dispatch(updateAicZones(res));
 173     });
 174   };
 175
 176   getLcpRegionsAndTenants = (globalCustomerId, serviceType): Observable<LcpRegionsAndTenants> => {
 177
 178     let pathQuery: string = Constants.Path.AAI_GET_TENANTS
 179       + globalCustomerId + Constants.Path.FORWARD_SLASH + serviceType + Constants.Path.ASSIGN + Math.random();
 180
 181     console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: "
 182       + globalCustomerId);
 183     if (globalCustomerId != null) {
 184       return this.http.get(pathQuery)
 185         .map(this.tenantResponseToLcpRegionsAndTenants).do((res) => {
 186           this.store.dispatch(updateLcpRegionsAndTenants(res));
 187         });
 188     }
 189   };
 190
 191   tenantResponseToLcpRegionsAndTenants = (cloudRegionTenantList): LcpRegionsAndTenants => {
 192
 193     const lcpRegionsTenantsMap = {};
 194
 195     const lcpRegionList = _.uniqBy(cloudRegionTenantList, 'cloudRegionID').map((cloudRegionTenant) => {
 196       const cloudOwner:string = cloudRegionTenant["cloudOwner"];
 197       const cloudRegionId:string = cloudRegionTenant["cloudRegionID"];
 198       const name:string = this.extractLcpRegionName(cloudRegionId, cloudOwner);
 199       const isPermitted:boolean = cloudRegionTenant["is-permitted"];
 200       return new LcpRegion(cloudRegionId, name, isPermitted, cloudOwner);
 201     });
 202
 203     lcpRegionList.forEach(region => {
 204       lcpRegionsTenantsMap[region.id] = _.filter(cloudRegionTenantList, {'cloudRegionID': region.id})
 205         .map((cloudRegionTenant) => {
 206           return new Tenant(cloudRegionTenant)
 207         });
 208       const reducer = (accumulator, currentValue) => {
 209         accumulator.isPermitted = accumulator.isPermitted || currentValue.isPermitted;
 210
 211         return accumulator;
 212       };
 213       region.isPermitted = lcpRegionsTenantsMap[region.id].reduce(reducer).isPermitted;
 214     });
 215
 216     return new LcpRegionsAndTenants(lcpRegionList, lcpRegionsTenantsMap);
 217   };
 218
 219   public extractLcpRegionName(cloudRegionId: string, cloudOwner: string):string {
 220     return this.featureFlagsService.getFlagState(Features.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ?
 221       cloudRegionId+AaiService.formatCloudOwnerTrailer(cloudOwner) : cloudRegionId;
 222   };
 223
 224   public static formatCloudOwnerTrailer(cloudOwner: string):string {
 225     return " ("+ cloudOwner.trim().toLowerCase().replace(/^[^-]*-/, "").toUpperCase() + ")";
 226   }
 227
 228   getServiceTypes = (subscriberId): Observable<ServiceType[]> => {
 229
 230     console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: " + subscriberId);
 231     if (_.has(this.store.getState().service.serviceTypes, subscriberId)) {
 232       return of(<ServiceType[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceTypes[subscriberId])));
 233     }
 234
 235     return this.getSubscriberDetails(subscriberId)
 236       .map(this.subDetailsResponseToServiceTypes)
 237       .do((res) => {
 238         this.store.dispatch(updateServiceTypes(res, subscriberId));
 239       });
 240   };
 241
 242   getSubscriberDetails = (subscriberId): Observable<GetSubDetailsResponse> => {
 243     let pathQuery: string = Constants.Path.AAI_SUB_DETAILS_PATH + subscriberId + Constants.Path.ASSIGN + Math.random() + Constants.Path.AAI_OMIT_SERVICE_INSTANCES + true;
 244
 245     if (subscriberId != null) {
 246       return this.http.get<GetSubDetailsResponse>(pathQuery);
 247     }
 248   };
 249
 250   subDetailsResponseToServiceTypes = (res: GetSubDetailsResponse): ServiceType[] => {
 251     if (res && res['service-subscriptions']) {
 252       const serviceSubscriptions = res['service-subscriptions']['service-subscription'];
 253       return serviceSubscriptions.map((subscription, index) => new ServiceType(String(index), subscription))
 254     } else {
 255       return [];
 256     }
 257   };
 258
 259
 260   public retrieveServiceInstanceTopology(serviceInstanceId : string, subscriberId: string, serviceType: string):Observable<ServiceInstance> {
 261     let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_INSTANCE_TOPOLOGY_PATH}${subscriberId}/${serviceType}/${serviceInstanceId}`;
 262     return this.http.get<ServiceInstance>(pathQuery);
 263   }
 264
 265   public retrieveActiveNetwork(cloudRegion : string, tenantId: string) : Observable<NetworkModalRow[]>{
 266     let pathQuery: string = `${Constants.Path.AAI_GET_ACTIVE_NETWORKS_PATH}?cloudRegion=${cloudRegion}&tenantId=${tenantId}`;
 267     return this.http.get<NetworkModalRow[]>(pathQuery);
 268   }
 269
 270   public retrieveActiveVPNs() : Observable<VPNModalRow[]>{
 271     let pathQuery: string = `${Constants.Path.AAI_GET_VPNS_PATH}`;
 272     return this.http.get<VPNModalRow[]>(pathQuery);
 273   }
 274
 275   public retrieveAndStoreServiceInstanceTopology(serviceInstanceId: string, subscriberId: string, serviceType: string, serviceModeId: string):Observable<ServiceInstance> {
 276     return this.retrieveServiceInstanceTopology(serviceInstanceId, subscriberId, serviceType).do((service:ServiceInstance) => {
 277       this.store.dispatch(createServiceInstance(service, serviceModeId));
 278     });
 279   };
 280
 281
 282   public retrieveServiceInstanceRetryTopology(jobId : string) :Observable<ServiceInstance> {
 283     let pathQuery: string = `${Constants.Path.SERVICES_RETRY_TOPOLOGY}/${jobId}`;
 284     return this.http.get<ServiceInstance>(pathQuery);
 285
 286   }
 287
 288   public retrieveAndStoreServiceInstanceRetryTopology(jobId: string, serviceModeId : string):Observable<ServiceInstance> {
 289     return this.retrieveServiceInstanceRetryTopology(jobId).do((service:ServiceInstance) => {
 290       this.store.dispatch(createServiceInstance(service, serviceModeId));
 291     });
 292   };
 293
 294   public getOptionalGroupMembers(serviceModelId: string, subscriberId: string, serviceType: string, serviceInvariantId: string, groupType: string, groupRole: string): Observable<VnfMember[]> {
 295     let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_GROUP_MEMBERS_PATH}${subscriberId}/${serviceType}/${serviceInvariantId}/${groupType}/${groupRole}`;
 296     if(_.has(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap,pathQuery)){
 297       return of(<VnfMember[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap[pathQuery])));
 298     }
 299     return this.http.get<VnfMember[]>(pathQuery)
 300       .do((res) => {
 301         this.store.dispatch(setOptionalMembersVnfGroupInstance(serviceModelId, pathQuery, res))
 302       });
 303   }
 304
 305   //TODO: make other places use this function
 306   extractSubscriberNameBySubscriberId(subscriberId: string) {
 307     let result: string = null;
 308     let filteredArray: any = _.filter(this.store.getState().service.subscribers, function (o: Subscriber) {
 309       return o.id === subscriberId
 310     });
 311     if (filteredArray.length > 0) {
 312       result = filteredArray[0].name;
 313     }
 314     return result;
 315   }
 316
 317   loadMockMembers(): any {
 318     return [
 319       {
 320         "action":"None",
 321         "instanceName":"VNF1_INSTANCE_NAME",
 322         "instanceId":"VNF1_INSTANCE_ID",
 323         "orchStatus":null,
 324         "productFamilyId":null,
 325         "lcpCloudRegionId":"hvf23b",
 326         "tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
 327         "tenantName":"APPC-24595-T-IST-02C",
 328         "modelInfo":{
 329           "modelInvariantId":"vnf-instance-model-invariant-id",
 330           "modelVersionId":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
 331           "modelVersion":"2.0",
 332           "modelName":"vf_vEPDG",
 333           "modelType":"vnf"
 334         },
 335         "instanceType":"VNF1_INSTANCE_TYPE",
 336         "provStatus":null,
 337         "inMaint":false,
 338         "uuid":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
 339         "originalName":null,
 340         "legacyRegion":null,
 341         "lineOfBusiness":null,
 342         "platformName":null,
 343         "trackById":"7a6ee536-f052-46fa-aa7e-2fca9d674c44:002",
 344         "serviceInstanceId":"service-instance-id1",
 345         "serviceInstanceName":"service-instance-name"
 346       },
 347       {
 348         "action":"None",
 349         "instanceName":"VNF2_INSTANCE_NAME",
 350         "instanceId":"VNF2_INSTANCE_ID",
 351         "orchStatus":null,
 352         "productFamilyId":null,
 353         "lcpCloudRegionId":"hvf23b",
 354         "tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
 355         "tenantName":"APPC-24595-T-IST-02C",
 356         "modelInfo":{
 357           "modelInvariantId":"vnf-instance-model-invariant-id",
 358           "modelVersionId":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
 359           "modelVersion":"1.0",
 360           "modelName":"vf_vEPDG",
 361           "modelType":"vnf"
 362         },
 363         "instanceType":"VNF2_INSTANCE_TYPE",
 364         "provStatus":null,
 365         "inMaint":true,
 366         "uuid":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
 367         "originalName":null,
 368         "legacyRegion":null,
 369         "lineOfBusiness":null,
 370         "platformName":null,
 371         "trackById":"eb5f56bf-5855-4e61-bd00-3e19a953bf02:003",
 372         "serviceInstanceId":"service-instance-id2",
 373         "serviceInstanceName":"service-instance-name"
 374       }
 375     ]
 376
 377   }
 378
 379
 380 }