src/app/utilities/start-stop-rebuild/StartStopRebuildComponent.ts

   1 /*
   2  Copyright 2020 TATA ELXSI
   3
   4  Licensed under the Apache License, Version 2.0 (the 'License');
   5  you may not use this file except in compliance with the License.
   6  You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10  Unless required by applicable law or agreed to in writing, software
  11  distributed under the License is distributed on an "AS IS" BASIS,
  12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  See the License for the specific language governing permissions and
  14  limitations under the License.
  15
  16  Author: SANDHYA JS (sandhya.j@tataelxsi.co.in)
  17 */
  18 /**
  19  * @file StartStopRebuild Component
  20  */
  21 import { HttpHeaders } from '@angular/common/http';
  22 import { Component, Injector, Input, OnInit } from '@angular/core';
  23 import { AbstractControl, FormBuilder, FormGroup, Validators } from '@angular/forms';
  24 import { Router } from '@angular/router';
  25 import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
  26 import { APIURLHEADER, ERRORDATA, MODALCLOSERESPONSEDATA, URLPARAMS } from 'CommonModel';
  27 import { environment } from 'environment';
  28 import { StartStopRebuild } from 'NSInstanceModel';
  29 import { RestService } from 'RestService';
  30 import { SharedService } from 'SharedService';
  31 import { isNullOrUndefined } from 'util';
  32 import { DF, VNFD } from 'VNFDModel';
  33 import { VDUR, VNFInstanceDetails } from 'VNFInstanceModel';
  34
  35 /**
  36  * Creating component
  37  * @Component takes StartStopRebuildComponent.html as template url
  38  */
  39 @Component({
  40     selector: 'app-start-stop-rebuild',
  41     templateUrl: './StartStopRebuildComponent.html',
  42     styleUrls: ['./StartStopRebuildComponent.scss']
  43 })
  44 export class StartStopRebuildComponent implements OnInit {
  45     /** To inject services @public */
  46     public injector: Injector;
  47     /** Instance for active modal service @public */
  48     public activeModal: NgbActiveModal;
  49     /** Check the loading results @public */
  50     public isLoadingResults: Boolean = false;
  51     /** Give the message for the loading @public */
  52     public message: string = 'PLEASEWAIT';
  53     /** FormGroup instance added to the form @ html @public */
  54     public startForm: FormGroup;
  55     /** Items for the memberVNFIndex @public */
  56     public memberTypes: {}[];
  57     /** Contains MemberVNFIndex values @public */
  58     public memberVnfIndex: {}[] = [];
  59     /** Contains vnfInstanceId of the selected MemberVnfIndex  @public */
  60     public instanceId: string;
  61     /** Items for vduId & countIndex @public */
  62     public vdu: {}[];
  63     /** Selected VNFInstanceId @public */
  64     public selectedvnfId: string = '';
  65     /** Check day1-2 operation  @public */
  66     public 'day1-2': boolean;
  67     /** Array holds VNFR Data filtered with nsr ID @public */
  68     public nsIdFilteredData: {}[] = [];
  69     /** Form valid on submit trigger @public */
  70     public submitted: boolean = false;
  71     /** Contains vduId @public */
  72     public vduId: {};
  73     /** Items for countIndex @public */
  74     public countIndex: {}[];
  75     /** Input contains Modal dialog component Instance @public */
  76     @Input() public instanceType: string;
  77     /** Input contains Modal dialog component Instance @public */
  78     @Input() public instanceTitle: string;
  79     /** Input contains component objects @private */
  80     @Input() private params: URLPARAMS;
  81     /** FormBuilder instance added to the formBuilder @private */
  82     private formBuilder: FormBuilder;
  83     /** Instance of the rest service @private */
  84     private restService: RestService;
  85     /** Controls the header form @private */
  86     private headers: HttpHeaders;
  87     /** Contains all methods related to shared @private */
  88     private sharedService: SharedService;
  89     /** Holds the instance of AuthService class of type AuthService @private */
  90     private router: Router;
  91     constructor(injector: Injector) {
  92         this.injector = injector;
  93         this.restService = this.injector.get(RestService);
  94         this.activeModal = this.injector.get(NgbActiveModal);
  95         this.formBuilder = this.injector.get(FormBuilder);
  96         this.sharedService = this.injector.get(SharedService);
  97         this.router = this.injector.get(Router);
  98     }
  99     /** convenience getter for easy access to form fields */
 100     get f(): FormGroup['controls'] { return this.startForm.controls; }
 101     /**
 102      * Lifecyle Hooks the trigger before component is instantiate
 103      */
 104     public ngOnInit(): void {
 105         this.initializeForm();
 106         this.getMemberVnfIndex();
 107         this.headers = new HttpHeaders({
 108             'Content-Type': 'application/json',
 109             Accept: 'application/json',
 110             'Cache-Control': 'no-cache, no-store, must-revalidate, max-age=0'
 111         });
 112     }
 113     /** Initialize start, stop or rebuild Forms @public */
 114     public initializeForm(): void {
 115         this.startForm = this.formBuilder.group({
 116             memberVnfIndex: [null, [Validators.required]],
 117             vduId: [null, [Validators.required]],
 118             countIndex: [null, [Validators.required]]
 119         });
 120     }
 121
 122     /** Getting MemberVnfIndex using VNFInstances API @public */
 123     public getMemberVnfIndex(): void {
 124         const vnfInstanceData: {}[] = [];
 125         this.restService.getResource(environment.VNFINSTANCES_URL).subscribe((vnfInstancesData: VNFInstanceDetails[]): void => {
 126             vnfInstancesData.forEach((vnfData: VNFInstanceDetails): void => {
 127                 const vnfDataObj: {} =
 128                 {
 129                     VNFD: vnfData['vnfd-ref'],
 130                     VNFInstanceId: vnfData._id,
 131                     MemberIndex: vnfData['member-vnf-index-ref'],
 132                     NS: vnfData['nsr-id-ref'],
 133                     VNFID: vnfData['vnfd-id']
 134                 };
 135                 vnfInstanceData.push(vnfDataObj);
 136             });
 137             const nsId: string = 'NS';
 138             this.nsIdFilteredData = vnfInstanceData.filter((vnfdData: {}[]): boolean => vnfdData[nsId] === this.params.id);
 139             this.nsIdFilteredData.forEach((resVNF: {}[]): void => {
 140                 const memberIndex: string = 'MemberIndex';
 141                 const vnfinstanceID: string = 'VNFInstanceId';
 142                 const assignMemberIndex: {} = {
 143                     id: resVNF[memberIndex],
 144                     vnfinstanceId: resVNF[vnfinstanceID]
 145                 };
 146                 this.memberVnfIndex.push(assignMemberIndex);
 147             });
 148             this.memberTypes = this.memberVnfIndex;
 149             this.isLoadingResults = false;
 150         }, (error: ERRORDATA): void => {
 151             this.restService.handleError(error, 'get');
 152             this.isLoadingResults = false;
 153         });
 154     }
 155
 156     /** Getting vdu-id & count-index from VNFInstance API */
 157     public getVdu(id: string): void {
 158         const vnfInstanceData: {}[] = [];
 159         this.getFormControl('vduId').setValue(null);
 160         this.getFormControl('countIndex').setValue(null);
 161         if (!isNullOrUndefined(id)) {
 162             this.restService.getResource(environment.VNFINSTANCES_URL + '/' + id).
 163                 subscribe((vnfInstanceDetail: VNFInstanceDetails[]): void => {
 164                     this.instanceId = id;
 165                     this.selectedvnfId = vnfInstanceDetail['vnfd-ref'];
 166                     const VDU: string = 'vdur';
 167                     if (vnfInstanceDetail[VDU] !== undefined) {
 168                         vnfInstanceDetail[VDU].forEach((vdu: VDUR): void => {
 169                             const vnfInstanceDataObj: {} =
 170                             {
 171                                 'count-index': vdu['count-index'],
 172                                 VDU: vdu['vdu-id-ref']
 173
 174                             };
 175                             vnfInstanceData.push(vnfInstanceDataObj);
 176                         });
 177                         this.vdu = vnfInstanceData;
 178                         const vduName: string = 'VDU';
 179                         this.vduId = this.vdu.filter((vdu: {}, index: number, self: {}[]): {} =>
 180                             index === self.findIndex((t: {}): {} => (
 181                                 t[vduName] === vdu[vduName]
 182                             ))
 183                         );
 184                     }
 185                     this.checkDay12Operation(this.selectedvnfId);
 186                 }, (error: ERRORDATA): void => {
 187                     this.restService.handleError(error, 'get');
 188                     this.isLoadingResults = false;
 189                 });
 190         }
 191     }
 192
 193     /** Getting count-index by filtering id */
 194     public getCountIndex(id: string): void {
 195         const VDU: string = 'VDU';
 196         this.countIndex = this.vdu.filter((vnfdData: {}[]): boolean => vnfdData[VDU] === id);
 197     }
 198
 199     /** To check primitve actions from VNFR  */
 200     public checkDay12Operation(id: string): void {
 201         const apiUrl: string = environment.VNFPACKAGES_URL + '?id=' + id;
 202         this.restService.getResource(apiUrl).subscribe((vnfdInfo: VNFD[]): void => {
 203             const vnfInstances: VNFD = vnfdInfo[0];
 204             if (!isNullOrUndefined(vnfInstances.df)) {
 205                 vnfInstances.df.forEach((df: DF): void => {
 206                     if (df['lcm-operations-configuration'] !== undefined) {
 207                         if (df['lcm-operations-configuration']['operate-vnf-op-config']['day1-2'] !== undefined) {
 208                             this['day1-2'] = true;
 209                         }
 210                     } else {
 211                         this['day1-2'] = false;
 212                     }
 213                 });
 214             }
 215         }, (error: ERRORDATA): void => {
 216             this.isLoadingResults = false;
 217             this.restService.handleError(error, 'get');
 218         });
 219     }
 220     /** Check Instance type is start or stop or rebuild and proceed action */
 221     public instanceCheck(instanceType: string): void {
 222         this.submitted = true;
 223         this.sharedService.cleanForm(this.startForm);
 224         if (this.startForm.invalid) { return; } // Proceed, onces form is valid
 225         if (instanceType === 'start') {
 226             const startPayload: StartStopRebuild = {
 227                 updateType: 'OPERATE_VNF',
 228                 operateVnfData: {
 229                     vnfInstanceId: this.instanceId,
 230                     changeStateTo: 'start',
 231                     additionalParam: {
 232                         'run-day1': false,
 233                         vdu_id: this.startForm.value.vduId,
 234                         'count-index': this.startForm.value.countIndex
 235                     }
 236                 }
 237             };
 238             this.startInitialization(startPayload);
 239         } else if (instanceType === 'stop') {
 240             const stopPayload: StartStopRebuild = {
 241                 updateType: 'OPERATE_VNF',
 242                 operateVnfData: {
 243                     vnfInstanceId: this.instanceId,
 244                     changeStateTo: 'stop',
 245                     additionalParam: {
 246                         'run-day1': false,
 247                         vdu_id: this.startForm.value.vduId,
 248                         'count-index': this.startForm.value.countIndex
 249                     }
 250                 }
 251             };
 252             this.startInitialization(stopPayload);
 253         } else {
 254             const rebuildPayload: StartStopRebuild = {
 255                 updateType: 'OPERATE_VNF',
 256                 operateVnfData: {
 257                     vnfInstanceId: this.instanceId,
 258                     changeStateTo: 'rebuild',
 259                     additionalParam: {
 260                         'run-day1': (this['day1-2'] === true) ? true : false,
 261                         vdu_id: this.startForm.value.vduId,
 262                         'count-index': this.startForm.value.countIndex
 263                     }
 264                 }
 265             };
 266             this.startInitialization(rebuildPayload);
 267         }
 268     }
 269
 270     /** Initialize the start, stop or rebuild operation @public */
 271     public startInitialization(startPayload: object): void {
 272         this.isLoadingResults = true;
 273         const apiURLHeader: APIURLHEADER = {
 274             url: environment.NSDINSTANCES_URL + '/' + this.params.id + '/update',
 275             httpOptions: { headers: this.headers }
 276         };
 277         const modalData: MODALCLOSERESPONSEDATA = {
 278             message: 'Done'
 279         };
 280         this.restService.postResource(apiURLHeader, startPayload).subscribe((result: {}): void => {
 281             this.activeModal.close(modalData);
 282             this.router.navigate(['/instances/ns/history-operations/' + this.params.id]).catch();
 283         }, (error: ERRORDATA): void => {
 284             this.restService.handleError(error, 'post');
 285             this.isLoadingResults = false;
 286         });
 287     }
 288
 289     /** Used to get the AbstractControl of controlName passed @private */
 290     private getFormControl(controlName: string): AbstractControl {
 291         return this.startForm.controls[controlName];
 292     }
 293 }