import { Component, OnInit, ViewChild } from '@angular/core';
import { NgForm } from '@angular/forms';
import { ActivatedRoute, Router } from '@angular/router';
import {
  SFComponent,
  SFSchema,
  SFSchemaEnum,
  SFSelectWidgetSchema,
  SFTextareaWidgetSchema,
  SFUISchema
} from '@delon/form';
import { SettingsService, _HttpClient } from '@delon/theme';
import { ShipperBaseService } from '@shared';
import { NzModalService } from 'ng-zorro-antd/modal';
import { of } from 'rxjs';
import { map } from 'rxjs/operators';
import { AmapPoiPickerComponent, AmapService } from 'src/app/shared/components/amap';
import { SupplyManagementService } from '../../services/supply-management.service';
import { PublishGoodsChooseFamifiarComponent } from '../choose-famifiar/choose-famifiar.component';
import { PublishAddressListComponent } from '../onecar-publish/address-list/address-list.component';
import { PublishSuccessComponent } from '../onecar-publish/publish-success/publish-success.component';
import { TranAgreementComponent } from '../tran-agreement/tran-agreement.component';
import differenceInCalendarDays from 'date-fns/differenceInCalendarDays';
import { SupplyManagementQrcodePageComponent } from '../qrcode-page/qrcode-page.component';
@Component({
  selector: 'app-publish-goods-bulk-publish',
  templateUrl: './bulk-release-publish.component.html',
  styleUrls: ['./bulk-release-publish.component.less']
})
export class SupplyManagementBulkReleasePublishComponent implements OnInit {
  @ViewChild('ngForm')
  ngForm!: NgForm;
  sf1data: any; // 货源单设置回显
  sf3data: any; // 货源单设置回显
  sf4data: any; // 货源单设置回显
  sf5data: any; // 货源单设置回显
  sf6data: any; // 货源单设置回显
  sf7data: any; // 货源单设置回显
  creatTime: any; // 货源单设置回显
  modifyTime: any; // 货源单设置回显
  totalFees: any; // 总数信息
  ruleOptions: any;
  id = '';
  type = 'add';
  limitValues = {
    maxMonth: 99,
    maxWeight: 99999,
    maxVolume: 99999,
    maxTrainNumber: 99999,
    maxFreight: 9999999
  }
  shipperName = '';
  // // 单位
  startInfo: any[] = [];
  endInfo: any[] = [];
  totalDistance = 0.0; //总里程
  totalTime = 0.0; //路程总时间
  freightTypeOptions: any;
  constructor(
    private http: _HttpClient,
    private modalService: NzModalService,
    private settingSrv: SettingsService,
    private service: SupplyManagementService,
    private router: Router,
    private route: ActivatedRoute,
    private amapService: AmapService,
    public shipperSrv: ShipperBaseService
  ) {
    
  }
  @ViewChild('sf1', { static: false }) sf1!: SFComponent;
  schema1: SFSchema = {};
  ui1!: SFUISchema;

  @ViewChild('sf3', { static: false }) sf3!: SFComponent;
  schema3: SFSchema = {};
  ui3!: SFUISchema;

  @ViewChild('sf4', { static: false }) sf4!: SFComponent;
  schema4: SFSchema = {};
  ui4!: SFUISchema;

