BookingHeChuan/Myshipping.Application/Service/BookingOrder/BookingMSKAPIService.cs

using Furion.FriendlyException;
using Furion.JsonSerialization;
using Furion.RemoteRequest.Extensions;
using Furion;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Myshipping.Application.Entity;
using Myshipping.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Furion.DynamicApiController;
using Furion.DependencyInjection;
using Myshipping.Core.Service;
using Microsoft.Extensions.Logging;

namespace Myshipping.Application.Service.BookingOrder
{
    /// <summary>
    /// 马士基API订舱
    /// </summary>
    [ApiDescriptionSettings("Application", Name = "BookingMSKAPI", Order = 10)]
    public class BookingMSKAPIService: IBookingMSKAPIService, IDynamicApiController, ITransient
    {
        private readonly SqlSugarRepository<BookingDeliveryRecord> _bookingDeliveryRecordRep;
        private readonly SqlSugarRepository<BookingDeliveryRecordCtn> _bookingDeliveryRecordCtnRep;
        private readonly ISysCacheService _cache;
        private readonly IDjyWebsiteAccountConfigService _webAccountConfig;
        private readonly ILogger<BookingMSKAPIService> _logger;

        const string CONST_MSK_API_COMMODITY_URL = "MSKApiCommodity";
        const string CONST_MSK_API_BOOKING_URL = "MSKApiBooking";
        const string CONST_MSK_API_Poing2P_SECD_URL = "MSKApiSailingSchedulePoint2Point";
        const string CONST_MSK_API_LOCATION_URL = "MSKApilocation";

        public BookingMSKAPIService(ILogger<BookingMSKAPIService> logger, ISysCacheService cache, 
            IDjyWebsiteAccountConfigService webAccountConfig, SqlSugarRepository<BookingDeliveryRecord> bookingDeliveryRecordRep,
            SqlSugarRepository<BookingDeliveryRecordCtn> bookingDeliveryRecordCtnRep)
        {
            _logger = logger;
            _cache = cache;
            _webAccountConfig = webAccountConfig;
            _bookingDeliveryRecordRep = bookingDeliveryRecordRep;
            _bookingDeliveryRecordCtnRep = bookingDeliveryRecordCtnRep;

        }

