gerrit.onap Code Review - usecase-ui.git/blob

   1 import { Component, EventEmitter, Input, OnInit, Output } from "@angular/core";
   2 import { COMMUNICATION_FORM_ITEMS,MASKTEXT } from "./constants";
   3 import { Util } from "../../../../../shared/utils/utils";
   4 import { SlicingTaskServices } from "../../../../../core/services/slicingTaskServices";
   5 import { NzMessageService } from "ng-zorro-antd";
   6
   7 @Component({
   8         selector: "app-business-order",
   9         templateUrl: "./business-order.component.html",
  10         styleUrls: ["./business-order.component.less"],
  11 })
  12 export class BusinessOrderComponent implements OnInit {
  13         constructor(
  14                 private myhttp: SlicingTaskServices,
  15                 private message: NzMessageService,
  16                 private Util: Util
  17         ) {}
  18
  19         ngOnInit() {
  20        console.log('MASKTEXT',MASKTEXT)
  21            this.masktext = MASKTEXT
  22         }
  23
  24         ngOnChanges() {
  25                 this.AreaFormatting();
  26         }
  27     detailFn(flag){
  28           COMMUNICATION_FORM_ITEMS.forEach((item, index) => {
  29                   if(item.key=='coverageAreaNumber'){
  30                         item["coverflag"] = flag == true ? false:true
  31                   }
  32           })
  33         }
  34
  35         @Input() showModel: boolean;
  36         @Output() cancel = new EventEmitter<boolean>();
  37         comunicationFormItems = COMMUNICATION_FORM_ITEMS;
  38         slicing_order_info = {
  39                 name: null,
  40                 maxNumberofUEs: null,
  41                 expDataRateDL: null,
  42                 latency: null,
  43                 expDataRateUL: null,
  44                 resourceSharingLevel: "shared",
  45                 uEMobilityLevel: "stationary",
  46                 coverageArea: "",
  47                 coverageAreaNumber: null,
  48         };
  49         areaList: any[] = [];
  50         validateRulesShow: any[] = [];
  51         rulesText: any[] = [];
  52         areaLevel: number = 4;
  53     masktext: string = "";
  54         AreaFormatting(): void {
  55                 let areaList = ["Beijing;Beijing;Haidian District;Wanshoulu Street"];
  56                 this.areaList = areaList.map((item: any) => {
  57                         let arr = item.split(";");
  58                         item = arr.map((it, index) => {
  59                                 let key: string;
  60                                 if (!index) {
  61                                         key = "province";
  62                                 } else if (index === 1) {
  63                                         key = "city";
  64                                 } else if (index === 2) {
  65                                         key = "district";
  66                                 } else {
  67                                         key = "street";
  68                                 }
  69                                 const obj: any = {};
  70                                 obj.key = key;
  71                                 obj.selected = it;
  72                                 obj.options = [{ name: it, id: it }];
  73                                 return obj;
  74                         });
  75                         return item;
  76                 });
  77         }
  78
  79         handleCancel(): void {
  80                 this.showModel = false;
  81                 this.cancel.emit(this.showModel);
  82                 this.slicing_order_info = {
  83                         name: null,
  84                         maxNumberofUEs: null,
  85                         expDataRateDL: null,
  86                         latency: null,
  87                         expDataRateUL: null,
  88                         resourceSharingLevel: "shared",
  89                         uEMobilityLevel: "stationary",
  90                         coverageArea: "",
  91                         coverageAreaNumber: null,
  92                 };
  93                 this.validateRulesShow = [];
  94         }
  95
  96         handleOk(): void {
  97                 const coverage_list: string[] = [];
  98                 let coverageAreas;
  99
 100                 COMMUNICATION_FORM_ITEMS.forEach((item, index) => {
 101                         if (item.required && item.type === "input") {
 102                                 this.Util.validator(
 103                                         item.title,
 104                                         item.key,
 105                                         this.slicing_order_info[item.key],
 106                                         index,
 107                                         this.rulesText,
 108                                         this.validateRulesShow
 109                                 );
 110                         }
 111                 });
 112                 if (this.validateRulesShow.indexOf(true) > -1) {
 113                         return;
 114                 }
 115
 116                 this.areaList.forEach((item) => {
 117                         let str = "";
 118                         item.forEach((area) => {
 119                                 str += area.selected + ";";
 120                         });
 121                         coverage_list.push(str.substring(0, str.length - 1));
 122                 });
 123                 if (coverage_list.length > 1) {
 124                         coverageAreas = coverage_list.join("|");
 125                 } else {
 126                         coverageAreas = coverage_list.toString();
 127                 }
 128                 const coverageAreaNumber = this.slicing_order_info[
 129                         "coverageAreaNumber"
 130                 ];
 131                 if (coverageAreaNumber) {
 132                         this.slicing_order_info.coverageArea = `${coverageAreas}-${coverageAreaNumber}`;
 133                 } else {
 134                         this.slicing_order_info.coverageArea = `${coverageAreas}`;
 135                 }
 136                 delete this.slicing_order_info.coverageAreaNumber;
 137
 138                 const paramsObj = {
 139                         slicing_order_info: this.slicing_order_info,
 140                 };
 141                 const csmfSlicingPurchaseFailedCallback = () => {
 142                         this.handleCancel();
 143                 };
 144                 this.myhttp
 145                         .csmfSlicingPurchase(paramsObj, csmfSlicingPurchaseFailedCallback)
 146                         .then((res) => {
 147                                 const result = res.result_header;
 148                                 if (
 149                                         result &&
 150                                         result.result_code &&
 151                                         +result.result_code === 200
 152                                 ) {
 153                                         console.log(res);
 154                                 } else {
 155                                         this.message.create("error", "Network error");
 156                                 }
 157                                 this.handleCancel();
 158                         });
 159         }
 160 }