import {Injectable} from '@angular/core'; import {ITreeNode} from 'angular-tree-component/dist/defs/api'; import {AppState} from '../../../shared/store/reducers'; import {LogService} from '../../../shared/utils/log/log.service'; import {NgRedux} from '@angular-redux/store'; import {VnfInstance} from "../../../shared/models/vnfInstance"; import {VfModuleMap} from "../../../shared/models/vfModulesMap"; import * as _ from "lodash"; import {DefaultDataGeneratorService} from "../../../shared/services/defaultDataServiceGenerator/default.data.generator.service"; import {TypeNodeInformation} from "../typeNodeInformation.model"; import {SdcUiCommon} from "onap-ui-angular"; import {changeInstanceCounter, duplicateBulkInstances} from "../../../shared/storeUtil/utils/general/general.actions"; import {IModalConfig} from "onap-ui-angular/dist/modals/models/modal-config"; import {FeatureFlagsService} from "../../../shared/services/featureFlag/feature-flags.service"; import {Utils} from "../../../shared/utils/utils"; import {SharedTreeService} from "../objectsToTree/shared.tree.service"; import {ModalService} from "../../../shared/components/customModal/services/modal.service"; @Injectable() export class DuplicateService { constructor(private _logService: LogService, private sharedTreeService : SharedTreeService, private _store: NgRedux, modalService: ModalService) { this.modalService = modalService; } numberOfDuplicates: number; setNumberOfDuplicates(numberOfDuplicates: number) { this.numberOfDuplicates = numberOfDuplicates; } currentInstanceId: string = null; currentServiceId: string = null; maxNumberOfDuplicate: number = 0; storeKey: string = null; padding = '0000'; modalService: ModalService; store: NgRedux; existingNames: { [key: string]: any }; currentNode: ITreeNode = null; canDuplicate(node: ITreeNode): boolean { let reduxState = JSON.parse(sessionStorage.getItem('reduxState')); return node.data.type === 'VF' || node.data.type === 'VL'; } isEnabled(node: ITreeNode, store: NgRedux, serviceId: string): boolean { if (!_.isNil(node) && !_.isNil(node.data.menuActions['duplicate'])) { if (this.hasMissingData(node)) return false; const typeNodeInformation: TypeNodeInformation = new TypeNodeInformation(node); const flags = FeatureFlagsService.getAllFlags(store); const currentExisting: number = store.getState().service.serviceInstance[serviceId][typeNodeInformation.existingMappingCounterName][node.data.modelUniqueId]; const maxInstances = Utils.getMaxFirstLevel(store.getState().service.serviceHierarchy[serviceId][typeNodeInformation.hierarchyName][node.data.modelName].properties, flags); if (_.isNil(maxInstances)) { return true; } else { return maxInstances - currentExisting > 0; } } else { return false; } } hasMissingData(node: ITreeNode): boolean { if (!_.isNil(node)) { if (node.data.missingData) return true; if (!_.isNil(node.data.children)) { for (let child of node.data.children) { if (child.missingData) { return true; } } } } return false; } getRemainsInstance(modelId: string, modelName: string, serviceId: string, store: NgRedux, node: ITreeNode): number { const typeNodeInformation: TypeNodeInformation = new TypeNodeInformation(node); const properties = store.getState().service.serviceHierarchy[serviceId][typeNodeInformation.hierarchyName][modelName].properties; const currentExisting: number = store.getState().service.serviceInstance[serviceId][typeNodeInformation.existingMappingCounterName][modelId]; const flags = FeatureFlagsService.getAllFlags(store); const maxInstances = Utils.getMaxFirstLevel(properties, flags); if (_.isNil(maxInstances)) { return 10; } else { return maxInstances - currentExisting; } } openDuplicateModal(currentServiceId: string, currentUuid: string, currentId: string, storeKey: string, numberOfDuplicate: number, _store: NgRedux, node: ITreeNode): IModalConfig { this.currentInstanceId = currentId; this.currentServiceId = currentServiceId; this.maxNumberOfDuplicate = this.getRemainsInstance(currentUuid, currentId, currentServiceId, _store, node); this.storeKey = storeKey; this.store = _store; this.currentNode = node; return { size: SdcUiCommon.ModalSize.medium, title: 'Duplicate Node', type: SdcUiCommon.ModalType.custom, buttons: [ {text: 'Duplicate', callback: this.duplicate.bind(this, this.currentNode), closeModal: true}, {text: 'Cancel', closeModal: true} ] }; } duplicate(node: ITreeNode): void { const typeNodeInformation: TypeNodeInformation = new TypeNodeInformation(node); this.existingNames = this.store.getState().service.serviceInstance[this.currentServiceId].existingNames; const toClone = this.store.getState().service.serviceInstance[this.currentServiceId][typeNodeInformation.hierarchyName][this.storeKey]; let newObjects = {}; for (let i = 0; i < this.numberOfDuplicates; i++) { const uniqueStoreKey = this.generateUniqueStoreKey(this.currentServiceId, this.currentInstanceId, this.store.getState().service.serviceInstance[this.currentServiceId][typeNodeInformation.hierarchyName], newObjects); const clone = this.cloneVnf(toClone, this.currentInstanceId); newObjects[uniqueStoreKey] = clone; } this.store.dispatch(duplicateBulkInstances(this.currentServiceId, newObjects, this.existingNames, node)); this.store.dispatch(changeInstanceCounter(this.sharedTreeService.modelUniqueId(toClone), this.currentServiceId, this.numberOfDuplicates, node)); this._logService.info("Duplicate " + this.storeKey + " serviceId: " + this.currentServiceId + "number of duplicate: " + this.numberOfDuplicates, toClone); } cloneVnf(vnf: VnfInstance, originalName: string): VnfInstance { let newUniqueVnf: VnfInstance = _.cloneDeep(vnf); newUniqueVnf.originalName = originalName; newUniqueVnf.trackById = DefaultDataGeneratorService.createRandomTrackById(); if (!_.isNil(vnf.instanceName)) { newUniqueVnf.instanceName = this.ensureUniqueNameOrGenerateOne(vnf.instanceName); } for (let vf_module_model_name in vnf.vfModules) { const vfModuleModel: VfModuleMap = vnf.vfModules[vf_module_model_name]; for (let vfModule in vfModuleModel) { newUniqueVnf.vfModules[vf_module_model_name][vfModule].trackById = DefaultDataGeneratorService.createRandomTrackById(); if (!_.isNil(vfModuleModel[vfModule].instanceName)) { newUniqueVnf.vfModules[vf_module_model_name][vfModule].instanceName = this.ensureUniqueNameOrGenerateOne(vfModuleModel[vfModule].instanceName); } if (!_.isNil(vfModuleModel[vfModule].volumeGroupName)) { newUniqueVnf.vfModules[vf_module_model_name][vfModule].volumeGroupName = this.ensureUniqueNameOrGenerateOne(vfModuleModel[vfModule].volumeGroupName); } } } return newUniqueVnf; } ensureUniqueNameOrGenerateOne(instanceName) { let uniqueInstanceName = instanceName; if (this.isAlreadyExists(instanceName, this.existingNames)) { uniqueInstanceName = this.generateNextUniqueName(instanceName, this.existingNames); this.existingNames[uniqueInstanceName.toLowerCase()] = ""; } return uniqueInstanceName; } isAlreadyExists(name: string, existingNames: { [key: string]: any }) { return _.has(existingNames, name.toLowerCase()); } generateNextUniqueName(name: string, existingNames: { [key: string]: any }): string { let suffix = "000"; let counter = 1; if (name.match(/^.*_[\d]{3}$/)) { name = name.substring(0, name.length - 4); } while (true) { let paddingNumber: string = this.getNumberAsPaddingString(counter, suffix); let candidateUniqueName = name + '_' + paddingNumber; if (!this.isAlreadyExists(candidateUniqueName, existingNames)) { return candidateUniqueName; } counter++; } } generateUniqueStoreKey(serviceId: string, objectName: string, existing: any, newObjects: any): string { let counter = 1; while (true) { let paddingNumber: string = this.getNumberAsPaddingString(counter, this.padding); const name = objectName + ':' + paddingNumber; if (_.isNil(existing[name]) && _.isNil(newObjects[name])) { return name; } counter++; } } getNumberAsPaddingString(val: number, padding: string): string { const str = "" + val; return padding.substring(0, padding.length - str.length) + str; } }