        #region 检索海运船期详情
        /// <summary>
        /// 检索海运船期详情
        /// </summary>
        /// <param name="model">请求船期详情</param>
        /// <returns>返回船期结果</returns>
        [HttpPost("/BookingOrder/SearchShipSailingSchedule")]
        public async Task<List<SearchShipSailingScheduleResultDto>> SearchShipSailingSchedule(QueryShipSailingScheduleDto model)
        {
            List<SearchShipSailingScheduleResultDto> list = new List<SearchShipSailingScheduleResultDto>();

            /*
             MSKApiSailingSchedulePoint2Point
             */
            try
            {
                if (string.IsNullOrWhiteSpace(model.collectionOriginCityName))
                    throw Oops.Oh($"始发地不能为空");

                if (string.IsNullOrWhiteSpace(model.deliveryDestinationCityName))
                    throw Oops.Oh($"目的地不能为空");

                if (string.IsNullOrWhiteSpace(model.vesselOperatorCarrierCode))
                    throw Oops.Oh($"服务船公司不能为空");

                if (string.IsNullOrWhiteSpace(model.carrierId))
                    throw Oops.Oh("船公司代码不能为空");

                if (string.IsNullOrWhiteSpace(model.startDate))
                    throw Oops.Oh($"预计离港日期不能为空");

                DateTime etd = DateTime.MinValue;

                if (!DateTime.TryParse(model.startDate, out etd))
                    throw Oops.Oh($"预计离港日期格式错误");

                string queryUrl = string.Empty;

                if (model.carrierId.Equals("MSK", StringComparison.OrdinalIgnoreCase))
                {
                    queryUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                        .FirstOrDefault(x => x.TypeCode == "url_set" && x.Code == CONST_MSK_API_Poing2P_SECD_URL)?.Value;
                }
                else
                {
                    throw Oops.Oh($"当前船公司 {model.carrierId} 未配置相应的请求接口");
                }

                if (string.IsNullOrWhiteSpace(queryUrl))
                    throw Oops.Oh("未配置查询船期请求接口地址，请联系管理员");

                var webAccountConfig = _webAccountConfig
                    .GetAccountConfig("MSKApi", UserManager.UserId).GetAwaiter().GetResult();

                if (webAccountConfig == null)
                    throw Oops.Oh("未配置个人账户，请先配置个人账户 类型-MSKApi");

                MSKAPISearchPoint2PointScheduleDto queryInfo = new MSKAPISearchPoint2PointScheduleDto
                {
                    userKey = App.Configuration["MSKAPIDjyUserKey"],
                    userSecret = App.Configuration["MSKAPIDjyUserSecret"],
                    operatingEnvironment = App.Configuration["MSKAPIOPEnvironment"],
                    mskAppKey = webAccountConfig.Account,
                    collectionOriginCityName = model.collectionOriginCityName,
                    collectionOriginCountryCode = model.collectionOriginCountryCode,
                    deliveryDestinationCityName = model.deliveryDestinationCityName,
                    deliveryDestinationCountryCode = model.deliveryDestinationCountryCode,
                    cargoType = model.cargoType,
                    exportServiceMode = model.exportServiceMode,
                    importServiceMode = model.importServiceMode,
                    vesselOperatorCarrierCode = model.vesselOperatorCarrierCode,
                    startDate = etd.ToString("yyyy-MM-dd"),
                    startDateType = "D",
                };

                MSKAPISearchPoint2PointScheduleResultDto resultInfo = null;

                var rlt = await queryUrl.SetBody(queryInfo)
                 .PostAsStringAsync();

                if (!string.IsNullOrWhiteSpace(rlt))
                {
                    try
                    {
                        resultInfo = JSON.Deserialize<MSKAPISearchPoint2PointScheduleResultDto>(rlt);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation($"请求MSK API查询船期异常，原因：{ex.Message}");

                        throw Oops.Bah($"请求MSK API查询船期异常，原因：{ex.Message}");
                    }
                }

                if (resultInfo != null && resultInfo.code == 200
                    && resultInfo.data != null && resultInfo.data.Count > 0)
                {
                    resultInfo.data.ForEach(a =>
                    {
                        a.transportSchedules.ForEach(b =>
                        {
                            SearchShipSailingScheduleResultDto info = new SearchShipSailingScheduleResultDto
                            {
                                carrierProductId = a.carrierProductId,
                                carrierProductSequenceId = a.carrierProductSequenceId,
                                ETD = b.departureDateTime,
                                ATD = b.arrivalDateTime,
                                vesselOperatorCarrierCode = b.vesselOperatorCarrierCode
                            };

                            if (b.departureDateTime.HasValue && b.arrivalDateTime.HasValue)
                            {
                                TimeSpan ts = b.arrivalDateTime.Value.Subtract(b.departureDateTime.Value);
                                var timeDiff = ts.TotalHours;

                                info.days = (int)Math.Ceiling(timeDiff / 24.0);
                            }

                            if (b.facilities != null)
                            {
                                info.orignCityName = b.facilities.collectionOrigin?.cityName;
                                info.orignCarrierSiteGeoID = b.facilities.collectionOrigin?.carrierSiteGeoID;
                                info.orignLocationName = b.facilities.collectionOrigin?.locationName;
                                info.orignCountryCode = b.facilities.collectionOrigin?.countryCode;
                                info.orignLocationType = b.facilities.collectionOrigin?.locationType;
                                info.orignUNLocationCode = b.facilities.collectionOrigin?.UNLocationCode;
                                info.orignUNRegionCode = b.facilities.collectionOrigin?.UNRegionCode;

                                info.deliveryCityName = b.facilities.deliveryDestination?.cityName;
                                info.deliveryCarrierSiteGeoID = b.facilities.deliveryDestination?.carrierSiteGeoID;
                                info.deliveryLocationName = b.facilities.deliveryDestination?.locationName;
                                info.deliveryCountryCode = b.facilities.deliveryDestination?.countryCode;
                                info.deliveryLocationType = b.facilities.deliveryDestination?.locationType;
                                info.deliveryUNLocationCode = b.facilities.deliveryDestination?.UNLocationCode;
                                info.deliveryUNRegionCode = b.facilities.deliveryDestination?.UNRegionCode;
                            }

                            info.vesselIMONumber = b.firstDepartureVessel?.vesselIMONumber;
                            info.carrierVesselCode = b.firstDepartureVessel?.carrierVesselCode;
                            info.vesselName = b.firstDepartureVessel?.vesselName;

                            if (b.transportLegs != null && b.transportLegs.Count > 0)
                            {
                                var firstTransportLegs = b.transportLegs.FirstOrDefault();

                                if (firstTransportLegs.transport != null)
                                {
                                    info.transportMode = firstTransportLegs.transport.transportMode;
                                    info.carrierDepartureVoyageNumber = firstTransportLegs.transport.carrierDepartureVoyageNumber;
                                }

                            }

                            list.Add(info);
                        });
                    });
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"检索海运船期详情异常，req={JSON.Serialize(model)} 原因：{ex.Message}");

                throw Oops.Bah($"检索海运船期详情失败，{ex.Message}");
            }

            return list;
        }
        #endregion

