vid-webpack-master/src/app/drawingBoard/service-planning/objectsToTree/models/vnfGrouping/vnfGrouping.model.info.ts

   1 import {ILevelNodeInfo} from "../basic.model.info";
   2 import {DynamicInputsService} from "../../dynamicInputs.service";
   3 import {ITreeNode} from "angular-tree-component/dist/defs/api";
   4 import {AvailableNodeIcons} from "../../../available-models-tree/available-models-tree.service";
   5 import {VnfGroupModel} from "../../../../../shared/models/vnfGroupModel";
   6 import {VnfGroupTreeNode} from "../../../../../shared/models/vnfGroupTreeNode";
   7 import {SharedTreeService} from "../../shared.tree.service";
   8 import {VnfGroupPopupService} from "../../../../../shared/components/genericFormPopup/genericFormServices/vnfGroup/vnfGroup.popup.service";
   9 import {
  10   GenericFormPopupComponent,
  11   PopupType
  12 } from "../../../../../shared/components/genericFormPopup/generic-form-popup.component";
  13 import {DialogService} from 'ng2-bootstrap-modal';
  14 import {AppState} from "../../../../../shared/store/reducers";
  15 import {NgRedux} from "@angular-redux/store";
  16 import {changeInstanceCounter, removeInstance} from "../../../../../shared/storeUtil/utils/general/general.actions";
  17 import {IframeService} from "../../../../../shared/utils/iframe.service";
  18 import {
  19   deleteActionVnfGroupInstance,
  20   undoDeleteActionVnfGroupInstance
  21 } from "../../../../../shared/storeUtil/utils/vnfGroup/vnfGroup.actions";
  22 import {RelatedVnfMemberInfoModel} from "../relatedVnfMember/relatedVnfMember.info.model";
  23 import {SearchElementsModalComponent} from "../../../../../shared/components/searchMembersModal/search-elements-modal.component";
  24 import * as _ from "lodash";
  25 import {MessageBoxData} from "../../../../../shared/components/messageBox/messageBox.data";
  26 import {MessageBoxService} from "../../../../../shared/components/messageBox/messageBox.service";
  27 import {ComponentInfoType} from "../../../component-info/component-info-model";
  28 import {ModelInformationItem} from "../../../../../shared/components/model-information/model-information.component";
  29 import {Level1Instance} from "../../../../../shared/models/level1Instance";
  30 import {AaiService} from "../../../../../shared/services/aaiService/aai.service";
  31 import {Observable} from "rxjs";
  32 import {createRelatedVnfMemberInstance} from "../../../../../shared/storeUtil/utils/relatedVnfMember/relatedVnfMember.actions";
  33 import {
  34   ITableContent,
  35   SearchFieldItemType
  36 } from "../../../../../shared/components/searchMembersModal/members-table/element-table-row.model";
  37 import {CustomTableColumnDefinition} from "../../../../../shared/components/searchMembersModal/members-table/elements-table.component";
  38
  39 export class VnfGroupingModelInfo implements ILevelNodeInfo {
  40   constructor(private _dynamicInputsService: DynamicInputsService,
  41               private _sharedTreeService: SharedTreeService,
  42               private _dialogService: DialogService,
  43               private _vnfGroupPopupService: VnfGroupPopupService,
  44               private _iframeService: IframeService,
  45               private _aaiService: AaiService,
  46               private _store: NgRedux<AppState>) {
  47   }
  48
  49   name: string = 'vnfGroups';
  50   type: string = 'VnfGroup';
  51   typeName: string = 'G';
  52   childNames: string[] = ['vnfs'];
  53   componentInfoType = ComponentInfoType.VNFGROUP;
  54   limitMembers: number;
  55
  56   /***********************************************************
  57    * return if user should provide instance name or not.
  58    *        get info from parent (VNF)
  59    * @param currentModel - current Model object
  60    ************************************************************/
  61   isEcompGeneratedNaming(currentModel): boolean {
  62     const ecompGeneratedNaming = currentModel.properties.ecomp_generated_naming;
  63     return ecompGeneratedNaming === "true";
  64   }
  65
  66   /***********************************************************
  67    * return model dynamic inputs
  68    * @param currentModel - current Model object
  69    ************************************************************/
  70   updateDynamicInputsDataFromModel = (currentModel): any => {
  71     let displayInputs = currentModel.inputs;
  72     return _.isEmpty(displayInputs) ? [] : this._dynamicInputsService.getArbitraryInputs(displayInputs);
  73   };
  74
  75   /***********************************************************
  76    * return next level object (null because is last level)
  77    ************************************************************/
  78   getNextLevelObject = (): RelatedVnfMemberInfoModel => {
  79     return new RelatedVnfMemberInfoModel(this._sharedTreeService, this._dynamicInputsService, this._store);
  80   };
  81
  82   getTooltip = (): string => 'VnfGroup';
  83
  84   getType = (): string => 'VnfGroup';
  85
  86   createInstanceTreeNode(instance: any, model: any, parentModel: any, storeKey: string, serviceModelId: string): any {
  87     let node = new VnfGroupTreeNode(instance, model, storeKey);
  88     node.missingData = this.hasMissingData(instance, node, model.isEcompGeneratedNaming);
  89     node = this._sharedTreeService.addingStatusProperty(node);
  90     node.typeName = this.typeName;
  91     node.menuActions = this.getMenuAction(<any>node, serviceModelId);
  92     node.isFailed = _.isNil(instance.isFailed) ? false : instance.isFailed;
  93     node.statusMessage = !_.isNil(instance.statusMessage) ? instance.statusMessage : "";
  94     node.limitMembers = (!_.isNil(model.properties.quantity)) ? model.properties.quantity : null;
  95     return node;
  96   }
  97
  98   getModel(instanceModel: any): any {
  99     return new VnfGroupModel(instanceModel);
 100   }
 101
 102   hasMissingData(instance, dynamicInputs: any, isEcompGeneratedNaming: boolean): boolean {
 103     return this._sharedTreeService.hasMissingData(instance, dynamicInputs, isEcompGeneratedNaming, []);
 104   }
 105
 106   onClickAdd(node: ITreeNode, serviceModelId: string): void {
 107     this._dialogService.addDialog(GenericFormPopupComponent, {
 108       type: PopupType.VNF_GROUP,
 109       uuidData: <any>{
 110         serviceId: serviceModelId,
 111         modelName: node.data.name,
 112         vnfGroupStoreKey: null,
 113         modelId: node.data.modelVersionId,
 114         type: node.data.type,
 115         popupService: this._vnfGroupPopupService
 116       },
 117       node: node,
 118       isUpdateMode: false
 119     });
 120   }
 121
 122   getNodeCount(node: ITreeNode, serviceModelId: string): number {
 123     let map = null;
 124     if (!_.isNil(this._store.getState().service.serviceInstance[serviceModelId])) {
 125       map = this._store.getState().service.serviceInstance[serviceModelId].existingVnfGroupCounterMap || 0;
 126       if (!_.isNil(map)) {
 127         let count = map[node.data.modelUniqueId] || 0;
 128         count -= this._sharedTreeService.getExistingInstancesWithDeleteMode(node, serviceModelId, 'vnfGroups');
 129         return count;
 130       }
 131     }
 132     return 0;
 133   }
 134
 135   /***********************************************************
 136    * should show node icon
 137    * @param node - current ITrees node
 138    * @param serviceModelId - service id
 139    ************************************************************/
 140   showNodeIcons(node: ITreeNode, serviceModelId: string): AvailableNodeIcons {
 141     const showAddIcon = this._sharedTreeService.shouldShowAddIcon();
 142     return new AvailableNodeIcons(showAddIcon, false);
 143   }
 144
 145   getMenuAction(node: ITreeNode, serviceModelId: string): { [methodName: string]: { method: Function, visible: Function, enable: Function } } {
 146     return {
 147       edit: {
 148         method: (node, serviceModelId) => {
 149           this._iframeService.addClassOpenModal('content');
 150           this._dialogService.addDialog(GenericFormPopupComponent, {
 151             type: PopupType.VNF_GROUP,
 152             uuidData: <any>{
 153               serviceId: serviceModelId,
 154               modelName: node.data.modelName,
 155               vnfGroupStoreKey: node.data.vnfGroupStoreKey,
 156               modelId: node.data.modelId,
 157               type: node.data.type,
 158               popupService: this._vnfGroupPopupService
 159             },
 160             node: node,
 161             isUpdateMode: true
 162           });
 163         },
 164         visible: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 165         enable: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node)
 166       },
 167       remove: {
 168         method: (node, serviceModelId) => {
 169           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 170             let storeKey: string = node.data.vnfGroupStoreKey;
 171             this._store.dispatch(removeInstance(node.data.vnfGroupStoreKey, serviceModelId, storeKey, node));
 172             this._store.dispatch(changeInstanceCounter(node.data.modelUniqueId, serviceModelId, -1, node));
 173             this._sharedTreeService.selectedVNF = null;
 174           } else {
 175             let messageBoxData: MessageBoxData = new MessageBoxData(
 176               "Remove VNFGroup",  // modal title
 177               "You are about to remove this group and all its children from this service. Are you sure you want to remove it?",
 178               <any>"warning",
 179               <any>"md",
 180               [
 181                 {
 182                   text: "Remove Group",
 183                   size: "large",
 184                   callback: this.removeGroup.bind(this, node, serviceModelId),
 185                   closeModal: true
 186                 },
 187                 {text: "Don’t Remove", size: "medium", closeModal: true}
 188               ]);
 189
 190             MessageBoxService.openModal.next(messageBoxData);
 191           }
 192         },
 193         visible: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node),
 194         enable: (node) => this._sharedTreeService.shouldShowRemoveAndEdit(node)
 195       },
 196
 197       addGroupMember: {
 198         method: (node, serviceModelId) => {
 199           let serviceHierarchy = this._store.getState().service.serviceHierarchy[serviceModelId];
 200           let serviceInstance = this._store.getState().service.serviceInstance[serviceModelId];
 201           let vnfGroupModel = new VnfGroupModel(serviceHierarchy['vnfGroups'][node.data.modelName]);
 202           this._dialogService.addDialog(SearchElementsModalComponent, {
 203               modalInformation: {
 204                 type: 'VNF',
 205                 serviceModelId : serviceModelId,
 206                 title: 'Add members to group',
 207                 description: 'Select VNF instances to associate',
 208                 noElementsMsg: 'No VNFs were found that can belong to this group.',
 209                 uniqObjectField: 'instanceId',
 210                 topButton: {
 211                   text: 'SET MEMBERS',
 212                   /********************************************************************************************************************************
 213                    iterate over all current elements:
 214
 215                    1) if element is selected then update REDUX store
 216                    2) if element is not selected then delete member
 217
 218                    @searchElementsModalComponent - all modal information (allElementsStatusMap, vnfGroupStoreKey, serviceId)
 219                    ********************************************************************************************************************************/
 220
 221                   action: (searchElementsModalComponent) => {
 222                     let tmpMembers = searchElementsModalComponent._membersTableService.allElementsStatusMap;
 223                     for (let key in tmpMembers) {
 224                       if (tmpMembers[key].isSelected) {
 225                         this._store.dispatch(createRelatedVnfMemberInstance(node.data.vnfGroupStoreKey, serviceModelId, tmpMembers[key]));
 226                       }
 227                     }
 228                     searchElementsModalComponent.closeDialog();
 229                   }
 230                 },
 231                 getElements: (): Observable<Level1Instance[]> => {
 232                   return this._aaiService.getOptionalGroupMembers(serviceModelId, serviceInstance.globalSubscriberId, serviceInstance.subscriptionServiceType, (Object.values(vnfGroupModel.members))[0].sourceModelInvariant, vnfGroupModel.properties.type, vnfGroupModel.properties.role).map((result) => {
 233                     return this.filterUsedVnfMembers(serviceModelId, result);
 234                   });
 235                 },
 236                 tableHeaders : this.getTableHeaders(),
 237                 tableContent: this.generateRelatedMemberTableContent(),
 238                 searchFields: [{
 239                   title: 'Service model name',
 240                   dataTestId: 'sourceModelName',
 241                   value: (Object.values(vnfGroupModel.members))[0].sourceModelName,
 242                   type: SearchFieldItemType.LABEL
 243                 },
 244                   {
 245                     title: 'Service invariant UUID',
 246                     dataTestId: 'sourceModelInvariant',
 247                     value: (Object.values(vnfGroupModel.members))[0].sourceModelInvariant,
 248                     type: SearchFieldItemType.LABEL
 249                   }]
 250               }
 251             }
 252           );
 253         },
 254         visible: (node) => !_.isNil(node.data.action) ? node.data.action.split('_').pop() !== 'Delete' : true,
 255         enable: (node) => !_.isNil(node.data.action) ? node.data.action.split('_').pop() !== 'Delete' : true
 256       },
 257       showAuditInfo: {
 258         method: (node, serviceModelId) => {
 259           let instance = this._store.getState().service.serviceInstance[serviceModelId].vnfGroups[node.data.vnfGroupStoreKey];
 260           this._sharedTreeService.openAuditInfoModal(node, serviceModelId, instance, 'VNFGROUP', this);
 261         },
 262         visible: (node) => this._sharedTreeService.shouldShowAuditInfo(node),
 263         enable: (node) => this._sharedTreeService.shouldShowAuditInfo(node)
 264       },
 265       delete: {
 266         method: (node, serviceModelId) => {
 267           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 268             this._store.dispatch(deleteActionVnfGroupInstance(node.data.vnfGroupStoreKey, serviceModelId));
 269           } else {
 270             this._sharedTreeService.shouldShowDeleteInstanceWithChildrenModal(node, serviceModelId, (node, serviceModelId) => {
 271               this._sharedTreeService.removeDeleteAllChild(node, serviceModelId, (node, serviceModelId) => {
 272                 this._store.dispatch(deleteActionVnfGroupInstance(node.data.vnfGroupStoreKey, serviceModelId));
 273               });
 274             });
 275           }
 276         },
 277         visible: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId),
 278         enable: (node) => this._sharedTreeService.shouldShowDelete(node, serviceModelId)
 279       },
 280       undoDelete: {
 281         method: (node, serviceModelId) => {
 282           if ((!_.isNil(node.data.children) && node.data.children.length === 0) || _.isNil(node.data.children)) {
 283             this._store.dispatch(undoDeleteActionVnfGroupInstance(node.data.vnfGroupStoreKey, serviceModelId));
 284           } else {
 285             this._sharedTreeService.undoDeleteAllChild(node, serviceModelId, (node, serviceModelId) => {
 286               this._store.dispatch(undoDeleteActionVnfGroupInstance(node.data.vnfGroupStoreKey, serviceModelId));
 287             });
 288           }
 289         },
 290         visible: (node) => this._sharedTreeService.shouldShowUndoDelete(node),
 291         enable: (node, serviceModelId) => this._sharedTreeService.shouldShowUndoDelete(node) && !this._sharedTreeService.isServiceOnDeleteMode(serviceModelId)
 292       }
 293     };
 294
 295
 296   }
 297
 298
 299   generateRelatedMemberTableContent(): ITableContent[] {
 300     return [
 301       {
 302         id: 'vnfName',
 303         contents: [{
 304           id: ['instanceName'],
 305           value: ['instanceName']
 306         }, {
 307           id: ['instanceId'],
 308           value: ["instanceId"],
 309           prefix: 'UUID: '
 310         }]
 311       },
 312       {
 313         id: 'version',
 314         contents: [{
 315           id: ['modelInfo', 'modelVersion'],
 316           value: ['modelInfo', 'modelVersion']
 317         }]
 318       },
 319       {
 320         id: 'modelName',
 321         contents: [{
 322           id: ['modelInfo', 'modelName'],
 323           value: ['modelInfo', 'modelName']
 324         }]
 325       },
 326       {
 327         id: 'provStatus',
 328         contents: [{
 329           id: ['provStatus'],
 330           value: ['provStatus']
 331         }]
 332       },
 333       {
 334         id: 'serviceInstance',
 335         contents: [{
 336           id: ['serviceInstanceName'],
 337           value: ['serviceInstanceName']
 338         }, {
 339           id: ['serviceInstanceId'],
 340           value: ["serviceInstanceId"],
 341           prefix: 'UUID: '
 342         }]
 343       },
 344       {
 345         id: 'cloudRegion',
 346         contents: [{
 347           id: ['lcpCloudRegionId'],
 348           value: ['lcpCloudRegionId']
 349         }]
 350       },
 351       {
 352         id: 'tenantName',
 353         contents: [{
 354           id: ['tenantName'],
 355           value: ['tenantName']
 356         }]
 357       }
 358     ];
 359   }
 360
 361   getTableHeaders() : CustomTableColumnDefinition[]{
 362     const type : string = 'VNF';
 363     return  [
 364       {displayName: `${type} instance name`, key: ['instanceName']},
 365       {displayName: `${type} version`, key: ['modelInfo', 'modelVersion']},
 366       {displayName: `${type} model name`, key: ['modelInfo', 'modelName']},
 367       {displayName: 'Prov Status', key: ['provStatus']},
 368       {displayName: 'Service instance name', key: ['serviceInstanceName']},
 369       {displayName: 'Cloud Region', key: ['lcpCloudRegionId']},
 370       {displayName: 'Tenant Name', key: ['tenantName']}
 371     ];
 372   }
 373
 374   filterUsedVnfMembers = (serviceModelId: string, result: Level1Instance[]): Level1Instance[] => {
 375     const allMembersMap = _.keyBy(result as Level1Instance[], 'instanceId');
 376     const vnfGroupsData = this._store.getState().service.serviceInstance[serviceModelId].vnfGroups;
 377     const vnfMembersArr = _.flatMap(vnfGroupsData).map((vnfGroup) => vnfGroup.vnfs);
 378     for (let vnf of vnfMembersArr) {
 379       for (let member in vnf) {
 380         delete allMembersMap[member];
 381       }
 382     }
 383     return _.flatMap(allMembersMap);
 384   };
 385
 386   removeGroup(this, node, serviceModelId) {
 387     this._store.dispatch(removeInstance(node.data.modelName, serviceModelId, node.data.vnfGroupStoreKey, node));
 388     this._store.dispatch(changeInstanceCounter(node.data.modelUniqueId, serviceModelId, -1, node));
 389     this._sharedTreeService.selectedVNF = null;
 390   }
 391
 392   updatePosition(that, node, instanceId): void {
 393     // TODO
 394   }
 395
 396   getNodePosition(instance): number {
 397     return !_.isNil(instance) ? instance.position : null;
 398   }
 399
 400   getInfo(model, instance): ModelInformationItem[] {
 401     return [];
 402   }
 403
 404 }