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                 COMMUNICATION_FORM_ITEMS.forEach((item, index) => {
  97                         if (item.required && item.type === "input" ) {
  98                                 this.Util.validator(
  99                                         item.title,
 100                                         item.key,
 101                                         this.slicing_order_info[item.key],
 102                                         index,
 103                                         this.rulesText,
 104                                         this.validateRulesShow
 105                                 );
 106                         }
 107                 });
 108                 if (this.validateRulesShow.indexOf(true) > -1) {
 109                         return;
 110                 }
 111                 for(var i=0;i<this.areaList.length;i++){
 112                         const _item = this.areaList[i]
 113                         let str = "";
 114                         for(var j=0;j<_item.length;j++){
 115                                 const area = _item[j]
 116                                 str += area.selected + ";";
 117                                 if(!area.selected){
 118                                         this.message.error("Please Area the form");
 119                                         return;
 120                                    }
 121                         }
 122                         coverage_list.push(str.substring(0, str.length - 1));
 123                 }
 124                 // this.areaList.forEach((item) => {
 125                 //      let str = "";
 126                 //      item.forEach((area) => {
 127                 //              str += area.selected + ";";
 128                 //      });
 129                 //      coverage_list.push(str.substring(0, str.length - 1));
 130                 // });
 131                 if (coverage_list.length > 1) {
 132                         coverageAreas = coverage_list.join("|");
 133                 } else {
 134                         coverageAreas = coverage_list.toString();
 135                 }
 136                 const coverageAreaNumber = this.slicing_order_info[
 137                         "coverageAreaNumber"
 138                 ];
 139                 if (coverageAreaNumber) {
 140                         this.slicing_order_info.coverageArea = `${coverageAreas}-${coverageAreaNumber}`;
 141                 } else {
 142                         this.slicing_order_info.coverageArea = `${coverageAreas}`;
 143                 }
 144                 console.log('jjjjkkk',this.slicing_order_info.coverageArea)
 145                 delete this.slicing_order_info.coverageAreaNumber;
 146
 147                 const paramsObj = {
 148                         slicing_order_info: this.slicing_order_info,
 149                 };
 150                 const csmfSlicingPurchaseFailedCallback = () => {
 151                         this.handleCancel();
 152                 };
 153
 154                 this.myhttp
 155                         .csmfSlicingPurchase(paramsObj, csmfSlicingPurchaseFailedCallback)
 156                         .then((res) => {
 157                                 const result = res.result_header;
 158                                 if (
 159                                         result &&
 160                                         result.result_code &&
 161                                         +result.result_code === 200
 162                                 ) {
 163                                         console.log(res);
 164                                 } else {
 165                                         this.message.create("error", "Network error");
 166                                 }
 167                                 this.handleCancel();
 168                         });
 169         }
 170 }