        #region 发送马士基订舱请求
        /// <summary>
        /// 发送马士基订舱请求
        /// </summary>
        /// <param name="model">请求订舱详情</param>
        /// <returns></returns>
        [HttpPost("/BookingOrder/SendMSKBooking")]
        public async Task<MSKBookingResultDto> SendMSKBooking(MSKBookingDto model)
        {
            MSKBookingResultDto result = new MSKBookingResultDto();

            /*
             MSKApiBooking
             */
            try
            {
                if (string.IsNullOrWhiteSpace(model.carrierCode))
                    throw Oops.Oh($"服务船公司不能为空");

                if (string.IsNullOrWhiteSpace(model.carrierId))
                    throw Oops.Oh("船公司代码不能为空");

                string sendUrl = string.Empty;

                if (model.carrierId.Equals("MSK", StringComparison.OrdinalIgnoreCase))
                {
                    sendUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                        .FirstOrDefault(x => x.TypeCode == "url_set" && x.Code == CONST_MSK_API_BOOKING_URL)?.Value;
                }
                else
                {
                    throw Oops.Oh($"当前船公司 {model.carrierId} 未配置相应的请求接口");
                }

                if (string.IsNullOrWhiteSpace(sendUrl))
                    throw Oops.Oh("未配置发送订舱请求接口地址，请联系管理员");

                var webAccountConfig = _webAccountConfig
                    .GetAccountConfig("MSKApi", UserManager.UserId).GetAwaiter().GetResult();

                if (webAccountConfig == null)
                    throw Oops.Oh("未配置个人账户，请先配置个人账户 类型-MSKApi");

                DateTime nowDate = DateTime.Now;

                var recordInfo = model.Adapt<BookingDeliveryRecord>();
                var recordCtnList = model.ctns.Adapt<List<BookingDeliveryRecordCtn>>();

                MSKAPIBookingDto bookingDto = new MSKAPIBookingDto
                {
                    userKey = App.Configuration["MSKAPIDjyUserKey"],
                    userSecret = App.Configuration["MSKAPIDjyUserSecret"],
                    operatingEnvironment = App.Configuration["MSKAPIOPEnvironment"],
                    mskAppKey = webAccountConfig.Account,
                    bookingBody = new MSKAPIBookingBodyDto()
                };

                bookingDto.bookingBody.references = new MSKAPIBookingReferenceDto
                {
                    priceReference = model.priceReference,
                    productCode = model.productCode,
                    sender = model.sender,
                };

                bookingDto.bookingBody.mandatoryParties = new MSKAPIBookingMandatoryParties
                {
                    bookedByCompanyName = model.bookedByCompanyName,
                    bookedByMaerskPartyCode = model.bookedByMaerskPartyCode,
                    bookedByPartyContact = new MSKAPIBookingMandatoryPartyContact
                    {
                        name = model.bookedByCompanyContactName,
                        email = model.bookedByCompanyContactEmail
                    },
                    priceOwnerCompanyName = model.priceOwnerCompanyName,
                    priceOwnerMaerskPartyCode = model.priceOwnerMaerskPartyCode,
                    priceOwnerPartyContact = new MSKAPIBookingMandatoryPartyContact
                    {
                        name = model.priceOwnerContactName,
                        email = model.priceOwnerContactEmail
                    },
                };

                bookingDto.bookingBody.transport = new MSKAPIBookingTransport
                {
                    carrierCode = model.carrierCode,
                    earliestDepartureDate = model.earliestDepartureDate,
                    exportServiceMode = model.exportServiceMode,
                    importServiceMode = model.importServiceMode,
                    routeDetails = new MSKAPIBookingRouteDetails
                    {
                        placeOfReceipt = new MSKAPIBookingRouteDetailsBase
                        {
                            UNLocationCode = model.placeOfReceiptUnLocCode,
                            cityName = model.placeOfReceiptCityName,
                        },
                        placeOfDelivery = new MSKAPIBookingRouteDetailsBase
                        {
                            UNLocationCode = model.placeOfDeliveryUnLocCode,
                            cityName = model.placeOfDeliveryCityName,
                        },
                        selectedRoute = new MSKAPIBookingRoute
                        {
                            bookingSchedules = new MSKAPIBookingSchedules
                            {
                                originDepartureDateTimeLocal = model.originDepartureDateTimeLocal.Value.ToString("yyyy-MM-dd"),
                                destinationArrivalDateTimeLocal = model.destinationArrivalDateTimeLocal.Value.ToString("yyyy-MM-dd"),
                                transportMode = new MSKAPIBookingTransportMode
                                {
                                    vessel = new MSKAPIBookingTransportModeVessel
                                    {
                                        name = model.vesselName,
                                        maerskVesselCode = model.carrierVesselCode,
                                    },
                                    exportVoyageNumber = model.exportVoyageNumber,
                                },
                                startLocation = new MSKAPIBookingRouteDetailsBase
                                {
                                    cityName = model.placeOfReceiptCityName,
                                    UNLocationCode = model.placeOfReceiptUnLocCode
                                },
                                endLocation = new MSKAPIBookingRouteDetailsBase
                                {
                                    cityName = model.placeOfDeliveryCityName,
                                    UNLocationCode = model.placeOfDeliveryUnLocCode
                                },
                                transportModeCode = model.transportMode
                            }
                        },
                    }
                };

                bookingDto.bookingBody.cargo = new MSKAPIBookingCargo
                {
                    commodityCode = model.commodityCode,
                    commodityCodeType = "MaerskCode",
                    cargoType = model.cargoType,
                    totalCargoWeight = model.totalCargoWeight
                };

                //是否冷冻处理
                if (model.isReefer)
                {
                    bookingDto.bookingBody.cargo.reeferSettings = new MSKAPIBookingCargoReeferSettings();

                    bookingDto.bookingBody.cargo.reeferSettings.temperatureDetails = model.temperature;
                    bookingDto.bookingBody.cargo.reeferSettings.temperatureMeasureUnit = "C";

                    bookingDto.bookingBody.cargo.reeferSettings.noOfProbes = model.noOfProbes;

                    //每小时需要的通风量，单位为立方米(0-285)
                    bookingDto.bookingBody.cargo.reeferSettings.ventilation = model.ventilation;

                    bookingDto.bookingBody.cargo.reeferSettings.humidity = model.humidity;
                }

                bookingDto.bookingBody.equipmentAndHaulage = new List<MSKAPIBookingEquipmentAndHaulage>();

                if (model.ctns != null && model.ctns.Count > 0)
                {
                    model.ctns.ForEach(ctn =>
                    {
                        MSKAPIBookingEquipmentAndHaulage haulage = new MSKAPIBookingEquipmentAndHaulage
                        {
                            equipmentDetails = new MSKAPIBookingEquipmentAndHaulageItem(),
                            stuffingDetails = new List<MSKAPIBookingStuffingdetails>()
                        };

                        haulage.equipmentDetails.ISOEquipmentCode = ctn.ctnCode;
                        haulage.equipmentDetails.equipmentQuantity = ctn.ctnNum;

                        haulage.stuffingDetails.Add(new MSKAPIBookingStuffingdetails
                        {
                            stuffingValue = (int)ctn.ctnSufferWeight.Value,
                            stuffingMeasurementType = "WEIGHT",
                            stuffingMeasurementUnit = "KGS"
                        });

                        bookingDto.bookingBody.equipmentAndHaulage.Add(haulage);
                    });
                }

                recordInfo.CreatedTime = nowDate;
                recordInfo.UpdatedTime = nowDate;
                recordInfo.CreatedUserId = UserManager.UserId;
                recordInfo.CreatedUserName = UserManager.Name;

                _bookingDeliveryRecordRep.Insert(recordInfo);

                if (recordCtnList.Count > 0)
                {
                    recordCtnList.ForEach(async x =>
                    {
                        x.RECORD_ID = recordInfo.Id;
                        x.CreatedTime = nowDate;
                        x.UpdatedTime = nowDate;
                        x.CreatedUserId = UserManager.UserId;
                        x.CreatedUserName = UserManager.Name;

                        await _bookingDeliveryRecordCtnRep.InsertAsync(x);
                    });
                }

                MSKAPIBookingResultDto resultInfo = null;

                var rlt = await sendUrl.SetBody(bookingDto)
                 .PostAsStringAsync();

                if (!string.IsNullOrWhiteSpace(rlt))
                {
                    try
                    {
                        resultInfo = JSON.Deserialize<MSKAPIBookingResultDto>(rlt);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation($"请求MSK API订舱异常，原因：{ex.Message}");

                        throw Oops.Bah($"请求MSK API订舱异常，原因：{ex.Message}");
                    }
                }

                var entity = _bookingDeliveryRecordRep
                    .FirstOrDefault(a => a.Id == recordInfo.Id);

                if (resultInfo != null && resultInfo.code == 200
                    && resultInfo.data != null)
                {
                    entity.REQUEST_ACKNOWLEDGEMENT_ID = resultInfo.data.requestAcknowledgementId;
                    entity.BOOKING_REFERENCE = resultInfo.data.bookingReference;
                    entity.STATUS = "SUCC";

                    await _bookingDeliveryRecordRep.AsUpdateable(entity).UpdateColumns(x => new
                    {
                        x.REQUEST_ACKNOWLEDGEMENT_ID,
                        x.BOOKING_REFERENCE,
                        x.STATUS
                    }).ExecuteCommandAsync();
                }
                else
                {
                    entity.STATUS = "SUCC";
                    entity.NOTES = resultInfo.msg.Length > 500 ? resultInfo.msg.Substring(0, 500) : resultInfo.msg;

                    await _bookingDeliveryRecordRep.AsUpdateable(entity).UpdateColumns(x => new
                    {
                        x.STATUS,
                        x.NOTES
                    }).ExecuteCommandAsync();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"MSK API订舱异常，req={JSON.Serialize(model)} 原因：{ex.Message}");

                throw Oops.Bah($"MSK API订舱失败，{ex.Message}");
            }

            return result;
        }
        #endregion

