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

 import {NgRedux} from "@angular-redux/store";
 import {HttpClient} from '@angular/common/http';
 import {Injectable} from '@angular/core';
 import * as _ from 'lodash';
 import 'rxjs/add/operator/catch';
 import 'rxjs/add/operator/do';
 import {Observable, of} from "rxjs";

 import {AicZone} from "../../models/aicZone";
 import {CategoryParams} from "../../models/categoryParams";
 import {LcpRegion} from "../../models/lcpRegion";
 import {LcpRegionsAndTenants} from "../../models/lcpRegionsAndTenants";
 import {OwningEntity} from "../../models/owningEntity";
 import {ProductFamily} from "../../models/productFamily";
 import {Project} from "../../models/project";
 import {SelectOption} from '../../models/selectOption';
 import {ServiceType} from "../../models/serviceType";
 import {Subscriber} from "../../models/subscriber";
 import {Tenant} from "../../models/tenant";
 import {Constants} from '../../utils/constants';
 import {AppState} from "../../store/reducers";
 import {GetAicZonesResponse} from "./responseInterfaces/getAicZonesResponseInterface";
 import {GetCategoryParamsResponseInterface} from "./responseInterfaces/getCategoryParamsResponseInterface";
 import {GetServicesResponseInterface} from "./responseInterfaces/getServicesResponseInterface";
 import {GetSubDetailsResponse} from "./responseInterfaces/getSubDetailsResponseInterface";
 import {GetSubscribersResponse} from "./responseInterfaces/getSubscribersResponseInterface";
 import {Root} from "./model/crawledAaiService";
 import {VnfInstance} from "../../models/vnfInstance";
 import {VfModuleInstance} from "../../models/vfModuleInstance";
 import {ServiceInstance} from "../../models/serviceInstance";
 import {VfModuleMap} from "../../models/vfModulesMap";
 import {
   updateAicZones,
   updateCategoryParameters,
   updateLcpRegionsAndTenants,
   updateServiceTypes,
   updateSubscribers,
   updateUserId
 } from "../../storeUtil/utils/general/general.actions";
 import {createServiceInstance, updateModel,} from "../../storeUtil/utils/service/service.actions";
 import {FeatureFlagsService, Features} from "../featureFlag/feature-flags.service";
 import {VnfMember} from "../../models/VnfMember";
 import {setOptionalMembersVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
 import {NetworkModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/networkStep/network.step.model";
 import {VPNModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/vpnStep/vpn.step.model";
 import {ModelInfo} from "../../models/modelInfo";

 @Injectable()
 export class AaiService {
   constructor(private http: HttpClient, private store: NgRedux<AppState>, private featureFlagsService:FeatureFlagsService) {

   }

   sdncPreload(): Observable<boolean> {
     let pathQuery: string = Constants.Path.PRE_LOAD;
     return this.http.post<boolean>(pathQuery, {})
   }

   getServiceModelById = (serviceModelId: string): Observable<any> => {
     if (_.has(this.store.getState().service.serviceHierarchy, serviceModelId)) {
       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.serviceHierarchy[serviceModelId])));
     }
     let pathQuery: string = Constants.Path.SERVICES_PATH + serviceModelId;
     return this.http.get(pathQuery).map(res => res)
       .do((res) => {
         this.store.dispatch(updateModel(res));
       });
   };

   retrieveServiceLatestUpdateableVersion = (modelInvariantId: string): Observable<ModelInfo> => {
     let pathQuery: string = Constants.Path.SERVICE_LATEST_VERSION + modelInvariantId;
     return this.http.get<ModelInfo>(pathQuery)
   };

   getUserId = (): Observable<any> => {
     return this.http.get("../../getuserID", {responseType: 'text'}).do((res) => this.store.dispatch(updateUserId(res)));
   };


   resolve = (root: Root, serviceInstance: ServiceInstance) => {
     if (root.type === 'service-instance') {
       serviceInstance.instanceName = root.name;
       serviceInstance.orchStatus = root.orchestrationStatus;
       serviceInstance.modelInavariantId = root.modelInvariantId;
       for (let i = 0; i < root.children.length; i++) {
         let child = root.children[i];
         if (child.type === 'generic-vnf') {
           let vnf = new VnfInstance();
           vnf.originalName = child.name;
           vnf.orchStatus = child.orchestrationStatus
           if (child.children.length > 0) {
             let vfModuleMap = new VfModuleMap();
             for (let j = 0; j < child.children.length; j++) {
               let child = root.children[i];
               if (child.type === 'vf-module') {
                 let vfModule = new VfModuleInstance();
                 vfModule.instanceName = child.name;
                 vfModule.orchStatus = child.orchestrationStatus;
                 vfModuleMap.vfModules[child.name] = vfModule;
               }
             }
             vnf.vfModules = {"a": vfModuleMap};
           }
           serviceInstance.vnfs[child.name] = vnf;

         }
       }

     }
   };


   getCRAccordingToNetworkFunctionId = (networkCollectionFunction, cloudOwner, cloudRegionId) => {
     return this.http.get('../../aai_get_instance_groups_by_cloudregion/' + cloudOwner + '/' + cloudRegionId + '/' + networkCollectionFunction)
       .map(res => res).do((res) => console.log(res));
   };

   getCategoryParameters = (familyName): Observable<CategoryParams> => {
     familyName = familyName || Constants.Path.PARAMETER_STANDARDIZATION_FAMILY;
     let pathQuery: string = Constants.Path.GET_CATEGORY_PARAMETERS + "?familyName=" + familyName + "&r=" + Math.random();

     return this.http.get<GetCategoryParamsResponseInterface>(pathQuery)
       .map(this.categoryParametersResponseToProductAndOwningEntity)
       .do(res => {
         this.store.dispatch(updateCategoryParameters(res))
       });
   };


   categoryParametersResponseToProductAndOwningEntity = (res: GetCategoryParamsResponseInterface): CategoryParams => {
     if (res && res.categoryParameters) {
       const owningEntityList = res.categoryParameters.owningEntity.map(owningEntity => new OwningEntity(owningEntity));
       const projectList = res.categoryParameters.project.map(project => new Project(project));
       const lineOfBusinessList = res.categoryParameters.lineOfBusiness.map(owningEntity => new SelectOption(owningEntity));
       const platformList = res.categoryParameters.platform.map(platform => new SelectOption(platform));

       return new CategoryParams(owningEntityList, projectList, lineOfBusinessList, platformList);
     } else {
       return new CategoryParams();
     }
   };

   getProductFamilies = (): Observable<ProductFamily[]> => {

     let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();

     return this.http.get<GetServicesResponseInterface>(pathQuery).map(res => res.service.map(service => new ProductFamily(service)));
   };

   getServices = (): Observable<GetServicesResponseInterface> => {
     let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();

     return this.http.get<GetServicesResponseInterface>(pathQuery);
   };

   getSubscribers = (): Observable<Subscriber[]> => {

     if (this.store.getState().service.subscribers) {
       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.subscribers)));
     }

     let pathQuery: string = Constants.Path.AAI_GET_SUBSCRIBERS + Constants.Path.ASSIGN + Math.random();

     return this.http.get<GetSubscribersResponse>(pathQuery).map(res =>
       res.customer.map(subscriber => new Subscriber(subscriber))).do((res) => {
       this.store.dispatch(updateSubscribers(res));
     });
   };

   getAicZones = (): Observable<AicZone[]> => {
     if (this.store.getState().service.aicZones) {
       return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.aicZones)));
     }

     let pathQuery: string = Constants.Path.AAI_GET_AIC_ZONES + Constants.Path.ASSIGN + Math.random();

     return this.http.get<GetAicZonesResponse>(pathQuery).map(res =>
       res.zone.map(aicZone => new AicZone(aicZone))).do((res) => {
       this.store.dispatch(updateAicZones(res));
     });
   };

   getLcpRegionsAndTenants = (globalCustomerId, serviceType): Observable<LcpRegionsAndTenants> => {

     let pathQuery: string = Constants.Path.AAI_GET_TENANTS
       + globalCustomerId + Constants.Path.FORWARD_SLASH + serviceType + Constants.Path.ASSIGN + Math.random();

     console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: "
       + globalCustomerId);
     if (globalCustomerId != null) {
       return this.http.get(pathQuery)
         .map(this.tenantResponseToLcpRegionsAndTenants).do((res) => {
           this.store.dispatch(updateLcpRegionsAndTenants(res));
         });
     }
   };

   tenantResponseToLcpRegionsAndTenants = (cloudRegionTenantList): LcpRegionsAndTenants => {

     const lcpRegionsTenantsMap = {};

     const lcpRegionList = _.uniqBy(cloudRegionTenantList, 'cloudRegionID').map((cloudRegionTenant) => {
       const cloudOwner:string = cloudRegionTenant["cloudOwner"];
       const cloudRegionId:string = cloudRegionTenant["cloudRegionID"];
       const name:string = this.extractLcpRegionName(cloudRegionId, cloudOwner);
       const isPermitted:boolean = cloudRegionTenant["is-permitted"];
       return new LcpRegion(cloudRegionId, name, isPermitted, cloudOwner);
     });

     lcpRegionList.forEach(region => {
       lcpRegionsTenantsMap[region.id] = _.filter(cloudRegionTenantList, {'cloudRegionID': region.id})
         .map((cloudRegionTenant) => {
           return new Tenant(cloudRegionTenant)
         });
       const reducer = (accumulator, currentValue) => {
         accumulator.isPermitted = accumulator.isPermitted || currentValue.isPermitted;

         return accumulator;
       };
       region.isPermitted = lcpRegionsTenantsMap[region.id].reduce(reducer).isPermitted;
     });

     return new LcpRegionsAndTenants(lcpRegionList, lcpRegionsTenantsMap);
   };

   public extractLcpRegionName(cloudRegionId: string, cloudOwner: string):string {
     return this.featureFlagsService.getFlagState(Features.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ?
       cloudRegionId+AaiService.formatCloudOwnerTrailer(cloudOwner) : cloudRegionId;
   };


   getLcpRegionsByOwningEntityAndLineOfBusiness = (owningEntityName, lineOfBusinessName): Observable<LcpRegion[]> => {
     // let pathQuery: string = Constants.Path.AAI_GET_LCP_REGIONS_BY____
     //   + "?"
     //   + "owningEntityName=" + owningEntityName
     //   + "lineOfBusinessName=" + lineOfBusinessName;

     return of([
       new LcpRegion("foo-id", "foo-name", true, "foo-cloud-owner"),
       new LcpRegion("foo2-id", "foo2-name", true, "foo2-cloud-owner"),
     ]);
   };


   getTenantsByCloudOwnerAndCloudRegionId = (cloudOwner, cloudRegionId): Observable<Tenant[]> => {
     // let pathQuery: string = Constants.Path.AAI_GET_TENANTS_BY____
     //   + "?"
     //   + "cloudOwner=" + cloudOwner
     //   + "&cloudRegionId=" + cloudRegionId;

     return of([
       new Tenant({
         tenantID: "tenantID", tenantName: "tenantName",
         cloudOwner: "cloudOwner", ['is-permitted']: true,
       }),
       new Tenant({
         tenantID: "tenant2ID", tenantName: "tenant2Name",
         cloudOwner: "cloudOwner", ['is-permitted']: true,
       }),
     ])
   };


   public static formatCloudOwnerTrailer(cloudOwner: string):string {
     return " ("+ cloudOwner.trim().toLowerCase().replace(/^[^-]*-/, "").toUpperCase() + ")";
   }

   getServiceTypes = (subscriberId): Observable<ServiceType[]> => {

     console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: " + subscriberId);
     if (_.has(this.store.getState().service.serviceTypes, subscriberId)) {
       return of(<ServiceType[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceTypes[subscriberId])));
     }

     return this.getSubscriberDetails(subscriberId)
       .map(this.subDetailsResponseToServiceTypes)
       .do((res) => {
         this.store.dispatch(updateServiceTypes(res, subscriberId));
       });
   };

   getSubscriberDetails = (subscriberId): Observable<GetSubDetailsResponse> => {
     let pathQuery: string = Constants.Path.AAI_SUB_DETAILS_PATH + subscriberId + Constants.Path.ASSIGN + Math.random() + Constants.Path.AAI_OMIT_SERVICE_INSTANCES + true;

     if (subscriberId != null) {
       return this.http.get<GetSubDetailsResponse>(pathQuery);
     }
   };

   subDetailsResponseToServiceTypes = (res: GetSubDetailsResponse): ServiceType[] => {
     if (res && res['service-subscriptions']) {
       const serviceSubscriptions = res['service-subscriptions']['service-subscription'];
       return serviceSubscriptions.map((subscription, index) => new ServiceType(String(index), subscription))
     } else {
       return [];
     }
   };


   public retrieveServiceInstanceTopology(serviceInstanceId : string, subscriberId: string, serviceType: string):Observable<ServiceInstance> {
     let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_INSTANCE_TOPOLOGY_PATH}${subscriberId}/${serviceType}/${serviceInstanceId}`;
     return this.http.get<ServiceInstance>(pathQuery);
   }

   public retrieveActiveNetwork(cloudRegion : string, tenantId: string) : Observable<NetworkModalRow[]>{
     let pathQuery: string = `${Constants.Path.AAI_GET_ACTIVE_NETWORKS_PATH}?cloudRegion=${cloudRegion}&tenantId=${tenantId}`;
     return this.http.get<NetworkModalRow[]>(pathQuery);
   }

   public retrieveActiveVPNs() : Observable<VPNModalRow[]>{
     let pathQuery: string = `${Constants.Path.AAI_GET_VPNS_PATH}`;
     return this.http.get<VPNModalRow[]>(pathQuery);
   }

   public retrieveAndStoreServiceInstanceTopology(serviceInstanceId: string, subscriberId: string, serviceType: string, serviceModeId: string):Observable<ServiceInstance> {
     return this.retrieveServiceInstanceTopology(serviceInstanceId, subscriberId, serviceType).do((service:ServiceInstance) => {
       this.store.dispatch(createServiceInstance(service, serviceModeId));
     });
   };


   public retrieveServiceInstanceRetryTopology(jobId : string) :Observable<ServiceInstance> {
     let pathQuery: string = `${Constants.Path.SERVICES_RETRY_TOPOLOGY}/${jobId}`;
     return this.http.get<ServiceInstance>(pathQuery);

   }

   public retrieveAndStoreServiceInstanceRetryTopology(jobId: string, serviceModeId : string):Observable<ServiceInstance> {
     return this.retrieveServiceInstanceRetryTopology(jobId).do((service:ServiceInstance) => {
       this.store.dispatch(createServiceInstance(service, serviceModeId));
     });
   };

   public getOptionalGroupMembers(serviceModelId: string, subscriberId: string, serviceType: string, serviceInvariantId: string, groupType: string, groupRole: string): Observable<VnfMember[]> {
     let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_GROUP_MEMBERS_PATH}${subscriberId}/${serviceType}/${serviceInvariantId}/${groupType}/${groupRole}`;
     if(_.has(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap,pathQuery)){
       return of(<VnfMember[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap[pathQuery])));
     }
     return this.http.get<VnfMember[]>(pathQuery)
       .do((res) => {
         this.store.dispatch(setOptionalMembersVnfGroupInstance(serviceModelId, pathQuery, res))
       });
   }

   //TODO: make other places use this function
   extractSubscriberNameBySubscriberId(subscriberId: string) {
     let result: string = null;
     let filteredArray: any = _.filter(this.store.getState().service.subscribers, function (o: Subscriber) {
       return o.id === subscriberId
     });
     if (filteredArray.length > 0) {
       result = filteredArray[0].name;
     }
     return result;
   }

   loadMockMembers(): any {
     return [
       {
         "action":"None",
         "instanceName":"VNF1_INSTANCE_NAME",
         "instanceId":"VNF1_INSTANCE_ID",
         "orchStatus":null,
         "productFamilyId":null,
         "lcpCloudRegionId":"hvf23b",
         "tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
         "tenantName":"APPC-24595-T-IST-02C",
         "modelInfo":{
           "modelInvariantId":"vnf-instance-model-invariant-id",
           "modelVersionId":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
           "modelVersion":"2.0",
           "modelName":"vf_vEPDG",
           "modelType":"vnf"
         },
         "instanceType":"VNF1_INSTANCE_TYPE",
         "provStatus":null,
         "inMaint":false,
         "uuid":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
         "originalName":null,
         "legacyRegion":null,
         "lineOfBusiness":null,
         "platformName":null,
         "trackById":"7a6ee536-f052-46fa-aa7e-2fca9d674c44:002",
         "serviceInstanceId":"service-instance-id1",
         "serviceInstanceName":"service-instance-name"
       },
       {
         "action":"None",
         "instanceName":"VNF2_INSTANCE_NAME",
         "instanceId":"VNF2_INSTANCE_ID",
         "orchStatus":null,
         "productFamilyId":null,
         "lcpCloudRegionId":"hvf23b",
         "tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
         "tenantName":"APPC-24595-T-IST-02C",
         "modelInfo":{
           "modelInvariantId":"vnf-instance-model-invariant-id",
           "modelVersionId":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
           "modelVersion":"1.0",
           "modelName":"vf_vEPDG",
           "modelType":"vnf"
         },
         "instanceType":"VNF2_INSTANCE_TYPE",
         "provStatus":null,
         "inMaint":true,
         "uuid":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
         "originalName":null,
         "legacyRegion":null,
         "lineOfBusiness":null,
         "platformName":null,
         "trackById":"eb5f56bf-5855-4e61-bd00-3e19a953bf02:003",
         "serviceInstanceId":"service-instance-id2",
         "serviceInstanceName":"service-instance-name"
       }
     ]

   }


 }
	import {NgRedux} from "@angular-redux/store";
	import {HttpClient} from '@angular/common/http';
	import {Injectable} from '@angular/core';
	import * as _ from 'lodash';
	import 'rxjs/add/operator/catch';
	import 'rxjs/add/operator/do';
	import {Observable, of} from "rxjs";

	import {AicZone} from "../../models/aicZone";
	import {CategoryParams} from "../../models/categoryParams";
	import {LcpRegion} from "../../models/lcpRegion";
	import {LcpRegionsAndTenants} from "../../models/lcpRegionsAndTenants";
	import {OwningEntity} from "../../models/owningEntity";
	import {ProductFamily} from "../../models/productFamily";
	import {Project} from "../../models/project";
	import {SelectOption} from '../../models/selectOption';
	import {ServiceType} from "../../models/serviceType";
	import {Subscriber} from "../../models/subscriber";
	import {Tenant} from "../../models/tenant";
	import {Constants} from '../../utils/constants';
	import {AppState} from "../../store/reducers";
	import {GetAicZonesResponse} from "./responseInterfaces/getAicZonesResponseInterface";
	import {GetCategoryParamsResponseInterface} from "./responseInterfaces/getCategoryParamsResponseInterface";
	import {GetServicesResponseInterface} from "./responseInterfaces/getServicesResponseInterface";
	import {GetSubDetailsResponse} from "./responseInterfaces/getSubDetailsResponseInterface";
	import {GetSubscribersResponse} from "./responseInterfaces/getSubscribersResponseInterface";
	import {Root} from "./model/crawledAaiService";
	import {VnfInstance} from "../../models/vnfInstance";
	import {VfModuleInstance} from "../../models/vfModuleInstance";
	import {ServiceInstance} from "../../models/serviceInstance";
	import {VfModuleMap} from "../../models/vfModulesMap";
	import {
	updateAicZones,
	updateCategoryParameters,
	updateLcpRegionsAndTenants,
	updateServiceTypes,
	updateSubscribers,
	updateUserId
	} from "../../storeUtil/utils/general/general.actions";
	import {createServiceInstance, updateModel,} from "../../storeUtil/utils/service/service.actions";
	import {FeatureFlagsService, Features} from "../featureFlag/feature-flags.service";
	import {VnfMember} from "../../models/VnfMember";
	import {setOptionalMembersVnfGroupInstance} from "../../storeUtil/utils/vnfGroup/vnfGroup.actions";
	import {NetworkModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/networkStep/network.step.model";
	import {VPNModalRow} from "../../../drawingBoard/service-planning/objectsToTree/models/vrf/vrfModal/vpnStep/vpn.step.model";
	import {ModelInfo} from "../../models/modelInfo";

	@Injectable()
	export class AaiService {
	constructor(private http: HttpClient, private store: NgRedux<AppState>, private featureFlagsService:FeatureFlagsService) {

	}

	sdncPreload(): Observable<boolean> {
	let pathQuery: string = Constants.Path.PRE_LOAD;
	return this.http.post<boolean>(pathQuery, {})
	}

	getServiceModelById = (serviceModelId: string): Observable<any> => {
	if (_.has(this.store.getState().service.serviceHierarchy, serviceModelId)) {
	return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.serviceHierarchy[serviceModelId])));
	}
	let pathQuery: string = Constants.Path.SERVICES_PATH + serviceModelId;
	return this.http.get(pathQuery).map(res => res)
	.do((res) => {
	this.store.dispatch(updateModel(res));
	});
	};

	retrieveServiceLatestUpdateableVersion = (modelInvariantId: string): Observable<ModelInfo> => {
	let pathQuery: string = Constants.Path.SERVICE_LATEST_VERSION + modelInvariantId;
	return this.http.get<ModelInfo>(pathQuery)
	};

	getUserId = (): Observable<any> => {
	return this.http.get("../../getuserID", {responseType: 'text'}).do((res) => this.store.dispatch(updateUserId(res)));
	};


	resolve = (root: Root, serviceInstance: ServiceInstance) => {
	if (root.type === 'service-instance') {
	serviceInstance.instanceName = root.name;
	serviceInstance.orchStatus = root.orchestrationStatus;
	serviceInstance.modelInavariantId = root.modelInvariantId;
	for (let i = 0; i < root.children.length; i++) {
	let child = root.children[i];
	if (child.type === 'generic-vnf') {
	let vnf = new VnfInstance();
	vnf.originalName = child.name;
	vnf.orchStatus = child.orchestrationStatus
	if (child.children.length > 0) {
	let vfModuleMap = new VfModuleMap();
	for (let j = 0; j < child.children.length; j++) {
	let child = root.children[i];
	if (child.type === 'vf-module') {
	let vfModule = new VfModuleInstance();
	vfModule.instanceName = child.name;
	vfModule.orchStatus = child.orchestrationStatus;
	vfModuleMap.vfModules[child.name] = vfModule;
	}
	}
	vnf.vfModules = {"a": vfModuleMap};
	}
	serviceInstance.vnfs[child.name] = vnf;

	}
	}

	}
	};


	getCRAccordingToNetworkFunctionId = (networkCollectionFunction, cloudOwner, cloudRegionId) => {
	return this.http.get('../../aai_get_instance_groups_by_cloudregion/' + cloudOwner + '/' + cloudRegionId + '/' + networkCollectionFunction)
	.map(res => res).do((res) => console.log(res));
	};

	getCategoryParameters = (familyName): Observable<CategoryParams> => {
	familyName = familyName \|\| Constants.Path.PARAMETER_STANDARDIZATION_FAMILY;
	let pathQuery: string = Constants.Path.GET_CATEGORY_PARAMETERS + "?familyName=" + familyName + "&r=" + Math.random();

	return this.http.get<GetCategoryParamsResponseInterface>(pathQuery)
	.map(this.categoryParametersResponseToProductAndOwningEntity)
	.do(res => {
	this.store.dispatch(updateCategoryParameters(res))
	});
	};


	categoryParametersResponseToProductAndOwningEntity = (res: GetCategoryParamsResponseInterface): CategoryParams => {
	if (res && res.categoryParameters) {
	const owningEntityList = res.categoryParameters.owningEntity.map(owningEntity => new OwningEntity(owningEntity));
	const projectList = res.categoryParameters.project.map(project => new Project(project));
	const lineOfBusinessList = res.categoryParameters.lineOfBusiness.map(owningEntity => new SelectOption(owningEntity));
	const platformList = res.categoryParameters.platform.map(platform => new SelectOption(platform));

	return new CategoryParams(owningEntityList, projectList, lineOfBusinessList, platformList);
	} else {
	return new CategoryParams();
	}
	};

	getProductFamilies = (): Observable<ProductFamily[]> => {

	let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();

	return this.http.get<GetServicesResponseInterface>(pathQuery).map(res => res.service.map(service => new ProductFamily(service)));
	};

	getServices = (): Observable<GetServicesResponseInterface> => {
	let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();

	return this.http.get<GetServicesResponseInterface>(pathQuery);
	};

	getSubscribers = (): Observable<Subscriber[]> => {

	if (this.store.getState().service.subscribers) {
	return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.subscribers)));
	}

	let pathQuery: string = Constants.Path.AAI_GET_SUBSCRIBERS + Constants.Path.ASSIGN + Math.random();

	return this.http.get<GetSubscribersResponse>(pathQuery).map(res =>
	res.customer.map(subscriber => new Subscriber(subscriber))).do((res) => {
	this.store.dispatch(updateSubscribers(res));
	});
	};

	getAicZones = (): Observable<AicZone[]> => {
	if (this.store.getState().service.aicZones) {
	return of(<any> JSON.parse(JSON.stringify(this.store.getState().service.aicZones)));
	}

	let pathQuery: string = Constants.Path.AAI_GET_AIC_ZONES + Constants.Path.ASSIGN + Math.random();

	return this.http.get<GetAicZonesResponse>(pathQuery).map(res =>
	res.zone.map(aicZone => new AicZone(aicZone))).do((res) => {
	this.store.dispatch(updateAicZones(res));
	});
	};

	getLcpRegionsAndTenants = (globalCustomerId, serviceType): Observable<LcpRegionsAndTenants> => {

	let pathQuery: string = Constants.Path.AAI_GET_TENANTS
	+ globalCustomerId + Constants.Path.FORWARD_SLASH + serviceType + Constants.Path.ASSIGN + Math.random();

	console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: "
	+ globalCustomerId);
	if (globalCustomerId != null) {
	return this.http.get(pathQuery)
	.map(this.tenantResponseToLcpRegionsAndTenants).do((res) => {
	this.store.dispatch(updateLcpRegionsAndTenants(res));
	});
	}
	};

	tenantResponseToLcpRegionsAndTenants = (cloudRegionTenantList): LcpRegionsAndTenants => {

	const lcpRegionsTenantsMap = {};

	const lcpRegionList = _.uniqBy(cloudRegionTenantList, 'cloudRegionID').map((cloudRegionTenant) => {
	const cloudOwner:string = cloudRegionTenant["cloudOwner"];
	const cloudRegionId:string = cloudRegionTenant["cloudRegionID"];
	const name:string = this.extractLcpRegionName(cloudRegionId, cloudOwner);
	const isPermitted:boolean = cloudRegionTenant["is-permitted"];
	return new LcpRegion(cloudRegionId, name, isPermitted, cloudOwner);
	});

	lcpRegionList.forEach(region => {
	lcpRegionsTenantsMap[region.id] = _.filter(cloudRegionTenantList, {'cloudRegionID': region.id})
	.map((cloudRegionTenant) => {
	return new Tenant(cloudRegionTenant)
	});
	const reducer = (accumulator, currentValue) => {
	accumulator.isPermitted = accumulator.isPermitted \|\| currentValue.isPermitted;

	return accumulator;
	};
	region.isPermitted = lcpRegionsTenantsMap[region.id].reduce(reducer).isPermitted;
	});

	return new LcpRegionsAndTenants(lcpRegionList, lcpRegionsTenantsMap);
	};

	public extractLcpRegionName(cloudRegionId: string, cloudOwner: string):string {
	return this.featureFlagsService.getFlagState(Features.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ?
	cloudRegionId+AaiService.formatCloudOwnerTrailer(cloudOwner) : cloudRegionId;
	};





	getLcpRegionsByOwningEntityAndLineOfBusiness = (owningEntityName, lineOfBusinessName): Observable<LcpRegion[]> => {
	// let pathQuery: string = Constants.Path.AAI_GET_LCP_REGIONS_BY____
	// + "?"
	// + "owningEntityName=" + owningEntityName
	// + "lineOfBusinessName=" + lineOfBusinessName;

	return of([
	new LcpRegion("foo-id", "foo-name", true, "foo-cloud-owner"),
	new LcpRegion("foo2-id", "foo2-name", true, "foo2-cloud-owner"),
	]);
	};


	getTenantsByCloudOwnerAndCloudRegionId = (cloudOwner, cloudRegionId): Observable<Tenant[]> => {
	// let pathQuery: string = Constants.Path.AAI_GET_TENANTS_BY____
	// + "?"
	// + "cloudOwner=" + cloudOwner
	// + "&cloudRegionId=" + cloudRegionId;

	return of([
	new Tenant({
	tenantID: "tenantID", tenantName: "tenantName",
	cloudOwner: "cloudOwner", ['is-permitted']: true,
	}),
	new Tenant({
	tenantID: "tenant2ID", tenantName: "tenant2Name",
	cloudOwner: "cloudOwner", ['is-permitted']: true,
	}),
	])
	};





	public static formatCloudOwnerTrailer(cloudOwner: string):string {
	return " ("+ cloudOwner.trim().toLowerCase().replace(/^[^-]*-/, "").toUpperCase() + ")";
	}

	getServiceTypes = (subscriberId): Observable<ServiceType[]> => {

	console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: " + subscriberId);
	if (_.has(this.store.getState().service.serviceTypes, subscriberId)) {
	return of(<ServiceType[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceTypes[subscriberId])));
	}

	return this.getSubscriberDetails(subscriberId)
	.map(this.subDetailsResponseToServiceTypes)
	.do((res) => {
	this.store.dispatch(updateServiceTypes(res, subscriberId));
	});
	};

	getSubscriberDetails = (subscriberId): Observable<GetSubDetailsResponse> => {
	let pathQuery: string = Constants.Path.AAI_SUB_DETAILS_PATH + subscriberId + Constants.Path.ASSIGN + Math.random() + Constants.Path.AAI_OMIT_SERVICE_INSTANCES + true;

	if (subscriberId != null) {
	return this.http.get<GetSubDetailsResponse>(pathQuery);
	}
	};

	subDetailsResponseToServiceTypes = (res: GetSubDetailsResponse): ServiceType[] => {
	if (res && res['service-subscriptions']) {
	const serviceSubscriptions = res['service-subscriptions']['service-subscription'];
	return serviceSubscriptions.map((subscription, index) => new ServiceType(String(index), subscription))
	} else {
	return [];
	}
	};


	public retrieveServiceInstanceTopology(serviceInstanceId : string, subscriberId: string, serviceType: string):Observable<ServiceInstance> {
	let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_INSTANCE_TOPOLOGY_PATH}${subscriberId}/${serviceType}/${serviceInstanceId}`;
	return this.http.get<ServiceInstance>(pathQuery);
	}

	public retrieveActiveNetwork(cloudRegion : string, tenantId: string) : Observable<NetworkModalRow[]>{
	let pathQuery: string = `${Constants.Path.AAI_GET_ACTIVE_NETWORKS_PATH}?cloudRegion=${cloudRegion}&tenantId=${tenantId}`;
	return this.http.get<NetworkModalRow[]>(pathQuery);
	}

	public retrieveActiveVPNs() : Observable<VPNModalRow[]>{
	let pathQuery: string = `${Constants.Path.AAI_GET_VPNS_PATH}`;
	return this.http.get<VPNModalRow[]>(pathQuery);
	}

	public retrieveAndStoreServiceInstanceTopology(serviceInstanceId: string, subscriberId: string, serviceType: string, serviceModeId: string):Observable<ServiceInstance> {
	return this.retrieveServiceInstanceTopology(serviceInstanceId, subscriberId, serviceType).do((service:ServiceInstance) => {
	this.store.dispatch(createServiceInstance(service, serviceModeId));
	});
	};


	public retrieveServiceInstanceRetryTopology(jobId : string) :Observable<ServiceInstance> {
	let pathQuery: string = `${Constants.Path.SERVICES_RETRY_TOPOLOGY}/${jobId}`;
	return this.http.get<ServiceInstance>(pathQuery);

	}

	public retrieveAndStoreServiceInstanceRetryTopology(jobId: string, serviceModeId : string):Observable<ServiceInstance> {
	return this.retrieveServiceInstanceRetryTopology(jobId).do((service:ServiceInstance) => {
	this.store.dispatch(createServiceInstance(service, serviceModeId));
	});
	};

	public getOptionalGroupMembers(serviceModelId: string, subscriberId: string, serviceType: string, serviceInvariantId: string, groupType: string, groupRole: string): Observable<VnfMember[]> {
	let pathQuery: string = `${Constants.Path.AAI_GET_SERVICE_GROUP_MEMBERS_PATH}${subscriberId}/${serviceType}/${serviceInvariantId}/${groupType}/${groupRole}`;
	if(_.has(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap,pathQuery)){
	return of(<VnfMember[]> JSON.parse(JSON.stringify(this.store.getState().service.serviceInstance[serviceModelId].optionalGroupMembersMap[pathQuery])));
	}
	return this.http.get<VnfMember[]>(pathQuery)
	.do((res) => {
	this.store.dispatch(setOptionalMembersVnfGroupInstance(serviceModelId, pathQuery, res))
	});
	}

	//TODO: make other places use this function
	extractSubscriberNameBySubscriberId(subscriberId: string) {
	let result: string = null;
	let filteredArray: any = _.filter(this.store.getState().service.subscribers, function (o: Subscriber) {
	return o.id === subscriberId
	});
	if (filteredArray.length > 0) {
	result = filteredArray[0].name;
	}
	return result;
	}

	loadMockMembers(): any {
	return [
	{
	"action":"None",
	"instanceName":"VNF1_INSTANCE_NAME",
	"instanceId":"VNF1_INSTANCE_ID",
	"orchStatus":null,
	"productFamilyId":null,
	"lcpCloudRegionId":"hvf23b",
	"tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
	"tenantName":"APPC-24595-T-IST-02C",
	"modelInfo":{
	"modelInvariantId":"vnf-instance-model-invariant-id",
	"modelVersionId":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
	"modelVersion":"2.0",
	"modelName":"vf_vEPDG",
	"modelType":"vnf"
	},
	"instanceType":"VNF1_INSTANCE_TYPE",
	"provStatus":null,
	"inMaint":false,
	"uuid":"7a6ee536-f052-46fa-aa7e-2fca9d674c44",
	"originalName":null,
	"legacyRegion":null,
	"lineOfBusiness":null,
	"platformName":null,
	"trackById":"7a6ee536-f052-46fa-aa7e-2fca9d674c44:002",
	"serviceInstanceId":"service-instance-id1",
	"serviceInstanceName":"service-instance-name"
	},
	{
	"action":"None",
	"instanceName":"VNF2_INSTANCE_NAME",
	"instanceId":"VNF2_INSTANCE_ID",
	"orchStatus":null,
	"productFamilyId":null,
	"lcpCloudRegionId":"hvf23b",
	"tenantId":"3e9a20a3e89e45f884e09df0cc2d2d2a",
	"tenantName":"APPC-24595-T-IST-02C",
	"modelInfo":{
	"modelInvariantId":"vnf-instance-model-invariant-id",
	"modelVersionId":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
	"modelVersion":"1.0",
	"modelName":"vf_vEPDG",
	"modelType":"vnf"
	},
	"instanceType":"VNF2_INSTANCE_TYPE",
	"provStatus":null,
	"inMaint":true,
	"uuid":"eb5f56bf-5855-4e61-bd00-3e19a953bf02",
	"originalName":null,
	"legacyRegion":null,
	"lineOfBusiness":null,
	"platformName":null,
	"trackById":"eb5f56bf-5855-4e61-bd00-3e19a953bf02:003",
	"serviceInstanceId":"service-instance-id2",
	"serviceInstanceName":"service-instance-name"
	}
	]

	}


	}