  @ViewChild('sf6', { static: false }) sf6!: SFComponent;
  schema6: SFSchema = {};
  ui6!: SFUISchema;
  // 初始化
  ngOnInit(): void {
    this.initSF1();
    this.initSF3();
    this.initSF4();
    this.initSF6();
    this.getLimitvalue();
    this.initDict();
    this.startInfo = [
      {
        detailedAddress: '',
        appUserName: '',
        contractTelephone: '',
        latitude: '',
        longitude: '',
        province: '',
        city: '',
        area: '',
        type: '1'
      }
    ];
    this.endInfo = [
      {
        detailedAddress: '',
        appUserName: '',
        contractTelephone: '',
        latitude: '',
        longitude: '',
        province: '',
        city: '',
        area: '',
        type: '2'
      }
    ];
  }
  initSF1() {
    this.schema1 = {
      properties: {
        shipperAppUserId: {
          title: '货主',
          type: 'string',
          maxLength: 30,
          ui: {
            widget: 'select',
            serverSearch: true,
            searchDebounceTime: 300,
            searchLoadingText: '搜索中...',
            allowClear: true,
            onSearch: (q: any) => {
              let str =q?.replace(/^\s+|\s+$/g,"");
              if (str) {
                return this.service
                  .request(this.service.$api_enterpriceList, { enterpriseName: str })
                  .pipe(map((res: any[]) => (res as any[]).map(i => ({ label: i.enterpriseName, value: i.id } as SFSchemaEnum))))
                  .toPromise();
              } else {
                return of([]);
              }
            },
            change: (q: any, qs: any) => {
              let str =q?.replace(/^\s+|\s+$/g,"");
              if (str) {
              this.getRegionCode(str);
              this.shipperName = qs?.label;
              }
            }
          } as SFSelectWidgetSchema
        },
        enterpriseProjectId: {
          type: 'string',
          title: '项目',
          ui: {
            widget: 'select',
            placeholder: '请选择',
            allowClear: true,
          } as SFSelectWidgetSchema
        },
        enterpriseInfoNamer: {
          type: 'string',
          title: '',
          ui: { hidden: true }
        },
        enterpriseInfoId: {
          type: 'string',
          title: '网络货运人',
          ui: {
            widget: 'select',
            placeholder: '请选择',
            allowClear: true,
            asyncData: () => this.shipperSrv.getNetworkFreightForwarder(),
            change: (q: any, qs: any) => {
              this.sf1.setValue('/enterpriseInfoNamer', qs.label);
            }
          }
        },
        deadlineTime: {
          title: '有效期',
          type: 'string',
          format: 'date-time',
          ui: {
            placeholder: '请输入',
            format: 'yyyy-MM-dd HH:mm:ss',
            validator: (val) => {
              let d = new Date();
              let year = d.getFullYear();
              let month = d.getMonth();
              let date = d.getDate();
              let mydate = new Date(year, month + this.limitValues.maxMonth, date);
              if (new Date(val) < new Date()) {
                return [{ keyword: 'validTime', message: '有效期时间需大于当前时间' }];
              }
              if (new Date(val) > mydate) {
                return [{ keyword: 'validTime2', message: `有效期最长为${this.limitValues.maxMonth}个月` }];
              }
              return [];
            },
          }
        },
        dispatchName: {
          type: 'string',
          title: '调度员姓名',
          maxLength: 30,
          ui: {
            optionalHelp: '选若未填写，司机直接联系您',
            placeholder: '请输入'
          }
        },
        dispatchPhone: {
          type: 'string',
          title: '调度员手机号',
          maxLength: 30,
          ui: {       
            placeholder: '请输入'
          }
        },
      },
      required: ['shipperAppUserId', 'enterpriseProjectId','enterpriseInfoName','enterpriseInfoId', 'deadlineTime',]
    };
    this.ui1 = {
      '*': {
        spanLabelFixed: 110,
        grid: { span: 12 }
      },
      $enterpriseInfoName: {
        grid: { span: 24 }
      }
    };
  }
  initSF3() {
    this.schema3 = {
      properties: {
        goodsTypeId: {
          type: 'string',
          title: '货物名称',
          ui: {
            widget: 'select',
            placeholder: '请选择',
            errors: { required: '请选择货物类型' },
            asyncData: () =>
              this.shipperSrv.loadConfigByKey('goods.name.config.type').pipe(
                map((data: any) => {
                  return data[0].children?.map((m: any) => {
                    return { label: m.name, value: m.id };
                  });
                })
              ),
            change: (value, data: any) => {
              this.changeGoodsType(value, data);
              this.sf3.setValue('/goodsTypeName', data.label);
            }
          } as SFSelectWidgetSchema
        },
        goodsTypeName: {
          type: 'string',
          title: '',
          ui: {
            hidden: true
          }
        },
        goodsNameId: {
          type: 'string',
          title: '',
          ui: {
            widget: 'select',
            placeholder: '请选择',
            errors: { required: '请填写货物名称' },
            change: (value: any, data: any) => {
              this.sf3.setValue('/goodsName', data.label);
            },
            visibleIf: {
              goodsTypeName: (value: any) => value && value !== '其它'
            }
          }
        },
        goodsName: {
          type: 'string',
          title: '',
          ui: {
            hidden: true,
            visibleIf: {
              goodsTypeName: (value: any) => value && value !== '其它'
            }
          }
        },
        goodsName1: {
          type: 'string',
          title: '',
          maxLength: 20,
          ui: {
            errors: { required: '请填写货物名称' },
            visibleIf: {
              goodsTypeName: (value: any) => value && value === '其它'
            }
          }
        }
      },
      required: ['goodsTypeId', 'goodsName', 'goodsNameId','goodsName1']
    };
    this.ui3 = {
      '*': {
        spanLabelFixed: 90,
        grid: { span: 12 }
      }
    };
  }
  initSF4() {
    this.schema4 = {
      properties: {
        freightPrice: {
          type: 'string',
          title: '运费单价',
          ui: {
            errors: { required: '请选择运费单价' },
            widget: 'custom',
            placeholder: '请输入'
          }
        },
        freightType: {
          type: 'string',
          title: '',
          ui: {
            hidden: true
          },
          default: '1'
        },

        rule: {
          type: 'string',
          title: '',
          ui: {
            widget: 'custom',
            errors: { required: '请选择运费取整规则' }
          }
        },
        settlementBasis: {
          type: 'string',
          title: '',
          ui: {
            widget: 'dict-select',
            params: { dictKey: 'goodresource:settlement:type' },
            placeholder: '结算依据',
            errors: { required: '请选择结算依据' }
          } as SFSelectWidgetSchema
        },
        weight: {
          type: 'string',
          title: '货物数量',
          ui: {
            widget: 'custom',
            placeholder: '请输入',
            errors: { required: '请填写总重量' }
          }
        },
        volume: {
          type: 'string',
          title: '',
          ui: {
            widget: 'custom',
            placeholder: '请输入'
          }
        },
        number: {
          type: 'string',
          title: '',
          ui: {
            widget: 'custom',
            placeholder: '请输入'
          }
        },
        carModel: {
          type: 'string',
          title: '车型/车长',
          ui: {
            widget: 'select',
            mode: 'multiple',
            maxMultipleCount:3,
            placeholder: '请选择车型',
            errors: { required: '请选择车型' },
            asyncData: () => this.service.getDictOptions({ dictKey: 'car:model' }),
            change:(tag:any , org:any)=>{
              if(tag.includes("999")){
                this.sf4.setValue('/carModel',["999"]);
              }
            }
          }
        },
        carLength: {
          type: 'string',
          title: '',
          ui: {
            widget: 'select',
            mode: 'multiple',
            maxMultipleCount:3,
            placeholder: '请选择车长',
            errors: { required: '请选择车长' },
            asyncData: () => this.service.getDictOptions({ dictKey: 'car:length' }),
            change:(tag:any , org:any)=>{
              if(tag.includes("999")){
                this.sf4.setValue('/carModel',["999"]);
              }
            }
          }
        },
      },
      required: ['weight', 'carModel', 'carLength', 'freightPrice', 'rule', 'settlementBasis']
    };
    this.ui4 = {
      '*': {
        spanLabelFixed: 90,
        grid: { span: 24 }
      },
      $freightPrice: {
        grid: { span: 8 }
      },
      $rule: {
        grid: { span: 8 }
      },
      $settlementBasis: {
        grid: { span: 8 }
      },
      $weight: {
        grid: { lg: 8, md: 12, sm: 12, xs: 24 }
      },
      $volume: {
        grid: { lg: 8, md: 12, sm: 12, xs: 24 }
      },
      $number: {
        grid: { lg: 8, md: 12, sm: 12, xs: 24 }
      },
      $carModel: {
        spanLabelFixed: 120,
        grid: { span: 8 }
      },
      $carLength: {
        grid: { span: 8 }
      }
    };
  }
  initSF6() {
    this.schema6 = {
      properties: {
        stateReceipt: {
          type: 'string',
          title: '是否回单',
          enum: [
            { label: '需要', value: true },
            { label: '不需要', value: false }
          ],
          ui: {
            widget: 'select',
            errors: { required: '请选择' },
            placeholder: '请选择'
          }
        },
        receiptType: {
          type: 'string',
          title: '回单类型',
          ui: {
            widget: 'dict-select',
            params: { dictKey: 'receipt:type' },
            containsAllLabel: false,
            placeholder: '请选择',
            errors: { required: '请选择' },
            visibleIf: {
              stateReceipt: value => value === true
            }
          }
        },
        receiptUserName: {
          type: 'string',
          title: '联系人',
          maxLength: 15,
          ui: {
            visibleIf: {
              receiptType: value => value === '2'
            }
          },
        },
        receiptUserPhone: {
          type: 'string',
          title: '联系电话',
          maxLength: 11,
          ui: {
            visibleIf: {
              receiptType: value => value === '2'
            }
          },
        },
        receiptAddressArea: {
          type: 'string',
          title: '所在地区',
          maxLength: 30,
          ui: {
            visibleIf: {
              receiptType: value => value === '2'
            }
          },
        },
        receiptAddress: {
          type: 'string',
          title: '详细地址',
          maxLength: 30,
          ui: {
            visibleIf: {
              receiptType: value => value === '2'
            }
          },
        },
        paymentDays: {
          type: 'string',
          title: '到货后',
          ui: {
            widget: 'custom',
            placeholder: '请输入',
            errors: { required: '请输入付款承诺天数' }
          }
        },
        remarks: {
          type: 'string',
          title: '备注',
          maxLength: 200,
          ui: {
            widget: 'textarea',
            placeholder: '请输入',
            autosize: { minRows: 3, maxRows: 3 }
          } as SFTextareaWidgetSchema
        }
      },
      required: ['stateReceipt', 'paymentDays', 'receiptType', 'receiptUserName','receiptUserPhone','receiptAddressArea','receiptAddress','paymentDays']
    };
    this.ui6 = {
      '*': {
        spanLabelFixed: 90,
        grid: { span: 24 }
      }
    };
  }
  initDict() {
    this.service.getDictByKey('freight:type').subscribe(res => {
      this.freightTypeOptions = res;
    });
    this.service.getDictByKey('goodresource:rounding:rules').subscribe(res => {
      this.ruleOptions = res;
    });
  }
  //指派熟车
  chooseFamifiar(item: any) {
    const modalRef = this.modalService.create({
      nzTitle: '指派熟车',
      nzContent: PublishGoodsChooseFamifiarComponent,
      nzComponentParams: {
        submitParams: item,
        submitUrl: this.service.$api_save_consignBulkAssign
      },
      nzWidth: 1300
    });
    modalRef.afterClose.subscribe(result => {
      if (result) {
        this.openFinishPage(result);
      }
    });
  }
  // 打开下单完成页面
  openFinishPage(resourceObj: any = null) {
    this.modalService.create({
      nzTitle: '',
      nzContent: PublishSuccessComponent,
      nzWidth: 900,
      nzFooter: null,
      nzComponentParams: { type: 'bulk' }
    });
  }
  // 提交前确认，委托运输协议弹窗
  submitConfirm(submitType?: any) {
      // 校验规则
      Object.keys(this.ngForm.form.controls).forEach(key => {
        this.ngForm.form.controls[key].markAsDirty();
        this.ngForm.form.controls[key].updateValueAndValidity();
      });
      this.sf1.validator({ emitError: true });
      this.sf3.validator({ emitError: true });
      this.sf4.validator({ emitError: true });
      this.sf6.validator({ emitError: true });
      if (this.ngForm.form.invalid || !this.sf1.valid || !this.sf3.valid || !this.sf4.valid || !this.sf6.valid) {
      this.service.msgSrv.warning('请完善必填项！');
        return;
      }
      if (this.totalDistance <= 0) {
        this.service.msgSrv.warning('起终点相同，请重新选择装卸货地址！');
        return;
      }
     // 校验各个输入限定值
     if (this.sf4.value.weight > this.limitValues.maxWeight || this.sf4.value.volume > this.limitValues.maxVolume || this.sf4.value.number > this.limitValues.maxTrainNumber) {
      this.service.msgSrv.error(`当前货物核载信息已超出限定值【${this.limitValues.maxWeight}吨、${this.limitValues.maxVolume}方、${this.limitValues.maxTrainNumber}车】`);
      return;
    }

    if (this.sf4.value.freightPrice > this.limitValues.maxFreight) {
      this.service.msgSrv.error(`当前运费单价已超出限定值【${this.limitValues.maxFreight}元】`);
      return;
    }

     // //装卸货信息
     const LoadingList = this.startInfo.concat(this.endInfo);

     // 货物信息
     const sf3Values = { ...this.sf3.value };
     if (sf3Values.goodsTypeName === '其它') {
       sf3Values.goodsName = sf3Values.goodsName1;
       delete sf3Values.goodsName1;
     }
     if (this.sf4.value.carModel.includes('999')) {
       this.sf4.value.carModel = ['999']
     }
     if (this.sf4.value.carLength.includes('999')) {
       this.sf4.value.carLength = ['999']
     }
   
     const goodsInfoList = [
       {
         ...sf3Values,
         ...this.sf4.value,
         carModel: this.sf4.value.carModel.join(','),
         carLength: this.sf4.value.carLength.join(',')
       }
     ];
     const params = {
       id: '',
       ...this.sf1.value,
       unLoadingPlaceDTOList: LoadingList,
       goodsInfoDTOList: goodsInfoList,
       ...this.sf6.value,
       estimatedKilometers: this.totalDistance,
       estimatedTravelTime: this.totalTime,
     };
      const modalRef = this.modalService.create({
        nzTitle: '运输协议',
        nzContent: TranAgreementComponent,
        nzWidth: 900,
        nzFooter: null,
        nzComponentParams: { object: params, shipperName: this.shipperName , type:'bulk'}
      });
      modalRef.afterClose.subscribe(result => {
        if (result) {
          this.submit(submitType, params);
        }
      });
  }
  // 确认提交（下单）
  submit(submitType?: string, params?: any): void {
   

    let reqUrl = this.service.$api_consignBulk;
    if (submitType === 'assign') {
      this.chooseFamifiar(params);
    }else if(submitType === 'qrcode'){
      this.service.request(this.service.$api_consignBulkQRCode, params).subscribe(res => {
        if (res) {
          this.assignedQrcode( res, params )
        }
      });
      return;
    } else {
      this.service.request(reqUrl, params).subscribe(res => {
        if (res) {
          this.modalService.create({
            nzTitle: '',
            nzContent: PublishSuccessComponent,
            nzWidth: 900,
            nzFooter: null,
            nzComponentParams: { type: 'bulk' }
          });
        }
      });
    }
  }
      // 生成二维码
      assignedQrcode(id:string,parms:any ) {
        const item = {
          id,
          enterpriseInfoName: parms.enterpriseInfoName,
          loadingAddressArr: this.startInfo.map((ele: any)=>ele.detailedAddress),
          unloadingAddressArr: this.endInfo.map((ele: any)=>ele.detailedAddress),
          deadlineTime: parms.deadlineTime,
        }
        const modalRef = this.modalService.create({
          nzTitle: '二维码',
          nzWidth: '468px',
          nzContent: SupplyManagementQrcodePageComponent,
          nzComponentParams: {
            i: item,
          },
          nzFooter: null,
        });
        modalRef.afterClose.subscribe(() => {
          this.router.navigate(['/supply-management/index'], { queryParams: { type: 'bulk' } });
        });
      }
  // 获取城市列表
  getRegionCode(regionCode: any) {
    return this.service
      .request(this.service.$api_get_enterprise_project, { id: regionCode })
      .pipe(
        map(res =>
          res.map((item: any) => ({
            label: item.projectName,
            value: item.id
          }))
        )
      )
      .subscribe(res => {
        this.sf1.getProperty('/enterpriseProjectId')!.schema.enum = res;
        this.sf1.getProperty('/enterpriseProjectId')!.widget.reset(res);
      });
  }
  // 打开地图
  openMap(type: string, index: number) {
    const modalRef = this.modalService.create({
      nzTitle: '',
      nzContent: AmapPoiPickerComponent,
      nzWidth: 900,
      nzOnOk: item => {
        if(item?.poi) {
        const poi = item.poi;
        const locList = poi.pois;
        switch (type) {
          case 'start':
            this.startInfo[index].detailedAddress = poi.formattedAddress;
            this.startInfo[index].longitude = locList[0];
            this.startInfo[index].latitude = locList[1];
            this.startInfo[index].province = poi.addressComponent.province;
            this.startInfo[index].city = poi.addressComponent.city;
            this.startInfo[index].area = poi.addressComponent.district;
            break;
          case 'end':
            this.endInfo[index].detailedAddress = poi.formattedAddress;
            this.endInfo[index].longitude = locList[0];
            this.endInfo[index].latitude = locList[1];
            this.endInfo[index].province = poi.addressComponent.province;
            this.endInfo[index].city = poi.addressComponent.city;
            this.endInfo[index].area = poi.addressComponent.district;
            break;
          default:
            break;
        }
        if (this.startInfo[0]?.area && this.endInfo[0]?.area) {
          this.amapService.drivingCompute([...this.startInfo], [...this.endInfo]).subscribe(res => {
            this.totalDistance = res.distance;
            this.totalTime = res.time;
          });
        }
        return true
      } else {
        this.service.msgSrv.warning('请重新手动选择地址！')
        return false
      }
      }
    });
  }
  // 选择地址
  chooseAddress(index: number, type: string) {
    const modalRef = this.modalService.create({
      nzTitle: '选择地址',
      nzContent: PublishAddressListComponent,
      nzWidth: 900,
      nzComponentParams: { spuStatus: '1' },
      nzOnOk: item => {
        const data = item.seleteData;
        if (JSON.stringify(data) === '{}') return;
        switch (type) {
          case 'start':
            this.startInfo[index] = {
              detailedAddress: data.detailedAddress,
              appUserName: data.contactName,
              contractTelephone: data.contactTelephone,
              latitude: data.contactTelephone,
              longitude: data.latitude,
              province: data.province,
              city: data.city,
              area: data.area,
              type: '1'
            };
            break;
          case 'end':
            this.endInfo[index] = {
              detailedAddress: data.detailedAddress,
              appUserName: data.contactName,
              contractTelephone: data.contactTelephone,
              latitude: data.contactTelephone,
              longitude: data.latitude,
              province: data.province,
              city: data.city,
              area: data.area,
              type: '2'
            };
            break;
          default:
            break;
        }
      }
    });
  }
  // 返回上一页
  goBack() {
    window.history.go(-1);
  }
  changeGoodsType(value: string, data: any) {
    if (data.label === '其它') return;
    const params = {
      pageIndex: 1,
      pageSize: 100,
      configId: value
    };
    this.service
      .request(this.service.$api_get_config_item_page, params)
      .pipe(
        map(data => {
          return data.records?.map((m: any) => {
            return { label: m.name, value: m.id };
          });
        })
      )
      .subscribe(res => {
        if (res) {
          this.sf3.getProperty('/goodsNameId')!.schema.enum = res;
          this.sf3.getProperty('/goodsNameId')!.widget.reset(res);
          if (this.sf3data?.goodsNameId) {
            this.sf3.setValue('/goodsNameId', this.sf3data.goodsNameId);
          }
        }
      });
  }
     // 装卸货地址互换
     swapAddress(){
      let item = this.startInfo;
      this.startInfo = this.endInfo;
      this.endInfo = item;
  
      this.startInfo.forEach((element: any) => {
        element.type = '1';
      });
      this.endInfo.forEach((element: any) => {
        element.type = '2';
      });
  
          // 计算里程，时间
    if (this.startInfo[0]?.detailedAddress && this.endInfo[0]?.detailedAddress) {
      this.amapService.drivingCompute([...this.startInfo], [...this.endInfo]).subscribe(res => {
        this.totalDistance = res.distance;
        this.totalTime = res.time;
      });
    }
    }
    getLimitvalue() {
      const getlimitvaluesParms = [
        this.service.limitKeys2.month,
        this.service.limitKeys2.weight,
        this.service.limitKeys2.volume,
        this.service.limitKeys2.trainNumber,
        this.service.limitKeys2.freight,
      ];
      this.service.request(this.service.$api_findItemValueByItemKeys, getlimitvaluesParms).subscribe((res) => {
        const maxMonth = res.filter((item: any) => item.itemKey === this.service.limitKeys2.month)[0].itemValue;
        const maxWeight = res.filter((item: any) => item.itemKey === this.service.limitKeys2.weight)[0].itemValue;
        const maxVolume = res.filter((item: any) => item.itemKey === this.service.limitKeys2.volume)[0].itemValue;
        const maxTrainNumber = res.filter((item: any) => item.itemKey === this.service.limitKeys2.trainNumber)[0].itemValue;
        const maxFreight = res.filter((item: any) => item.itemKey === this.service.limitKeys2.freight)[0].itemValue;
        this.limitValues = {
          maxMonth: Number(maxMonth),
          maxWeight: Number(maxWeight),
          maxVolume: Number(maxVolume),
          maxTrainNumber: Number(maxTrainNumber),
          maxFreight: Number(maxFreight)
        }
      })
    }
}