        #region 检索商品名称
        /// <summary>
        /// 检索商品名称
        /// </summary>
        /// <param name="model">请求详情</param>
        /// <returns>返回检索结果</returns>
        [HttpPost("/BookingOrder/SearchCommodities")]
        public async Task<List<SearchCommodityResultDto>> SearchCommodities(QueryCommoditiesDto model)
        {
            List<SearchCommodityResultDto> list = new List<SearchCommodityResultDto>();

            /*
             MSKApiCommodity
             */
            try
            {
                if (string.IsNullOrWhiteSpace(model.commodityName))
                    throw Oops.Oh("商品名称不能为空");

                if (string.IsNullOrWhiteSpace(model.carrierId))
                    throw Oops.Oh("船公司代码不能为空");

                if (model.commodityName.Length < 3)
                    throw Oops.Oh("商品名称至少输入3个以上字符");

                string queryUrl = string.Empty;

                if (model.carrierId.Equals("MSK", StringComparison.OrdinalIgnoreCase))
                {
                    queryUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                        .FirstOrDefault(x => x.TypeCode == "url_set" && x.Code == CONST_MSK_API_COMMODITY_URL)?.Value;
                }
                else
                {
                    throw Oops.Oh($"当前船公司 {model.carrierId} 未配置相应的请求接口");
                }

                if (string.IsNullOrWhiteSpace(queryUrl))
                    throw Oops.Oh("未配置商品请求接口地址，请联系管理员");

                var webAccountConfig = _webAccountConfig
                    .GetAccountConfig("MSKApi", UserManager.UserId).GetAwaiter().GetResult();

                if (webAccountConfig == null)
                    throw Oops.Oh("未配置个人账户，请先配置个人账户 类型-MSKApi");

                MSKAPISearchCommodityDto queryInfo = new MSKAPISearchCommodityDto
                {
                    userKey = App.Configuration["MSKAPIDjyUserKey"],
                    userSecret = App.Configuration["MSKAPIDjyUserSecret"],
                    operatingEnvironment = App.Configuration["MSKAPIOPEnvironment"],
                    commodityName = model.commodityName,
                    mskAppKey = webAccountConfig.Account
                };

                MSKAPISearchCommodityResultDto resultInfo = null;

                var rlt = await queryUrl.SetBody(queryInfo)
                 .PostAsStringAsync();

                if (!string.IsNullOrWhiteSpace(rlt))
                {
                    try
                    {
                        resultInfo = JSON.Deserialize<MSKAPISearchCommodityResultDto>(rlt);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation($"请求MSK API检索商品异常，原因：{ex.Message}");

                        throw Oops.Bah($"请求MSK API检索商品异常，原因：{ex.Message}");
                    }
                }

                if (resultInfo != null && resultInfo.code == 200
                    && resultInfo.data != null && resultInfo.data.Count > 0)
                {
                    list = resultInfo.data.Adapt<List<SearchCommodityResultDto>>();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"检索商品名称异常，req={JSON.Serialize(model)} 原因：{ex.Message}");

                throw Oops.Bah($"检索商品名称失败，{ex.Message}");
            }

            return list;
        }
        #endregion

