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

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