aboutsummaryrefslogtreecommitdiffstats
path: root/vid-webpack-master/src/app/services
diff options
context:
space:
mode:
authorSonsino, Ofir (os0695) <os0695@intl.att.com>2018-07-10 15:57:37 +0300
committerSonsino, Ofir (os0695) <os0695@intl.att.com>2018-07-10 15:57:37 +0300
commitff76b5ed0aa91d5fdf9dc4f95e8b20f91ed9d072 (patch)
treeaae42404a93fdffdd16ff050eaa28129959f7577 /vid-webpack-master/src/app/services
parentc72d565bb58226b20625b2bce5f0019046bee649 (diff)
New Angular UI from 1806
Change-Id: I39c160db0e0a6ec2e587ccf007ee1b23c6a08666 Issue-ID: VID-208 Signed-off-by: Sonsino, Ofir (os0695) <os0695@intl.att.com>
Diffstat (limited to 'vid-webpack-master/src/app/services')
-rw-r--r--vid-webpack-master/src/app/services/aaiService/aai.actions.ts75
-rw-r--r--vid-webpack-master/src/app/services/aaiService/aai.epics.ts81
-rw-r--r--vid-webpack-master/src/app/services/aaiService/aai.service.ts189
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getAicZonesResponseInterface.ts3
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getCategoryParamsResponseInterface.ts10
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServiceModelResponseInterface.ts5
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServicesResponseInterface.ts9
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubDetailsResponseInterface.ts12
-rw-r--r--vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubscribersResponseInterface.ts5
-rw-r--r--vid-webpack-master/src/app/services/configuration.service.ts34
-rw-r--r--vid-webpack-master/src/app/services/data.service.ts528
-rw-r--r--vid-webpack-master/src/app/services/flags.resolve.ts14
-rw-r--r--vid-webpack-master/src/app/services/msoService/mso.service.ts26
-rw-r--r--vid-webpack-master/src/app/services/sdc.service.ts28
-rw-r--r--vid-webpack-master/src/app/services/service-planning.service.spec.ts467
-rw-r--r--vid-webpack-master/src/app/services/service-planning.service.ts282
16 files changed, 1768 insertions, 0 deletions
diff --git a/vid-webpack-master/src/app/services/aaiService/aai.actions.ts b/vid-webpack-master/src/app/services/aaiService/aai.actions.ts
new file mode 100644
index 000000000..649fb1456
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/aai.actions.ts
@@ -0,0 +1,75 @@
+import {Action, ActionCreator} from "redux";
+
+export const LOAD_PRODUCT_FAMILIES = '[PRODUCT_FAMILIES] Load';
+
+export const LOAD_LCP_TENANT = '[LCP_TENANT] Load';
+
+export const LOAD_AIC_ZONES = '[AIC_ZONES] Load';
+
+export const LOAD_CATEGORY_PARAMETERS = '[LOAD_CATEGORY_PARAMETERS] Load';
+
+export const LOAD_SERVICE_MDOEL_BY_UUID = '[LOAD_SERVICE_MDOEL_BY_UUID] Load';
+
+export const LOAD_NETWORK_ACCORDING_TO_NF = '[LOAD_NETWORK_ACCORDING_TO_NF] Load'
+
+export const LOAD_USER_ID = '[LOAD_USER_ID] Load'
+
+
+export interface LoadProductFamiliesAction extends Action {}
+
+interface LoadLcpTenant extends Action {}
+
+interface LoadAicZones extends Action {}
+
+interface LoadCategoryParameters extends Action {}
+
+interface LoadServiceModelByUuid extends Action {}
+
+interface LoadNetworkAccordingToNetworkCF extends Action{}
+
+interface LoadUserId extends Action{}
+
+
+export const loadServiceAccordingToUuid : ActionCreator<LoadServiceModelByUuid> =
+ (uuid : string) =>({
+ type : LOAD_SERVICE_MDOEL_BY_UUID,
+ modelId : uuid
+ })
+
+
+export const loadProductFamiliesAction: ActionCreator<LoadProductFamiliesAction> =
+ () => ({
+ type: LOAD_PRODUCT_FAMILIES,
+ });
+
+
+export const loadUserId: ActionCreator<LoadUserId> =
+() => ({
+ type: LOAD_USER_ID,
+});
+
+
+ export const loadLcpTenant: ActionCreator<LoadLcpTenant> =
+ () => ({
+ type: LOAD_LCP_TENANT,
+ });
+
+
+export const loadAicZones: ActionCreator<LoadAicZones> =
+ () => ({
+ type: LOAD_AIC_ZONES,
+ });
+
+export const loadCategoryParameters: ActionCreator<LoadCategoryParameters> =
+ () => ({
+ type: LOAD_CATEGORY_PARAMETERS,
+ });
+
+
+export const loadAaiNetworkAccordingToNetworkCF: ActionCreator<LoadNetworkAccordingToNetworkCF> =
+ (networkFunction,cloudOwner,cloudRegionId) => ({
+ type: LOAD_NETWORK_ACCORDING_TO_NF,
+ networkFunctions: networkFunction,
+ cloudOwner: cloudOwner,
+ cloudRegionId: cloudRegionId
+ });
diff --git a/vid-webpack-master/src/app/services/aaiService/aai.epics.ts b/vid-webpack-master/src/app/services/aaiService/aai.epics.ts
new file mode 100644
index 000000000..5249cea82
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/aai.epics.ts
@@ -0,0 +1,81 @@
+import {updateServiceInstance} from './../../service.actions';
+import {Injectable} from '@angular/core';
+import {createEpicMiddleware} from 'redux-observable';
+import 'rxjs/add/operator/catch';
+import 'rxjs/add/operator/map';
+import 'rxjs/add/operator/do';
+import 'rxjs/add/operator/startWith';
+import {
+ LOAD_PRODUCT_FAMILIES,
+ LOAD_LCP_TENANT,
+ LOAD_AIC_ZONES,
+ LOAD_CATEGORY_PARAMETERS,
+ LOAD_SERVICE_MDOEL_BY_UUID,
+ LOAD_NETWORK_ACCORDING_TO_NF,
+ LOAD_USER_ID
+} from "./aai.actions";
+import {AaiService} from "./aai.service";
+import {
+ updateAicZones, updateCategoryParameters, updateLcpRegionsAndTenants, updateNetworkCollectionFunction,
+ updateProductFamilies, updateUserId
+} from "../../service.actions";
+import {AppState} from "../../store/reducers";
+
+const notFetchedAlready = (state: AppState): boolean => state.service.productFamilies !== null;
+
+@Injectable()
+export class AAIEpics {
+ constructor(private aaiService: AaiService) {
+ }
+
+ public createEpic() {
+ return [createEpicMiddleware(this.loadProductFamiliesEpic)
+ , createEpicMiddleware(this.loadLcpTenants)
+ , createEpicMiddleware(this.loadAicZones)
+ , createEpicMiddleware(this.loadCategoryParameters)
+ , createEpicMiddleware(this.loadServiceAccordingToUuid)
+ , createEpicMiddleware(this.loadNetworkAccordingToNetworkFunction)
+ , createEpicMiddleware(this.loadUserId)
+ ];
+ }
+
+ private loadLcpTenants = (action$, store) =>
+ action$
+ .ofType(LOAD_LCP_TENANT)
+ .switchMap(() => this
+ .aaiService
+ .getLcpRegionsAndTenants('e433710f-9217-458d-a79d-1c7aff376d89', 'VIRTUAL USP')
+ .map(data => updateLcpRegionsAndTenants(data)));
+
+ private loadProductFamiliesEpic = (action$, store) => action$
+ .ofType(LOAD_PRODUCT_FAMILIES)
+ .switchMap(() => this.aaiService.getProductFamilies().map(data => updateProductFamilies(data)));
+
+ private loadCategoryParameters = (action$, store) => action$
+ .ofType(LOAD_CATEGORY_PARAMETERS)
+ .switchMap(() => this.aaiService.getCategoryParameters(null).map(data => updateCategoryParameters(data)));
+
+
+ private loadNetworkAccordingToNetworkFunction = (action$, store) => action$
+ .ofType(LOAD_NETWORK_ACCORDING_TO_NF)
+ .flatMap((action) => this.aaiService.getCRAccordingToNetworkFunctionId(action.networkFunctions, action.cloudOwner, action.cloudRegionId).map((res) =>
+ updateNetworkCollectionFunction(action.networkFunctions, res)));
+
+ private loadServiceAccordingToUuid = (action$, store) => action$
+ .ofType(LOAD_SERVICE_MDOEL_BY_UUID)
+ .switchMap((action) => this.aaiService.getServiceModelById(action.modelId)
+ .map(data => updateServiceInstance(action.uuid, data)));
+
+ private loadUserId = (action$, store) => action$
+ .ofType(LOAD_USER_ID)
+ .switchMap(() => this.aaiService.getUserId()
+ .map(res => updateUserId(res)));
+
+
+ private loadAicZones = (action$, store) => action$
+ .ofType(LOAD_AIC_ZONES)
+ .switchMap(() => this.aaiService.getAicZones().map(data => updateAicZones(data)));
+ // .catch(response => of(this.actions.loadFailed(status)))
+ // .startWith(this.actions.loadStarted()));
+
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/aai.service.ts b/vid-webpack-master/src/app/services/aaiService/aai.service.ts
new file mode 100644
index 000000000..dd9d9fb29
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/aai.service.ts
@@ -0,0 +1,189 @@
+import {Injectable} from '@angular/core';
+import {HttpClient, HttpHeaders} from '@angular/common/http';
+import { Constants } from '../../shared/utils/constants';
+import { ServiceType } from "../../shared/models/serviceType";
+import {GetSubDetailsResponse} from "./responseInterfaces/getSubDetailsResponseInterface";
+import {Observable} from "rxjs/Observable";
+import * as _ from 'lodash';
+import {CategoryParams} from "../../shared/models/categoryParams";
+import {GetCategoryParamsResponseInterface} from "./responseInterfaces/getCategoryParamsResponseInterface";
+import {Project} from "../../shared/models/project";
+import {OwningEntity} from "../../shared/models/owningEntity";
+import {GetServicesResponseInterface} from "./responseInterfaces/getServicesResponseInterface";
+import {Subscriber} from "../../shared/models/subscriber";
+import {GetSubscribersResponse} from "./responseInterfaces/getSubscribersResponseInterface";
+import {AicZone} from "../../shared/models/aicZone";
+import {GetAicZonesResponse} from "./responseInterfaces/getAicZonesResponseInterface";
+import {LcpRegionsAndTenants} from "../../shared/models/lcpRegionsAndTenants";
+import {LcpRegion} from "../../shared/models/lcpRegion";
+import {Tenant} from "../../shared/models/tenant";
+import {ProductFamily} from "../../shared/models/productFamily"
+import {
+ updateAicZones, updateCategoryParameters, updateLcpRegionsAndTenants, updateModel, updateProductFamilies,
+ updateServiceTypes, updateSubscribers, updateUserId
+} from '../../service.actions';
+import {SelectOption} from '../../shared/models/selectOption';
+import {NgRedux} from "@angular-redux/store";
+import {AppState} from "../../store/reducers";
+import {ResponseContentType, ResponseType} from "@angular/http";
+import 'rxjs/add/operator/do';
+import 'rxjs/add/observable/of';
+import 'rxjs/add/operator/catch';
+
+@Injectable()
+export class AaiService {
+
+ constructor (private http: HttpClient, private store: NgRedux<AppState>) {}
+
+ public getServiceModelById(serviceModelId: string): Observable<any> {
+ if (_.has(this.store.getState().service.serviceHierarchy,serviceModelId)){
+ return Observable.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));
+ });
+ }
+
+ public getUserId() : Observable<any>{
+ return this.http.get("../../getuserID",{responseType: 'text'}).do((res)=>this.store.dispatch(updateUserId(res)));
+ }
+
+
+ public 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));
+ }
+
+ public 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();
+ }
+ }
+
+ public getProductFamilies(): Observable<ProductFamily[]> {
+ return this.getServices().map(res => res.service.map(service => new ProductFamily(service)));
+ }
+
+ public getServices(): Observable<GetServicesResponseInterface> {
+ let pathQuery: string = Constants.Path.AAI_GET_SERVICES + Constants.Path.ASSIGN + Math.random();
+
+ return this.http.get<GetServicesResponseInterface>(pathQuery);
+ }
+
+ public getSubscribers(): Observable<Subscriber[]> {
+ if (this.store.getState().service.subscribers){
+ return Observable.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));
+ });
+ }
+
+ public getAicZones(): Observable<AicZone[]> {
+ if (this.store.getState().service.aicZones){
+ return Observable.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));
+ });
+ }
+
+ public getLcpRegionsAndTenants(globalCustomerId, serviceType): Observable<LcpRegionsAndTenants> {
+ if (this.store.getState().service.lcpRegionsAndTenants.lcpRegionList.length !== 0){
+ return Observable.of(<any> JSON.parse(JSON.stringify(this.store.getState().service.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) => {
+ return new LcpRegion(cloudRegionTenant)
+ });
+
+ 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 getServiceTypes(subscriberId): Observable<ServiceType[]> {
+ console.log("AaiService:getSubscriptionServiceTypeList: globalCustomerId: " + subscriberId);
+ if (_.has(this.store.getState().service.serviceTypes, subscriberId)){
+ return Observable.of(<any> 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));});
+ }
+
+ public getSubscriberDetails(subscriberId): Observable<GetSubDetailsResponse> {
+ let pathQuery: string = Constants.Path.AAI_SUB_DETAILS_PATH + subscriberId + Constants.Path.ASSIGN + Math.random();
+
+ 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 [];
+ }
+ }
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getAicZonesResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getAicZonesResponseInterface.ts
new file mode 100644
index 000000000..62581c9e2
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getAicZonesResponseInterface.ts
@@ -0,0 +1,3 @@
+export interface GetAicZonesResponse {
+ zone: any[];
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getCategoryParamsResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getCategoryParamsResponseInterface.ts
new file mode 100644
index 000000000..06398904c
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getCategoryParamsResponseInterface.ts
@@ -0,0 +1,10 @@
+interface CategoryParametersResponse {
+ owningEntity: any[],
+ project: any[]
+ lineOfBusiness: any[]
+ platform: any[]
+}
+
+export interface GetCategoryParamsResponseInterface {
+ categoryParameters: CategoryParametersResponse;
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServiceModelResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServiceModelResponseInterface.ts
new file mode 100644
index 000000000..87671155d
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServiceModelResponseInterface.ts
@@ -0,0 +1,5 @@
+import {ServiceModelResponseInterface} from "../../../shared/models/serviceModel";
+
+export interface GetServiceModelResponseInterface {
+ service: ServiceModelResponseInterface
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServicesResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServicesResponseInterface.ts
new file mode 100644
index 000000000..ae04055e4
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getServicesResponseInterface.ts
@@ -0,0 +1,9 @@
+export interface ServiceResponseInterface {
+ 'service-id': string,
+ 'service-description': string
+ 'is-permitted': boolean
+}
+
+export interface GetServicesResponseInterface {
+ service: ServiceResponseInterface[];
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubDetailsResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubDetailsResponseInterface.ts
new file mode 100644
index 000000000..dbfb695d0
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubDetailsResponseInterface.ts
@@ -0,0 +1,12 @@
+export interface Subscription {
+ 'service-type': string;
+ 'is-permitted': boolean;
+}
+
+interface ServiceSubscriptions {
+ 'service-subscription': Subscription[];
+}
+
+export interface GetSubDetailsResponse {
+ 'service-subscriptions': ServiceSubscriptions;
+}
diff --git a/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubscribersResponseInterface.ts b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubscribersResponseInterface.ts
new file mode 100644
index 000000000..065f66e21
--- /dev/null
+++ b/vid-webpack-master/src/app/services/aaiService/responseInterfaces/getSubscribersResponseInterface.ts
@@ -0,0 +1,5 @@
+import {Subscriber} from "../../../shared/models/subscriber";
+
+export interface GetSubscribersResponse {
+ customer: Subscriber[];
+}
diff --git a/vid-webpack-master/src/app/services/configuration.service.ts b/vid-webpack-master/src/app/services/configuration.service.ts
new file mode 100644
index 000000000..4edd8ffb5
--- /dev/null
+++ b/vid-webpack-master/src/app/services/configuration.service.ts
@@ -0,0 +1,34 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from "@angular/common/http";
+import {Constants} from "../shared/utils/constants";
+import {Observable} from 'rxjs/Observable';
+import {updateFlags} from "../global.actions";
+import {NgRedux} from "@angular-redux/store";
+import {AppState} from "../store/reducers";
+
+@Injectable()
+export class ConfigurationService {
+ store : NgRedux<AppState>;
+
+ constructor(private _http: HttpClient, _store : NgRedux<AppState>) {
+ this.store = _store;
+ }
+
+ getConfiguration(key : string): Observable<any> {
+ let pathQuery = Constants.Path.CONFIGURATION_PATH;
+ pathQuery = pathQuery.replace("{name}",key);
+ return this._http.get(pathQuery).map(response => response);
+ }
+
+ getFlags(): Observable<{[key: string] : boolean}> {
+ let flags = this.store.getState().global.flags;
+ if (flags) {
+ return Observable.of(flags);
+ }
+ let pathQuery = Constants.Path.FEATURES_FLAG_PATH;
+ return this._http.get<{[key: string] : boolean}>(pathQuery).map(response => {
+ this.store.dispatch(updateFlags(response));
+ return response;
+ });
+ }
+}
diff --git a/vid-webpack-master/src/app/services/data.service.ts b/vid-webpack-master/src/app/services/data.service.ts
new file mode 100644
index 000000000..4f8bf3623
--- /dev/null
+++ b/vid-webpack-master/src/app/services/data.service.ts
@@ -0,0 +1,528 @@
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class DataService {
+
+ private static _availableVolumeGroupList;
+ private static _cloudRegionTenantList;
+ private static _globalCustomerId;
+ private static _customizationUUID;
+ private static _rescustomizationUUID;
+ private static _inventoryItem;
+ private static _modelId;
+ private static _modelInstanceName;
+ private static _modelInfo;
+ private static _networkInstanceId;
+ private static _serviceIdList;
+ private static _aicZones;
+ private static _aicZone;
+ private static _serviceInstanceId;
+ private static _serviceInstanceName;
+ private static _serviceName;
+ private static _serviceType;
+ private static _serviceUuid;
+ private static _serviceTypeName;
+ private static _createSubscriberName;
+ private static _uploadSupplementoryDataFile;
+ private static _supplementoryDataFile;
+ private static _subscriberId;
+ private static _loggedInUserId;
+ private static _subscriberName;
+ private static _subscribers;
+ private static _subscriptionServiceTypeList;
+ private static _userParams;
+ private static _userServiceInstanceName;
+ private static _vfModuleInstanceId;
+ private static _vnfInstanceId;
+ private static _vfModuleInstanceName;
+ private static _volumeGroupInstanceId;
+ private static _lcpRegion;
+ private static _tenant;
+ private static _treeHandle;
+ private static _serviceInstanceToCustomer;
+ private static _aLaCarte: boolean;
+ private static _macro: boolean;
+ private static _resources;
+ private static _syspropProvStatusList;
+ private static _updatedvnfProvStatus;
+ private static _arbitraryParameters;
+ private static _hideServiceFields;
+ private static _serviceProxies;
+ private static _sourceServiceProxies;
+ private static _collectorServiceProxies;
+ private static _configurationByPolicy;
+ private static _suppressRollback;
+ private static _portMirroningConfigFields;
+ private static _configurationInstanceId: string;
+ private static _configurationStatus: string;
+ private static _portStatus: string;
+ private static _portId: string;
+ private static _pnf;
+ private static _owningEntityProperties;
+
+ static get availableVolumeGroupList() {
+ return this._availableVolumeGroupList;
+ }
+
+ static set availableVolumeGroupList(value) {
+ this._availableVolumeGroupList = value;
+ }
+
+ static get cloudRegionTenantList() {
+ return this._cloudRegionTenantList;
+ }
+
+ static set cloudRegionTenantList(value) {
+ this._cloudRegionTenantList = value;
+ }
+
+ static get globalCustomerId() {
+ return this._globalCustomerId;
+ }
+
+ static set globalCustomerId(value) {
+ this._globalCustomerId = value;
+ }
+
+ static get customizationUUID() {
+ return this._customizationUUID;
+ }
+
+ static set customizationUUID(value) {
+ this._customizationUUID = value;
+ }
+
+ static get rescustomizationUUID() {
+ return this._rescustomizationUUID;
+ }
+
+ static set rescustomizationUUID(value) {
+ this._rescustomizationUUID = value;
+ }
+
+ static get inventoryItem() {
+ return this._inventoryItem;
+ }
+
+ static set inventoryItem(value) {
+ this._inventoryItem = value;
+ }
+
+ static get modelId() {
+ return this._modelId;
+ }
+
+ static set modelId(value) {
+ this._modelId = value;
+ }
+
+ static get modelInstanceName() {
+ return this._modelInstanceName;
+ }
+
+ static set modelInstanceName(value) {
+ this._modelInstanceName = value;
+ }
+
+ static get modelInfo() {
+ return this._modelInfo;
+ }
+
+ static set modelInfo(value) {
+ this._modelInfo = value;
+ }
+
+ static getModelInfo(componentId) {
+ return this._modelInfo[componentId];
+ }
+
+ static setModelInfo(componentId, modelInfo) {
+ if (!this._modelInfo) {
+ this._modelInfo = {};
+ }
+ this._modelInfo[componentId] = modelInfo;
+ }
+
+ static get networkInstanceId() {
+ return this._networkInstanceId;
+ }
+
+ static set networkInstanceId(value) {
+ this._networkInstanceId = value;
+ }
+
+ static get serviceIdList() {
+ return this._serviceIdList;
+ }
+
+ static set serviceIdList(value) {
+ this._serviceIdList = value;
+ }
+
+ static get aicZones() {
+ return this._aicZones;
+ }
+
+ static set aicZones(value) {
+ this._aicZones = value;
+ }
+
+ static get aicZone() {
+ return this._aicZone;
+ }
+
+ static set aicZone(value) {
+ this._aicZone = value;
+ }
+
+ static get serviceInstanceId() {
+ return this._serviceInstanceId;
+ }
+
+ static set serviceInstanceId(value) {
+ this._serviceInstanceId = value;
+ }
+
+ static get serviceInstanceName() {
+ return this._serviceInstanceName;
+ }
+
+ static set serviceInstanceName(value) {
+ this._serviceInstanceName = value;
+ }
+
+ static get serviceName() {
+ return this._serviceName;
+ }
+
+ static set serviceName(value) {
+ this._serviceName = value;
+ }
+
+ static get serviceType() {
+ return this._serviceType;
+ }
+
+ static set serviceType(value) {
+ this._serviceType = value;
+ }
+
+ static get serviceUuid() {
+ return this._serviceUuid;
+ }
+
+ static set serviceUuid(value) {
+ this._serviceUuid = value;
+ }
+
+ static get serviceTypeName() {
+ return this._serviceTypeName;
+ }
+
+ static set serviceTypeName(value) {
+ this._serviceTypeName = value;
+ }
+
+ static get createSubscriberName() {
+ return this._createSubscriberName;
+ }
+
+ static set createSubscriberName(value) {
+ this._createSubscriberName = value;
+ }
+
+ static get uploadSupplementoryDataFile() {
+ return this._uploadSupplementoryDataFile;
+ }
+
+ static set uploadSupplementoryDataFile(value) {
+ this._uploadSupplementoryDataFile = value;
+ }
+
+ static get supplementoryDataFile() {
+ return this._supplementoryDataFile;
+ }
+
+ static set supplementoryDataFile(value) {
+ this._supplementoryDataFile = value;
+ }
+
+ static get subscriberId() {
+ return this._subscriberId;
+ }
+
+ static set subscriberId(value) {
+ this._subscriberId = value;
+ }
+
+ static get loggedInUserId() {
+ return this._loggedInUserId;
+ }
+
+ static set loggedInUserId(value) {
+ this._loggedInUserId = value;
+ }
+
+ static get subscriberName() {
+ return this._subscriberName;
+ }
+
+ static set subscriberName(value) {
+ this._subscriberName = value;
+ }
+
+ static get subscribers() {
+ return this._subscribers;
+ }
+
+ static set subscribers(value) {
+ this._subscribers = value;
+ }
+
+ static get subscriptionServiceTypeList() {
+ return this._subscriptionServiceTypeList;
+ }
+
+ static set subscriptionServiceTypeList(value) {
+ this._subscriptionServiceTypeList = value;
+ }
+
+ static get userParams() {
+ return this._userParams;
+ }
+
+ static set userParams(value) {
+ this._userParams = value;
+ }
+
+ static get userServiceInstanceName() {
+ return this._userServiceInstanceName;
+ }
+
+ static set userServiceInstanceName(value) {
+ this._userServiceInstanceName = value;
+ }
+
+ static get vfModuleInstanceId() {
+ return this._vfModuleInstanceId;
+ }
+
+ static set vfModuleInstanceId(value) {
+ this._vfModuleInstanceId = value;
+ }
+
+ static get vnfInstanceId() {
+ return this._vnfInstanceId;
+ }
+
+ static set vnfInstanceId(value) {
+ this._vnfInstanceId = value;
+ }
+
+ static get vfModuleInstanceName() {
+ return this._vfModuleInstanceName;
+ }
+
+ static set vfModuleInstanceName(value) {
+ this._vfModuleInstanceName = value;
+ }
+
+ static get volumeGroupInstanceId() {
+ return this._volumeGroupInstanceId;
+ }
+
+ static set volumeGroupInstanceId(value) {
+ this._volumeGroupInstanceId = value;
+ }
+
+ static get lcpRegion() {
+ return this._lcpRegion;
+ }
+
+ static set lcpRegion(value) {
+ this._lcpRegion = value;
+ }
+
+ static get tenant() {
+ return this._tenant;
+ }
+
+ static set tenant(value) {
+ this._tenant = value;
+ }
+
+ static get treeHandle() {
+ return this._treeHandle;
+ }
+
+ static set treeHandle(value) {
+ this._treeHandle = value;
+ }
+
+ static get serviceInstanceToCustomer() {
+ return this._serviceInstanceToCustomer;
+ }
+
+ static set serviceInstanceToCustomer(value) {
+ this._serviceInstanceToCustomer = value;
+ }
+
+ static get aLaCarte() {
+ if (!this._aLaCarte) {
+ return true;
+ }
+ return this._aLaCarte;
+ }
+
+ static set aLaCarte(value: boolean) {
+ this._aLaCarte = value;
+ }
+
+ static get macro() {
+ if (!this._macro) {
+ return false;
+ }
+ return this._macro;
+ }
+
+ static set macro(value: boolean) {
+ this._macro = value;
+ }
+
+ static get resources() {
+ return this._resources;
+ }
+
+ static set resources(value) {
+ this._resources = value;
+ }
+
+ static get syspropProvStatusList() {
+ return this._syspropProvStatusList;
+ }
+
+ static set syspropProvStatusList(value) {
+ this._syspropProvStatusList = value;
+ }
+
+ static get updatedvnfProvStatus() {
+ return this._updatedvnfProvStatus;
+ }
+
+ static set updatedvnfProvStatus(value) {
+ this._updatedvnfProvStatus = value;
+ }
+
+ static get arbitraryParameters() {
+ return this._arbitraryParameters;
+ }
+
+ static set arbitraryParameters(value) {
+ this._arbitraryParameters = value;
+ }
+
+ static get hideServiceFields() {
+ return this._hideServiceFields;
+ }
+
+ static set hideServiceFields(value) {
+ this._hideServiceFields = value;
+ }
+
+ static get serviceProxies() {
+ return this._serviceProxies;
+ }
+
+ static set serviceProxies(value) {
+ this._serviceProxies = value;
+ }
+
+ static get sourceServiceProxies() {
+ return this._sourceServiceProxies;
+ }
+
+ static set sourceServiceProxies(value) {
+ this._sourceServiceProxies = value;
+ }
+
+ static get collectorServiceProxies() {
+ return this._collectorServiceProxies;
+ }
+
+ static set collectorServiceProxies(value) {
+ this._collectorServiceProxies = value;
+ }
+
+ static get configurationByPolicy() {
+ return this._configurationByPolicy;
+ }
+
+ static set configurationByPolicy(value) {
+ this._configurationByPolicy = value;
+ }
+
+ static get suppressRollback() {
+ return this._suppressRollback;
+ }
+
+ static set suppressRollback(value) {
+ this._suppressRollback = value;
+ }
+
+ static get portMirroningConfigFields() {
+ return this._portMirroningConfigFields;
+ }
+
+ static set portMirroningConfigFields(value) {
+ this._portMirroningConfigFields = value;
+ }
+
+ static get configurationInstanceId(): string {
+ return this._configurationInstanceId;
+ }
+
+ static set configurationInstanceId(value: string) {
+ this._configurationInstanceId = value;
+ }
+
+ static get configurationStatus(): string {
+ return this._configurationStatus;
+ }
+
+ static set configurationStatus(value: string) {
+ this._configurationStatus = value;
+ }
+
+ static get portStatus(): string {
+ return this._portStatus;
+ }
+
+ static set portStatus(value: string) {
+ this._portStatus = value;
+ }
+
+ static get portId(): string {
+ return this._portId;
+ }
+
+ static set portId(value: string) {
+ this._portId = value;
+ }
+
+ static get pnf() {
+ return this._pnf;
+ }
+
+ static set pnf(value) {
+ this._pnf = value;
+ }
+
+ static get owningEntityProperties() {
+ return this._owningEntityProperties;
+ }
+
+ static set owningEntityProperties(value) {
+ this._owningEntityProperties = value;
+ }
+
+}
diff --git a/vid-webpack-master/src/app/services/flags.resolve.ts b/vid-webpack-master/src/app/services/flags.resolve.ts
new file mode 100644
index 000000000..70449379f
--- /dev/null
+++ b/vid-webpack-master/src/app/services/flags.resolve.ts
@@ -0,0 +1,14 @@
+import {ActivatedRouteSnapshot, Resolve} from "@angular/router";
+import {Injectable} from "@angular/core";
+import {ConfigurationService} from "./configuration.service";
+import {Observable} from "rxjs/Observable";
+
+@Injectable()
+export class FlagsResolve implements Resolve<Observable< { [key: string]: boolean }>> {
+
+ constructor(private _configurationService: ConfigurationService) {}
+
+ resolve(route: ActivatedRouteSnapshot) {
+ return this._configurationService.getFlags();
+ }
+}
diff --git a/vid-webpack-master/src/app/services/msoService/mso.service.ts b/vid-webpack-master/src/app/services/msoService/mso.service.ts
new file mode 100644
index 000000000..1402b50f7
--- /dev/null
+++ b/vid-webpack-master/src/app/services/msoService/mso.service.ts
@@ -0,0 +1,26 @@
+import {Injectable} from "@angular/core";
+import {HttpClient} from "@angular/common/http";
+import {Observable} from "rxjs/Observable";
+import {Constants} from "../../shared/utils/constants";
+
+@Injectable()
+export class MsoService {
+ httpClient: HttpClient;
+
+ constructor(http: HttpClient) {
+ this.httpClient = http;
+ }
+
+
+ public submitMsoTask(instanceFields): Observable<any> {
+ let path = '../../asyncInstantiation/bulk';
+ return this.httpClient.post(path, instanceFields);
+ }
+ public createVnf(requestDetails, serviceInstanceId): Observable<any> {
+ let pathQuery: string = Constants.Path.MSO_CREATE_VNF_INSTANCE + serviceInstanceId;
+
+ return this.httpClient.post( pathQuery, {
+ requestDetails : requestDetails
+ });
+ }
+}
diff --git a/vid-webpack-master/src/app/services/sdc.service.ts b/vid-webpack-master/src/app/services/sdc.service.ts
new file mode 100644
index 000000000..d4eba260a
--- /dev/null
+++ b/vid-webpack-master/src/app/services/sdc.service.ts
@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import 'rxjs/add/operator/map';
+import { Constants } from '../shared/utils/constants';
+import { VidConfiguration } from '../configuration/vid.configuration';
+
+@Injectable()
+export class SdcService {
+
+
+ constructor (private http: HttpClient) {
+ }
+
+ public getServicesModels(): any {
+ let pathQuery: string = Constants.Path.SERVICES_DIST_STATUS_PATH + VidConfiguration.ASDC_MODEL_STATUS;
+
+ if ( VidConfiguration.ASDC_MODEL_STATUS === Constants.Status.ALL) {
+ pathQuery = Constants.Path.SERVICES_PATH;
+ }
+
+ return this.http.get(pathQuery);
+ }
+
+ getService(uuid: string) {
+ return this.http.get(Constants.Path.SERVICES_PATH + uuid);
+ }
+
+}
diff --git a/vid-webpack-master/src/app/services/service-planning.service.spec.ts b/vid-webpack-master/src/app/services/service-planning.service.spec.ts
new file mode 100644
index 000000000..5d60e29f7
--- /dev/null
+++ b/vid-webpack-master/src/app/services/service-planning.service.spec.ts
@@ -0,0 +1,467 @@
+import {ServicePlanningService} from "./service-planning.service";
+import {ReflectiveInjector} from "@angular/core";
+import {NgRedux} from "@angular-redux/store";
+import {ServiceNodeTypes} from "../shared/models/ServiceNodeTypes";
+
+export class MockAppStore<T> {
+}
+
+describe('Service planning service', () => {
+ let injector;
+ let service: ServicePlanningService;
+
+ beforeEach(() => {
+
+ let injector = ReflectiveInjector.resolveAndCreate([
+ ServicePlanningService,
+ {provide: NgRedux, useClass: MockAppStore}
+ ]);
+
+ service = injector.get(ServicePlanningService);
+ });
+
+ describe('#updateDynamicInputsVnfDataFromModel', () => {
+ it('get vfModule instance params', (done: DoneFn) => {
+ //get vfModule instance params
+ let dynamicInputs = service.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VFmodule, generateVFModule());
+ expect(dynamicInputs).toEqual([{
+ id: '2017488_adiodvpe0_vnf_config_template_version',
+ type: 'string',
+ name: '2017488_adiodvpe0_vnf_config_template_version',
+ value: '17.2',
+ isRequired: true,
+ description: 'VPE Software Version'
+ }, {
+ id: '2017488_adiodvpe0_AIC_CLLI',
+ type: 'string',
+ name: '2017488_adiodvpe0_AIC_CLLI',
+ value: 'ATLMY8GA',
+ isRequired: true,
+ description: 'AIC Site CLLI'
+ }]);
+
+ //get vfModule with no instance params should return empty array
+ dynamicInputs = service.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VFmodule, generateVFModule2);
+ expect(dynamicInputs).toEqual([]);
+
+ //get vf instance params should be undefined
+ dynamicInputs = service.updateDynamicInputsVnfDataFromModel(ServiceNodeTypes.VF, generateVNF());
+ expect(dynamicInputs).toEqual([]);
+ done();
+ });
+ });
+
+ describe('#isUserProvidedNaming', () => {
+ it('get vfModule with generate ecompNaming should return userProvided false', (done: DoneFn) => {
+ //get vfModule with generate ecompNaming should return userProvided false
+ let isUserProvidedNaming = service.isUserProvidedNaming(ServiceNodeTypes.VFmodule, generateVFModule(), generateVNF());
+ expect(isUserProvidedNaming).toBeFalsy();
+
+ //get vfModule without generate ecompNaming should return userProvided true
+ isUserProvidedNaming = service.isUserProvidedNaming(ServiceNodeTypes.VFmodule, generateVFModule(), generateVNF_ecompNamingFalse());
+ expect(isUserProvidedNaming).toBeTruthy();
+
+ //get vnf with generate ecompNaming should return userProvided false
+ isUserProvidedNaming = service.isUserProvidedNaming(ServiceNodeTypes.VF, generateVNF(), null);
+ expect(isUserProvidedNaming).toBeFalsy();
+
+ //get vnf without generate ecompNaming should return userProvided true
+ isUserProvidedNaming = service.isUserProvidedNaming(ServiceNodeTypes.VF, generateVNF_ecompNamingFalse(), null);
+ expect(isUserProvidedNaming).toBeTruthy();
+ done();
+ });
+ });
+
+ function generateVFModule() {
+ return {
+ 'uuid': '25284168-24bb-4698-8cb4-3f509146eca5',
+ 'invariantUuid': '7253ff5c-97f0-4b8b-937c-77aeb4d79aa1',
+ 'customizationUuid': 'f7e7c365-60cf-49a9-9ebf-a1aa11b9d401',
+ 'description': null,
+ 'name': '2017488AdiodVpe..ADIOD_vRE_BV..module-1',
+ 'version': '6',
+ 'modelCustomizationName': '2017488AdiodVpe..ADIOD_vRE_BV..module-1',
+ 'properties': {'minCountInstances': 0, 'maxCountInstances': null, 'initialCount': 0},
+ 'commands': {},
+ 'volumeGroupAllowed': true,
+ 'inputs': {
+ '2017488_adiodvpe0_vnf_config_template_version': {
+ 'type': 'string',
+ 'description': 'VPE Software Version',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': '17.2'
+ },
+ '2017488_adiodvpe0_AIC_CLLI': {
+ 'type': 'string',
+ 'description': 'AIC Site CLLI',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'ATLMY8GA'
+ }
+ }
+ };
+ }
+
+ function generateVFModule2() {
+ return {
+ 'uuid': '0a0dd9d4-31d3-4c3a-ae89-a02f383e6a9a',
+ 'invariantUuid': 'eff8cc59-53a1-4101-aed7-8cf24ecf8339',
+ 'customizationUuid': '3cd946bb-50e0-40d8-96d3-c9023520b557',
+ 'description': null,
+ 'name': '2017488AdiodVpe..ADIOD_vPFE_BV..module-2',
+ 'version': '6',
+ 'modelCustomizationName': '2017488AdiodVpe..ADIOD_vPFE_BV..module-2',
+ 'properties': {'minCountInstances': 0, 'maxCountInstances': null, 'initialCount': 0},
+ 'commands': {},
+ 'volumeGroupAllowed': true,
+ 'inputs': {}
+ };
+ }
+
+ function generateVNF() {
+ return {
+ 'uuid': '0903e1c0-8e03-4936-b5c2-260653b96413',
+ 'invariantUuid': '00beb8f9-6d39-452f-816d-c709b9cbb87d',
+ 'description': 'Name ADIOD vPE Description The provider edge function for the ADIOD service supported by the Junipers VMX product Category Router Vendor Juniper Vendor Release Code 17.2 Owners Mary Fragale. Updated 9-25 to use v8.0 of the Juniper Valid 2 VLM',
+ 'name': '2017-388_ADIOD-vPE',
+ 'version': '1.0',
+ 'customizationUuid': '280dec31-f16d-488b-9668-4aae55d6648a',
+ 'inputs': {
+ 'vnf_config_template_version': {
+ 'type': 'string',
+ 'description': 'VPE Software Version',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': '17.2'
+ },
+ 'bandwidth_units': {
+ 'type': 'string',
+ 'description': 'Units of bandwidth',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'Gbps'
+ },
+ 'bandwidth': {
+ 'type': 'string',
+ 'description': 'Requested VPE bandwidth',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': '10'
+ },
+ 'AIC_CLLI': {
+ 'type': 'string',
+ 'description': 'AIC Site CLLI',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'ATLMY8GA'
+ },
+ 'ASN': {
+ 'type': 'string',
+ 'description': 'AV/PE',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'AV_vPE'
+ },
+ 'vnf_instance_name': {
+ 'type': 'string',
+ 'description': 'The hostname assigned to the vpe.',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'mtnj309me6'
+ }
+ },
+ 'commands': {
+ 'vnf_config_template_version': {
+ 'displayName': 'vnf_config_template_version',
+ 'command': 'get_input',
+ 'inputName': '2017488_adiodvpe0_vnf_config_template_version'
+ },
+ 'bandwidth_units': {
+ 'displayName': 'bandwidth_units',
+ 'command': 'get_input',
+ 'inputName': 'adiodvpe0_bandwidth_units'
+ },
+ 'bandwidth': {'displayName': 'bandwidth', 'command': 'get_input', 'inputName': 'adiodvpe0_bandwidth'},
+ 'AIC_CLLI': {'displayName': 'AIC_CLLI', 'command': 'get_input', 'inputName': '2017488_adiodvpe0_AIC_CLLI'},
+ 'ASN': {'displayName': 'ASN', 'command': 'get_input', 'inputName': '2017488_adiodvpe0_ASN'},
+ 'vnf_instance_name': {
+ 'displayName': 'vnf_instance_name',
+ 'command': 'get_input',
+ 'inputName': '2017488_adiodvpe0_vnf_instance_name'
+ }
+ },
+ 'properties': {
+ 'vmxvre_retype': 'RE-VMX',
+ 'vnf_config_template_version': 'get_input:2017488_adiodvpe0_vnf_config_template_version',
+ 'sriov44_net_id': '48d399b3-11ee-48a8-94d2-f0ea94d6be8d',
+ 'int_ctl_net_id': '2f323477-6936-4d01-ac53-d849430281d9',
+ 'vmxvpfe_sriov41_0_port_mac': '00:11:22:EF:AC:DF',
+ 'int_ctl_net_name': 'VMX-INTXI',
+ 'vmx_int_ctl_prefix': '128.0.0.0',
+ 'sriov43_net_id': 'da349ca1-6de9-4548-be88-2d88e99bfef5',
+ 'sriov42_net_id': '760669ba-013d-4d9b-b0e7-4151fe2e6279',
+ 'sriov41_net_id': '25ad52d5-c165-40f8-b3b0-ddfc2373280a',
+ 'nf_type': 'vPE',
+ 'vmxvpfe_int_ctl_ip_1': '128.0.0.16',
+ 'is_AVPN_service': 'false',
+ 'vmx_RSG_name': 'vREXI-affinity',
+ 'vmx_int_ctl_forwarding': 'l2',
+ 'vmxvre_oam_ip_0': '10.40.123.5',
+ 'vmxvpfe_sriov44_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvpfe_sriov41_0_port_vlanstrip': 'false',
+ 'vmxvpfe_sriov42_0_port_vlanfilter': '4001',
+ 'vmxvpfe_sriov44_0_port_unknownunicastallow': 'true',
+ 'vmxvre_image_name_0': 'VRE-ENGINE_17.2-S2.1.qcow2',
+ 'vmxvre_instance': '0',
+ 'vmxvpfe_sriov43_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvre_flavor_name': 'ns.c1r16d32.v5',
+ 'vmxvpfe_volume_size_0': '40.0',
+ 'vmxvpfe_sriov43_0_port_vlanfilter': '4001',
+ 'nf_naming': '{ecomp_generated_naming=true}',
+ 'nf_naming_code': 'Navneet',
+ 'vmxvre_name_0': 'vREXI',
+ 'vmxvpfe_sriov42_0_port_vlanstrip': 'false',
+ 'vmxvpfe_volume_name_0': 'vPFEXI_FBVolume',
+ 'vmx_RSG_id': 'bd89a33c-13c3-4a04-8fde-1a57eb123141',
+ 'vmxvpfe_image_name_0': 'VPE_ROUTING-ENGINE_17.2R1-S2.1.qcow2',
+ 'vmxvpfe_sriov43_0_port_unknownunicastallow': 'true',
+ 'vmxvpfe_sriov44_0_port_unknownmulticastallow': 'true',
+ 'vmxvre_console': 'vidconsole',
+ 'vmxvpfe_sriov44_0_port_vlanfilter': '4001',
+ 'vmxvpfe_sriov42_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvpfe_volume_id_0': '47cede15-da2f-4397-a101-aa683220aff3',
+ 'vmxvpfe_sriov42_0_port_unknownmulticastallow': 'true',
+ 'vmxvpfe_sriov44_0_port_vlanstrip': 'false',
+ 'vf_module_id': '123',
+ 'nf_function': 'JAI',
+ 'vmxvpfe_sriov43_0_port_unknownmulticastallow': 'true',
+ 'vmxvre_int_ctl_ip_0': '128.0.0.1',
+ 'AIC_CLLI': 'get_input:2017488_adiodvpe0_AIC_CLLI',
+ 'vnf_name': 'mtnj309me6vre',
+ 'vmxvpfe_sriov41_0_port_unknownunicastallow': 'true',
+ 'vmxvre_volume_type_1': 'HITACHI',
+ 'vmxvpfe_sriov44_0_port_broadcastallow': 'true',
+ 'vmxvre_volume_type_0': 'HITACHI',
+ 'vmxvpfe_volume_type_0': 'HITACHI',
+ 'vmxvpfe_sriov43_0_port_broadcastallow': 'true',
+ 'bandwidth_units': 'get_input:adiodvpe0_bandwidth_units',
+ 'vnf_id': '123',
+ 'vmxvre_oam_prefix': '24',
+ 'availability_zone_0': 'mtpocfo-kvm-az01',
+ 'ASN': 'get_input:2017488_adiodvpe0_ASN',
+ 'vmxvre_chassis_i2cid': '161',
+ 'vmxvpfe_name_0': 'vPFEXI',
+ 'bandwidth': 'get_input:adiodvpe0_bandwidth',
+ 'availability_zone_max_count': '1',
+ 'vmxvre_volume_size_0': '45.0',
+ 'vmxvre_volume_size_1': '50.0',
+ 'vmxvpfe_sriov42_0_port_broadcastallow': 'true',
+ 'vmxvre_oam_gateway': '10.40.123.1',
+ 'vmxvre_volume_name_1': 'vREXI_FAVolume',
+ 'vmxvre_ore_present': '0',
+ 'vmxvre_volume_name_0': 'vREXI_FBVolume',
+ 'vmxvre_type': '0',
+ 'vnf_instance_name': 'get_input:2017488_adiodvpe0_vnf_instance_name',
+ 'vmxvpfe_sriov41_0_port_unknownmulticastallow': 'true',
+ 'oam_net_id': 'b95eeb1d-d55d-4827-abb4-8ebb94941429',
+ 'vmx_int_ctl_len': '24',
+ 'vmxvpfe_sriov43_0_port_vlanstrip': 'false',
+ 'vmxvpfe_sriov41_0_port_broadcastallow': 'true',
+ 'vmxvre_volume_id_1': '6e86797e-03cd-4fdc-ba72-2957119c746d',
+ 'vmxvpfe_sriov41_0_port_vlanfilter': '4001',
+ 'nf_role': 'Testing',
+ 'vmxvre_volume_id_0': 'f4eacb79-f687-4e9d-b760-21847c8bb15a',
+ 'vmxvpfe_sriov42_0_port_unknownunicastallow': 'true',
+ 'vmxvpfe_flavor_name': 'ns.c20r16d25.v5'
+ },
+ 'type': 'VF',
+ 'modelCustomizationName': '2017-388_ADIOD-vPE 1',
+ 'vfModules': {},
+ 'volumeGroups': {}
+ };
+ }
+
+ function generateVNF_ecompNamingFalse() {
+ return {
+ 'uuid': '0903e1c0-8e03-4936-b5c2-260653b96413',
+ 'invariantUuid': '00beb8f9-6d39-452f-816d-c709b9cbb87d',
+ 'description': 'Name ADIOD vPE Description The provider edge function for the ADIOD service supported by the Junipers VMX product Category Router Vendor Juniper Vendor Release Code 17.2 Owners Mary Fragale. Updated 9-25 to use v8.0 of the Juniper Valid 2 VLM',
+ 'name': '2017-388_ADIOD-vPE',
+ 'version': '1.0',
+ 'customizationUuid': '280dec31-f16d-488b-9668-4aae55d6648a',
+ 'inputs': {
+ 'vnf_config_template_version': {
+ 'type': 'string',
+ 'description': 'VPE Software Version',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': '17.2'
+ },
+ 'bandwidth_units': {
+ 'type': 'string',
+ 'description': 'Units of bandwidth',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'Gbps'
+ },
+ 'bandwidth': {
+ 'type': 'string',
+ 'description': 'Requested VPE bandwidth',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': '10'
+ },
+ 'AIC_CLLI': {
+ 'type': 'string',
+ 'description': 'AIC Site CLLI',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'ATLMY8GA'
+ },
+ 'ASN': {
+ 'type': 'string',
+ 'description': 'AV/PE',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'AV_vPE'
+ },
+ 'vnf_instance_name': {
+ 'type': 'string',
+ 'description': 'The hostname assigned to the vpe.',
+ 'entry_schema': null,
+ 'constraints': [],
+ 'required': true,
+ 'default': 'mtnj309me6'
+ }
+ },
+ 'commands': {
+ 'vnf_config_template_version': {
+ 'displayName': 'vnf_config_template_version',
+ 'command': 'get_input',
+ 'inputName': '2017488_adiodvpe0_vnf_config_template_version'
+ },
+ 'bandwidth_units': {
+ 'displayName': 'bandwidth_units',
+ 'command': 'get_input',
+ 'inputName': 'adiodvpe0_bandwidth_units'
+ },
+ 'bandwidth': {'displayName': 'bandwidth', 'command': 'get_input', 'inputName': 'adiodvpe0_bandwidth'},
+ 'AIC_CLLI': {'displayName': 'AIC_CLLI', 'command': 'get_input', 'inputName': '2017488_adiodvpe0_AIC_CLLI'},
+ 'ASN': {'displayName': 'ASN', 'command': 'get_input', 'inputName': '2017488_adiodvpe0_ASN'},
+ 'vnf_instance_name': {
+ 'displayName': 'vnf_instance_name',
+ 'command': 'get_input',
+ 'inputName': '2017488_adiodvpe0_vnf_instance_name'
+ }
+ },
+ 'properties': {
+ 'ecomp_generated_naming': "false",
+ 'vmxvre_retype': 'RE-VMX',
+ 'vnf_config_template_version': 'get_input:2017488_adiodvpe0_vnf_config_template_version',
+ 'sriov44_net_id': '48d399b3-11ee-48a8-94d2-f0ea94d6be8d',
+ 'int_ctl_net_id': '2f323477-6936-4d01-ac53-d849430281d9',
+ 'vmxvpfe_sriov41_0_port_mac': '00:11:22:EF:AC:DF',
+ 'int_ctl_net_name': 'VMX-INTXI',
+ 'vmx_int_ctl_prefix': '128.0.0.0',
+ 'sriov43_net_id': 'da349ca1-6de9-4548-be88-2d88e99bfef5',
+ 'sriov42_net_id': '760669ba-013d-4d9b-b0e7-4151fe2e6279',
+ 'sriov41_net_id': '25ad52d5-c165-40f8-b3b0-ddfc2373280a',
+ 'nf_type': 'vPE',
+ 'vmxvpfe_int_ctl_ip_1': '128.0.0.16',
+ 'is_AVPN_service': 'false',
+ 'vmx_RSG_name': 'vREXI-affinity',
+ 'vmx_int_ctl_forwarding': 'l2',
+ 'vmxvre_oam_ip_0': '10.40.123.5',
+ 'vmxvpfe_sriov44_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvpfe_sriov41_0_port_vlanstrip': 'false',
+ 'vmxvpfe_sriov42_0_port_vlanfilter': '4001',
+ 'vmxvpfe_sriov44_0_port_unknownunicastallow': 'true',
+ 'vmxvre_image_name_0': 'VRE-ENGINE_17.2-S2.1.qcow2',
+ 'vmxvre_instance': '0',
+ 'vmxvpfe_sriov43_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvre_flavor_name': 'ns.c1r16d32.v5',
+ 'vmxvpfe_volume_size_0': '40.0',
+ 'vmxvpfe_sriov43_0_port_vlanfilter': '4001',
+ 'nf_naming': '{ecomp_generated_naming=false}',
+ 'nf_naming_code': 'Navneet',
+ 'vmxvre_name_0': 'vREXI',
+ 'vmxvpfe_sriov42_0_port_vlanstrip': 'false',
+ 'vmxvpfe_volume_name_0': 'vPFEXI_FBVolume',
+ 'vmx_RSG_id': 'bd89a33c-13c3-4a04-8fde-1a57eb123141',
+ 'vmxvpfe_image_name_0': 'VPE_ROUTING-ENGINE_17.2R1-S2.1.qcow2',
+ 'vmxvpfe_sriov43_0_port_unknownunicastallow': 'true',
+ 'vmxvpfe_sriov44_0_port_unknownmulticastallow': 'true',
+ 'vmxvre_console': 'vidconsole',
+ 'vmxvpfe_sriov44_0_port_vlanfilter': '4001',
+ 'vmxvpfe_sriov42_0_port_mac': '00:11:22:EF:AC:DF',
+ 'vmxvpfe_volume_id_0': '47cede15-da2f-4397-a101-aa683220aff3',
+ 'vmxvpfe_sriov42_0_port_unknownmulticastallow': 'true',
+ 'vmxvpfe_sriov44_0_port_vlanstrip': 'false',
+ 'vf_module_id': '123',
+ 'nf_function': 'JAI',
+ 'vmxvpfe_sriov43_0_port_unknownmulticastallow': 'true',
+ 'vmxvre_int_ctl_ip_0': '128.0.0.1',
+ 'AIC_CLLI': 'get_input:2017488_adiodvpe0_AIC_CLLI',
+ 'vnf_name': 'mtnj309me6vre',
+ 'vmxvpfe_sriov41_0_port_unknownunicastallow': 'true',
+ 'vmxvre_volume_type_1': 'HITACHI',
+ 'vmxvpfe_sriov44_0_port_broadcastallow': 'true',
+ 'vmxvre_volume_type_0': 'HITACHI',
+ 'vmxvpfe_volume_type_0': 'HITACHI',
+ 'vmxvpfe_sriov43_0_port_broadcastallow': 'true',
+ 'bandwidth_units': 'get_input:adiodvpe0_bandwidth_units',
+ 'vnf_id': '123',
+ 'vmxvre_oam_prefix': '24',
+ 'availability_zone_0': 'mtpocfo-kvm-az01',
+ 'ASN': 'get_input:2017488_adiodvpe0_ASN',
+ 'vmxvre_chassis_i2cid': '161',
+ 'vmxvpfe_name_0': 'vPFEXI',
+ 'bandwidth': 'get_input:adiodvpe0_bandwidth',
+ 'availability_zone_max_count': '1',
+ 'vmxvre_volume_size_0': '45.0',
+ 'vmxvre_volume_size_1': '50.0',
+ 'vmxvpfe_sriov42_0_port_broadcastallow': 'true',
+ 'vmxvre_oam_gateway': '10.40.123.1',
+ 'vmxvre_volume_name_1': 'vREXI_FAVolume',
+ 'vmxvre_ore_present': '0',
+ 'vmxvre_volume_name_0': 'vREXI_FBVolume',
+ 'vmxvre_type': '0',
+ 'vnf_instance_name': 'get_input:2017488_adiodvpe0_vnf_instance_name',
+ 'vmxvpfe_sriov41_0_port_unknownmulticastallow': 'true',
+ 'oam_net_id': 'b95eeb1d-d55d-4827-abb4-8ebb94941429',
+ 'vmx_int_ctl_len': '24',
+ 'vmxvpfe_sriov43_0_port_vlanstrip': 'false',
+ 'vmxvpfe_sriov41_0_port_broadcastallow': 'true',
+ 'vmxvre_volume_id_1': '6e86797e-03cd-4fdc-ba72-2957119c746d',
+ 'vmxvpfe_sriov41_0_port_vlanfilter': '4001',
+ 'nf_role': 'Testing',
+ 'vmxvre_volume_id_0': 'f4eacb79-f687-4e9d-b760-21847c8bb15a',
+ 'vmxvpfe_sriov42_0_port_unknownunicastallow': 'true',
+ 'vmxvpfe_flavor_name': 'ns.c20r16d25.v5'
+ },
+ 'type': 'VF',
+ 'modelCustomizationName': '2017-388_ADIOD-vPE 1',
+ 'vfModules': {},
+ 'volumeGroups': {}
+ };
+ }
+
+});
+
+
+
+
diff --git a/vid-webpack-master/src/app/services/service-planning.service.ts b/vid-webpack-master/src/app/services/service-planning.service.ts
new file mode 100644
index 000000000..75720c8a1
--- /dev/null
+++ b/vid-webpack-master/src/app/services/service-planning.service.ts
@@ -0,0 +1,282 @@
+import {Injectable} from '@angular/core';
+import {Constants} from "../shared/utils/constants";
+import {Utils} from "../utils/utils";
+import * as _ from 'lodash';
+import Parameter = Constants.Parameter;
+import {ITreeNode} from "angular-tree-component/dist/defs/api";
+import {ServiceInstance} from "../shared/models/serviceInstance";
+import {VNFModel} from "../shared/models/vnfModel";
+import {ServiceNodeTypes} from "../shared/models/ServiceNodeTypes";
+import {VfModuleMap} from "../shared/models/vfModulesMap";
+import {VnfInstance} from "../shared/models/vnfInstance";
+import {VfModuleTreeNode} from "../shared/models/vfModuleTreeNode";
+import {VfModule} from "../shared/models/vfModule";
+import {VnfTreeNode} from "../shared/models/vnfTreeNode";
+import {NgRedux} from "@angular-redux/store";
+import {AppState} from "../store/reducers";
+import {InputType} from "../shared/models/inputTypes";
+
+
+@Injectable()
+export class ServicePlanningService {
+
+ modelDataTree: any[] = [];
+ drawingDataTree: any[] = [];
+ service: any = {name:'My Service'} ;
+ public requiredFields = {
+ VF: [InputType.LCP_REGION, InputType.TENANT, InputType.PLATFORM],
+ VFmodule: []
+ };
+
+ constructor(private store: NgRedux<AppState>) {}
+
+
+ public getServiceName() :string{
+ return this.service.name;
+ }
+
+ public getServiceInstance(serviceModelId): ServiceInstance {
+ return this.store.getState().service.serviceInstance[serviceModelId];
+ }
+
+ public getVnfInstance(serviceModelId, vnfModelName): VnfInstance {
+ return this.getServiceInstance(serviceModelId).vnfs[vnfModelName];
+ }
+
+ public getVfModuleMap(serviceModelId, vnfModelName, vfModuleModelName): VfModuleMap {
+ let vnfInstance = this.getVnfInstance(serviceModelId, vnfModelName);
+ return _.get(vnfInstance, ['vfModules', vfModuleModelName]);
+ }
+
+ public convertServiceModelToTreeNodes(serviceModel) {
+ let _this = this;
+
+ _.forOwn(serviceModel.vnfs, function(item, key) {
+ _this.addFirstLevelModel(key, item, item.type, serviceModel);
+ });
+
+ _.forOwn(serviceModel.configurations, function(item, key) {
+ _this.addFirstLevelModel(key, item, ServiceNodeTypes.Configuration, serviceModel);
+ });
+
+ _.forOwn(serviceModel.networks, function(network, key) {
+ _this.addFirstLevelModel(key, network, ServiceNodeTypes.Network, serviceModel);
+ });
+
+ return this.modelDataTree;
+ }
+
+ private addFirstLevelModel(key, value, valueType, serviceModel) {
+
+ let node = this.convertItemToTreeNode(key, value, valueType, null, false);
+ let vnfInstance = this.getVnfInstance(serviceModel.service.uuid, key);
+ if(value.vfModules) {
+ node.children = Object.keys(value.vfModules).map((vmKey) =>
+ this.convertItemToTreeNode(vmKey, value.vfModules[vmKey], ServiceNodeTypes.VFmodule, value, !vnfInstance));
+ }
+ this.modelDataTree.push(node);
+ }
+
+ private convertItemToTreeNode(key, value, valueType, parentModel , disabled) {
+
+ return {
+ id: value.uuid,
+ name: key,
+ tooltip: valueType,
+ type: valueType,
+ count: value.count || 0,
+ max: value.max || 1,
+ children: [],
+ disabled: disabled,
+ dynamicInputs: this.updateDynamicInputsVnfDataFromModel(valueType, value),
+ userProvidedNaming: this.isUserProvidedNaming(valueType, value, parentModel)
+ }
+ }
+
+ public convertServiceInstanceToTreeData(serviceInstance: ServiceInstance, modelId: string): any {
+ let drawingBoardData = [];
+ let _this = this;
+ _.forOwn(serviceInstance.vnfs, (vnfInstance, vnfModelName) => {
+ let vnfModel: VNFModel = _this.store.getState().service.serviceHierarchy[modelId].vnfs[vnfModelName];
+ let vnfNode = new VnfTreeNode(vnfInstance, vnfModel);
+
+ let vfModuleNodes = [];
+ _.forOwn(vnfInstance.vfModules, (vfModuleMap, vfModuleModelName) => {
+ _.forOwn(vfModuleMap, (vfModuleInstance, vfModuleInstsanceName) => {
+ let vfModule: VfModule = _this.store.getState().service.serviceHierarchy[modelId].vnfs[vnfModelName].vfModules[vfModuleModelName];
+ let vfModuleNode: VfModuleTreeNode = new VfModuleTreeNode(vfModuleInstance, vfModule, vfModuleModelName);
+ vfModuleNodes.push(vfModuleNode);
+ });
+ });
+ vnfNode.children = vfModuleNodes;
+ drawingBoardData.push(vnfNode);
+ });
+
+ return drawingBoardData;
+ }
+
+ public getArbitraryInputs(inputs) {
+ let parameter;
+ let parameterList = [];
+ for (let key in inputs) {
+ parameter = {
+ id : key,
+ type : Parameter.STRING,
+ name : key,
+ value : inputs[key][Parameter.DEFAULT],
+ isRequired : inputs[key][Parameter.REQUIRED],
+ description : inputs[key][Parameter.DESCRIPTION]
+ };
+ switch (inputs[key][Parameter.TYPE]) {
+ case Parameter.INTEGER:
+ parameter.type = Parameter.NUMBER;
+ break;
+ case Parameter.BOOLEAN:
+ parameter.type = Parameter.BOOLEAN;
+ break;
+ case Parameter.RANGE:
+ break;
+ case Parameter.LIST:
+ parameter.type = Parameter.LIST;
+ break;
+ case Parameter.MAP:
+ parameter.type = Parameter.MAP;
+ break;
+ }
+ if ( Utils.hasContents(inputs[key][Parameter.CONSTRAINTS])
+ && ( inputs[key][Parameter.CONSTRAINTS].length > 0 ) ) {
+ let constraintsArray = inputs[key][Parameter.CONSTRAINTS];
+ this.addConstraintParameters (parameterList, constraintsArray, key, inputs, parameter);
+ }
+ else {
+
+ parameterList.push(parameter);
+ }
+ }
+ return parameterList;
+ }
+
+ private addConstraintParameters(parameterList, constraintsArray, key, inputs, parameter) {
+ // If there are constraints and the operator is "valid_values",
+ // use a select parameter type.
+ let i:number = constraintsArray.length;
+ let parameterPushed: boolean = false;
+ if ( i > 0 ) {
+ while ( (i--) && (!parameterPushed) ) {
+ let keys = Object.keys(constraintsArray[i]);
+ for ( let operator in keys ) {
+ switch (keys[operator]) {
+ case Parameter.VALID_VALUES:
+ let j: number = constraintsArray[i][Parameter.VALID_VALUES].length;
+ if ( j > 0 ) {
+ let oList = [];
+ let option;
+ while (j--) {
+ option = {
+ name: constraintsArray[i][Parameter.VALID_VALUES][j],
+ isDefault: false
+ };
+ if ( (Utils.hasContents (inputs[key][Parameter.DEFAULT]) )
+ && (inputs[key][Parameter.DEFAULT] === constraintsArray[i][Parameter.VALID_VALUES][j] ) ) {
+ option = {
+ name: constraintsArray[i][Parameter.VALID_VALUES][j],
+ isDefault: true
+ }
+ }
+ oList.push(option);
+ }
+ parameter.type = Parameter.SELECT;
+ parameter.optionList = oList;
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+
+ case Parameter.EQUAL:
+ if ( constraintsArray[i][Parameter.EQUAL] != null ) {
+ //override parameter type
+ parameter.type = Parameter.STRING;
+ parameter.isReadOnly = true;
+ parameter.value = constraintsArray[i][Parameter.EQUAL];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+
+ case Parameter.LENGTH:
+ if ( constraintsArray[i][Parameter.LENGTH] != null ) {
+ parameter.minLength = constraintsArray[i][Parameter.LENGTH];
+ parameter.maxLength = constraintsArray[i][Parameter.LENGTH];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+ case Parameter.MAX_LENGTH:
+ if ( constraintsArray[i][Parameter.MAX_LENGTH] != null ) {
+ parameter.maxLength = constraintsArray[i][Parameter.MAX_LENGTH];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+ case Parameter.MIN_LENGTH:
+ if ( constraintsArray[i][Parameter.MIN_LENGTH] != null ) {
+ parameter.minLength = constraintsArray[i][Parameter.MIN_LENGTH];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+ case Parameter.IN_RANGE:
+ if ( constraintsArray[i][Parameter.IN_RANGE] != null ) {
+ if (constraintsArray[i][Parameter.IN_RANGE].length > 1 ) {
+ parameter.min = constraintsArray[i][Parameter.IN_RANGE][0];
+ parameter.max = constraintsArray[i][Parameter.IN_RANGE][1];
+ parameter.type = Parameter.NUMBER;
+ parameter.value = inputs[key][Parameter.DEFAULT];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ }
+ break;
+ case Parameter.GREATER_THAN:
+ if ( constraintsArray[i][Parameter.GREATER_THAN] != null ) {
+ parameter.type = Parameter.NUMBER;
+ parameter.min = constraintsArray[i][Parameter.GREATER_THAN];
+ parameter.value = inputs[key][Parameter.DEFAULT];
+ parameterList.push(parameter);
+ parameterPushed = true;
+ }
+ break;
+ }//switch
+ }//for
+ }//while
+ }//if
+ };
+
+ public static isVfModule(node:ITreeNode): boolean {
+ return node.data.type=='VFmodule';
+ }
+
+ public static isVnf(node:ITreeNode): boolean {
+ return node.data.type == ServiceNodeTypes.VF;
+ }
+
+ updateDynamicInputsVnfDataFromModel(modelType: string, model: any): Array<any> {
+ let displayInputs;
+ if (modelType === ServiceNodeTypes.VFmodule) {
+ displayInputs = model.inputs;
+ }
+ return _.isEmpty(displayInputs) ? [] : this.getArbitraryInputs(displayInputs);
+ }
+
+ isUserProvidedNaming(type: string, nodeModel: any, parentModel: any) : boolean {
+ let model;
+ if (type === ServiceNodeTypes.VFmodule) {
+ model = parentModel;
+ }
+ else {
+ model = nodeModel;
+ }
+ const ecompGeneratedNaming = model.properties.ecomp_generated_naming;
+ return ecompGeneratedNaming !== undefined && ecompGeneratedNaming === "false";
+ }
+}