        #region 检索始发地、目的港口信息
        /// <summary>
        /// 检索始发地、目的港口信息
        /// </summary>
        /// <param name="model">请求详情</param>
        /// <returns>返回检索结果</returns>
        [HttpPost("/BookingOrder/SearchLocations")]
        public async Task<List<QueryLocationsResultDto>> SearchLocations(QueryLocationsDto model)
        {
            List<QueryLocationsResultDto> list = new List<QueryLocationsResultDto>();

            /*
             MSKApiCommodity
             */
            try
            {
                if (string.IsNullOrWhiteSpace(model.cityName))
                    throw Oops.Oh("港口或城市名称不能为空");

                if (string.IsNullOrWhiteSpace(model.carrierCode))
                    throw Oops.Oh("服务船公司不能为空");

                if (string.IsNullOrWhiteSpace(model.carrierId))
                    throw Oops.Oh("船公司代码不能为空");

                if (model.cityName.Length < 3)
                    throw Oops.Oh("港口或城市名称至少输入3个以上字符");


                string queryUrl = string.Empty;

                if (model.carrierId.Equals("MSK", StringComparison.OrdinalIgnoreCase))
                {
                    queryUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                        .FirstOrDefault(x => x.TypeCode == "url_set" && x.Code == CONST_MSK_API_LOCATION_URL)?.Value;
                }
                else
                {
                    throw Oops.Oh($"当前船公司 {model.carrierId} 未配置相应的请求接口");
                }

                if (string.IsNullOrWhiteSpace(queryUrl))
                    throw Oops.Oh("未配置商品请求接口地址，请联系管理员");

                var webAccountConfig = _webAccountConfig
                    .GetAccountConfig("MSKApi", UserManager.UserId).GetAwaiter().GetResult();

                if (webAccountConfig == null)
                    throw Oops.Oh("未配检索始发地、目的港口，请先配置个人账户 类型-MSKApi");

                MSKAPISearchLocationDto queryInfo = new MSKAPISearchLocationDto
                {
                    userKey = App.Configuration["MSKAPIDjyUserKey"],
                    userSecret = App.Configuration["MSKAPIDjyUserSecret"],
                    operatingEnvironment = App.Configuration["MSKAPIOPEnvironment"],
                    name = model.cityName,
                    mskAppKey = webAccountConfig.Account,
                    carrierCode = model.carrierCode
                };

                MSKAPISearchLocationResultDto resultInfo = null;

                var rlt = await queryUrl.SetBody(queryInfo)
                 .PostAsStringAsync();

                if (!string.IsNullOrWhiteSpace(rlt))
                {
                    try
                    {
                        resultInfo = JSON.Deserialize<MSKAPISearchLocationResultDto>(rlt);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogInformation($"请求MSK API检索始发地、目的港口异常，原因：{ex.Message}");

                        throw Oops.Bah($"请求MSK API检索始发地、目的港口异常，原因：{ex.Message}");
                    }
                }

                if (resultInfo != null && resultInfo.code == 200
                    && resultInfo.data != null && resultInfo.data.Count > 0)
                {
                    list = resultInfo.data.Adapt<List<QueryLocationsResultDto>>();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"检索始发地、目的港口异常，req={JSON.Serialize(model)} 原因：{ex.Message}");

                throw Oops.Bah($"检索始发地、目的港口失败，{ex.Message}");
            }

            return list;
        }
        #endregion
    }
}