vid-webpack-master/src/app/instantiationStatus/instantiationStatus.component.service.ts

   1 import {Injectable} from '@angular/core';
   2 import {ServiceInfoModel, ServiceInfoUiModel} from '../shared/server/serviceInfo/serviceInfo.model';
   3 import * as _ from 'lodash';
   4 import {Observable} from 'rxjs/Observable';
   5 import {NgRedux} from "@angular-redux/store";
   6 import {AppState} from "../shared/store/reducers";
   7 import {AaiService} from "../shared/services/aaiService/aai.service";
   8 import {ServiceModel} from "../shared/models/serviceModel";
   9 import {FeatureFlagsService, Features} from "../shared/services/featureFlag/feature-flags.service";
  10 import {DrawingBoardModes} from "../drawingBoard/service-planning/drawing-board.modes";
  11 import {updateDrawingBoardStatus} from "../shared/storeUtil/utils/global/global.actions";
  12 import {Router, UrlTree} from "@angular/router";
  13 import {of} from "rxjs";
  14 import {MsoService} from "../shared/services/msoService/mso.service";
  15 import {ServiceAction} from "../shared/models/serviceInstanceActions";
  16 import {InstantiationBase} from "../shared/models/InstantiationBase";
  17
  18 export let PENDING : string = "pending";
  19 export let INPROGRESS : string = "in_progress";
  20 export let PAUSE : string = "pause";
  21 export let X_O : string = "x-circle-o";
  22 export let SUCCESS_CIRCLE : string = "success-circle-o";
  23 export let STOPPED : string = "stop";
  24 export let COMPLETED_WITH_ERRORS : string = "success_with_warning";
  25 export let PAUSE_UPON_COMPLETION : string = "stopped-upon-success";
  26 export let UNKNOWN : string = "question-mark-circle-o";
  27
  28
  29 @Injectable()
  30 export class InstantiationStatusComponentService {
  31   constructor( private _aaiService: AaiService,
  32                private _msoService: MsoService,
  33                private _router : Router,
  34                private _store: NgRedux<AppState>,
  35                private _featureFlagsService:FeatureFlagsService) {
  36   }
  37
  38   generateServiceInfoDataMapping(arr: ServiceInfoModel[]) : { [serviceInstanceId: string]: ServiceInfoModel[]}{
  39     let serviceInfoData: { [serviceInstanceId: string]: ServiceInfoModel[]; } = {};
  40     for(let item of arr){
  41       if(_.isNil(serviceInfoData[item.templateId])){
  42         serviceInfoData[item.templateId] = [item];
  43       }else {
  44         serviceInfoData[item.templateId].push(item);
  45       }
  46     }
  47     return serviceInfoData;
  48   }
  49
  50   convertObjectToArray(arr: ServiceInfoModel[]) : Observable<ServiceInfoUiModel[]>{
  51     const obj = this.generateServiceInfoDataMapping(arr);
  52     let index:number = 0;
  53     let result = [];
  54     for(let item in obj) {
  55       obj[item].map(item => {
  56         item['serviceStatus'] = this.getStatus(item.jobStatus);
  57         item['serviceIndex'] = index;
  58       });
  59       index++;
  60       result = result.concat(obj[item]);
  61     }
  62
  63     console.log(result);
  64     return of(result);
  65   }
  66
  67   isDrawingBoardViewEdit(serviceModel: ServiceModel): boolean {
  68     if (!_.isNil(serviceModel.vidNotions) && !_.isNil(serviceModel.vidNotions.viewEditUI)
  69       && serviceModel.vidNotions.viewEditUI !== 'legacy'){
  70       return true;
  71     }
  72     return false;
  73   }
  74
  75   open(item: ServiceInfoModel): void {
  76     if (this._featureFlagsService.getFlagState(Features.FLAG_1902_VNF_GROUPING)) {
  77       this._aaiService.getServiceModelById(item['serviceModelId']).subscribe((result)=>{
  78         const serviceModel =  new ServiceModel(result);
  79
  80         if (this.isDrawingBoardViewEdit(serviceModel)) {
  81           this.navigateToNewViewEdit(item, DrawingBoardModes.EDIT);
  82           return;
  83         }
  84
  85         this.navigateToNewViewOnlyOrOldEditView(item);
  86
  87       });
  88     }
  89
  90     /*this else is here only to save time in case we don't need to retrieve service model
  91     it can be removed once it service model is always needed, and it doesn't save time*/
  92     else {
  93       this.navigateToNewViewOnlyOrOldEditView(item);
  94     }
  95   }
  96
  97   navigateToNewViewOnlyOrOldEditView(item: ServiceInfoModel) {
  98     if (this._featureFlagsService.getFlagState(Features.FLAG_1902_NEW_VIEW_EDIT)) {
  99       this.navigateToNewViewEdit(item, DrawingBoardModes.VIEW);
 100     }
 101     else {
 102       this.navigateToOldViewEdit(item);
 103     }
 104   }
 105
 106   navigateToOldViewEdit(item: ServiceInfoModel) {
 107     let query =
 108       `subscriberId=${item.subscriberId}&` +
 109       `subscriberName=${item.subscriberName}&` +
 110       `serviceType=${item.serviceType}&` +
 111       `serviceInstanceId=${item.serviceInstanceId}`;
 112
 113     this._store.dispatch(updateDrawingBoardStatus(DrawingBoardModes.OLD_VIEW_EDIT));
 114     window.parent.location.assign('../../serviceModels.htm#/instantiate?' + query);
 115   }
 116
 117   navigateToNewViewEdit(item: InstantiationBase, mode: DrawingBoardModes): void {
 118     console.log("Mode : ", mode);
 119     this._store.dispatch(updateDrawingBoardStatus(mode));
 120     const viewEditUrlTree:UrlTree = this.getNewViewEditUrlTree(item, mode);
 121     this._router.navigateByUrl(viewEditUrlTree);
 122     window.parent.location.assign(this.getViewEditUrl(viewEditUrlTree));
 123   }
 124
 125   getNewViewEditUrlTree(item: InstantiationBase, mode: DrawingBoardModes): UrlTree {
 126     return this._router.createUrlTree(
 127       ['/servicePlanning/' + mode],
 128       {
 129         queryParams:
 130         mode==DrawingBoardModes.RECREATE ?
 131           this.getRecreateQueryParams(item) :
 132           this.getDefaultViewEditQueryParams(<ServiceInfoModel> item)
 133       });
 134   }
 135
 136   private getDefaultViewEditQueryParams(item: ServiceInfoModel) {
 137     return {
 138       serviceModelId: item.serviceModelId,
 139       serviceInstanceId: item.serviceInstanceId,
 140       serviceType: item.serviceType,
 141       subscriberId: item.subscriberId,
 142       jobId: item.jobId
 143     };
 144   }
 145
 146   private getRecreateQueryParams(item: InstantiationBase) {
 147     return {
 148       serviceModelId: item.serviceModelId,
 149       jobId: item.jobId
 150     };
 151   }
 152
 153   getViewEditUrl(viewEditUrlTree:UrlTree): string {
 154     return '../../serviceModels.htm#' + viewEditUrlTree.toString();
 155   }
 156
 157   getStatus(status : string) : ServiceStatus {
 158     switch(`${status}`.toUpperCase()) {
 159       case  'PENDING' :
 160         return new ServiceStatus(PENDING, 'primary', 'Pending: The action required will be sent as soon as possible.');
 161       case  'IN_PROGRESS' :
 162         return new ServiceStatus(INPROGRESS, 'primary', 'In-progress: the service is in process of the action required.');
 163       case  'PAUSED' :
 164         return new ServiceStatus(PAUSE, 'primary', 'Paused: Service has paused and waiting for your action.\n Select actions from the menu to the right.');
 165       case  'FAILED' :
 166         return new ServiceStatus(X_O, 'error', 'Failed: All planned actions have failed.');
 167       case  'COMPLETED' :
 168         return new ServiceStatus(SUCCESS_CIRCLE, 'success', 'Completed successfully: Service is successfully instantiated, updated or deleted.');
 169       case  'STOPPED' :
 170         return new ServiceStatus(STOPPED, 'error', 'Stopped: Due to previous failure, will not be instantiated.');
 171       case  'COMPLETED_WITH_ERRORS' :
 172         return new ServiceStatus(COMPLETED_WITH_ERRORS, 'success', 'Completed with errors: some of the planned actions where successfully committed while other have not.\n Open the service to check it out.');
 173       case  'COMPLETED_AND_PAUSED' :
 174         return new ServiceStatus(PAUSE_UPON_COMPLETION, 'default','Pause upon completion. you may resume the instantiation.\n Open the service to check it out.' );
 175       default:
 176         return new ServiceStatus(UNKNOWN, 'primary', `Unexpected status: "${status}"`);
 177     }
 178   }
 179
 180   retry(item: ServiceInfoModel): void {
 181       this.navigateToNewViewEdit(item, DrawingBoardModes.RETRY_EDIT);
 182   }
 183
 184   resume(item: ServiceInfoModel): void {
 185     this.navigateToNewViewEdit(item, DrawingBoardModes.RESUME);
 186   }
 187
 188   recreate(item: ServiceInfoModel): void {
 189     this.navigateToNewViewEdit(item, DrawingBoardModes.RECREATE);
 190   }
 191
 192   isRecreateEnabled(item: ServiceInfoModel): boolean {
 193     return item.action === ServiceAction.INSTANTIATE;
 194   }
 195
 196   isRecreateVisible(): boolean {
 197     return this._featureFlagsService.getFlagState(Features.FLAG_2004_CREATE_ANOTHER_INSTANCE_FROM_TEMPLATE);
 198   }
 199
 200   isNewViewEditVisible(): boolean {
 201     return this._featureFlagsService.getFlagState(Features.FLAG_2006_NEW_VIEW_EDIT_BUTTON_IN_INSTANTIATION_STATUS);
 202   }
 203
 204   forwardToNewViewEdit(item: ServiceInfoModel): void {
 205     this.navigateToNewViewEdit(item, DrawingBoardModes.EDIT);
 206   }
 207 }
 208
 209
 210 export class ServiceStatus {
 211   iconClassName : string;
 212   color : string;
 213   tooltip : string;
 214
 215   constructor(_iconClassName : string, _color : string, _tooltip : string){
 216     this.iconClassName = _iconClassName;
 217     this.color = _color;
 218     this.tooltip = _tooltip;
 219   }
 220 }