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