BookingHeChuan/Myshipping.Application/Service/TaskManagePlat/TaskManageService.cs

using Furion;
using Furion.DependencyInjection;
using Furion.DistributedIDGenerator;
using Furion.DynamicApiController;
using Furion.Extensions;
using Furion.FriendlyException;
using Furion.JsonSerialization;
using Furion.Localization;
using Furion.Logging.Extensions;
using Furion.RemoteRequest;
using Furion.RemoteRequest.Extensions;
using HtmlAgilityPack;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.Extensions.Logging;
using Myshipping.Application.EDI;
using Myshipping.Application.Entity;
using Myshipping.Application.Entity.TaskManagePlat;
using Myshipping.Application.Helper;
using Myshipping.Application.Service.BookingOrder;
using Myshipping.Application.Service.BookingSlot.Dto;
using Myshipping.Application.Service.ExpressDelivery.Dto.SF;
using Myshipping.Application.Service.TaskManagePlat.Interface;
using Myshipping.Core;
using Myshipping.Core.Const;
using Myshipping.Core.Entity;
using Myshipping.Core.Helper;
using Myshipping.Core.Service;
using MySqlX.XDevAPI.Common;
using NetTaste;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Npoi.Mapper;
using NPOI.HPSF;
using NPOI.HSSF.UserModel;
using NPOI.OpenXmlFormats;
using NPOI.OpenXmlFormats.Dml.Diagram;
using NPOI.OpenXmlFormats.Wordprocessing;
using NPOI.POIFS.Crypt.Dsig;
using NPOI.SS.Formula.Atp;
using NPOI.SS.Formula.Eval;
using NPOI.SS.Formula.Functions;
using NPOI.SS.UserModel;
using NPOI.Util;
using NPOI.XSSF.Model;
using NPOI.XSSF.UserModel;
using Org.BouncyCastle.Asn1.Tsp;
using Org.BouncyCastle.Asn1.X500;
using Org.BouncyCastle.Asn1.X9;
using SixLabors.ImageSharp.Processing.Processors.Transforms;
using SqlSugar;
using StackExchange.Profiling.Internal;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.DirectoryServices.ActiveDirectory;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.InteropServices;
using System.Security.Policy;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using static Aliyun.OSS.Model.CreateSelectObjectMetaInputFormatModel;
using static Aliyun.OSS.Model.ListPartsResult;

namespace Myshipping.Application
{
    /// <summary>
    /// 任务管理
    /// </summary>
    [ApiDescriptionSettings("Application", Name = "TaskManage", Order = 10)]
    public class TaskManageService : ITaskManageService, IDynamicApiController, ITransient
    {
        private readonly SqlSugarRepository<TaskBaseInfo> _taskBaseInfoRepository;
        private readonly SqlSugarRepository<TaskSISubmitted> _taskSISubmittedRepository;
        private readonly SqlSugarRepository<TaskSISubmittedCtn> _taskSISubmittedCtnRepository;
        private readonly SqlSugarRepository<TaskBillFeeDetailInfo> _taskBillFeeDetailInfoRepository;
        private readonly SqlSugarRepository<TaskFileInfo> _taskFileInfoRepository;
        private readonly SqlSugarRepository<TaskEmailInfo> _taskEmailInfoRepository;
        private readonly SqlSugarRepository<TaskVGMInfo> _taskVGMInfoRepository;
        private readonly SqlSugarRepository<TaskVGMCtnInfo> _taskVGMCtnInfoRepository;
        private readonly SqlSugarRepository<BookingCtnVGM> _bookingCtnVGMRepository;
        private readonly SqlSugarRepository<SysUser> _sysUserRepository;
        private readonly SqlSugarRepository<TaskStatManageInfo> _taskStatManageInfoRepository;
        private readonly SqlSugarRepository<TaskOriginalDownloadHisInfo> _taskOriginalDownloadHisInfoRepository;
        private readonly SqlSugarRepository<TaskChargesHisInfo> _taskChargesHisInfoRepository;
        private readonly SqlSugarRepository<TaskLARAPaperInfo> _taskLARAPaperInfoRepository;
        private readonly SqlSugarRepository<TaskPerBillBaseInfo> _taskPerBillBaseInfoRepository;
        private readonly SqlSugarRepository<TaskStoreMsgInfo> _taskStoreMsgInfoRepository;
        private readonly SqlSugarRepository<TaskChangeShipHisInfo> _taskChangeShipHisInfoRepository;
        private readonly SqlSugarRepository<TaskBCInfo> _taskBCInfoRepository;
        private readonly SqlSugarRepository<TaskBCCTNInfo> _taskBCCTNInfoRepository;
        private readonly SqlSugarRepository<BookingSlotBase> _bookingSlotBaseRepository;

        private readonly SqlSugarRepository<BookingOrder> _bookingOrderRepository;
        private readonly SqlSugarRepository<BookingCtn> _bookingOrderContaRepository;
        private readonly SqlSugarRepository<BookingCtnDetail> _bookingOrderContaCargoRepository;
        private readonly SqlSugarRepository<BookingStatus> _bookingStatusRepository;
        private readonly SqlSugarRepository<BookingOrderContact> _bookingOrderContactRepository;

        private readonly SqlSugarRepository<DjyUserMailAccount> _djyUserMailAccountRepository;
        private readonly SqlSugarRepository<TaskTruckInfo> _taskTruckInfoRepository;
        private readonly SqlSugarRepository<TaskTruckCtn> _taskTruckCtnRepository;

        private readonly SqlSugarRepository<TaskCutDateChangeInfo> _taskCutDateChangeInfoRepository;
        private readonly SqlSugarRepository<TaskCutDateChangeDetailInfo> _taskCutDateChangeDetailInfoRepository;
        private readonly SqlSugarRepository<TaskRollingNominationInfo> _taskRollingNominationInfoRepository;
        private readonly SqlSugarRepository<TaskRollingNominationShipInfo> _taskRollingNominationShipInfoRepository;
        private readonly SqlSugarRepository<TaskRollingNominationDetailInfo> _taskRollingNominationDetailInfoRepository;
        private readonly SqlSugarRepository<TaskDraftInfo> _taskDraftInfoRepository;
        private readonly SqlSugarRepository<TaskPODDischargeGateoutFullInfo> _taskPODDischargeGateoutFullInfoRepository;
        private readonly SqlSugarRepository<TaskPODDischargeGateoutFullDetailInfo> _taskPODDischargeGateoutFullDetailInfoRepository;

        private readonly SqlSugarRepository<TaskCautionNoticeInfo> _taskCautionNoticeInfoRepository;
        private readonly SqlSugarRepository<TaskCautionNoticeDetailInfo> _taskCautionNoticeDetailInfoRepository;

        private readonly SqlSugarRepository<TaskRouteChangeAdvisoryInfo> _taskRouteChangeAdvisoryInfoRepository;
        private readonly SqlSugarRepository<TaskRouteChangeAdvisoryDetailInfo> _taskRouteChangeAdvisoryDetailInfoRepository;

        private readonly SqlSugarRepository<TaskTransPlanHasChangeInfo> _taskTransPlanHasChangeInfoRepository;
        private readonly SqlSugarRepository<TaskTransPlanHasChangeDetailInfo> _taskTransPlanHasChangeDetailInfoRepository;

        private readonly SqlSugarRepository<TaskPOLContainerNotPickUpInfo> _taskPOLContainerNotPickUpInfoRepository;

        private readonly SqlSugarRepository<TaskFlowTenant> _taskFlowTenant;



        private readonly IDjyWebsiteAccountConfigService _webAccountConfig;
        private readonly ISysCacheService _cache;
        private readonly ILogger<BookingOrderService> _logger;
        private readonly ISysDataUserMenu _sysDataUserMenuService;

        private readonly INamedServiceProvider<IBookingOrderService> _namedBookingOrderServiceProvider;
        private readonly INamedServiceProvider<ITaskManageRollingNominationService> _namedRollingNominationServiceProvider;
        private readonly INamedServiceProvider<ITaskManageBCService> _namedTaskManageBCServiceProvider;
        private readonly INamedServiceProvider<IBookingMSKAPIService> _namedBookingMSKAPIServiceProvider;
        private readonly INamedServiceProvider<ITaskManageSISubmittedService> _namedtaskSISubmittedServiceProvider;
        private readonly INamedServiceProvider<ITaskCautionNoticeService> _namedTaskCautionNoticeServiceProvider;
        private readonly INamedServiceProvider<ITaskTransPlanHasChangeService> _namedTaskTransPlanHasChangeServiceProvider;
        private readonly INamedServiceProvider<ITaskPOLContainerNotPickUpService> _namedTaskPOLContainerNotPickUpServiceProvider;
        private readonly INamedServiceProvider<ITaskManageCutDateChangeService> _namedTaskManageCutDateChangeServiceProvider;
        private readonly INamedServiceProvider<IRouteChangeAdvisoryService> _namedRouteChangeAdvisoryServiceServiceProvider;
        private readonly INamedServiceProvider<IBookingLabelService> _namedBookingLabelServiceServiceProvider;
        private readonly INamedServiceProvider<ITaskManagePODDischargeGateoutFullService> _namedPODDischargeGateoutFullProvider;
        private readonly INamedServiceProvider<ITaskManageVGMService> _namedVGMServiceProvider;

        private readonly IBookingValueAddedService _bookingValueAddedService;

        const string CONST_WEB_ACCOUNT_TYPE = "CmaWeb";
        const string CONST_BOOK_ORIGINAL_DOWN_URL_CODE = "bookOriginalDownUrl";

        const string CONST_WEB_LARA_ACCOUNT_TYPE = "LaraWeb";
        const string CONST_LARA_DOWN_URL_CODE = "LaraPaperPostUrl";

        const string CONST_MAPPING_MODULE = "YunJia";

        //LARA纸计算常量
        const int LARA_PARER_DRAFT_VAR = 3;
        private readonly BookingOrderAutoService _bookingOrderAuto;

        public TaskManageService(SqlSugarRepository<TaskBaseInfo> taskBaseInfoRepository,
            SqlSugarRepository<TaskSISubmitted> taskSISubmittedRepository,
            SqlSugarRepository<TaskSISubmittedCtn> taskSISubmittedCtnRepository,
            SqlSugarRepository<TaskBillFeeDetailInfo> taskBillFeeDetailInfoRepository,
            SqlSugarRepository<TaskFileInfo> taskFileInfoRepository,
            SqlSugarRepository<TaskEmailInfo> taskEmailInfoRepository,
            SqlSugarRepository<TaskVGMInfo> taskVGMInfoRepository,
            SqlSugarRepository<TaskVGMCtnInfo> taskVGMCtnInfoRepository,
            SqlSugarRepository<SysUser> sysUserRepository,
            SqlSugarRepository<TaskStatManageInfo> taskStatManageInfoRepository,
            SqlSugarRepository<TaskOriginalDownloadHisInfo> taskOriginalDownloadHisInfoRepository,
            SqlSugarRepository<TaskChargesHisInfo> taskChargesHisInfoRepository,
            SqlSugarRepository<BookingOrder> bookingOrderRepository,
            SqlSugarRepository<TaskLARAPaperInfo> taskLARAPaperInfoRepository,
            SqlSugarRepository<BookingCtn> bookingOrderContaRepository,
            SqlSugarRepository<BookingCtnDetail> bookingOrderContaCargoRepository,
            SqlSugarRepository<BookingStatus> bookingStatusRepository,
            SqlSugarRepository<DjyUserMailAccount> djyUserMailAccountRepository,
            SqlSugarRepository<TaskPerBillBaseInfo> taskPerBillBaseInfoRepository,
            SqlSugarRepository<TaskStoreMsgInfo> taskStoreMsgInfoRepository,
            SqlSugarRepository<TaskChangeShipHisInfo> taskChangeShipHisInfoRepository,
            SqlSugarRepository<BookingOrderContact> bookingOrderContactRepository,
            SqlSugarRepository<TaskTruckInfo> taskTruckInfoRepository,
            SqlSugarRepository<TaskTruckCtn> taskTruckCtnRepository,
            SqlSugarRepository<TaskBCInfo> taskBCInfoRepository,
            SqlSugarRepository<TaskBCCTNInfo> taskBCCTNInfoRepository,
            SqlSugarRepository<TaskCutDateChangeInfo> taskCutDateChangeInfoRepository,
            SqlSugarRepository<TaskCutDateChangeDetailInfo> taskCutDateChangeDetailInfoRepository,
            SqlSugarRepository<TaskRollingNominationInfo> taskRollingNominationInfoRepository,
            SqlSugarRepository<TaskRollingNominationShipInfo> taskRollingNominationShipInfoRepository,
            SqlSugarRepository<TaskRollingNominationDetailInfo> taskRollingNominationDetailInfoRepository,
            SqlSugarRepository<BookingCtnVGM> bookingCtnVGMRepository,
            SqlSugarRepository<BookingSlotBase> bookingSlotBaseRepository,
            SqlSugarRepository<TaskDraftInfo> taskDraftInfoRepository,
            SqlSugarRepository<TaskPODDischargeGateoutFullInfo> taskPODDischargeGateoutFullInfoRepository,
            SqlSugarRepository<TaskPODDischargeGateoutFullDetailInfo> taskPODDischargeGateoutFullDetailInfoRepository,
            SqlSugarRepository<TaskCautionNoticeInfo> taskCautionNoticeInfoRepository,
            SqlSugarRepository<TaskCautionNoticeDetailInfo> taskCautionNoticeDetailInfoRepository,
            SqlSugarRepository<TaskRouteChangeAdvisoryInfo> taskRouteChangeAdvisoryInfoRepository,
            SqlSugarRepository<TaskRouteChangeAdvisoryDetailInfo> taskRouteChangeAdvisoryDetailInfoRepository,
            SqlSugarRepository<TaskTransPlanHasChangeInfo> taskTransPlanHasChangeInfoRepository,
            SqlSugarRepository<TaskTransPlanHasChangeDetailInfo> taskTransPlanHasChangeDetailInfoRepository,
            SqlSugarRepository<TaskPOLContainerNotPickUpInfo> taskPOLContainerNotPickUpInfoRepository,
            INamedServiceProvider<IBookingOrderService> namedBookingOrderServiceProvider,
            IDjyWebsiteAccountConfigService webAccountConfig,
            ISysCacheService cache,
            ISysDataUserMenu sysDataUserMenuService,
            INamedServiceProvider<ITaskManageRollingNominationService> namedRollingNominationServiceProvider,
            INamedServiceProvider<ITaskManageBCService> namedTaskManageBCServiceProvider,
            IBookingValueAddedService bookingValueAddedService,
            INamedServiceProvider<IBookingMSKAPIService> namedBookingMSKAPIServiceProvider,
            INamedServiceProvider<ITaskManageSISubmittedService> namedtaskSISubmittedServiceProvider,
            INamedServiceProvider<ITaskCautionNoticeService> namedTaskCautionNoticeServiceProvider,
            INamedServiceProvider<ITaskTransPlanHasChangeService> namedTaskTransPlanHasChangeServiceProvider,
            INamedServiceProvider<ITaskPOLContainerNotPickUpService> namedTaskPOLContainerNotPickUpServiceProvider,
            INamedServiceProvider<ITaskManageCutDateChangeService> namedTaskManageCutDateChangeServiceProvider,
            INamedServiceProvider<IRouteChangeAdvisoryService> namedRouteChangeAdvisoryServiceServiceProvider,
            INamedServiceProvider<IBookingLabelService> namedBookingLabelServiceServiceProvider,
            INamedServiceProvider<ITaskManagePODDischargeGateoutFullService> namedPODDischargeGateoutFullProvider,
            INamedServiceProvider<ITaskManageVGMService> namedVGMServiceProvider,
            ILogger<BookingOrderService> logger, BookingOrderAutoService bookingOrderAuto,
               SqlSugarRepository<TaskFlowTenant> taskFlowTenant)
        {
            _taskBaseInfoRepository = taskBaseInfoRepository;
            _taskSISubmittedRepository = taskSISubmittedRepository;
            _taskSISubmittedCtnRepository = taskSISubmittedCtnRepository;
            _taskBillFeeDetailInfoRepository = taskBillFeeDetailInfoRepository;
            _taskFileInfoRepository = taskFileInfoRepository;
            _taskEmailInfoRepository = taskEmailInfoRepository;
            _taskVGMInfoRepository = taskVGMInfoRepository;
            _taskVGMCtnInfoRepository = taskVGMCtnInfoRepository;
            _sysUserRepository = sysUserRepository;
            _taskStatManageInfoRepository = taskStatManageInfoRepository;
            _taskOriginalDownloadHisInfoRepository = taskOriginalDownloadHisInfoRepository;
            _taskChargesHisInfoRepository = taskChargesHisInfoRepository;
            _bookingOrderRepository = bookingOrderRepository;
            _taskLARAPaperInfoRepository = taskLARAPaperInfoRepository;
            _bookingOrderContaRepository = bookingOrderContaRepository;
            _bookingOrderContaCargoRepository = bookingOrderContaCargoRepository;
            _bookingStatusRepository = bookingStatusRepository;
            _djyUserMailAccountRepository = djyUserMailAccountRepository;
            _taskPerBillBaseInfoRepository = taskPerBillBaseInfoRepository;
            _taskStoreMsgInfoRepository = taskStoreMsgInfoRepository;
            _taskChangeShipHisInfoRepository = taskChangeShipHisInfoRepository;
            _bookingOrderContactRepository = bookingOrderContactRepository;
            _taskTruckInfoRepository = taskTruckInfoRepository;
            _taskTruckCtnRepository = taskTruckCtnRepository;
            _taskBCInfoRepository = taskBCInfoRepository;
            _taskBCCTNInfoRepository = taskBCCTNInfoRepository;
            _taskCutDateChangeInfoRepository = taskCutDateChangeInfoRepository;
            _taskCutDateChangeDetailInfoRepository = taskCutDateChangeDetailInfoRepository;
            _taskRollingNominationInfoRepository = taskRollingNominationInfoRepository;
            _taskRollingNominationShipInfoRepository = taskRollingNominationShipInfoRepository;
            _taskRollingNominationDetailInfoRepository = taskRollingNominationDetailInfoRepository;
            _bookingCtnVGMRepository = bookingCtnVGMRepository;

            _namedBookingOrderServiceProvider = namedBookingOrderServiceProvider;
            _namedRollingNominationServiceProvider = namedRollingNominationServiceProvider;
            _bookingValueAddedService = bookingValueAddedService;
            _namedTaskManageBCServiceProvider = namedTaskManageBCServiceProvider;
            _namedtaskSISubmittedServiceProvider = namedtaskSISubmittedServiceProvider;
            _namedTaskCautionNoticeServiceProvider = namedTaskCautionNoticeServiceProvider;

            _sysDataUserMenuService = sysDataUserMenuService;

            _webAccountConfig = webAccountConfig;
            _cache = cache;

            _logger = logger;

            _bookingSlotBaseRepository = bookingSlotBaseRepository;
            _taskDraftInfoRepository = taskDraftInfoRepository;
            _taskPODDischargeGateoutFullInfoRepository = taskPODDischargeGateoutFullInfoRepository;
            _taskPODDischargeGateoutFullDetailInfoRepository = taskPODDischargeGateoutFullDetailInfoRepository;

            _namedBookingMSKAPIServiceProvider = namedBookingMSKAPIServiceProvider;

            _taskCautionNoticeInfoRepository = taskCautionNoticeInfoRepository;
            _taskCautionNoticeDetailInfoRepository = taskCautionNoticeDetailInfoRepository;

            _taskRouteChangeAdvisoryInfoRepository = taskRouteChangeAdvisoryInfoRepository;
            _taskRouteChangeAdvisoryDetailInfoRepository = taskRouteChangeAdvisoryDetailInfoRepository;

            _taskTransPlanHasChangeInfoRepository = taskTransPlanHasChangeInfoRepository;
            _taskTransPlanHasChangeDetailInfoRepository = taskTransPlanHasChangeDetailInfoRepository;
            _namedTaskTransPlanHasChangeServiceProvider = namedTaskTransPlanHasChangeServiceProvider;
            _taskPOLContainerNotPickUpInfoRepository = taskPOLContainerNotPickUpInfoRepository;
            _namedTaskPOLContainerNotPickUpServiceProvider = namedTaskPOLContainerNotPickUpServiceProvider;
            _namedTaskManageCutDateChangeServiceProvider = namedTaskManageCutDateChangeServiceProvider;
            _namedRouteChangeAdvisoryServiceServiceProvider = namedRouteChangeAdvisoryServiceServiceProvider;
            _bookingOrderAuto = bookingOrderAuto;
            _taskFlowTenant = taskFlowTenant;

            _namedBookingLabelServiceServiceProvider = namedBookingLabelServiceServiceProvider;
            _namedPODDischargeGateoutFullProvider = namedPODDischargeGateoutFullProvider;
            _namedVGMServiceProvider = namedVGMServiceProvider;
        }

        #region 创建任务
        /// <summary>
        /// 创建任务
        /// </summary>
        /// <param name="info">任务详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/TaskManage/CreateTaskJob"), AllowAnonymous, ApiUser(ApiCode = "BCTaskManage")]
        public async Task<TaskManageOrderResultDto> CreateTaskJob(TaskManageOrderMessageInfo info)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} 接收到创建任务报文 报文={msg}", batchNo, JSON.Serialize(info));

            try
            {
                result = await InitTaskJob(info, batchNo);
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"请求任务异常,{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 新增任务
        /// <summary>
        /// 新增任务
        /// </summary>
        /// <param name="info">任务详情</param>
        /// <param name="batchNo">批次号</param>
        /// <param name="file">文件</param>
        /// <param name="modifyFile">变更文件内容后的文件</param>
        /// <returns>返回回执</returns>
        [SqlSugarUnitOfWork]
        private async Task<TaskManageOrderResultDto> InitTaskJob(TaskManageOrderMessageInfo info,string batchNo, IFormFile file = null, IFormFile modifyFile = null)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                _logger.LogInformation("批次={no} 接收到创建任务报文 开始查询任务 OUT_BUSI_NO={out}", batchNo, $"{info.Head.SenderId}_{info.Head.GID}");

                var taskInfo = _taskBaseInfoRepository.AsQueryable().OrderByDescending(a=>a.CreatedTime)
                    .First(t => t.OUT_BUSI_NO == $"{info.Head.SenderId}_{info.Head.GID}");

                _logger.LogInformation("批次={no} 接收到创建任务报文 结束查询任务 {msg}", batchNo, taskInfo == null ? "不存在" : "存在");
                /*
                 只要任务最后一次处理任务的状态是已取消、已完成，就可以重入新的任务
                 */
                if (taskInfo != null && taskInfo.STATUS != TaskStatusEnum.Cancel.ToString() && taskInfo.STATUS != TaskStatusEnum.Complete.ToString())
                {
                    _logger.LogInformation("批次={no} 状态已存在，不能重复创建任务 status={status}", batchNo, taskInfo.STATUS);

                    throw Oops.Oh($"状态已存在，不能重复创建任务");
                }

                //如果文件路径不为空 判断文件是否真实存在
                if (!string.IsNullOrWhiteSpace(info.Main.FilePath) && !File.Exists(info.Main.FilePath))
                {
                    throw Oops.Oh(string.Format("{0}文件不存在", info.Main.FilePath));
                }

                //如果文件路径不为空 判断文件是否真实存在
                if (!string.IsNullOrWhiteSpace(info.Main.ModifyFile) && !File.Exists(info.Main.ModifyFile))
                {
                    throw Oops.Oh(string.Format("{0}文件不存在", info.Main.ModifyFile));
                }


                taskInfo = new TaskBaseInfo
                {
                    PK_ID = IDGen.NextID().ToString(),
                    STATUS = TaskStatusEnum.Create.ToString(),
                    IsDeleted = false,
                    IS_EXCEPT = 0,
                    IS_COMPLETE = 0,
                    MBL_NO = info.Main.MBlNo,
                    TASK_BASE_TYPE = info.Main.TaskType.ToString(),
                    CARRIER_ID = info.Main.CarrierId?.Trim(),
                    IS_PUBLIC = string.IsNullOrWhiteSpace(info.Main.TaskUserId) ? 1 : 0,
                    BOOK_ORDER_NO = info.Main.BookingOrderNo,
                    OUT_BUSI_NO = $"{info.Head.SenderId}_{info.Head.GID}",
                    TASK_TITLE = info.Main.TaskTitle,
                    TASK_DESP = info.Main.TaskDesp,
                    TASK_SOURCE = info.Main.TaskSource.ToString(),
                    TASK_TYPE = info.Main.TaskType.ToString(),
                    VESSEL_VOYNO = info.Main.VesselVoyno?.Trim(),
                    CONTA_INFO = info.Main.ContaInfo,
                    TASK_REQ_USERNAME = info.Main.TaskUserName,
                    YARD_NAME = info.Main.YardName,
                    ETD = info.Main.ETD,
                    CUSTOMER_ID = info.Main.CustomerId,
                    CUSTOMER_NAME = info.Main.CustomerName,
                    BATCH_STATIC = info.Main.BatchStatic,
                    DJYUserId = info.Head.DJYUserId,
                    SYSTEM_CODE = info.Main.SYSTEM_CODE,
                    SYSTEM_NAME = info.Main.SYSTEM_NAME,

                };

                long taskReqUserId = 0;

                if (!string.IsNullOrWhiteSpace(info.Main.TaskUserId))
                {
                    if (long.TryParse(info.Main.TaskUserId, out taskReqUserId))
                    {
                        taskInfo.TASK_REQ_USERID = taskReqUserId;
                    }
                }

                UserTendDto userTendInfo = null;

                //如果大简云用户ID不为空，接收人为空时，通过大简云用户ID关联订舱人ID
                if (UserManager.UserId != null)
                {
                    //这里只有派车不是公共任务，其他基本都是公共任务
                    if (info.Main.TaskType == TaskBaseTypeEnum.TRUCK_DISPATCH)
                    {
                        userTendInfo = GetUserTendInfo(info.Main.RecvUserId);

                        taskInfo.IS_PUBLIC = 0;
                    }
                    else if (info.Main.TaskType == TaskBaseTypeEnum.CAUTION_NOTICE)
                    {
                        userTendInfo = GetUserTendInfo(info.Main.TaskUserId);

                        taskInfo.IS_PUBLIC = 0;
                    }
                    else
                    {
                        userTendInfo = new UserTendDto
                        {
                            userId = UserManager.UserId,
                            userName = UserManager.Name,
                            tendId = UserManager.TENANT_ID,
                            tenantName = UserManager.TENANT_NAME
                        };

                        if (info.Main.TaskType != TaskBaseTypeEnum.CAUTION_NOTICE)
                        {
                            taskInfo.IS_PUBLIC = 1;
                        }
                    }
                }
                else if (!string.IsNullOrWhiteSpace(info.Main.DJYRecvUserId) && string.IsNullOrWhiteSpace(info.Main.TaskUserId))
                {
                    userTendInfo = GetUserTendInfoByDJYUserId(info.Main.DJYRecvUserId, info.Main.DJYRecvUserEmail);

                    if (userTendInfo != null)
                    {
                        taskInfo.IS_PUBLIC = 0;
                    }
                }
                else if (string.IsNullOrWhiteSpace(info.Main.DJYRecvUserId) && string.IsNullOrWhiteSpace(info.Main.TaskUserId) &&
                    !string.IsNullOrWhiteSpace(info.Main.TaskRecvEmail) && info.Main.TaskTenatId.HasValue && info.Main.TaskTenatId.Value > 0)
                {
                    userTendInfo = GetUserTendInfoByEmail(info.Main.TaskTenatId.Value, info.Main.TaskRecvEmail);

                    if (userTendInfo != null)
                    {
                        taskInfo.IS_PUBLIC = 1;
                    }
                }
                else
                {
                    userTendInfo = GetUserTendInfo(info.Main.RecvUserId);
                }
                

                taskInfo.CreatedUserId = userTendInfo.userId;
                taskInfo.CreatedUserName = userTendInfo.userName;
                taskInfo.TenantId = userTendInfo.tendId;
                taskInfo.TenantName = userTendInfo.tenantName;

                _logger.LogInformation("批次={no} 获取登录人详情 userid={userid} userinfo={userinfo}", batchNo, 
                    info.Main.RecvUserId, 
                    JSON.Serialize(userTendInfo));

                taskInfo.CreatedTime = DateTime.Now;
                taskInfo.UpdatedTime = taskInfo.CreatedTime;

                if (!string.IsNullOrWhiteSpace(taskInfo.CARRIER_ID)
                    && taskInfo.CARRIER_ID == "MSC")
                {
                    if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                        taskInfo.TASK_TYPE = TaskBusiTypeEnum.MSC_BC.ToString();

                    if (taskInfo.IS_EXCEPT == 1)
                        taskInfo.TASK_TYPE = TaskBusiTypeEnum.MSC_EXCEPT.ToString();
                }

                if (info.Main != null && info.Main.TruckInfo != null && info.Main.TruckInfo.NeedArriveTime.HasValue)
                {
                    taskInfo.NeedArriveTime = info.Main.TruckInfo.NeedArriveTime;
                }

                //新增
                _taskBaseInfoRepository.Insert(taskInfo);


                if (!string.IsNullOrWhiteSpace( info.Main.FilePath))
                {
                    string attachFileType = string.Empty;
                    string fileCategory = string.Empty;

                    if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "bcfiles";

                        fileCategory = TaskFileCategoryEnum.BC.ToString();
                    }
                    else if (TaskBaseTypeEnum.BC_MODIFY.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "bcmodifyfiles";

                        fileCategory = TaskFileCategoryEnum.BC_MODIFY.ToString();
                    }
                    else if (TaskBaseTypeEnum.CANCELLATION.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "bccancelfiles";

                        fileCategory = TaskFileCategoryEnum.BC_CANCEL.ToString();
                    }
                    else if (TaskBaseTypeEnum.DRAFT.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "draftfiles";

                        fileCategory = TaskFileCategoryEnum.DRAFT.ToString();
                    }
                    else if (TaskBaseTypeEnum.SI_FEEDBACK.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "sisubmittedfiles";

                        fileCategory = TaskFileCategoryEnum.SI_SUBMITTED.ToString();
                    }
                    else if (TaskBaseTypeEnum.ROUTE_CUT_CHANGE.ToString() == taskInfo.TASK_BASE_TYPE)
                    {
                        attachFileType = "advisoryfiles";

                        fileCategory = TaskFileCategoryEnum.ADVISORY.ToString();
                    }

                    if (info.Main.FileList == null)
                    {
                        info.Main.FileList = new List<TaskManageOrderFileInfo>();
                    }
                    info.Main.FileList.Add(new TaskManageOrderFileInfo
                    {
                        PKId = IDGen.NextID().ToString(),
                        FileName = Path.GetFileName(info.Main.FilePath),
                        FileType = Path.GetExtension(info.Main.FilePath).ToLower(),
                        FilePath = info.Main.FilePath,
                        FileCategory = fileCategory
                    });

                }
                else
                { 
                    if (file != null)
                    {
                        var bytes = file.ToByteArray();

                        string attachFileType = string.Empty;
                        string fileCategory = string.Empty;

                        if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bcfiles";

                            fileCategory = TaskFileCategoryEnum.BC.ToString();
                        }
                        else if (TaskBaseTypeEnum.BC_MODIFY.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bcmodifyfiles";

                            fileCategory = TaskFileCategoryEnum.BC_MODIFY.ToString();
                        }
                        else if (TaskBaseTypeEnum.CANCELLATION.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bccancelfiles";

                            fileCategory = TaskFileCategoryEnum.BC_CANCEL.ToString();
                        }
                        else if (TaskBaseTypeEnum.DRAFT.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "draftfiles";

                            fileCategory = TaskFileCategoryEnum.DRAFT.ToString();
                        }
                        else if (TaskBaseTypeEnum.SI_FEEDBACK.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "sisubmittedfiles";

                            fileCategory = TaskFileCategoryEnum.SI_SUBMITTED.ToString();
                        }
                        else if (TaskBaseTypeEnum.ROUTE_CUT_CHANGE.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "advisoryfiles";

                            fileCategory = TaskFileCategoryEnum.ADVISORY.ToString();
                        }

                        var noExtensionFileName = Path.GetFileNameWithoutExtension(file.FileName);
                        var fileFullName = await FileAttachHelper.SaveFile(taskInfo.PK_ID, bytes, batchNo, noExtensionFileName,
                            GetFileType(file.FileName), attachFileType);

                        if (!string.IsNullOrWhiteSpace(fileFullName))
                        {
                            if (info.Main.FileList == null)
                            {
                                info.Main.FileList = new List<TaskManageOrderFileInfo>();
                            }

                            info.Main.FileList.Add(new TaskManageOrderFileInfo
                            {
                                PKId = IDGen.NextID().ToString(),
                                FileName = file.FileName,
                                FileType = Path.GetExtension(file.FileName).ToLower(),
                                FilePath = fileFullName,
                                FileCategory = fileCategory
                            });
                        }
                    }
                }


                if (!string.IsNullOrWhiteSpace(info.Main.ModifyFile))
                {

                    string fileCategory = string.Empty;

                    if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                        fileCategory = TaskFileCategoryEnum.BC_NOTICE.ToString();

                    else if (TaskBaseTypeEnum.BC_MODIFY.ToString() == taskInfo.TASK_BASE_TYPE)
                        fileCategory = TaskFileCategoryEnum.BC_MODIFY_NOTICE.ToString();

                    else if (TaskBaseTypeEnum.CANCELLATION.ToString() == taskInfo.TASK_BASE_TYPE)
                        fileCategory = TaskFileCategoryEnum.BC_CANCEL_NOTICE.ToString();

                    else if (TaskBaseTypeEnum.DRAFT.ToString() == taskInfo.TASK_BASE_TYPE)
                        fileCategory = TaskFileCategoryEnum.DRAFT_NOTICE.ToString();

                    if (info.Main.FileList == null)
                        info.Main.FileList = new List<TaskManageOrderFileInfo>();

                    info.Main.FileList.Add(new TaskManageOrderFileInfo
                    {
                        PKId = IDGen.NextID().ToString(),
                        FileName = Path.GetFileName(info.Main.ModifyFile),
                        FileType = Path.GetExtension(info.Main.ModifyFile).ToLower(),
                        FilePath = info.Main.FilePath,
                        FileCategory = fileCategory
                    });
                }
                else
                {
                    if (modifyFile != null)
                    {
                        var bytes = modifyFile.ToByteArray();

                        string attachFileType = string.Empty;
                        string fileCategory = string.Empty;

                        if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bcnoticefiles";

                            fileCategory = TaskFileCategoryEnum.BC_NOTICE.ToString();

                        }
                        else if (TaskBaseTypeEnum.BC_MODIFY.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bcmodifynoticefiles";

                            fileCategory = TaskFileCategoryEnum.BC_MODIFY_NOTICE.ToString();
                        }
                        else if (TaskBaseTypeEnum.CANCELLATION.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "bccancelnoticefiles";

                            fileCategory = TaskFileCategoryEnum.BC_CANCEL_NOTICE.ToString();
                        }
                        else if (TaskBaseTypeEnum.DRAFT.ToString() == taskInfo.TASK_BASE_TYPE)
                        {
                            attachFileType = "draftnoticefiles";

                            fileCategory = TaskFileCategoryEnum.DRAFT_NOTICE.ToString();
                        }

                        var noExtensionFileName = Path.GetFileNameWithoutExtension(modifyFile.FileName);
                        var fileFullName = await FileAttachHelper.SaveFile(taskInfo.PK_ID, bytes, batchNo, noExtensionFileName,
                            GetFileType(modifyFile.FileName), attachFileType);

                        if (!string.IsNullOrWhiteSpace(fileFullName))
                        {
                            if (info.Main.FileList == null)
                            {
                                info.Main.FileList = new List<TaskManageOrderFileInfo>();
                            }

                            info.Main.FileList.Add(new TaskManageOrderFileInfo
                            {
                                PKId = IDGen.NextID().ToString(),
                                FileName = modifyFile.FileName,
                                FileType = Path.GetExtension(modifyFile.FileName).ToLower(),
                                FilePath = fileFullName,
                                FileCategory = fileCategory
                            });
                        }
                    }
                }

              

                #region 附件
                //附件
                if (info.Main.FileList != null && info.Main.FileList.Count > 0)
                {
                    info.Main.FileList.ForEach(async file =>
                    {
                        var fileInfo = new TaskFileInfo();

                        fileInfo.PK_ID = IDGen.NextID().ToString();
                        fileInfo.TASK_PKID = taskInfo.PK_ID;

                        fileInfo.CreatedTime = taskInfo.CreatedTime;
                        fileInfo.UpdatedTime = taskInfo.CreatedTime;

                        fileInfo.CreatedUserId = taskInfo.CreatedUserId;
                        fileInfo.CreatedUserName = taskInfo.CreatedUserName;
                        fileInfo.TenantId = taskInfo.TenantId;
                        fileInfo.TenantName = taskInfo.TenantName;

                        fileInfo.FILE_PATH = file.FilePath;
                        fileInfo.FILE_NAME = file.FileName;
                        fileInfo.FILE_TYPE = file.FileType;

                        if (string.IsNullOrWhiteSpace(file.FileCategory))
                        {
                            if (TaskBaseTypeEnum.BC.ToString() == taskInfo.TASK_BASE_TYPE)
                            {
                                fileInfo.FILE_CATEGORY = TaskFileCategoryEnum.BC.ToString();
                                fileInfo.FILE_CATEGORY_NAME = TaskFileCategoryEnum.BC.GetDescription();
                            }
                            else if (TaskBaseTypeEnum.BC_MODIFY.ToString() == taskInfo.TASK_BASE_TYPE)
                            {
                                fileInfo.FILE_CATEGORY = TaskFileCategoryEnum.BC_MODIFY.ToString();
                                fileInfo.FILE_CATEGORY_NAME = TaskFileCategoryEnum.BC_MODIFY.GetDescription();
                            }
                        }
                        else
                        {
                            TaskFileCategoryEnum fileCategoryEnum = TaskFileCategoryEnum.NONE;

                            System.Enum.TryParse(file.FileCategory, out fileCategoryEnum);

                            fileInfo.FILE_CATEGORY = fileCategoryEnum.ToString();
                            fileInfo.FILE_CATEGORY_NAME = fileCategoryEnum.GetDescription();
                        }

                        if (string.IsNullOrWhiteSpace(fileInfo.FILE_NAME))
                        {
                            var fileModel = new FileInfo(file.FilePath);

                            fileInfo.FILE_NAME = fileModel.Name;
                            fileInfo.FILE_TYPE = fileModel.Extension?.Replace(".", "");
                        }

                        await _taskFileInfoRepository.InsertAsync(fileInfo);
                    });
                }
                #endregion

                #region 邮件
                //邮件
                if (info.Main.EmailList != null && info.Main.EmailList.Count > 0)
                {
                    info.Main.EmailList.ForEach(async email =>
                    {
                        var emailInfo = new TaskEmailInfo();

                        emailInfo.PK_ID = IDGen.NextID().ToString();
                        emailInfo.TASK_PKID = taskInfo.PK_ID;

                        emailInfo.CreatedTime = taskInfo.CreatedTime;
                        emailInfo.UpdatedTime = taskInfo.CreatedTime;

                        emailInfo.CreatedUserId = taskInfo.CreatedUserId;
                        emailInfo.CreatedUserName = taskInfo.CreatedUserName;
                        emailInfo.TenantId = taskInfo.TenantId;
                        emailInfo.TenantName = taskInfo.TenantName;

                        emailInfo.MAIL_PATH = email.MailPath;

                        await _taskEmailInfoRepository.InsertAsync(emailInfo);
                    });
                }
                #endregion

                #region SI反馈入库
                //SI反馈入库
                if (info.Main.TaskType == TaskBaseTypeEnum.SI_FEEDBACK)
                {
                    if (info.Main.SIFeedBack == null)
                        throw Oops.Oh($"任务类型={info.Main.TaskType.ToString()} SIFeedBack信息必传");

                    TaskSISubmitted taskSISubmitted = info.Main.SIFeedBack.Adapt<TaskSISubmitted>();

                    taskSISubmitted.PK_ID = IDGen.NextID().ToString();
                    taskSISubmitted.TASK_ID = taskInfo.PK_ID;

                    taskSISubmitted.CreatedTime = taskInfo.CreatedTime;
                    taskSISubmitted.UpdatedTime = taskInfo.CreatedTime;

                    taskSISubmitted.CreatedUserId = taskInfo.CreatedUserId;
                    taskSISubmitted.CreatedUserName = taskInfo.CreatedUserName;
                    taskSISubmitted.TenantId = taskInfo.TenantId;
                    taskSISubmitted.TenantName = taskInfo.TenantName;

                    _taskSISubmittedRepository.Insert(taskSISubmitted);


                    //SI反馈箱信息入库
                    if (info.Main.SIFeedBack.ContaList != null && info.Main.SIFeedBack.ContaList.Count > 0)
                    {
                        var ediCtnList = _cache.GetAllCodeCtn().GetAwaiter().GetResult();

                        info.Main.SIFeedBack.ContaList.ForEach(ctn =>
                        {
                            var contaInfo = ctn.Adapt<TaskSISubmittedCtn>();

                            contaInfo.PK_ID = IDGen.NextID().ToString();
                            contaInfo.P_PKID = taskSISubmitted.PK_ID;

                            contaInfo.CreatedTime = taskInfo.CreatedTime;
                            contaInfo.UpdatedTime = taskInfo.CreatedTime;

                            contaInfo.CreatedUserId = taskInfo.CreatedUserId;
                            contaInfo.CreatedUserName = taskInfo.CreatedUserName;
                            contaInfo.TenantId = taskInfo.TenantId;
                            contaInfo.TenantName = taskInfo.TenantName;

                            if (string.IsNullOrWhiteSpace(contaInfo.CTNCODE) && !string.IsNullOrWhiteSpace(contaInfo.CTNALL))
                            {
                                if (ediCtnList != null && ediCtnList.Count > 0)
                                {
                                    var ctnCodeInfo = ediCtnList.FirstOrDefault(x => !string.IsNullOrWhiteSpace(x.Name) 
                                        && x.Name.Equals(contaInfo.CTNALL, StringComparison.OrdinalIgnoreCase));

                                    if (ctnCodeInfo != null)
                                    {
                                        contaInfo.CTNCODE = ctnCodeInfo.Code;
                                    }
                                }
                            }

                            _taskSISubmittedCtnRepository.Insert(contaInfo);
                        });
                    }

                    var siService = _namedtaskSISubmittedServiceProvider
                        .GetService<ITransient>(nameof(TaskManageSISubmittedService));

                    await siService.ProcessSISubmitted(taskSISubmitted.TASK_ID);

                }
                #endregion

                #region 费用明细
                //费用明细
                if (info.Main.TaskType == TaskBaseTypeEnum.INVOICE_BILL_MAIL)
                {
                    if (info.Main.FeeList != null && info.Main.FeeList.Count > 0)
                    {
                        info.Main.FeeList.ForEach(async fee =>
                        {
                            var feeInfo = fee.Adapt<TaskBillFeeDetailInfo>();

                            feeInfo.PK_ID = IDGen.NextID().ToString();
                            feeInfo.TASK_PKID = taskInfo.PK_ID;

                            feeInfo.CreatedTime = taskInfo.CreatedTime;
                            feeInfo.UpdatedTime = taskInfo.CreatedTime;

                            feeInfo.CreatedUserId = taskInfo.CreatedUserId;
                            feeInfo.CreatedUserName = taskInfo.CreatedUserName;
                            feeInfo.TenantId = taskInfo.TenantId;
                            feeInfo.TenantName = taskInfo.TenantName;

                            await _taskBillFeeDetailInfoRepository.InsertAsync(feeInfo);
                        });
                    }
                }
                #endregion

                #region 单票账单
                if (info.Main.TaskType == TaskBaseTypeEnum.PER_BILL)
                {
                    TaskPerBillBaseInfo taskPerBillBaseInfo = info.Main.PerBillInfo.Adapt<TaskPerBillBaseInfo>();
                    //写入
                    await _taskPerBillBaseInfoRepository.InsertAsync(taskPerBillBaseInfo);

                    if (info.Main.FeeList != null && info.Main.FeeList.Count > 0)
                    {
                        info.Main.FeeList.ForEach(async fee =>
                        {
                            var feeInfo = fee.Adapt<TaskBillFeeDetailInfo>();

                            feeInfo.PK_ID = IDGen.NextID().ToString();
                            feeInfo.TASK_PKID = taskInfo.PK_ID;

                            feeInfo.CreatedTime = taskInfo.CreatedTime;
                            feeInfo.UpdatedTime = taskInfo.CreatedTime;

                            feeInfo.CreatedUserId = taskInfo.CreatedUserId;
                            feeInfo.CreatedUserName = taskInfo.CreatedUserName;
                            feeInfo.TenantId = taskInfo.TenantId;
                            feeInfo.TenantName = taskInfo.TenantName;

                            await _taskBillFeeDetailInfoRepository.InsertAsync(feeInfo);
                        });
                    }
                }
                #endregion

                #region 派车任务
                if (info.Main.TaskType == TaskBaseTypeEnum.TRUCK_DISPATCH)
                {
                    //派车任务
                    if (info.Main.TruckInfo == null)
                    {
                        throw Oops.Oh($"派车任务主信息不能为空，请查看请求报文");
                    }

                    var truckInfo = info.Main.TruckInfo.Adapt<TaskTruckInfo>();

                    truckInfo.PK_ID = IDGen.NextID().ToString();
                    truckInfo.TASK_ID = taskInfo.PK_ID;
                    truckInfo.BookingTruckId = info.Main.TruckInfo.Id;
                    truckInfo.CreatedTime = taskInfo.CreatedTime;
                    truckInfo.UpdatedTime = taskInfo.CreatedTime;

                    truckInfo.CreatedUserId = taskInfo.CreatedUserId;
                    truckInfo.CreatedUserName = taskInfo.CreatedUserName;
                    truckInfo.TenantId = taskInfo.TenantId;
                    truckInfo.TenantName = taskInfo.TenantName;
                    truckInfo.Status = BookingTruckStatus.TEMP.ToString();

                    //异步写入
                    await _taskTruckInfoRepository.InsertAsync(truckInfo);

                    if(info.Main.TruckInfo.ContaList != null && info.Main.TruckInfo.ContaList.Count > 0)
                    {
                        var contaList = info.Main.TruckInfo.ContaList.Adapt<List<TaskTruckCtn>>();

                        contaList.ForEach(async x =>
                        {
                            x.P_ID = truckInfo.PK_ID;
                            x.PK_ID = IDGen.NextID().ToString();

                            x.CreatedTime = taskInfo.CreatedTime;
                            x.UpdatedTime = taskInfo.CreatedTime;

                            x.CreatedUserId = taskInfo.CreatedUserId;
                            x.CreatedUserName = taskInfo.CreatedUserName;
                            x.TenantId = taskInfo.TenantId;
                            x.TenantName = taskInfo.TenantName;

                            await _taskTruckCtnRepository.InsertAsync(x);
                        });
                    }
                }
                #endregion

                #region BC 任务
                if (info.Main.TaskType == TaskBaseTypeEnum.BC || info.Main.TaskType == TaskBaseTypeEnum.BC_MODIFY 
                    || info.Main.TaskType == TaskBaseTypeEnum.CANCELLATION)
                {
                    //异步写入
                    var bcInfo = info.Main.BCInfo.Adapt<TaskBCInfo>();

                    bcInfo.PK_ID = IDGen.NextID().ToString();
                    bcInfo.TASK_ID = taskInfo.PK_ID;

                    bcInfo.CreatedTime = taskInfo.CreatedTime;
                    bcInfo.UpdatedTime = taskInfo.CreatedTime;

                    bcInfo.CreatedUserId = taskInfo.CreatedUserId;
                    bcInfo.CreatedUserName = taskInfo.CreatedUserName;
                    bcInfo.TenantId = taskInfo.TenantId;
                    bcInfo.TenantName = taskInfo.TenantName;

                    if (info.Main.BCInfo.BookingSlotId.HasValue && info.Main.BCInfo.BookingSlotId.Value > 0)
                        bcInfo.BOOKING_SLOT_ID = info.Main.BCInfo.BookingSlotId.Value;

                    await _taskBCInfoRepository.InsertAsync(bcInfo);

                    //异步写入集装箱
                    info.Main.BCInfo.CtnList.ForEach(async ctn =>
                    {
                        var bcCtnInfo = ctn.Adapt<TaskBCCTNInfo>();

                        bcCtnInfo.PK_ID = IDGen.NextID().ToString();
                        bcCtnInfo.P_ID = bcInfo.PK_ID;

                        bcInfo.CreatedTime = taskInfo.CreatedTime;
                        bcInfo.UpdatedTime = taskInfo.CreatedTime;

                        bcInfo.CreatedUserId = taskInfo.CreatedUserId;
                        bcInfo.CreatedUserName = taskInfo.CreatedUserName;
                        bcInfo.TenantId = taskInfo.TenantId;
                        bcInfo.TenantName = taskInfo.TenantName;

                        await _taskBCCTNInfoRepository.InsertAsync(bcCtnInfo);
                    });

                    /*
                     BC_MODIFY
                     1、检索对应舱位，提取比对差异结果
                     2、检索舱位对应的订舱信息，如果有则生成用户通知邮件
                     3、推送钉钉消息@操作人 通知收到变更
                     CANCELLATION
                     1、检索舱位对应的订舱信息，如果有则生成用户通知邮件
                     2、推送钉钉消息@操作人 通知收到变更
                     */

                    if (info.Main.TaskType == TaskBaseTypeEnum.BC)
                    {
                        var service = _namedBookingMSKAPIServiceProvider
                        .GetService<ITransient>(nameof(BookingMSKAPIService));

                        var synRlt = await service.SyncBCInfo(info.Main.BCInfo.MBLNo, taskInfo.TenantId.Value);

                        _logger.LogInformation($"入库完BC，自动推送状态到API订舱列表 mblno={info.Main.BCInfo.MBLNo} synRlt={JSON.Serialize(synRlt)}");
                    }
                    else if (info.Main.TaskType == TaskBaseTypeEnum.CANCELLATION)
                    {
                        var service = _namedBookingMSKAPIServiceProvider
                        .GetService<ITransient>(nameof(BookingMSKAPIService));

                        var synRlt = await service.SyncBCInfo(info.Main.BCInfo.MBLNo, taskInfo.TenantId.Value,"Cancellation");

                        _logger.LogInformation($"入库完BC，自动推送状态到API订舱列表 mblno={info.Main.BCInfo.MBLNo} synRlt={JSON.Serialize(synRlt)}");
                    }

                    if (info.Main.TaskType == TaskBaseTypeEnum.BC_MODIFY)
                    {
                        var name = _namedTaskManageBCServiceProvider
                        .GetService<ITransient>(nameof(TaskManageBCService));

                        await name.SyncBookingSlotChange(bcInfo.TASK_ID, bcInfo.TenantId.Value);
                    }


                    #region 自动化处理
                    if (taskInfo.CARRIER_ID =="CMA")
                    {
                        var flow = _taskFlowTenant.AsQueryable().Filter(null, true).Where(t => t.FlowCode == "CMABC" && t.IsMain == true &&t.TenantId== taskInfo.TenantId.Value).First();
                        if (flow!=null)
                        {
                            //方法请求参数
                            RecursiveMethodModel mt = new RecursiveMethodModel();
                            //TODO待完善请求参数
                            mt.parse_attachment = info.Main.parse_attachment;



                            RecursiveMethod(flow, 0, mt);
                        }
                     

                    }

                    
                     
                    #endregion
                }
                #endregion

                #region 截止时间变更通知
                if (info.Main.TaskType == TaskBaseTypeEnum.CUT_MODIFY)
                {
                    var cutInfo = info.Main.CutDateChange.Adapt<TaskCutDateChangeInfo>();

                    cutInfo.PK_ID = IDGen.NextID().ToString();
                    cutInfo.TASK_ID = taskInfo.PK_ID;

                    cutInfo.CreatedTime = taskInfo.CreatedTime;
                    cutInfo.UpdatedTime = taskInfo.CreatedTime;

                    cutInfo.CreatedUserId = taskInfo.CreatedUserId;
                    cutInfo.CreatedUserName = taskInfo.CreatedUserName;
                    cutInfo.TenantId = taskInfo.TenantId;
                    cutInfo.TenantName = taskInfo.TenantName;

                    _taskCutDateChangeInfoRepository.Insert(cutInfo);

                    if (info.Main.CutDateChange.Details != null && info.Main.CutDateChange.Details.Count > 0)
                    {
                        //异步写入明细
                        info.Main.CutDateChange.Details.ForEach(detail =>
                        {
                            var cutDetail = detail.Adapt<TaskCutDateChangeDetailInfo>();

                            cutDetail.PK_ID = IDGen.NextID().ToString();
                            cutDetail.P_ID = cutInfo.PK_ID;

                            cutDetail.CreatedTime = taskInfo.CreatedTime;
                            cutDetail.UpdatedTime = taskInfo.CreatedTime;

                            cutDetail.CreatedUserId = taskInfo.CreatedUserId;
                            cutDetail.CreatedUserName = taskInfo.CreatedUserName;
                            cutDetail.TenantId = taskInfo.TenantId;
                            cutDetail.TenantName = taskInfo.TenantName;

                            _taskCutDateChangeDetailInfoRepository.Insert(cutDetail);
                        });
                    }

                    //触发推送消息
                    var name = _namedTaskManageCutDateChangeServiceProvider
                        .GetService<ITransient>(nameof(TaskManageCutDateChangeService));

                    await name.AutoTransferNotice(taskInfo.PK_ID);
                }
                #endregion

                #region VGM回执或VGM未提交提醒
                if (info.Main.TaskType == TaskBaseTypeEnum.VGM_FEEDBACK 
                    || info.Main.TaskType == TaskBaseTypeEnum.VGM_MISSING)
                {
                    List<TaskVGMInfo> vgmList = new List<TaskVGMInfo>();

                    info.Main.VGMFeedBack.ForEach(p =>
                    {
                        //异步写入
                        var vgmInfo = p.Adapt<TaskVGMInfo>();

                        vgmInfo.PK_ID = IDGen.NextID().ToString();
                        vgmInfo.TASK_ID = taskInfo.PK_ID;

                        vgmInfo.CreatedTime = taskInfo.CreatedTime;
                        vgmInfo.UpdatedTime = taskInfo.CreatedTime;

                        vgmInfo.CreatedUserId = taskInfo.CreatedUserId;
                        vgmInfo.CreatedUserName = taskInfo.CreatedUserName;
                        vgmInfo.TenantId = taskInfo.TenantId;
                        vgmInfo.TenantName = taskInfo.TenantName;
                        vgmInfo.TASK_TYPE = info.Main.TaskType.ToString();

                        _taskVGMInfoRepository.InsertAsync(vgmInfo);

                        vgmList.Add(vgmInfo);

                        if (p.CtnList != null && p.CtnList.Count > 0)
                        {
                            //异步写入集装箱
                            p.CtnList.ForEach(ctn =>
                            {
                                var vgmCtnInfo = ctn.Adapt<TaskVGMCtnInfo>();

                                vgmCtnInfo.PK_ID = IDGen.NextID().ToString();
                                vgmCtnInfo.P_ID = vgmInfo.PK_ID;

                                vgmCtnInfo.CreatedTime = taskInfo.CreatedTime;
                                vgmCtnInfo.UpdatedTime = taskInfo.CreatedTime;

                                vgmCtnInfo.CreatedUserId = taskInfo.CreatedUserId;
                                vgmCtnInfo.CreatedUserName = taskInfo.CreatedUserName;
                                vgmCtnInfo.TenantId = taskInfo.TenantId;
                                vgmCtnInfo.TenantName = taskInfo.TenantName;

                                _taskVGMCtnInfoRepository.InsertAsync(vgmCtnInfo);
                            });
                        }
                    });

                    var mblNoList = info.Main.VGMFeedBack.Select(p => p.MBlNo).Distinct().ToList();
                    /*
                     1、入库完检索对应的订舱信息。
                     2、推送订舱相关的状态。
                     */
                    var bookingList = _bookingOrderRepository.AsQueryable().Filter(null, true)
                         .Where(x => mblNoList.Contains(x.MBLNO) && (x.ParentId == 0 || x.ParentId == null)
                         && x.IsDeleted == false && x.TenantId == taskInfo.TenantId).ToList();

                    if (bookingList.Count > 0)
                    {
                        vgmList.ForEach(vgmInfo =>
                        {
                            var bookingInfo = bookingList.FirstOrDefault(a =>
                                a.MBLNO.Equals(vgmInfo.MBL_NO, StringComparison.OrdinalIgnoreCase));

                            if (bookingInfo != null)
                            {
                                var vgmEntity = _taskVGMInfoRepository.AsQueryable().Filter(null, true)
                                .First(x => x.PK_ID == vgmInfo.PK_ID && x.IsDeleted == false && x.TenantId == taskInfo.TenantId);

                                vgmEntity.BOOKING_ID = bookingInfo.Id;

                                _taskVGMInfoRepository.AsUpdateable(vgmEntity).UpdateColumns(x => x.BOOKING_ID).ExecuteCommandAsync();

                                var ctnVGMList = _bookingCtnVGMRepository.AsQueryable().Filter(null, true)
                                    .Where(x => x.BILLID == bookingInfo.Id && x.IsDeleted == false && x.TenantId == taskInfo.TenantId).ToList();

                                var bookCtnList = _bookingOrderContaRepository.AsQueryable().Filter(null, true)
                                    .Where(x => x.BILLID == bookingInfo.Id && x.IsDeleted == false && x.TenantId == taskInfo.TenantId).ToList();

                                var ctnList = info.Main.VGMFeedBack
                                        .FirstOrDefault(x => x.MBlNo.Equals(vgmInfo.MBL_NO, StringComparison.OrdinalIgnoreCase)).CtnList;

                                if (info.Main.TaskType == TaskBaseTypeEnum.VGM_FEEDBACK)
                                {
                                    //推送状态
                                    var pushModel = new ModifyServiceProjectStatusDto
                                    {
                                        BookingId = bookingInfo.Id,
                                        SourceType = TrackingSourceTypeEnum.AUTO,
                                        StatusCodes = new List<ModifyServiceProjectStatusDetailDto> {
                                    new ModifyServiceProjectStatusDetailDto { StatusCode = "VGMCG" } }
                                    };

                                    var saveStatusRlt = _bookingValueAddedService.SaveServiceStatus(pushModel).GetAwaiter().GetResult();

                                    _logger.LogInformation("请求JSON={json} 异步推送服务状态完成，结果={rlt}", JSON.Serialize(pushModel), JSON.Serialize(saveStatusRlt));

                                    foreach (var ctn in ctnList)
                                    {
                                        var bookCtnVGM = ctnVGMList.FirstOrDefault(t => t.CNTRNO.Equals(ctn.CntrNo, StringComparison.OrdinalIgnoreCase));
                                        var bookCtn = bookCtnList.FirstOrDefault(t => t.CNTRNO.Equals(ctn.CntrNo, StringComparison.OrdinalIgnoreCase));

                                        if (bookCtnVGM != null)
                                        {
                                            //更新
                                            bookCtnVGM.UpdatedTime = taskInfo.CreatedTime;
                                            bookCtnVGM.UpdatedUserId = taskInfo.CreatedUserId;
                                            bookCtnVGM.UpdatedUserName = taskInfo.CreatedUserName;
                                            bookCtnVGM.IS_MISSING = false;
                                            bookCtnVGM.SUBMISSION_DEADLINE = null;

                                            _bookingCtnVGMRepository.AsUpdateable(bookCtnVGM).UpdateColumns(x => new
                                            {
                                                x.VGM_WEIGHT,
                                                x.VGM_WEIGHT_UNIT,
                                                x.VGM_METHOD,
                                                x.IS_MATCH,
                                                x.UpdatedTime,
                                                x.UpdatedUserId,
                                                x.UpdatedUserName
                                            }).ExecuteCommand();
                                        }
                                        else
                                        {
                                            //写入
                                            var bookingCtnVGM = new BookingCtnVGM
                                            {
                                                CNTRNO = ctn.CntrNo,
                                                BILLID = bookingInfo.Id,
                                                VGM_WEIGHT = ctn.VGMWeight,
                                                VGM_WEIGHT_UNIT = ctn.VGMWeightUnit,
                                                VGM_METHOD = ctn.VGMWeightMethod,
                                                IS_MATCH = bookCtn != null,
                                                CreatedTime = taskInfo.CreatedTime,
                                                UpdatedTime = taskInfo.CreatedTime,
                                                CreatedUserId = taskInfo.CreatedUserId,
                                                CreatedUserName = taskInfo.CreatedUserName,
                                                TenantId = taskInfo.TenantId,
                                                REC_TIME = vgmInfo.NOTICE_DATE
                                            };

                                            _bookingCtnVGMRepository.Insert(bookingCtnVGM);
                                        }
                                    }
                                }
                                else
                                {
                                    if (ctnList.Count > 0)
                                    {
                                        foreach (var ctn in ctnList)
                                        {
                                            var bookCtnVGM = ctnVGMList.FirstOrDefault(t => t.CNTRNO.Equals(ctn.CntrNo, StringComparison.OrdinalIgnoreCase));
                                            var bookCtn = bookCtnList.FirstOrDefault(t => t.CNTRNO.Equals(ctn.CntrNo, StringComparison.OrdinalIgnoreCase));

                                            if (bookCtnVGM == null)
                                            {
                                                //写入
                                                var bookingCtnVGM = new BookingCtnVGM
                                                {
                                                    CNTRNO = ctn.CntrNo,
                                                    BILLID = bookingInfo.Id,
                                                    VGM_WEIGHT = ctn.VGMWeight,
                                                    VGM_WEIGHT_UNIT = ctn.VGMWeightUnit,
                                                    VGM_METHOD = ctn.VGMWeightMethod,
                                                    IS_MATCH = bookCtn != null,
                                                    CreatedTime = taskInfo.CreatedTime,
                                                    UpdatedTime = taskInfo.CreatedTime,
                                                    CreatedUserId = taskInfo.CreatedUserId,
                                                    CreatedUserName = taskInfo.CreatedUserName,
                                                    TenantId = taskInfo.TenantId,
                                                    REC_TIME = vgmInfo.NOTICE_DATE,
                                                    IS_MISSING = true,
                                                    SUBMISSION_DEADLINE = vgmInfo.VGM_SUBMISSION_DEADLINE
                                                };

                                                _bookingCtnVGMRepository.Insert(bookingCtnVGM);
                                            }
                                        }
                                    }
                                }

                            }
                        });
                    }

                    //触发推送消息
                    var name = _namedVGMServiceProvider
                        .GetService<ITransient>(nameof(TaskManageVGMService));

                    await name.SendVGMMissingNotice(taskInfo.PK_ID);
                    

                }

                #endregion

                #region Rolling Nomination(预甩货通知)
                if (info.Main.TaskType == TaskBaseTypeEnum.ROLLING_NOMINATION || info.Main.TaskType == TaskBaseTypeEnum.TRANSFER_NOMINATION)
                {
                    var rollingNomination = info.Main.RollingNomination.Adapt<TaskRollingNominationInfo>();

                    rollingNomination.PK_ID = IDGen.NextID().ToString();
                    rollingNomination.TASK_ID = taskInfo.PK_ID;

                    rollingNomination.CreatedTime = taskInfo.CreatedTime;
                    rollingNomination.UpdatedTime = taskInfo.CreatedTime;

                    rollingNomination.CreatedUserId = taskInfo.CreatedUserId;
                    rollingNomination.CreatedUserName = taskInfo.CreatedUserName;
                    rollingNomination.TenantId = taskInfo.TenantId;
                    rollingNomination.TenantName = taskInfo.TenantName;

                    //这里把多条的预甩计划列表合并保存，展示时只需要用\n拆分返回给前端
                    if (info.Main.RollingNomination.RollingPlanList != null && info.Main.RollingNomination.RollingPlanList.Count > 0)
                    {
                        rollingNomination.PLAN_TXT = string.Join("\\n", info.Main.RollingNomination.RollingPlanList.ToArray());
                    }

                    await _taskRollingNominationInfoRepository.InsertAsync(rollingNomination);

                    if (info.Main.RollingNomination.From != null && info.Main.RollingNomination.From.Count > 0)
                    {
                        info.Main.RollingNomination.From.ForEach(k =>
                        {
                            var rollingNominationShip = k.Adapt<TaskRollingNominationShipInfo>();

                            rollingNominationShip.PK_ID = IDGen.NextID().ToString();
                            rollingNominationShip.TASK_ID = taskInfo.PK_ID;
                            rollingNominationShip.NOM_ID = rollingNomination.PK_ID;

                            rollingNominationShip.CreatedTime = taskInfo.CreatedTime;
                            rollingNominationShip.UpdatedTime = taskInfo.CreatedTime;

                            rollingNominationShip.CreatedUserId = taskInfo.CreatedUserId;
                            rollingNominationShip.CreatedUserName = taskInfo.CreatedUserName;
                            rollingNominationShip.TenantId = taskInfo.TenantId;
                            rollingNominationShip.TenantName = taskInfo.TenantName;

                            _taskRollingNominationShipInfoRepository.Insert(rollingNominationShip);

                        });
                    }

                    if (info.Main.RollingNomination.ToDetail != null && info.Main.RollingNomination.ToDetail.Count > 0)
                    {
                        var ctnCodeList = _cache.GetAllCodeCtn().GetAwaiter().GetResult().ToList();

                        info.Main.RollingNomination.ToDetail.ForEach(t =>
                        {
                            var rollingNominationShip = t.Adapt<TaskRollingNominationShipInfo>();

                            rollingNominationShip.PK_ID = IDGen.NextID().ToString();
                            rollingNominationShip.TASK_ID = taskInfo.PK_ID;
                            rollingNominationShip.NOM_ID = rollingNomination.PK_ID;

                            rollingNominationShip.CreatedTime = taskInfo.CreatedTime;
                            rollingNominationShip.UpdatedTime = taskInfo.CreatedTime;

                            rollingNominationShip.CreatedUserId = taskInfo.CreatedUserId;
                            rollingNominationShip.CreatedUserName = taskInfo.CreatedUserName;
                            rollingNominationShip.TenantId = taskInfo.TenantId;
                            rollingNominationShip.TenantName = taskInfo.TenantName;

                            _taskRollingNominationShipInfoRepository.Insert(rollingNominationShip);

                            if (t.NominationList != null && t.NominationList.Count > 0)
                            {
                                //这里直接批量检索订舱信息，如果有对应的提单号直接写入订舱主键

                                var billNoList = t.NominationList.Select(x => x.Shipment.ToUpper())
                                    .Distinct().ToArray();

                                var bookList = _bookingOrderRepository.AsQueryable().Filter(null, true)
                                    .Where(x => billNoList.Contains(x.MBLNO) && x.IsDeleted == false && x.TenantId == taskInfo.TenantId).ToList();

                                t.NominationList.ForEach(x =>
                                {
                                    var rollingNominationDetail = x.Adapt<TaskRollingNominationDetailInfo>();

                                    if (!string.IsNullOrWhiteSpace(rollingNominationDetail.CTNALL))
                                    {
                                        var ctnCode = ctnCodeList.FirstOrDefault(a => !string.IsNullOrWhiteSpace(a.Name) &&
                                            a.Name.Equals(rollingNominationDetail.CTNALL, StringComparison.OrdinalIgnoreCase));

                                        rollingNominationDetail.CTNCODE = ctnCode?.Code;
                                    }

                                    rollingNominationDetail.PK_ID = IDGen.NextID().ToString();
                                    rollingNominationDetail.NOM_SHIP_ID = rollingNominationShip.PK_ID;
                                    rollingNominationDetail.NOM_ID = rollingNomination.PK_ID;

                                    rollingNominationDetail.CreatedTime = taskInfo.CreatedTime;
                                    rollingNominationDetail.UpdatedTime = taskInfo.CreatedTime;

                                    rollingNominationDetail.CreatedUserId = taskInfo.CreatedUserId;
                                    rollingNominationDetail.CreatedUserName = taskInfo.CreatedUserName;
                                    rollingNominationDetail.TenantId = taskInfo.TenantId;
                                    rollingNominationDetail.TenantName = taskInfo.TenantName;

                                    var bookingInfo = bookList.FirstOrDefault(x =>
                                        x.MBLNO.Equals(rollingNominationDetail.SHIPMENT, StringComparison.OrdinalIgnoreCase));

                                    if (bookingInfo != null)
                                    {
                                        rollingNominationDetail.BOOKING_ID = bookingInfo.Id;
                                        rollingNominationDetail.CUSTOMERID = bookingInfo.CUSTOMERID;
                                        rollingNominationDetail.CUSTOMERNAME = bookingInfo.CUSTOMERNAME;
                                    }

                                    _taskRollingNominationDetailInfoRepository.Insert(rollingNominationDetail);

                                });
                            }

                        });
                    }

                    //异步生成调度
                    var rollNominationService = _namedRollingNominationServiceProvider
                        .GetService<ITransient>(nameof(TaskManageRollingNominationService));

                    var dispatchRlt = await rollNominationService.DispatchRollingNomination(new RollingNominationDispatchRequestDto { 
                        isAdd = true,
                        nominationId = rollingNomination.PK_ID
                    });
                }
                #endregion

                #region DRAFT转发客户
                if (info.Main.TaskType == TaskBaseTypeEnum.DRAFT)
                {
                    TaskDraftInfo taskDraftInfo = info.Main.DraftInfo.Adapt<TaskDraftInfo>();

                    taskDraftInfo.PK_ID = IDGen.NextID().ToString();
                    taskDraftInfo.TASK_ID = taskInfo.PK_ID;

                    taskDraftInfo.CreatedTime = taskInfo.CreatedTime;
                    taskDraftInfo.UpdatedTime = taskInfo.CreatedTime;

                    taskDraftInfo.CreatedUserId = taskInfo.CreatedUserId;
                    taskDraftInfo.CreatedUserName = taskInfo.CreatedUserName;
                    taskDraftInfo.TenantId = taskInfo.TenantId;
                    taskDraftInfo.TenantName = taskInfo.TenantName;

                    await _taskDraftInfoRepository.InsertAsync(taskDraftInfo);
                }
                #endregion

                #region 任务目的港未提货/任务目的港提货未返空
                if (info.Main.TaskType == TaskBaseTypeEnum.POD_DISCHARGE_FULL || info.Main.TaskType == TaskBaseTypeEnum.POD_GATEOUT_FULL)
                {
                    TaskPODDischargeGateoutFullInfo dischargeGateout = info.Main.PODDischargeGateoutFull.Adapt<TaskPODDischargeGateoutFullInfo>();

                    dischargeGateout.PK_ID = IDGen.NextID().ToString();
                    dischargeGateout.TASK_ID = taskInfo.PK_ID;

                    dischargeGateout.CreatedTime = taskInfo.CreatedTime;
                    dischargeGateout.UpdatedTime = taskInfo.CreatedTime;

                    dischargeGateout.CreatedUserId = taskInfo.CreatedUserId;
                    dischargeGateout.CreatedUserName = taskInfo.CreatedUserName;
                    dischargeGateout.TenantId = taskInfo.TenantId;
                    dischargeGateout.TenantName = taskInfo.TenantName;

                    await _taskPODDischargeGateoutFullInfoRepository.InsertAsync(dischargeGateout);

                    //明细入库
                    if (info.Main.PODDischargeGateoutFull.DetailList != null 
                        && info.Main.PODDischargeGateoutFull.DetailList.Count > 0)
                    {
                        info.Main.PODDischargeGateoutFull.DetailList.ForEach(async ctn =>
                        {
                            var detailInfo = ctn.Adapt<TaskPODDischargeGateoutFullDetailInfo>();

                            detailInfo.PK_ID = IDGen.NextID().ToString();
                            detailInfo.P_ID = dischargeGateout.PK_ID;

                            detailInfo.CreatedTime = taskInfo.CreatedTime;
                            detailInfo.UpdatedTime = taskInfo.CreatedTime;

                            detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                            detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                            detailInfo.TenantId = taskInfo.TenantId;
                            detailInfo.TenantName = taskInfo.TenantName;

                            await _taskPODDischargeGateoutFullDetailInfoRepository.InsertAsync(detailInfo);
                        });
                    }

                    //触发推送消息
                    var name = _namedPODDischargeGateoutFullProvider
                        .GetService<ITransient>(nameof(TaskManagePODDischargeGateoutFullService));

                    await name.AutoTransferNotice(taskInfo.PK_ID);
                }
                #endregion

                #region 重要提醒
                if (info.Main.TaskType == TaskBaseTypeEnum.CAUTION_NOTICE)
                {
                    TaskCautionNoticeInfo taskCautionNoticeInfo = info.Main.CautionNoticeInfo.Adapt<TaskCautionNoticeInfo>();

                    taskCautionNoticeInfo.PK_ID = IDGen.NextID().ToString();
                    taskCautionNoticeInfo.TASK_ID = taskInfo.PK_ID;

                    taskCautionNoticeInfo.CreatedTime = taskInfo.CreatedTime;
                    taskCautionNoticeInfo.UpdatedTime = taskInfo.CreatedTime;

                    taskCautionNoticeInfo.CreatedUserId = taskInfo.CreatedUserId;
                    taskCautionNoticeInfo.CreatedUserName = taskInfo.CreatedUserName;
                    taskCautionNoticeInfo.TenantId = taskInfo.TenantId;
                    taskCautionNoticeInfo.TenantName = taskInfo.TenantName;

                    taskCautionNoticeInfo.CAUTION_NOTICE_TYPE = info.Main.CautionNoticeInfo.CautionNoticeType.ToString();

                    await _taskCautionNoticeInfoRepository.InsertAsync(taskCautionNoticeInfo);

                    //异步写入集装箱
                    info.Main.CautionNoticeInfo.NoticeList.ForEach(async notice =>
                    {
                        var noticeInfo = notice.Adapt<TaskCautionNoticeDetailInfo>();

                        noticeInfo.NOTIFY_METHOD = notice.CautionNoticeType.ToString();

                        noticeInfo.PK_ID = IDGen.NextID().ToString();
                        noticeInfo.P_ID = taskCautionNoticeInfo.PK_ID;

                        noticeInfo.CreatedTime = taskInfo.CreatedTime;
                        noticeInfo.UpdatedTime = taskInfo.CreatedTime;

                        noticeInfo.CreatedUserId = taskInfo.CreatedUserId;
                        noticeInfo.CreatedUserName = taskInfo.CreatedUserName;
                        noticeInfo.TenantId = taskInfo.TenantId;
                        noticeInfo.TenantName = taskInfo.TenantName;

                        noticeInfo.STATUS = TaskCautionNoticeStatusEnum.TEMP.ToString();
                        noticeInfo.STATUS_NAME = TaskCautionNoticeStatusEnum.TEMP.GetDescription();

                        await _taskCautionNoticeDetailInfoRepository.InsertAsync(noticeInfo);
                    });

                    //这里加了个判断如果没有标记自动发送消息就不触发转发功能
                    if (info.Main.CautionNoticeInfo.IsAutoSendNotice == true)
                    {
                        //触发推送消息
                        var name = _namedTaskCautionNoticeServiceProvider
                            .GetService<ITransient>(nameof(TaskCautionNoticeService));

                        await name.TriggerSendNotice(taskInfo.PK_ID, taskInfo.TenantId.Value);
                    }
                }
                #endregion

                #region 航线船舶截止时间调整的通知
                if (info.Main.TaskType == TaskBaseTypeEnum.ROUTE_CUT_CHANGE)
                {
                    TaskRouteChangeAdvisoryInfo taskRouteChangeAdvisoryInfo = info.Main.RouteChangeAdvisoryInfo.Adapt<TaskRouteChangeAdvisoryInfo>();

                    taskRouteChangeAdvisoryInfo.PK_ID = IDGen.NextID().ToString();
                    taskRouteChangeAdvisoryInfo.TASK_ID = taskInfo.PK_ID;

                    taskRouteChangeAdvisoryInfo.CreatedTime = taskInfo.CreatedTime;
                    taskRouteChangeAdvisoryInfo.UpdatedTime = taskInfo.CreatedTime;

                    taskRouteChangeAdvisoryInfo.CreatedUserId = taskInfo.CreatedUserId;
                    taskRouteChangeAdvisoryInfo.CreatedUserName = taskInfo.CreatedUserName;
                    taskRouteChangeAdvisoryInfo.TenantId = taskInfo.TenantId;
                    taskRouteChangeAdvisoryInfo.TenantName = taskInfo.TenantName;

                    if (!string.IsNullOrWhiteSpace(taskRouteChangeAdvisoryInfo.READ_PORTLOAD))
                    {
                        var portList = _cache.GetAllCodePortLoad().GetAwaiter().GetResult();

                        if (portList != null && portList.Count > 0)
                        {
                            var portInfo = portList.FirstOrDefault(a => !string.IsNullOrWhiteSpace(a.EnName) && a.EnName.Equals(taskRouteChangeAdvisoryInfo.READ_PORTLOAD,StringComparison.OrdinalIgnoreCase));

                            if (portInfo != null)
                            {
                                taskRouteChangeAdvisoryInfo.PORTLOADID = portInfo?.EdiCode;
                                taskRouteChangeAdvisoryInfo.PORTLOAD = portInfo?.EnName;
                            }
                        }
                    }

                    await _taskRouteChangeAdvisoryInfoRepository.InsertAsync(taskRouteChangeAdvisoryInfo);

                    //触发推送消息
                    var name = _namedRouteChangeAdvisoryServiceServiceProvider
                        .GetService<ITransient>(nameof(RouteChangeAdvisoryService));

                    await name.AutoTransferNotice(taskInfo.PK_ID);
                }
                #endregion

                #region 货物运输计划已变更
                if (info.Main.TaskType == TaskBaseTypeEnum.TRNAS_PLAN_HAS_CHANGE)
                {
                    TaskTransPlanHasChangeInfo taskTransPlanHasChangeInfo  = info.Main.TransportPlanHasChangeInfo.Adapt<TaskTransPlanHasChangeInfo>();

                    taskTransPlanHasChangeInfo.PK_ID = IDGen.NextID().ToString();
                    taskTransPlanHasChangeInfo.TASK_ID = taskInfo.PK_ID;

                    taskTransPlanHasChangeInfo.CreatedTime = taskInfo.CreatedTime;
                    taskTransPlanHasChangeInfo.UpdatedTime = taskInfo.CreatedTime;

                    taskTransPlanHasChangeInfo.CreatedUserId = taskInfo.CreatedUserId;
                    taskTransPlanHasChangeInfo.CreatedUserName = taskInfo.CreatedUserName;
                    taskTransPlanHasChangeInfo.TenantId = taskInfo.TenantId;
                    taskTransPlanHasChangeInfo.TenantName = taskInfo.TenantName;

                    await _taskTransPlanHasChangeInfoRepository.InsertAsync(taskTransPlanHasChangeInfo);

                    if(info.Main.TransportPlanHasChangeInfo.From != null)
                    {
                        if(info.Main.TransportPlanHasChangeInfo.From.portList != null 
                            && info.Main.TransportPlanHasChangeInfo.From.portList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.From.portList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo { 
                                    PORTLOAD = p.PortName,
                                    PORTLOAD_COUNTRY = p.CountryCode,
                                    PORTLOAD_TERMINAL = p.TerminalName,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "FROM";
                                detailInfo.COLUMN_TYPE = "PORT";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }

                        if (info.Main.TransportPlanHasChangeInfo.From.dateList != null
                            && info.Main.TransportPlanHasChangeInfo.From.dateList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.From.dateList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                                {
                                    ETD = p.DateVal,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "FROM";
                                detailInfo.COLUMN_TYPE = "EATD";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }

                        if (info.Main.TransportPlanHasChangeInfo.From.vesselList != null
                            && info.Main.TransportPlanHasChangeInfo.From.vesselList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.From.vesselList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                                {
                                    VESSEL = p.Vessel,
                                    VOYNO = p.Voyno,
                                    SHIP_FLAG = p.Flag,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "FROM";
                                detailInfo.COLUMN_TYPE = "VESSEL";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }
                    }

                    if (info.Main.TransportPlanHasChangeInfo.To != null)
                    {
                        if (info.Main.TransportPlanHasChangeInfo.To.portList != null
                            && info.Main.TransportPlanHasChangeInfo.To.portList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.To.portList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                                {
                                    PORTDISCHARGE = p.PortName,
                                    PORTDISCHARGE_COUNTRY = p.CountryCode,
                                    PORTDISCHARGE_TERMINAL = p.TerminalName,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "TO";
                                detailInfo.COLUMN_TYPE = "PORT";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }

                        if (info.Main.TransportPlanHasChangeInfo.To.dateList != null
                            && info.Main.TransportPlanHasChangeInfo.To.dateList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.To.dateList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                                {
                                    ETA = p.DateVal,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "TO";
                                detailInfo.COLUMN_TYPE = "EATD";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }

                        if (info.Main.TransportPlanHasChangeInfo.To.vesselList != null
                            && info.Main.TransportPlanHasChangeInfo.To.vesselList.Count > 0)
                        {
                            info.Main.TransportPlanHasChangeInfo.To.vesselList.ForEach(p => {
                                TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                                {
                                    VESSEL = p.Vessel,
                                    VOYNO = p.Voyno,
                                    SHIP_FLAG = p.Flag,
                                    SORT_NO = p.Indx,
                                    IS_REMOVED = p.IsRemoved
                                };

                                detailInfo.PK_ID = IDGen.NextID().ToString();
                                detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                                detailInfo.PLAN_TYPE = "TO";
                                detailInfo.COLUMN_TYPE = "VESSEL";

                                detailInfo.CreatedTime = taskInfo.CreatedTime;
                                detailInfo.UpdatedTime = taskInfo.CreatedTime;

                                detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                                detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                                detailInfo.TenantId = taskInfo.TenantId;
                                detailInfo.TenantName = taskInfo.TenantName;

                                _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                            });
                        }
                    }


                    if (info.Main.TransportPlanHasChangeInfo.ContaNoList != null && info.Main.TransportPlanHasChangeInfo.ContaNoList.Count > 0)
                    {
                        info.Main.TransportPlanHasChangeInfo.ContaNoList.ForEach(p =>
                        {
                            TaskTransPlanHasChangeDetailInfo detailInfo = new TaskTransPlanHasChangeDetailInfo
                            {
                                CONTA_NO = p,
                            };

                            detailInfo.PK_ID = IDGen.NextID().ToString();
                            detailInfo.P_ID = taskTransPlanHasChangeInfo.PK_ID;

                            detailInfo.COLUMN_TYPE = "CTN";

                            detailInfo.CreatedTime = taskInfo.CreatedTime;
                            detailInfo.UpdatedTime = taskInfo.CreatedTime;

                            detailInfo.CreatedUserId = taskInfo.CreatedUserId;
                            detailInfo.CreatedUserName = taskInfo.CreatedUserName;
                            detailInfo.TenantId = taskInfo.TenantId;
                            detailInfo.TenantName = taskInfo.TenantName;

                            _taskTransPlanHasChangeDetailInfoRepository.Insert(detailInfo);

                        });
                    }

                    //触发推送消息
                    var name = _namedTaskTransPlanHasChangeServiceProvider
                        .GetService<ITransient>(nameof(TaskTransPlanHasChangeService));

                    await name.AutoTransferNotice(taskInfo.PK_ID);
                    
                }
                #endregion

                #region 装货港未提箱通知
                if (info.Main.TaskType == TaskBaseTypeEnum.POL_CTN_NOT_PICKUP)
                {
                    TaskPOLContainerNotPickUpInfo taskPOLContainerNotPickUpInfo = info.Main.POLContainerNotPickupInfo.Adapt<TaskPOLContainerNotPickUpInfo>();

                    taskPOLContainerNotPickUpInfo.PK_ID = IDGen.NextID().ToString();
                    taskPOLContainerNotPickUpInfo.TASK_ID = taskInfo.PK_ID;

                    taskPOLContainerNotPickUpInfo.CreatedTime = taskInfo.CreatedTime;
                    taskPOLContainerNotPickUpInfo.UpdatedTime = taskInfo.CreatedTime;

                    taskPOLContainerNotPickUpInfo.CreatedUserId = taskInfo.CreatedUserId;
                    taskPOLContainerNotPickUpInfo.CreatedUserName = taskInfo.CreatedUserName;
                    taskPOLContainerNotPickUpInfo.TenantId = taskInfo.TenantId;
                    taskPOLContainerNotPickUpInfo.TenantName = taskInfo.TenantName;

                    await _taskPOLContainerNotPickUpInfoRepository.InsertAsync(taskPOLContainerNotPickUpInfo);

                    //触发推送消息
                    var name = _namedTaskPOLContainerNotPickUpServiceProvider
                        .GetService<ITransient>(nameof(TaskPOLContainerNotPickUpService));

                    await name.AutoTransferNotice(taskInfo.PK_ID);
                }
                #endregion


                if (info.Main.SerialMsgInfo != null)
                {
                    var storeInfo = new TaskStoreMsgInfo
                    {
                        PK_ID = IDGen.NextID().ToString(),
                        TASK_PKID = taskInfo.PK_ID,
                        MSG_JSON = info.Main.SerialMsgInfo.SerialMsg,
                        MSG_TYPE = info.Main.SerialMsgInfo.SerialType,
                        CreatedTime = taskInfo.CreatedTime,
                        UpdatedTime = taskInfo.CreatedTime,

                        CreatedUserId = taskInfo.CreatedUserId,
                        CreatedUserName = taskInfo.CreatedUserName,
                        TenantId = taskInfo.TenantId,
                        TenantName = taskInfo.TenantName,
                    };

                    await _taskStoreMsgInfoRepository.InsertAsync(storeInfo);
                }

                result.succ = true;
                result.msg = "新增任务成功";

                var md = _taskBaseInfoRepository.AsQueryable().First(a => a.PK_ID == taskInfo.PK_ID);
                //回写任务号
                result.ext = md?.TASK_NO;
            }
            catch (Exception ex)
            {
                throw Oops.Oh($"{ex.Message}");
            }

            return result;
        }
        #endregion

        /// <summary>
        /// 执行方法
        /// </summary>
        /// <param name="flow">当前流程配置</param>
        /// <param name="depth">循环深度</param>
        public   void RecursiveMethod(TaskFlowTenant flow,int depth, RecursiveMethodModel model)
        {
            depth = depth++;
            
            //防止配置错误引发死循环,此处设置最多深度20层
            if (depth>=20)
            {
                return;
            }
            // 获取方法信息
            MethodInfo methodInfo = typeof(BookingOrderAutoService).GetMethod(flow.MethodName);

            // 确保方法存在
            if (methodInfo != null)
            {
                // 调用方法
                object result = methodInfo.Invoke(_bookingOrderAuto, new object[] { model });
                //如果返回类型为bool
                if (flow.IsBoolReturn)
                {
                    if ((bool)result)
                    {
                        if (string.IsNullOrEmpty( flow.TrueMethod))
                        {
                            return;
                        }
                        var newflow = _taskFlowTenant.AsQueryable().Filter(null, true).Where(t => t.MethodName == flow.TrueMethod).First();
                        RecursiveMethod(newflow, depth,model);
                    }

                    if ((bool)result)
                    {
                        if (flow.TrueMethod==null)
                        {
                            return;
                        }

                        var newflow = _taskFlowTenant.AsQueryable().Filter(null, true).Where(t => t.MethodName == flow.FalseMethod).First();
                        RecursiveMethod(newflow, depth, model);
                    }
                }
                else
                {
                    var newflow = _taskFlowTenant.AsQueryable().Filter(null, true).Where(t => t.PId == flow.PK_ID).First();
                    if (newflow==null)
                    {
                        return;
                    }
                    RecursiveMethod(newflow, depth,model);
                }
            }
            else
            {
                ($"方法{flow.MethodName}不存在").LogInformation();
                return;
            }

             
        }

        #region 查询订舱表查询用户和租户信息
        /// <summary>
        /// 查询订舱表查询用户和租户信息
        /// </summary>
        /// <param name="userId">用户ID</param>
        /// <returns>返回用户和租户信息</returns>
        private UserTendDto GetUserTendInfo(string userId)
        {
            UserTendDto userTendDto = null;

            //这里因为接口是不做授权验证的，所以这里直接写的动态sql提取了用户和租户信息
            var userTendInfo = _sysUserRepository.EntityContext.Queryable<dynamic>("user").AS("sys_user")
                    .AddJoinInfo("sys_tenant", "ten", "user.TenantId=ten.Id")
                    .Where("user.Id=@id", new { id = long.Parse(userId) })
                    .Select("user.Id as UserId,user.Name as UserName,ten.Id as TendId,ten.Name as TendName").First();

            if (userTendInfo == null || userTendInfo.TendId == null)
                throw Oops.Oh("当前用户详情获取失败，请确认{0}赋值是否准确", nameof(TaskManageOrderMessageInfo.Main.TaskUserId));

            userTendDto = new UserTendDto
            {
                userId = long.Parse(userTendInfo.UserId.ToString()),
                userName = userTendInfo.UserName.ToString(),
                tendId = long.Parse(userTendInfo.TendId.ToString()),
                tenantName = userTendInfo.TendName.ToString()
            };

            return userTendDto;
        }
        #endregion

        #region 查询订舱表查询用户和租户信息
        /// <summary>
        /// 查询订舱表查询用户和租户信息
        /// </summary>
        /// <param name="djyUserId">大简云用户ID</param>
        /// <param name="djyUserEmail">大简云用户邮箱</param>
        /// <returns>返回用户和租户信息</returns>
        private UserTendDto GetUserTendInfoByDJYUserId(string djyUserId,string djyUserEmail)
        {
            UserTendDto userTendDto = null;

            //这里因为接口是不做授权验证的，所以这里直接写的动态sql提取了用户和租户信息
            var userTendInfo = _sysUserRepository.EntityContext.Queryable<dynamic>("user").AS("sys_user")
                    .AddJoinInfo("sys_tenant", "ten", "user.TenantId=ten.Id")
                    .Where("user.DjyUserId=@id and user.Email like '%"+ djyUserEmail + "%'", new { id = djyUserId})
                    .Select("user.Id as UserId,user.Name as UserName,ten.Id as TendId,ten.Name as TendName").First();

            if (userTendInfo == null || userTendInfo.TendId == null)
                throw Oops.Oh("当前用户详情获取失败，请确认{0}赋值是否准确", nameof(TaskManageOrderMessageInfo.Main.TaskUserId));

            userTendDto = new UserTendDto
            {
                userId = long.Parse(userTendInfo.UserId.ToString()),
                userName = userTendInfo.UserName.ToString(),
                tendId = long.Parse(userTendInfo.TendId.ToString()),
                tenantName = userTendInfo.TendName.ToString()
            };

            return userTendDto;
        }
        #endregion

        #region 通过租户ID和邮箱获取用户信息
        /// <summary>
        /// 通过租户ID和邮箱获取用户信息
        /// </summary>
        /// <param name="tenantId">大简云租户ID</param>
        /// <param name="emailAccount">大简云用户邮箱</param>
        /// <returns>返回用户和租户信息</returns>
        private UserTendDto GetUserTendInfoByEmail(long tenantId, string emailAccount)
        {
            UserTendDto userTendDto = null;

            //这里因为接口是不做授权验证的，所以这里直接写的动态sql提取了用户和租户信息
            var userTendInfo = _sysUserRepository.EntityContext.Queryable<dynamic>("user").AS("sys_user")
                    .AddJoinInfo("sys_tenant", "ten", "user.TenantId=ten.Id")
                    .Where("ten.Id=@id and UPPER(user.Email) = '"+ emailAccount.ToUpper()+ "'", new { id = tenantId })
                    .Select("user.Id as UserId,user.Name as UserName,ten.Id as TendId,ten.Name as TendName").First();

            if (userTendInfo == null || userTendInfo.TendId == null)
                throw Oops.Oh("当前用户详情获取失败，请确认{0}赋值是否准确", nameof(TaskManageOrderMessageInfo.Main.TaskUserId));

            userTendDto = new UserTendDto
            {
                userId = long.Parse(userTendInfo.UserId.ToString()),
                userName = userTendInfo.UserName.ToString(),
                tendId = long.Parse(userTendInfo.TendId.ToString()),
                tenantName = userTendInfo.TendName.ToString()
            };

            return userTendDto;
        }
        #endregion

        #region 获取查询参数
        /// <summary>
        /// 获取查询参数
        /// </summary>
        /// <param name="ParaType">参数类型 STATUS-任务状态;TASK_TYPE-任务类型;SOURCE-任务来源 CATEGORY-分类</param>
        /// <returns>返回回执</returns>
        /// <example>TASK_TYPE</example>
        [HttpGet("/TaskManage/GetParaInfo")]
        public async Task<TaskManageOrderResultDto> GetParaInfo([QueryString] string ParaType)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();
            try
            {
                Dictionary<string, string> dict = new Dictionary<string, string>();

                if (ParaType == "STATUS")
                {
                    dict = EnumUtil.GetEnumDictionaryWithKey(typeof(TaskStatusEnum));
                }
                else if (ParaType == "TASK_TYPE")
                {
                    dict = EnumUtil.GetEnumDictionaryWithKey(typeof(TaskBusiTypeEnum));
                }
                else if (ParaType == "SOURCE")
                {
                    dict = EnumUtil.GetEnumDictionaryWithKey(typeof(TaskSourceEnum));
                }
                else if (ParaType == "CATEGORY")
                {
                    dict = EnumUtil.GetEnumDictionaryWithKey(typeof(TaskStatLevelEnum));
                }

                result.succ = true;
                result.rows = dict.Select(t => new { Code = t.Key, Name = t.Value }).ToList();
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = ex.Message;
            }

            return result;
        }
        #endregion

        #region 获取登陆人相关的任务统计信息
        /// <summary>
        /// 获取登陆人相关的任务统计信息
        /// </summary>
        /// <param name="isReCalc">是否强制计算</param>
        /// <returns>返回回执</returns>
        [HttpGet("/TaskManage/GetCurrentTotalStat")]
        public async Task<TaskUserStatResultInfo> GetCurrentTotalStat([FromQuery] bool isReCalc = false)
        {
            TaskUserStatResultInfo resultInfo = new TaskUserStatResultInfo
            {
                LevelTop = new List<TaskUserStatItem>(),
                LevelNext = new List<TaskUserStatItemNext>(),
                LevelTree = new List<TaskUserStatItemTree>()
            };

            /*
             1、首先判断当前登陆人是否有统计记录，如果没有触发统计生成统计记录。
             2、如果isReCalc=true，表示强制重新统计数据，并重新更新统计数据。
             3、按照统计类型（个人/公共）、任务状态、是否异常分组汇总，并写入统计表。
             */
            try
            {
                var userTendInfo = await _sysUserRepository.AsQueryable()
                    .LeftJoin<SysTenant>((usr, ten) => usr.TenantId == ten.Id)
                    .Where(usr => usr.Id == UserManager.UserId)
                    .Select((usr, ten) => new { User = usr, Tend = ten }).FirstAsync();

                if (userTendInfo == null)
                    throw Oops.Oh($"当前用户关联租户信息获取失败");

                //var statList = _taskStatManageInfoRepository.AsQueryable().Where(t => (t.USER_ID == userTendInfo.User.Id
                //&& t.STAT_TYPE == TaskStatLevelEnum.PERSON.ToString()) || (t.COMP_ID == userTendInfo.Tend.Id && t.STAT_TYPE == TaskStatLevelEnum.PUBLIC.ToString())).ToList();

                //菜单375504048771141=我的任务台账
                List<long> userlist = await _sysDataUserMenuService.GetDataScopeList(MenuConst.MenuTaskManage);

                bool isAdmin = userlist == null;
                //任务列表分组统计
                var groupList = _taskBaseInfoRepository.AsQueryable()
                    .Where(t => isAdmin 
                    || (userlist.Contains(t.CreatedUserId) && t.IS_PUBLIC == 0) 
                    || (t.RealUserId !=null && userlist.Contains(t.RealUserId.Value) && t.IS_PUBLIC == 0) 
                    || (t.TenantId == userTendInfo.Tend.Id && t.IS_PUBLIC == 1))
                    .GroupBy(p => new { p.TASK_TYPE, p.STATUS, p.IS_EXCEPT, p.IS_PUBLIC })
                    .Select(p => new
                    {
                        Total = SqlFunc.AggregateCount(p.PK_ID),
                        TaskType = p.TASK_TYPE,
                        Status = p.STATUS,
                        IsExcept = p.IS_EXCEPT,
                        IsPublic = p.IS_PUBLIC
                    }).ToList();

                var exceptList = groupList
                    .Where(t => t.IsExcept == 1).ToList();

                var personList = groupList
                    .Where(t => t.IsExcept == 0 && t.IsPublic == 0).ToList();

                var publicList = groupList
                    .Where(t => t.IsExcept == 0 && t.IsPublic == 1).ToList();

                #region 异常
                if (exceptList.Count > 0)
                {
                    resultInfo.LevelTop.Add(new TaskUserStatItem
                    {
                        Key = TaskStatLevelEnum.EXCPTION.ToString(),
                        Name = TaskStatLevelEnum.EXCPTION.GetDescription(),
                        Total = exceptList.Sum(t => t.Total),
                        SortNo = (int)TaskStatLevelEnum.EXCPTION,
                        ActionKey = TaskStatLevelEnum.EXCPTION.ToString()
                    });

                    var nextList = new List<TaskUserStatItemNext>();

                    exceptList.GroupBy(t => t.Status)
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskStatusEnum currEnum = (TaskStatusEnum)System.Enum.Parse(typeof(TaskStatusEnum), t.Key);

                            nextList.Add(new TaskUserStatItemNext
                            {
                                TopKey = TaskStatLevelEnum.EXCPTION.ToString(),
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.EXCPTION.ToString()}#{currEnum.ToString()}"
                            });

                        });

                    if (nextList.Count > 0)
                        resultInfo.LevelNext.AddRange(nextList.OrderBy(t => t.SortNo).ToList());

                    exceptList.GroupBy(t => new { t.Status, t.TaskType })
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskBusiTypeEnum currEnum = (TaskBusiTypeEnum)System.Enum.Parse(typeof(TaskBusiTypeEnum), t.Key.TaskType);

                            resultInfo.LevelTree.Add(new TaskUserStatItemTree
                            {
                                TopKey = TaskStatLevelEnum.EXCPTION.ToString(),
                                NextKey = t.Key.Status,
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.EXCPTION.ToString()}#{t.Key.Status}#{currEnum.ToString()}"
                            });

                        });
                }
                #endregion

                #region 个人
                if (personList.Count > 0)
                {
                    resultInfo.LevelTop.Add(new TaskUserStatItem
                    {
                        Key = TaskStatLevelEnum.PERSON.ToString(),
                        Name = TaskStatLevelEnum.PERSON.GetDescription(),
                        Total = personList.Sum(t => t.Total),
                        SortNo = (int)TaskStatLevelEnum.PERSON,
                        ActionKey = TaskStatLevelEnum.PERSON.ToString()
                    });

                    var nextList = new List<TaskUserStatItemNext>();
                    personList.GroupBy(t => t.Status)
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskStatusEnum currEnum = (TaskStatusEnum)System.Enum.Parse(typeof(TaskStatusEnum), t.Key);

                            nextList.Add(new TaskUserStatItemNext
                            {
                                TopKey = TaskStatLevelEnum.PERSON.ToString(),
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.PERSON.ToString()}#{currEnum.ToString()}"
                            });

                        });

                    if (nextList.Count > 0)
                        resultInfo.LevelNext.AddRange(nextList.OrderBy(t => t.SortNo).ToList());

                    personList.GroupBy(t => new { t.Status, t.TaskType })
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskBusiTypeEnum currEnum = (TaskBusiTypeEnum)System.Enum.Parse(typeof(TaskBusiTypeEnum), t.Key.TaskType);

                            resultInfo.LevelTree.Add(new TaskUserStatItemTree
                            {
                                TopKey = TaskStatLevelEnum.PERSON.ToString(),
                                NextKey = t.Key.Status,
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.PERSON.ToString()}#{t.Key.Status}#{currEnum.ToString()}"
                            });

                        });
                }
                #endregion

                #region 公共
                if (publicList.Count > 0)
                {
                    resultInfo.LevelTop.Add(new TaskUserStatItem
                    {
                        Key = TaskStatLevelEnum.PUBLIC.ToString(),
                        Name = TaskStatLevelEnum.PUBLIC.GetDescription(),
                        Total = publicList.Sum(t => t.Total),
                        SortNo = (int)TaskStatLevelEnum.PUBLIC,
                        ActionKey = TaskStatLevelEnum.PUBLIC.ToString()
                    });

                    var nextList = new List<TaskUserStatItemNext>();

                    publicList.GroupBy(t => t.Status)
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskStatusEnum currEnum = (TaskStatusEnum)System.Enum.Parse(typeof(TaskStatusEnum), t.Key);

                            nextList.Add(new TaskUserStatItemNext
                            {
                                TopKey = TaskStatLevelEnum.PUBLIC.ToString(),
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.PUBLIC.ToString()}#{currEnum.ToString()}"
                            });

                        });

                    if (nextList.Count > 0)
                        resultInfo.LevelNext.AddRange(nextList.OrderBy(t => t.SortNo).ToList());

                    publicList.GroupBy(t => new { t.Status, t.TaskType })
                        .Select(t => new { Key = t.Key, Total = t.ToList().Sum(p => p.Total) })
                        .ToList().ForEach(t =>
                        {
                            TaskBusiTypeEnum currEnum = (TaskBusiTypeEnum)System.Enum.Parse(typeof(TaskBusiTypeEnum), t.Key.TaskType);

                            resultInfo.LevelTree.Add(new TaskUserStatItemTree
                            {
                                TopKey = TaskStatLevelEnum.PUBLIC.ToString(),
                                NextKey = t.Key.Status,
                                Key = currEnum.ToString(),
                                Name = currEnum.GetDescription(),
                                Total = t.Total,
                                SortNo = (int)currEnum,
                                ActionKey = $"{TaskStatLevelEnum.PUBLIC.ToString()}#{t.Key.Status}#{currEnum.ToString()}"
                            });

                        });
                }
                #endregion

                if(resultInfo.LevelTree != null && resultInfo.LevelTree.Count > 0)
                {
                    resultInfo.LevelTree = resultInfo.LevelTree.OrderBy(x => x.SortNo).ToList();
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取登录人相关的任务统计信息异常,{0}", ex.Message);
            }

            return resultInfo;
        }
        #endregion

        #region 任务台账查询
        /// <summary>
        /// 任务台账查询
        /// </summary>
        /// <param name="QuerySearch">任务台账查询请求</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/GetPage")]
        public async Task<SqlSugarPagedList<dynamic>> GetPageAsync(QueryTaskManageDto QuerySearch)
        {
            List<string> mblList = new List<string>();

            if (!string.IsNullOrWhiteSpace(QuerySearch.MBlNo))
            {
                if (Regex.IsMatch(QuerySearch.MBlNo, "(\\t|\\n\\r|\\n)"))
                {
                    mblList = Regex.Replace(QuerySearch.MBlNo, "(\\t |\\n\\r |\\n)", "#").Split(new char[] { '#' }).Select(t => t?.Trim()).ToList();
                }
                else
                {
                    mblList.Add(QuerySearch.MBlNo.Trim().ToUpper());
                }
            }

            DateTime etdBegin = DateTime.MinValue;
            DateTime etdEnd = DateTime.MinValue;

            DateTime taskDateBegin = DateTime.MinValue;
            DateTime taskDateEnd = DateTime.MinValue;

            if (!string.IsNullOrWhiteSpace(QuerySearch.ETDBegin))
            {
                if (!DateTime.TryParse(QuerySearch.ETDBegin, out etdBegin))
                    throw Oops.Oh($"开船起始日期格式错误，{QuerySearch.ETDBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.ETDEnd))
            {
                if (!DateTime.TryParse(QuerySearch.ETDEnd, out etdEnd))
                    throw Oops.Oh($"开船结束日期格式错误，{QuerySearch.ETDEnd}");

                etdEnd = etdEnd.AddDays(1);
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.TaskDateBegin))
            {
                if (!DateTime.TryParse(QuerySearch.TaskDateBegin, out taskDateBegin))
                    throw Oops.Oh($"任务起始日期格式错误，{QuerySearch.TaskDateBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.TaskDateEnd))
            {
                if (!DateTime.TryParse(QuerySearch.TaskDateEnd, out taskDateEnd))
                    throw Oops.Oh($"任务结束日期格式错误，{QuerySearch.TaskDateEnd}");

                taskDateEnd = taskDateEnd.AddDays(1);
            }

            string entityOrderCol = "CreatedTime";

            //这里因为返回给前端的台账数据是DTO，所以这里排序时候需要转换成Entity对应的字段
            if (!string.IsNullOrWhiteSpace(QuerySearch.SortField))
                entityOrderCol = MapsterExtHelper.GetAdaptProperty<TaskBaseInfoDto, TaskBaseInfo>(QuerySearch.SortField);

            //菜单375504048771141=我的任务台账
            List<long> userlist = await _sysDataUserMenuService.GetDataScopeList(MenuConst.MenuTaskManage);

            if (userlist == null)
                userlist = new List<long> { UserManager.UserId };

            if (userlist.Count > 0)
                userlist = userlist.Distinct().ToList();

            _logger.LogInformation("任务台账权限范围 {list}", userlist);


            List<string> userIds = new List<string>();
            if (!string.IsNullOrWhiteSpace( QuerySearch.DJYUserId))
            {
                //获取缓存数据

                if (!_cache.Exists(QuerySearch.DJYUserId+ "Authorization"))
                {
                    throw Oops.Bah("无效授权");
                }
                userIds = JsonConvert.DeserializeObject<List<string>>( _cache.Get(QuerySearch.DJYUserId));

            }
            

            switch (QuerySearch.TaskType)
            {
                case "BC":
                    var bc = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskBCInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                   .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                   .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                   .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                   .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                   .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                   .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                   .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                   .Select<dynamic>((t, bc) => new
                                   {
                                       PK_ID = t.PK_ID.SelectAll(),
                                       bc.BUSI_TYPE,
                                       bc.SHIPPER,
                                       bc.CONSIGNEE,
                                       bc.NOTIFYPARTY,
                                       bc.BC_MODIFY_TIMES,
                                       bc.BC_MODIFY_DATE,
                                       //bc.MBL_NO,
                                       bc.VESSEL,
                                       bc.VOYNO,
                                       bc.CARRIER,
                                       bc.PLACERECEIPT,
                                       bc.PORTLOAD,
                                       bc.CLOSING_DATE,
                                       bc.VGM_CUTOFF_TIME,
                                       bc.ETA,
                                       //bc.ETD,
                                       bc.POD_ETA,
                                       bc.CUT_SINGLE_TIME,
                                       bc.PORTDISCHARGE,
                                       bc.PLACEDELIVERY,
                                       bc.SHIPPING_METHOD,
                                       bc.SERVICE,
                                       bc.PRETRANS_MODE,
                                       bc.DESCRIPTION,
                                       bc.ISSUEPLACE,
                                       bc.COLLECTION_TERMINAL,
                                       bc.CONTRACTNO,
                                       bc.PREPARDAT,
                                       bc.SHIP_AGENT,
                                       bc.YARD,
                                       bc.YARD_CONTACT_USR,
                                       bc.YARD_CONTACT_TEL,
                                       bc.FST_CUSTOMER_SER_USRNAME,
                                       bc.FST_CUSTOMER_SER_TEL,
                                       bc.FST_CUSTOMER_SER_EMAIL,
                                       bc.REMARK1,
                                       bc.CY_CUTOFF_TIME,
                                       bc.CARRIERID,
                                       bc.LANECODE,
                                       bc.LANENAME,
                                       bc.CARRIAGE_TYPE,
                                       bc.CARRIAGE_TYPE_NAME,
                                       bc.BOOKING_SLOT_TYPE,
                                       bc.BOOKING_SLOT_TYPE_NAME,
                                       bc.CTN_STAT,
                                       bc.WEEK_AT,
                                       bc.DETENSION_FREE_DAYS,
                                       bc.SI_CUT_DATE,
                                       bc.MANIFEST_CUT_DATE,
                                       bc.MDGF_CUT_DATE,
                                       bc.TRANSFER_PORT_1,
                                       bc.TRANSFER_PORT_2,
                                       bc.SECOND_VESSEL,
                                       bc.SECOND_VOYNO,
                                       bc.SECOND_ETD,
                                       bc.SECOND_ETA,
                                       //bc.STATUS,
                                       bc.FILE_MD5,
                                       bc.LAST_TOBOOKING_DATE,
                                       bc.FROM_EMAIL,
                                       bc.RECV_EMAIL,
                                       bc.BOOKING_ORDER_ID,
                                       bc.BOOKING_SLOT_ID,
                                       bc.BOOKING_COMFIRM_DATE,
                                       bc.BATCH_NO,
                                       bc.CUSTOM_SI_CUT_DATE,
                                       bc.IS_SET_AUTO_EMAIL,
                                       bc.IS_SEND_EMAIL,
                                       bc.DIFF_NUM,
                                       bc.AUTO_SEND_USER,
                                       bc.PROCESS_STATUS,
                                       bc.PROCESS_RESULT,
                                       bc.PROCESS_DATE,
                                       bc.PRICE_CALCULATION_DATE
                                        
                                   })


                                    .ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return bc.Adapt<SqlSugarPagedList<dynamic>>();

                case "SI_FEEDBACK":
                    var SI_FEEDBACK = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskSISubmitted>((t, bc) => t.PK_ID==bc.TASK_ID)
                                   .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                   .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                   .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                   .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                   .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                   .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                   .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                   .Select<dynamic>((t, bc) => new
                                   {
                                       PK_ID = t.PK_ID.SelectAll(),
                                       bc.CARRIER,
                                       //bc.MBL_NO,
                                       bc.TAKE_ISSUETYPE_NAME,
                                       bc.ISSUETYPE,
                                       bc.NOTICE_DATE,
                                       bc.BOOKING_ID,
                                       bc.SUBMITTED_DATE,
                                       bc.BILLOF_NUM,
                                       bc.RELEASE_INSTRUCTION,
                                       bc.SI_SUBTYPE,
                                       bc.SHIPPER,
                                       bc.CONSIGNEE,
                                       bc.NOTIFYPARTY,
                                       bc.NOTIFYPARTY2,
                                       bc.TRANSPORT_RECEIVER,
                                       bc.MARKS,
                                       bc.HSCODE,
                                       bc.DESCRIPTION,
                                       bc.PKGS,
                                       bc.KINDPKGS,
                                       bc.KGS,
                                       bc.CBM,
                                       bc.VESSEL,
                                       bc.VOYNO,
                                       bc.COMMODITY,
                                       bc.PLACERECEIPTID,
                                       bc.PLACERECEIPT,
                                       bc.PORTLOADID,
                                       bc.PORTLOAD,
                                       bc.PORTDISCHARGEID,
                                       bc.PORTDISCHARGE,
                                       bc.PLACEDELIVERYID,
                                       bc.PLACEDELIVERY,
                                       bc.PROCESS_STATUS,
                                       bc.IS_SET_AUTO_UPD_BOOKING,
                                       bc.PROCESS_RESULT,
                                       bc.PROCESS_DATE,
                                       bc.DIFF_NUM,
                                       bc.IS_UPDATE_BOOKING,
                                       bc.UPDATE_BOOKING_DATE

                                   }) .ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return SI_FEEDBACK.Adapt<SqlSugarPagedList<dynamic>>();

                case "INVOICE_BILL_MAIL":

                    var INVOICE_BILL_MAIL = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskPerBillBaseInfo>((t, bc) => t.PK_ID==bc.TASK_PKID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_PKID,
                                      //bc.MBL_NO,
                                      bc.INVOICE_NO,
                                      bc.CANCEL_NO,
                                      bc.TOTAL_AMOUNT,
                                      bc.IS_DONGSH_RECV,
                                      bc.IS_DONGSH_RESULT,
                                      bc.DONGSH_RECV_TIME,
                                      bc.DONGSH_RESULT_TIME,
                                      bc.DONGSH_RECV_REASON

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return INVOICE_BILL_MAIL.Adapt<SqlSugarPagedList<dynamic>>();


                case "TRUCK_DISPATCH":

                    var TRUCK_DISPATCH = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskTruckInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.BookingTruckId,
                                      bc.BookingId,
                                      bc.TruckId,
                                      bc.TruckCode,
                                      bc.TruckName,
                                      bc.ToName,
                                      bc.Attn,
                                      bc.AttnTel,
                                      bc.AttnMail,
                                      bc.AttnFax,
                                      bc.FromName,
                                      bc.FromTel,
                                      bc.FromMail,
                                      bc.FromMobile,
                                      bc.FromFax,
                                      bc.KGS,
                                      bc.Fee,
                                      bc.PayMethod,
                                      bc.PayMethodName,
                                      bc.TruckTime,
                                      bc.YARDID,
                                      bc.YARD,
                                      bc.YARDCONTRACT,
                                      bc.YARDCONTRACTTEL,
                                      bc.FactoryId,
                                      bc.FactoryCode,
                                      bc.FactoryName,
                                      bc.FactoryContact,
                                      bc.FactoryTel,
                                      bc.ReturnTime,
                                      bc.InYardID,
                                      bc.InYard,
                                      bc.InYardContact,
                                      bc.InYardContractTel,
                                      //bc.NeedArriveTime,
                                      bc.ClosingTime,
                                      bc.PickUpTime,
                                      bc.IsGuaJi,
                                      //bc.Status,
                                      bc.Attention,
                                      bc.Remark,
                                      bc.DispatcherId,
                                      bc.DispatcherName,
                                      bc.TruckFlowNo,
                                      bc.TaskNo,
                                      bc.Vessel,
                                      bc.VoyNo,
                                      bc.MBLNo,
                                      bc.CntrTotal,
                                      bc.FactoryAddr

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return TRUCK_DISPATCH.Adapt<SqlSugarPagedList<dynamic>>();

                case "CUT_MODIFY":

                    var CUT_MODIFY = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskCutDateChangeInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.CARRIER,
                                      bc.VESSEL,
                                      bc.VOYNO,
                                      bc.NOTICE_DATE

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return CUT_MODIFY.Adapt<SqlSugarPagedList<dynamic>>();

                case "ROLLING_NOMINATION":
                case "TRANSFER_NOMINATION":

                    var ysh = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskRollingNominationInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.PLAN_TYPE,
                                      bc.BATCH_NO,
                                      bc.CARRIERID,
                                      bc.CARRIER,
                                      bc.CONFIRM_DEAD_LINE,
                                      bc.READ_CREATE_TIME,
                                      bc.ROLL_DOUBLE_REMARK,
                                      bc.PLAN_TXT,
                                      //bc.REMARK,
                                      bc.TASK_BATCH_TOTAL,
                                      bc.TASK_BATCH_PER_TOTAL

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return ysh.Adapt<SqlSugarPagedList<dynamic>>();


                case "DRAFT":

                    var DRAFT = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskDraftInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.CARRIER,
                                      //bc.MBL_NO,
                                      bc.BOOKING_ID,
                                      bc.IS_CHANGE,
                                      bc.IS_EMAIL_SEND,
                                      bc.SEND_EMAIL_DATE,
                                      bc.NOTICE_DATE,

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return DRAFT.Adapt<SqlSugarPagedList<dynamic>>();


                case "POD_DISCHARGE_FULL":
                case "POD_GATEOUT_FULL":

                    var POD = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskPODDischargeGateoutFullInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.CARRIER,
                                      bc.NOTICE_TYPE,
                                      bc.NOTICE_TYPE_NAME,
                                      //bc.MBL_NO,
                                      bc.NOTICE_DATE

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return POD.Adapt<SqlSugarPagedList<dynamic>>();


                case "CAUTION_NOTICE":

                    var CAUTION_NOTICE = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskCautionNoticeInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.SOURCE_SYSTEM,
                                      bc.SOURCE_BUSI_TYPE,
                                      bc.SOURCE_BUSI_TYPENAME,
                                      bc.NOTIFY_CONTENT,
                                      //bc.MBL_NO,
                                      bc.CARRIER,
                                      bc.CAUTION_NOTICE_TYPE,
                                      bc.IS_WEEK_DIFF,
                                      bc.IS_PRICE_DATE_DIFF,
                                      bc.IS_TRANSFER,
                                      bc.IS_VESSEL_CHANGE,
                                      bc.IS_CUT_DATE_ADVANCED,
                                      bc.BOOKING_ID,
                                      bc.BOOKING_SLOT_ID,
                                      bc.SOURCE_TASK_ID,
                                      bc.OLD_VAL,
                                      bc.NEW_VAL,

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return CAUTION_NOTICE.Adapt<SqlSugarPagedList<dynamic>>();

                case "ROUTE_CUT_CHANGE":

                    var ROUTE_CUT_CHANGE = await _taskBaseInfoRepository.AsQueryable().LeftJoin<TaskRouteChangeAdvisoryInfo>((t, bc) => t.PK_ID==bc.TASK_ID)
                                  .Where((t, bc) => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), (t, bc) => mblList.Contains(t.MBL_NO))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), (t, bc) => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                  .WhereIF(etdBegin != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                  .WhereIF(etdEnd != DateTime.MinValue, (t, bc) => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                  .WhereIF(taskDateBegin != DateTime.MinValue, (t, bc) => t.CreatedTime >= taskDateBegin)
                                  .WhereIF(taskDateEnd != DateTime.MinValue, (t, bc) => t.CreatedTime < taskDateEnd)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), (t, bc) => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), (t, bc) => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), (t, bc) => t.IS_EXCEPT == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), (t, bc) => t.IS_PUBLIC == 1)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), (t, bc) => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), (t, bc) => t.STATUS.Equals(QuerySearch.Status))
                                  .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), (t, bc) => t.PK_ID.Equals(QuerySearch.PKId))
                                  .WhereIF(userIds.Count>0, (t, bc) => userIds.Contains(t.DJYUserId))
                                  .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                  .Select<dynamic>((t, bc) => new
                                  {
                                      PK_ID = t.PK_ID.SelectAll(),
                                      bc.TASK_ID,
                                      bc.VESSEL,
                                      bc.VOYNO,
                                      bc.CARRIER,
                                      bc.READ_PORTLOAD,
                                      bc.ORIG_ETD,
                                      bc.MDGF_CUT_DATE,
                                      bc.ETA,
                                      //bc.ETD,
                                      bc.SI_CUT_DATE,
                                      bc.TM_SHIFT_CUT_DATE,
                                      bc.VGM_CUTOFF_TIME,
                                      bc.CY_CUT_DATE,
                                      bc.ROUTE_CODE,
                                      bc.EMAIL_SUBJECT,
                                      bc.WEEK,
                                      bc.PORTLOADID,
                                      bc.PORTLOAD

                                  }).ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return ROUTE_CUT_CHANGE.Adapt<SqlSugarPagedList<dynamic>>();

                default:
                    var entities = await _taskBaseInfoRepository.AsQueryable()
                                   .Where(t => userlist.Contains(t.CreatedUserId) || (t.RealUserId != null && userlist.Contains(t.RealUserId.Value)) || t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.MBlNo), t => mblList.Contains(t.MBL_NO))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskRecvName), t => t.CreatedUserName.Contains(QuerySearch.TaskRecvName.Trim()))
                                   .WhereIF(etdBegin != DateTime.MinValue, t => t.ETD.HasValue && t.ETD.Value >= etdBegin)
                                   .WhereIF(etdEnd != DateTime.MinValue, t => t.ETD.HasValue && t.ETD.Value < etdEnd)
                                   .WhereIF(taskDateBegin != DateTime.MinValue, t => t.CreatedTime >= taskDateBegin)
                                   .WhereIF(taskDateEnd != DateTime.MinValue, t => t.CreatedTime < taskDateEnd)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskType), t => t.TASK_TYPE.Equals(QuerySearch.TaskType))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskSource), t => t.TASK_SOURCE.Equals(QuerySearch.TaskSource))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.EXCPTION.ToString(), t => t.IS_EXCEPT == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PUBLIC.ToString(), t => t.IS_PUBLIC == 1)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.TaskCategory) && QuerySearch.TaskCategory == TaskStatLevelEnum.PERSON.ToString(), t => t.IS_PUBLIC == 0 && t.IS_EXCEPT == 0)
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.Status), t => t.STATUS.Equals(QuerySearch.Status))
                                   .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.PKId), t => t.PK_ID.Equals(QuerySearch.PKId))
                                   .WhereIF(userIds.Count>0, t => userIds.Contains(t.DJYUserId))
                                   .OrderBy(entityOrderCol + (QuerySearch.descSort ? " desc " : " asc "))

                                   .Select<dynamic>(t => new
                                   {
                                       PK_ID = t.PK_ID.SelectAll()

                                   })
                                   .ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);
                    return entities.Adapt<SqlSugarPagedList<dynamic>>();
                    break;
            }
             
        }
        #endregion
         
        #region 下载正本提单(可批量)
        /// <summary>
        /// 下载正本提单(可批量)
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/DownloadOriginalTask")]
        public async Task<TaskManageOrderResultDto> DownloadOriginalTask(string[] PKIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} 下载正本提单开始", batchNo, string.Join(",", PKIds));

            try
            {
                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID)).ToList();

                _logger.LogInformation("批次={no} 获取任务完成，Num={Num}", batchNo, taskList.Count);

                //获取个人对应的账户,这里GetAccountConfig逻辑优先取个人，个人没有配置取公司对应配置
                var userWebAccountConfig = _webAccountConfig.GetAccountConfig(CONST_WEB_ACCOUNT_TYPE, UserManager.UserId).GetAwaiter().GetResult();

                _logger.LogInformation("批次={no} 获取获取网站的账户完成，result={Num}", batchNo, JSON.Serialize(userWebAccountConfig));

                if (userWebAccountConfig == null)
                    throw Oops.Bah($"个人/公司网站【{CONST_WEB_ACCOUNT_TYPE}】获取失败，请维护个人/公司网站账户信息");

                taskList.ForEach(async tsk =>
                {

                    await InnerDownloadOriginalTask(batchNo, tsk, userWebAccountConfig);
                });

            }
            catch (Exception ex)
            {
                throw Oops.Bah("下载正本提单异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 单票正本下载
        /// <summary>
        /// 单票正本下载
        /// </summary>
        /// <param name="batchNo">批次号</param>
        /// <param name="taskBaseInfo">任务详情</param>
        /// <param name="webAccountConfig">网站账户配置</param>
        /// <returns>返回回执</returns>
        private async Task<TaskManageOrderResultDto> InnerDownloadOriginalTask(string batchNo, TaskBaseInfo taskBaseInfo,
            DjyWebsiteAccountConfig webAccountConfig)
        {
            var result = new TaskManageOrderResultDto();

            /*
             1、TaskOriginalDownloadHisInfo表中处理任务是succ/temp不允许重复下载。failure/timeout的记录可以再次发起下载。
             2、从任务表提取RESULT_NOTE回执信息，里面包含了JSON数据 {"pageUrl":"http://www.cnc-ebusiness.com/ebusiness/bl/detail/AASM104300"}
             3、异步请求正本下载的链接，有超时时间。
             4、下载完成后写入记录
             */

            //正本下载URL
            string originalUrl = string.Empty;

            try
            {
                var hisList = _taskOriginalDownloadHisInfoRepository
                     .Where(t => t.TASK_ID == taskBaseInfo.PK_ID).ToList();

                if (hisList.Any(t => new string[] { "succ", "temp" }.Contains(t.STATUS)))
                    throw Oops.Bah("下载URL不存在，请用最新任务数据");


                if (string.IsNullOrWhiteSpace(taskBaseInfo.RESULT_NOTE))
                    throw Oops.Bah("下载URL不存在，请用最新任务数据");

                var resultObj = JSON.Deserialize<dynamic>(taskBaseInfo.RESULT_NOTE);

                originalUrl = resultObj.pageUrl.ToString();

                if (string.IsNullOrWhiteSpace(originalUrl))
                    throw Oops.Bah("解析下载URL不存在，请用最新任务数据");

                DateTime startDate = DateTime.Now;

                var downloadUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                    .First(t => t.Code.Equals(CONST_BOOK_ORIGINAL_DOWN_URL_CODE, StringComparison.OrdinalIgnoreCase))?.Value;

                if (string.IsNullOrWhiteSpace(downloadUrl))
                    throw Oops.Bah($"正本下载URL不存在，请确认字典是否配置 code={CONST_BOOK_ORIGINAL_DOWN_URL_CODE}");

                TaskOriginalDownloadHisInfo taskOriginalDownloadHisInfo = new TaskOriginalDownloadHisInfo
                {
                    PK_ID = IDGen.NextID().ToString(),
                    TASK_ID = taskBaseInfo.PK_ID,
                    REQUEST_URL = originalUrl,
                    CreatedUserId = UserManager.UserId,
                    CreatedUserName = UserManager.Name,
                    STATUS = "temp",
                    IS_TIMEOUT = 0,
                    START_DATE = startDate,
                    TenantId = UserManager.TENANT_ID,
                    TenantName = UserManager.TENANT_NAME
                };

                //写入记录
                _taskOriginalDownloadHisInfoRepository.Insert(taskOriginalDownloadHisInfo);

                //请求远程链接
                Dictionary<string, string> formDict = new Dictionary<string, string> {
                    {"bno", taskBaseInfo.MBL_NO },
                    {"page_url", downloadUrl },
                    {"web_user", webAccountConfig.Account },
                    {"web_pwd", webAccountConfig.Password },
                    {"web_pwd", "myshipping_task" },
                    {"web_pwd", "" }
                };

                //请求下载正本
                var postResult = await InnerRemoteDownOriginal(batchNo, downloadUrl, formDict);

                //重新获取下载历史 
                var downloadHisInfo = _taskOriginalDownloadHisInfoRepository.AsQueryable()
                       .First(t => t.PK_ID == taskOriginalDownloadHisInfo.PK_ID);

                //更新任务状态
                var taskModel = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskBaseInfo.PK_ID);

                downloadHisInfo.END_DATE = (DateTime)postResult.ext;
                downloadHisInfo.RESULT_NOTE = postResult.msg;

                bool isDownSucc = false;

                //下载返回成功后，更新记录并生成扣费记录
                if (postResult.succ)
                {
                    downloadHisInfo.STATUS = "succ";
                    downloadHisInfo.RESULT_URL = postResult.msg;

                    taskModel.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                    taskModel.COMPLETE_DEAL_NAME = TaskCompleteDealEnum.MANUAL.GetDescription();
                    taskModel.COMPLETE_DATE = DateTime.Now;
                    taskModel.STATUS = TaskStatusEnum.Complete.ToString();
                    taskModel.IS_COMPLETE = 1;

                    isDownSucc = true;
                }
                else
                {
                    if (postResult.isTimeout)
                    {
                        downloadHisInfo.STATUS = "timeout";
                    }
                    else
                    {
                        downloadHisInfo.STATUS = "failure";
                    }
                }

                //更新下载历史
                await _taskOriginalDownloadHisInfoRepository.AsUpdateable(downloadHisInfo).IgnoreColumns(it => new
                {
                    it.TenantId,
                    it.CreatedUserId,
                    it.CreatedUserName
                }).ExecuteCommandAsync();

                //异步扣费,这里不管是否失败都生成扣费记录，只在状态上做标识。
                var chargeResult = await InnerChargeFee(taskBaseInfo, isDownSucc);

                _taskBaseInfoRepository.AsUpdateable(taskModel).UpdateColumns(it => new
                {
                    it.COMPLETE_DATE,
                    it.COMPLETE_DEAL,
                    it.COMPLETE_DEAL_NAME

                }).ExecuteCommand();
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = ex.Message;
            }

            return result;
        }
        #endregion

        #region 远程请求正本下载
        /// <summary>
        /// 远程请求正本下载
        /// </summary>
        /// <param name="batchNo">批次号</param>
        /// <param name="url">请求URL</param>
        /// <param name="dic">请求参数</param>
        /// <returns></returns>
        private async Task<TaskManageOrderResultDto> InnerRemoteDownOriginal(string batchNo, string url, Dictionary<string, string> dic)
        {
            var result = new TaskManageOrderResultDto();

            DateTime bDate = DateTime.Now;

            try
            {
                _logger.LogInformation("批次={no} 请求报文开始", batchNo);

                var res = await url.SetHttpMethod(HttpMethod.Post)
                        .SetBody(dic, "application/x-www-form-urlencoded")
                        .SetContentEncoding(Encoding.UTF8)
                    .PostAsync();

                DateTime eDate = DateTime.Now;
                TimeSpan ts = eDate.Subtract(bDate);
                var timeDiff = ts.TotalMilliseconds;

                _logger.LogInformation("批次={no} 请求完成,耗时：{timeDiff}ms. 结果{msg}", batchNo, timeDiff, JSON.Serialize(res));

                if (res.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    var userResult = await res.Content.ReadAsStringAsync();

                    var downResult = JSON.Deserialize<dynamic>(userResult);

                    //返回详情
                    result.msg = downResult.message.ToString();

                    //返回代码
                    if (downResult.status.ToString() == "1")
                    {
                        result.succ = true;
                    }
                    else
                    {
                        result.succ = false;
                    }
                }

                result.ext = eDate;
            }
            catch (Exception ex)
            {
                //如果有异常直接抛出错误
                throw Oops.Bah(ex.Message);
            }

            return result;
        }
        #endregion

        #region 扣费
        /// <summary>
        /// 扣费
        /// </summary>
        /// <param name="taskBaseInfo">任务信息</param>
        /// <param name="isCharge">是否执行扣费 true-执行扣费 false-不执行扣费（主要是符合扣费条件但是由于超时没有得到准确回执）</param>
        /// <returns>返回回执</returns>
        private async Task<TaskManageOrderResultDto> InnerChargeFee(TaskBaseInfo taskBaseInfo, bool isCharge = true)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto { succ = false };
            try
            {
                decimal balance = 0;
                decimal price = 0;
                decimal total = 0;

                TaskChargesHisInfo model = new TaskChargesHisInfo
                {
                    PK_ID = IDGen.NextID().ToString(),
                    TASK_ID = taskBaseInfo.PK_ID,
                    BEFORE_BALANCE = balance,
                    PRICE = price,
                    BUSI_TYPE = "21",
                    BUSI_TYPE_NAME = String.Empty,
                    SEND_TYPE = "1001",
                    SEND_TYPE_NAME = String.Empty,
                    REMARK = "正本下载",
                    QTY = 1,
                    TOTAL_AMOUNT = total,
                };

                if (!isCharge)
                {
                    model.STATUS = TaskChargeStatusEnum.UNKNOW_RESULT.ToString();
                    model.STATUS_NAME = TaskChargeStatusEnum.UNKNOW_RESULT.GetDescription();
                }

                //写入记录
                await _taskChargesHisInfoRepository.InsertAsync(model);

                result.succ = false;
                result.msg = "扣费失败";
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = ex.Message;
            }

            return result;
        }
        #endregion

        #region 完成任务(可批量)
        /// <summary>
        /// 完成任务(可批量)
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/CompleteTask")]
        public async Task<TaskManageOrderResultDto> CompleteTask([FromBody] string[] PKIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            List<TaskManageOrderResultDto> taskRunList = new List<TaskManageOrderResultDto>();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} 完成任务开始", batchNo, string.Join(",", PKIds));

            try
            {
                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID)).ToList();

                _logger.LogInformation("批次={no} 获取任务完成，Num={Num}", batchNo, taskList.Count);

                var noList = PKIds.Select((a, idx) => new { no = idx + 1, id = a }).ToList();

                foreach (var bk in taskList)
                {
                    var sortNo = noList.FirstOrDefault(a => a.id == bk.PK_ID).no;
                    taskRunList.Add(InnerManualTask(batchNo,bk, TaskOperTypeEnum.COMPLETE_TASK, sortNo).GetAwaiter().GetResult());
                }

                //Task.WaitAll(taskRunList.ToArray());

                result.succ = true;
                result.msg = "执行成功";

                var downResultList = taskRunList.Select(x => x).ToList();

                if (downResultList.Any(x => !x.succ))
                {
                    result.succ = false;
                    result.msg = "执行失败";
                }
                else
                {
                    result.succ = true;
                    result.msg = downResultList.FirstOrDefault().msg;
                }

                result.ext = downResultList;

                var succ = downResultList.Count(x => x.succ);
                var fail = downResultList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"执行异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 单票执行任务
        /// <summary>
        /// 单票执行任务
        /// </summary>
        /// <param name="batchNo">批次号</param>
        /// <param name="taskBaseInfo">任务详情</param>
        /// <param name="taskOperTypeEnum">操作类型</param>
        /// <param name="sortNo">顺序号</param>
        /// <returns>返回回执</returns>
        private async Task<TaskManageOrderResultDto> InnerManualTask(string batchNo, TaskBaseInfo model, 
            TaskOperTypeEnum taskOperTypeEnum, int sortNo)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            result.bno = model.TASK_NO;

            try
            {
                //var model = _taskBaseInfoRepository.Context.CopyNew().Queryable<TaskBaseInfo>().First(t => t.PK_ID == taskBaseInfo.PK_ID);

                if (taskOperTypeEnum == TaskOperTypeEnum.COMPLETE_TASK)
                {
                    if(model.TASK_TYPE == TaskBusiTypeEnum.TRUCK_DISPATCH.ToString())
                    {
                        if(model.STATUS == TaskStatusEnum.Cancel.ToString())
                        {
                            throw Oops.Bah($"当前状态是{TaskStatusEnum.Cancel.GetDescription()} 不能执行完成");
                        }
                    }

                    if (model.TASK_TYPE == TaskBusiTypeEnum.CANCELLATION.ToString())
                    {
                        //收到订舱已被取消邮件后生成的任务，如果点击完成，(订舱状态变为【退舱】,注意这里还需要确认)
                    }

                    model.COMPLETE_DATE = DateTime.Now;
                    model.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                    model.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.GetDescription();
                    model.IS_COMPLETE = 1;
                    model.STATUS = TaskStatusEnum.Complete.ToString();
                    model.STATUS_NAME = TaskStatusEnum.Complete.GetDescription();

                    await _taskBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.COMPLETE_DATE,
                        it.COMPLETE_DEAL,
                        it.COMPLETE_DEAL_NAME,
                        it.IS_COMPLETE,
                        it.STATUS,
                        it.STATUS_NAME
                    }).ExecuteCommandAsync();
                }
                else if (taskOperTypeEnum == TaskOperTypeEnum.CANCEL_TASK)
                {
                    if (model.TASK_TYPE == TaskBusiTypeEnum.CHANGE_SHIP.ToString())
                    {
                        model.STATUS = TaskStatusEnum.Cancel.ToString();
                        model.STATUS_NAME = TaskStatusEnum.Cancel.GetDescription();

                        await _taskBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                        {
                            it.COMPLETE_DATE,
                            it.COMPLETE_DEAL,
                            it.COMPLETE_DEAL_NAME,
                            it.IS_COMPLETE,
                            it.STATUS,
                            it.STATUS_NAME
                        }).ExecuteCommandAsync();
                    }
                    else if (model.TASK_TYPE == TaskBusiTypeEnum.ABORT_CHANGE_SHIP.ToString())
                    {
                        /*
                        1.如果原换船通知已经接受，需要把原船名航次恢复并通知客户取消换船。
                        2.如果原换船通知未作处理，点击接受或者结束任务时提示：本票货存在未处理换船通知，请先结束原换船任务然后结束本任务。
                        3.如果原换船任务为结束任务，在取消换船任务点接受时，提示未做换船，请点击结束任务。
                        */

                        //查询同票主单的是否有未处理的换船通知
                        //_taskBaseInfoRepository.AsQueryable().Where(t=>t.MBL_NO.Equals(taskBaseInfo.MBL_NO) && )
                    }
                    else
                    {
                        model.STATUS = TaskStatusEnum.Cancel.ToString();
                        model.STATUS_NAME = TaskStatusEnum.Cancel.GetDescription();
                        model.UpdatedTime = DateTime.Now;
                        model.UpdatedUserId = UserManager.UserId;
                        model.UpdatedUserName = UserManager.Name;

                        await _taskBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                        {
                            it.UpdatedTime,
                            it.UpdatedUserId,
                            it.UpdatedUserName,
                            it.STATUS,
                            it.STATUS_NAME
                        }).ExecuteCommandAsync();
                    }
                }

                result.succ = true;
                result.msg = "执行成功";
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = ex.Message;
            }

            return result;
        }
        #endregion

        #region 取消任务(可批量)
        /// <summary>
        /// 取消任务(可批量)
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/CancelTask")]
        public async Task<TaskManageOrderResultDto> CancelTask([FromBody] string[] PKIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            List<TaskManageOrderResultDto> taskRunList = new List<TaskManageOrderResultDto>();

            _logger.LogInformation("批次={no} ids={ids} 取消任务开始", batchNo, string.Join(",", PKIds));

            try
            {
                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID)).ToList();

                _logger.LogInformation("批次={no} 获取任务完成，Num={Num}", batchNo, taskList.Count);

                var noList = PKIds.Select((a, idx) => new { no = idx + 1, id = a }).ToList();

                foreach (var bk in taskList)
                {
                    var sortNo = noList.FirstOrDefault(a => a.id == bk.PK_ID).no;
                    taskRunList.Add(InnerManualTask(batchNo, bk, TaskOperTypeEnum.CANCEL_TASK, sortNo).GetAwaiter().GetResult());
                }

                //Task.WaitAll(taskRunList.ToArray());

                result.succ = true;
                result.msg = "执行成功";

                var downResultList = taskRunList.Select(x => x).ToList();

                if (downResultList.Any(x => !x.succ))
                {
                    result.succ = false;
                    result.msg = "执行失败";
                }
                else
                {
                    result.succ = true;
                    result.msg = downResultList.FirstOrDefault().msg;
                }

                result.ext = downResultList;

                var succ = downResultList.Count(x => x.succ);
                var fail = downResultList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("执行异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 挂起任务(可批量)
        /// <summary>
        /// 挂起任务(可批量)
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/PendingTask")]
        public async Task<TaskManageOrderResultDto> PendingTask(string[] PKIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} 挂起任务开始", batchNo, string.Join(",", PKIds));

            List<TaskManageOrderResultDto> taskRunList = new List<TaskManageOrderResultDto>();

            try
            {
                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID)).ToList();

                _logger.LogInformation("批次={no} 获取任务完成，Num={Num}", batchNo, taskList.Count);

                var noList = PKIds.Select((a, idx) => new { no = idx + 1, id = a }).ToList();

                foreach (var bk in taskList)
                {
                    var sortNo = noList.FirstOrDefault(a => a.id == bk.PK_ID).no;
                    taskRunList.Add(InnerManualTask(batchNo, bk, TaskOperTypeEnum.PENDING_TASK, sortNo).GetAwaiter().GetResult());
                }

                //Task.WaitAll(taskRunList.ToArray());

                result.succ = true;
                result.msg = "执行成功";

                var downResultList = taskRunList.Select(x => x).ToList();

                if (downResultList.Any(x => !x.succ))
                {
                    result.succ = false;
                    result.msg = "执行失败";
                }
                else
                {
                    result.succ = true;
                    result.msg = downResultList.FirstOrDefault().msg;
                }

                result.ext = downResultList;

                var succ = downResultList.Count(x => x.succ);
                var fail = downResultList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("完成任务异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 提单纸页数计算
        /// <summary>
        /// 提单纸页数计算
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/LaraPaperCalc")]
        public async Task<List<LaraPaperCalcInfo>> LaraPaperCalc(string[] PKIds)
        {
            List<LaraPaperCalcInfo> list = new List<LaraPaperCalcInfo>();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} 提单纸页数计算开始", batchNo, string.Join(",", PKIds));

            try
            {
                //根据任务主键获取所有主单号列表
                var mblnoList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID) && !string.IsNullOrWhiteSpace(t.MBL_NO))
                    .Select(t => t.MBL_NO).Distinct().ToList();

                if (mblnoList.Count > 0)
                {
                    //根据主单号获取任务类型是DRAFT的任务，取时间最新的
                    var fileList = _taskBaseInfoRepository.EntityContext.Queryable<TaskBaseInfo>()
                        .InnerJoin<TaskFileInfo>((tsk, file) => tsk.PK_ID == file.TASK_PKID)
                        .Where((tsk, file) =>
                        tsk.TASK_TYPE == TaskBusiTypeEnum.DRAFT.ToString() && mblnoList.Contains(tsk.MBL_NO))
                        .Select((tsk, file) => new { tsk = tsk, file = file }).ToList();

                    var calcList = fileList.GroupBy(t => t.tsk.PK_ID)
                        .Select(a =>
                        {
                            var currList = a.ToList();

                            return new
                            {
                                tsk = currList.FirstOrDefault().tsk,
                                clist = a.Select(x => x.file).ToList()
                            };
                        }).OrderByDescending(t => t.tsk.CreatedTime).ToList();


                    list = mblnoList.Select((mbl, idx) =>
                    {
                        var calcInfo = new LaraPaperCalcInfo();

                        calcInfo.MBLNo = mbl;
                        calcInfo.Indx = idx + 1;

                        var files = calcList.FirstOrDefault(t => t.tsk.MBL_NO.Equals(mbl, StringComparison.OrdinalIgnoreCase));

                        if (files != null)
                        {
                            calcInfo.DraftNum = files.clist.Select(t => t.FILE_NAME.GetPageNum()).Sum();
                        }

                        calcInfo.PaperNum = calcInfo.DraftNum * 3;

                        return calcInfo;
                    }).ToList();
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("提单纸页数计算异常,{0}", ex.Message);
            }

            return list;

        }
        #endregion

        #region 请求提单纸登记
        /// <summary>
        /// 请求提单纸登记
        /// </summary>
        /// <param name="laraPaperList">提单纸登记请求参数列表</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/LaraPaperRegistPost")]
        public async Task<TaskManageOrderResultDto> LaraPaperRegistPost(List<LaraPaperRegistPostDto> laraPaperList)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} num={num} LARA提单纸登记开始", batchNo, laraPaperList.Count);

            /*
             1、读取LARA网站的配置账户。
             2、读取字典的URL。
             3、组织请求参数。
             4、写入TASK_LARA_PAPER。
             5、远程请求。
             6、更新状态
             */

            
            try
            {
                var taskArg = laraPaperList.Select(t => t.TaskId).Distinct().ToArray();

                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => taskArg.Contains(t.PK_ID)).ToList();


                _logger.LogInformation("批次={no} 获取任务完成", batchNo);

                //获取个人对应的账户,这里GetAccountConfig逻辑优先取个人，个人没有配置取公司对应配置
                var userWebAccountConfig = _webAccountConfig.GetAccountConfig(CONST_WEB_LARA_ACCOUNT_TYPE, UserManager.UserId).GetAwaiter().GetResult();

                _logger.LogInformation("批次={no} 获取获取网站的账户完成，result={Num}", batchNo, JSON.Serialize(userWebAccountConfig));

                if (userWebAccountConfig == null)
                    throw Oops.Bah($"个人/公司网站【{CONST_WEB_LARA_ACCOUNT_TYPE}】获取失败，请维护个人/公司网站账户信息");

                var downloadUrl = _cache.GetAllDictData().GetAwaiter().GetResult()
                    .First(t => t.Code.Equals(CONST_LARA_DOWN_URL_CODE, StringComparison.OrdinalIgnoreCase))?.Value;

                if (string.IsNullOrWhiteSpace(downloadUrl))
                    throw Oops.Bah($"LARA纸下载URL不存在，请确认字典是否配置 code={CONST_LARA_DOWN_URL_CODE}");

                JObject jobjPost = new JObject();
                jobjPost.Add("customer_user", "myshipping");
                jobjPost.Add("customer_pwd", "");
                JArray jarr = new JArray();
                jobjPost.Add("lara_list", jarr);

                laraPaperList.ForEach(async lara =>
                {
                    TaskLARAPaperInfo taskLARAPaperInfo = new TaskLARAPaperInfo
                    {
                        PK_ID = IDGen.NextID().ToString(),
                        TASK_ID = lara.TaskId,
                        BOOKING_ORDER_NO = "",
                        CreatedUserId = UserManager.UserId,
                        CreatedUserName = UserManager.Name,
                        STATUS = "temp",
                        IS_TIMEOUT = 0,
                        START_DATE = DateTime.Now,
                        TenantId = UserManager.TENANT_ID,
                        TenantName = UserManager.TENANT_NAME,
                        PAGE_NUMBERS = lara.PageNumbers,
                        PAGE_SUM = lara.PageSum,
                        ISSUE_TYPE = lara.ISSUETYPE,
                        MBL_NO = lara.MBLNO,
                        NUMBER_FROM = lara.NumberFrom,
                        NUMBER_TO = lara.NumberTo,
                        DRAFT_NUM = lara.DraftNum,
                    };

                    //写入记录
                    await _taskLARAPaperInfoRepository.InsertAsync(taskLARAPaperInfo);

                    JObject jobjItem = new JObject();
                    jobjItem.Add("customer_user", "myshipping");
                    jobjItem.Add("customer_pwd", "");
                    jobjItem.Add("web_user", userWebAccountConfig.Account);
                    jobjItem.Add("web_pwd", userWebAccountConfig.Password);
                    jobjItem.Add("bno", lara.MBLNO);
                    jobjItem.Add("num_from", lara.NumberFrom);
                    jobjItem.Add("num_to", lara.NumberTo);
                    jobjItem.Add("numbers", lara.PageNumbers);
                    jobjItem.Add("vessel_code", "");
                    jobjItem.Add("voyage_code", "");
                    jobjItem.Add("bl_status", "All");
                    jobjItem.Add("bl_type", "Original Bill");
                    jobjItem.Add("issue_code", "ALL");
                    jarr.Add(jobjItem);

                });
                //await InnerDownloadOriginalTask(batchNo, taskInfo, userWebAccountConfig);

                var postResult = await InnerRemoteDownLaraPaper(batchNo, downloadUrl, JSON.Serialize(jobjPost));

                if (postResult.succ)
                {
                    result.succ = true;
                    result.msg = "成功";
                }
                else
                {
                    result.succ = false;
                    result.msg = postResult.msg;
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("请求提单纸登记异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 远程请求请求提单纸登记
        /// <summary>
        /// 远程请求请求提单纸登记
        /// </summary>
        /// <param name="batchNo">批次号</param>
        /// <param name="url">请求URL</param>
        /// <param name="jsonMsg">请求参数</param>
        /// <returns></returns>
        private async Task<TaskManageOrderResultDto> InnerRemoteDownLaraPaper(string batchNo, string url, string jsonMsg)
        {
            var result = new TaskManageOrderResultDto();

            DateTime bDate = DateTime.Now;

            try
            {
                _logger.LogInformation("批次={no} 请求报文开始", batchNo);

                var res = await url.SetHttpMethod(HttpMethod.Post)
                        .SetBody(jsonMsg, "application/json")
                        .SetContentEncoding(Encoding.UTF8)
                    .PostAsync();

                DateTime eDate = DateTime.Now;
                TimeSpan ts = eDate.Subtract(bDate);
                var timeDiff = ts.TotalMilliseconds;

                _logger.LogInformation("批次={no} 请求完成,耗时：{timeDiff}ms. 结果{msg}", batchNo, timeDiff, JSON.Serialize(res));

                if (res.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    var userResult = await res.Content.ReadAsStringAsync();

                    var downResult = JSON.Deserialize<dynamic>(userResult);

                    //返回详情
                    result.msg = downResult.message.ToString();

                    //返回代码
                    if (downResult.status.ToString() == "1")
                    {
                        result.succ = true;
                    }
                    else
                    {
                        result.succ = false;
                    }
                }

                result.ext = eDate;
            }
            catch (Exception ex)
            {
                //如果有异常直接抛出错误
                throw Oops.Bah(ex.Message);
            }

            return result;
        }
        #endregion

        #region LARA提单纸登记
        /// <summary>
        /// LARA提单纸登记
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/LaraPaperRegist")]
        public async Task<LaraPaperRegistDto> LaraPaperRegist([FromQuery]string[] PKIds)
        {
            LaraPaperRegistDto result = new LaraPaperRegistDto();

            List<LaraPaperRegistDetailDto> list = new List<LaraPaperRegistDetailDto>();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} LARA提单纸登记开始", batchNo, string.Join(",", PKIds));

            /*
             1、通过任务主键记录关联所有相同订舱主键相同并且任务类型是（DRAFT）的记录。
             2、关联任务正本下载运行表（结束时间）

             问题：提单纸页数计算是通过主单号来最新记录提取文件页数，为什么LARA提单纸登记没有用这个模式。（没理解）
             */
            try
            {
                //
                var List = _taskBaseInfoRepository.EntityContext.Queryable<TaskBaseInfo>()
                        .InnerJoin<TaskBaseInfo>((tsk, tsk2) => tsk.BOOK_ORDER_NO == tsk2.BOOK_ORDER_NO)
                        .Where((tsk, tsk2) => PKIds.Contains(tsk.PK_ID) && tsk2.TASK_TYPE == TaskBusiTypeEnum.DRAFT.ToString())
                        .Select((tsk, tsk2) => new { tsk = tsk, tsk2 = tsk2 }).ToList();

                var list2 = List.GroupBy(t => t.tsk.PK_ID).Select(t =>
                {
                    var curList = t.ToList();

                    if (curList.Count > 0)
                    {
                        return new { tsk = curList.FirstOrDefault().tsk, tsk2 = curList.OrderByDescending(a => a.tsk2.CreatedTime).FirstOrDefault().tsk2 };
                    }

                    return null;

                }).Where(t => t != null).ToList();

                if (list2.Count > 0)
                {
                    var taskPKIdList = list2.Select(t => t.tsk2.PK_ID).Distinct().ToArray();

                    var originalDownloadHisInfo = _taskOriginalDownloadHisInfoRepository.AsQueryable()
                        .Where(t => taskPKIdList.Contains(t.TASK_ID))
                        .OrderByDescending(t => t.END_DATE)
                        .First();

                    var fileList = _taskBaseInfoRepository.EntityContext.Queryable<TaskBaseInfo>()
                        .InnerJoin<TaskFileInfo>((tsk, file) => tsk.PK_ID == file.TASK_PKID)
                        .Where((tsk, file) =>
                        tsk.TASK_TYPE == TaskBusiTypeEnum.DRAFT.ToString() && taskPKIdList.Contains(tsk.PK_ID))
                        .Select((tsk, file) => new { tsk = tsk, file = file }).ToList();

                    var calcList = fileList.GroupBy(t => t.tsk.PK_ID)
                        .Select(a =>
                        {
                            var currList = a.ToList();

                            return new
                            {
                                tsk = currList.FirstOrDefault().tsk,
                                clist = a.Select(x => x.file).ToList()
                            };
                        }).OrderByDescending(t => t.tsk.CreatedTime).ToList();

                    var bookingNoList = list2.Select(t => !string.IsNullOrWhiteSpace(t.tsk.BOOK_ORDER_NO) ?long.Parse(t.tsk.BOOK_ORDER_NO):0)
                        .Where(t=>t > 0).Distinct().ToList();

                    var orderList = _bookingOrderRepository.AsQueryable().Where(t => bookingNoList.Contains(t.Id)).ToList();

                    list2.ForEach(t =>
                    {
                        LaraPaperRegistDetailDto laraInfo = new LaraPaperRegistDetailDto();

                        laraInfo.OrderNo = t.tsk.BOOK_ORDER_NO;
                        laraInfo.TaskId = t.tsk.PK_ID;
                        laraInfo.MBLNo = t.tsk.MBL_NO;

                        var files = calcList.FirstOrDefault(a => a.tsk.PK_ID.Equals(t.tsk2.PK_ID));

                        if (files != null)
                        {
                            laraInfo.DraftNum = files.clist.Select(t => t.FILE_NAME.GetPageNum()).Sum();
                        }

                        laraInfo.OriginalDownTime = originalDownloadHisInfo?.END_DATE;

                        var orderInfo = orderList.FirstOrDefault(a => a.Id == long.Parse(t.tsk.BOOK_ORDER_NO));

                        laraInfo.IssueType = orderInfo?.ISSUETYPE;
                        //laraInfo.IssueTypeName = t.tsk2.issu;

                        list.Add(laraInfo);
                    });

                    result.DetailList = list;
                }

                var laraPaperInfo = _taskLARAPaperInfoRepository.AsQueryable()
                     .Where(t => t.CreatedUserId == UserManager.UserId)
                     .OrderByDescending(t => t.NUMBER_TO).First();

                result.NumberTo = laraPaperInfo != null ? laraPaperInfo.NUMBER_TO : "1".PadLeft(9, '0'); ;

                result.CalcList = InnerCalcLaraPageNumbers(new CalcLaraPageNumbersDto
                {
                    numberTo = result.NumberTo,
                    paperList = result.DetailList.Select((t, idx) =>
                    {
                        return new LaraPaperRegistPostDto
                        {
                            DraftNum = t.DraftNum,
                            ISSUETYPE = t.IssueType,
                            MBLNO = t.MBLNo,
                            TaskId = t.TaskId,
                            ORDNO = t.OrderNo,
                            SortNo = idx + 1,
                        };
                    }).ToList()
                },true);

            }
            catch (Exception ex)
            {
                throw Oops.Bah("LARA提单纸登记异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 下载任务附件
        /// <summary>
        /// 下载任务附件
        /// </summary>
        /// <param name="taskPKId"></param>
        /// <returns>返回文件流</returns>
        [HttpGet("/TaskManage/DownloadTaskAttach")]
        public async Task<IActionResult> DownloadTaskAttach([FromQuery] string taskPKId)
        {
            FileStreamResult result = null;

            string batchNo = IDGen.NextID().ToString();

            var fileList = _taskFileInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskPKId).OrderByDescending(t=>t.CreatedTime).ToList();

            var fileInfo = fileList.FirstOrDefault();
            if (fileInfo.FILE_PATH.StartsWith("http://"))
            {
                var fileStream = await InnerGetDownloadFile(fileInfo.FILE_PATH, taskPKId, batchNo);

                result = new FileStreamResult(fileStream, "application/octet-stream") { FileDownloadName = fileInfo.FILE_NAME };
            }
            else if (System.IO.File.Exists(fileInfo.FILE_PATH))
            {
                result = new FileStreamResult(new FileStream(fileInfo.FILE_PATH, FileMode.Open), "application/octet-stream") { FileDownloadName = fileInfo.FILE_NAME };
            }

            return result;
        }
        #endregion

        #region 异步下载文件
        /// <summary>
        /// 异步下载文件
        /// </summary>
        /// <param name="fileUrl">文件请求URL</param>
        /// <param name="taskPKId">任务主键</param>
        /// <param name="batchNo">批次号</param>
        /// <returns>返回文件流</returns>
        private async Task<Stream> InnerGetDownloadFile(string fileUrl,string taskPKId,string batchNo)
        {
            Stream stream = null;
            try
            {
                DateTime bDate = DateTime.Now;

                stream = await fileUrl.GetAsStreamAsync();

                DateTime eDate = DateTime.Now;
                TimeSpan ts = eDate.Subtract(bDate);
                var timeDiff = ts.TotalMilliseconds;

                _logger.LogInformation("批次={no} url={url} 请求完成,耗时：{timeDiff}ms.", batchNo, fileUrl, timeDiff);
            }
            catch (Exception ex)
            {
                _logger.LogInformation("批次={no} url={url} 下载文件异常, 结果{msg}", batchNo, fileUrl, ex.Message);
                
                throw Oops.Bah(nameof(InnerGetDownloadFile)+"下载文件异常,{0}", ex.Message);
            }

            return stream;
        }
        #endregion

        #region 正本附件批量打印
        /// <summary>
        /// 正本附件批量打印
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回文件流</returns>
        [HttpPost("/TaskManage/PrintBatch")]
        public async Task<IActionResult> PrintBatch(string[] PKIds)
        {
            FileStreamResult result = null;
            /*
             1、通过任务主键获取所有的文件列表。只合并PDF文件，其他的文件不处理。
             2、创建临时文件存放目录。
             3、如果是http://开头的文档，需要使用下载文件,并变更为本地文件
             4、PDF合成所有文件。
             5、写入下载记录表。
             6、返回文件流。
             */

            try
            {
                var fileList = _taskBaseInfoRepository.EntityContext.Queryable<TaskBaseInfo>()
                    .InnerJoin<TaskFileInfo>((tsk, file) => tsk.PK_ID == file.TASK_PKID)
                    .Where((tsk, file) => PKIds.Contains(tsk.PK_ID) && file.FILE_TYPE.Equals(".pdf"))
                    .Select((tsk, file) => new { tsk = tsk, file = file }).ToList();

                var calcList = fileList.GroupBy(t => t.tsk.PK_ID)
                    .Select(a =>
                    {
                        var currList = a.ToList();

                        return new
                        {
                            tsk = currList.FirstOrDefault().tsk,
                            clist = a.Select(x => x.file).ToList()
                        };
                    }).OrderByDescending(t => t.tsk.CreatedTime).ToList();

                var pdfList = calcList.SelectMany(t => t.clist).Select((t, idx) => new
                {
                    Idx = idx,
                    file = t
                }).ToList();


                if (pdfList.Count == 0)
                    throw Oops.Oh($"没有可以合并的PDF文件");

                string filePath = string.Empty;
                string tempFileName = IDGen.NextID().ToString();

                var opt = App.GetOptions<TempFileOptions>().Path;

                filePath = $"{Path.Combine(App.WebHostEnvironment.WebRootPath, opt)}\\TempPDFMerge\\";//服务器路径

                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                {
                    filePath = filePath.Replace("\\", "/");
                }

                //预先创建目录
                if (!Directory.Exists(filePath))
                {
                    Directory.CreateDirectory(filePath);
                }

                var mergePdfPath = Path.Combine(filePath, $"{tempFileName}.pdf");

                /*
                Document document = null;
                PdfCopy copy = null;

                pdfList.ForEach(t => { 
                    if(t.Idx == 0)
                    {
                        if(t.file.FILE_PATH.IndexOf("http://") >=0)
                        {
                            //var dw = InnerRemoteDownFile(t.file.FILE_PATH).GetAwaiter().GetResult();

                            WebClient wc = new WebClient();
                            wc.DownloadFile(t.file.FILE_PATH, Path.Combine(filePath, $"{tempFileName}abc.pdf"));

                            //document = new Document(new PdfReader(dw).GetPageSize(1));
                        }
                        else
                        {
                            document = new Document(new PdfReader(t.file.FILE_PATH).GetPageSize(1));
                        }

                        copy = new PdfCopy(document, new FileStream(mergePdfPath, FileMode.Create));
                    }
                    else
                    {
                        PdfReader reader = null;

                        if (t.file.FILE_PATH.IndexOf("http://") >= 0)
                        {
                            var dw = InnerRemoteDownFile(t.file.FILE_PATH).GetAwaiter().GetResult();

                            reader = new PdfReader(dw);
                        }
                        else
                        {
                            reader = new PdfReader(t.file.FILE_PATH);
                        }

                        int n = reader.NumberOfPages;
                        for (int j = 1; j <= n; j++)
                        {
                            document.NewPage();
                            PdfImportedPage page = copy.GetImportedPage(reader, j);
                            copy.AddPage(page);
                        }
                        reader.Close();
                    }
                });

                document.Close();
                */

                result = new FileStreamResult(new FileStream(mergePdfPath, FileMode.Open), "application/octet-stream") { FileDownloadName = $"{tempFileName}.pdf" };
            }
            catch (Exception ex)
            {
                throw Oops.Bah("LARA提单纸登记异常,{0}", ex.Message);
            }


            return result;
        }
        #endregion

        #region 下载文件
        private async Task<Stream> InnerRemoteDownFile(string filePath)
        {
            using (HttpClient client = new HttpClient())
            {
                HttpResponseMessage response = await client.GetAsync(filePath);

                if (response.IsSuccessStatusCode)
                {
                    System.Net.Http.HttpContent content = response.Content;
                    var contentStream = await content.ReadAsStreamAsync(); // get the actual content stream
                    return contentStream;
                }
                else
                {
                    throw new FileNotFoundException($"{filePath} 文件下载失败");
                }
            }
        }
        #endregion

        #region 接收换船
        /// <summary>
        /// 接收换船
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/AcceptChangeShip")]
        public async Task<TaskManageOrderResultDto> AcceptChangeShip([FromQuery]string taskPKId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                _logger.LogInformation("批次={no} ids={ids} 获取任务完成", batchNo, taskPKId);

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.CHANGE_SHIP.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.CHANGE_SHIP.GetDescription()}，不能接收换船");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.STATUS != TaskStatusEnum.Create.ToString())
                    Oops.Oh($"任务状态不是{0}，不能【接收换船】", TaskStatusEnum.Create.GetDescription());

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                if (orderInfo == null)
                {
                    orderInfo = _bookingOrderRepository.AsQueryable().First(t => t.MBLNO == taskInfo.MBL_NO);

                    _logger.LogInformation("批次={no} 订舱主键{id}获取任务失败，通过主单号{mblno}提取完成", batchNo, taskInfo.BOOK_ORDER_NO, taskInfo.MBL_NO);
                }
                    

                if (orderInfo == null)
                    Oops.Oh($"订舱信息获取失败");

                var userMail = _djyUserMailAccountRepository.AsQueryable().First(x => x.CreatedUserId == orderInfo.CreatedUserId);


                if (userMail == null || string.IsNullOrWhiteSpace(userMail.SmtpServer) || userMail.SmtpPort == 0)
                {
                    Oops.Oh($"发件邮箱未配置,或者配置不完整");
                }

                _logger.LogInformation("批次={no} 获取用户邮箱配置完成", batchNo);

                if (!string.IsNullOrWhiteSpace(taskInfo.RESULT_NOTE))
                    Oops.Oh($"获取换船任务详情失败");

                _logger.LogInformation("批次={no} 获取换船任务详情,{note}", batchNo, taskInfo.RESULT_NOTE);

                var jsonObj = JSON.Deserialize<dynamic>(taskInfo.RESULT_NOTE);

                var taskChangeShipModel = new TaskChangeShipHisInfo {
                    PK_ID = IDGen.NextID().ToString(),
                    TASK_PKID = taskInfo.PK_ID,
                    BOOK_ORDER_NO = orderInfo.Id.ToString(),
                    MBL_NO = orderInfo.MBLNO,
                    VESSEL_TO = jsonObj.vessel.ToString(),
                    VOYNO_TO = jsonObj.voyno.ToString(),
                    SHIP_AGENCY_TO = jsonObj.shipagency != null ? jsonObj.shipagency : "",
                    VESSEL_SRC = orderInfo.VESSEL,
                    VOYNO_SRC = orderInfo.VOYNO,
                    SHIP_AGENCY_SRC = orderInfo.SHIPAGENCY,
                    CreatedTime = DateTime.Now,
                    CreatedUserId = UserManager.UserId,
                    CreatedUserName = UserManager.Name
                };

                //写入换船历史表
                await _taskChangeShipHisInfoRepository.InsertAsync(taskChangeShipModel);

                _logger.LogInformation("批次={no} 写入换船历史表完成{id}", batchNo, taskChangeShipModel.PK_ID);

                //更新任务状态
                orderInfo = _bookingOrderRepository.AsQueryable().First(t => t.Id == orderInfo.Id);

                var oldOrderInfo = orderInfo.Adapt<BookingOrder>();

                orderInfo.VESSEL = taskChangeShipModel.VESSEL_TO;
                orderInfo.VOYNO = taskChangeShipModel.VOYNO_TO;
                orderInfo.SHIPAGENCY = taskChangeShipModel.SHIP_AGENCY_TO;
                orderInfo.CreatedTime = DateTime.Now;
                orderInfo.CreatedUserId = UserManager.UserId;
                orderInfo.CreatedUserName = UserManager.Name;

                //更新订舱详情
                await _bookingOrderRepository.AsUpdateable(orderInfo).UpdateColumns(it => new
                {
                    it.UpdatedTime,
                    it.UpdatedUserId,
                    it.UpdatedUserName,
                    it.VESSEL,
                    it.VOYNO
                }).ExecuteCommandAsync();

                // 记录日志
                var bookingOrderService = _namedBookingOrderServiceProvider.GetService<ITransient>(nameof(BookingOrderService));
                await bookingOrderService.SaveLog(orderInfo, oldOrderInfo, "接收换船后更新订舱");

                _logger.LogInformation("批次={no} 更新订舱完成", batchNo);

                taskInfo.STATUS = TaskStatusEnum.Complete.ToString();
                taskInfo.STATUS_NAME = TaskStatusEnum.Complete.GetDescription();

                taskInfo.COMPLETE_DATE = DateTime.Now;
                taskInfo.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                taskInfo.COMPLETE_DEAL_NAME = TaskCompleteDealEnum.MANUAL.GetDescription();

                taskInfo.UpdatedTime = DateTime.Now;
                taskInfo.UpdatedUserId = UserManager.UserId;
                taskInfo.UpdatedUserName = UserManager.Name;

                //更新任务表
                await _taskBaseInfoRepository.AsUpdateable(taskInfo).UpdateColumns(it => new
                {
                    it.STATUS,
                    it.STATUS_NAME,
                    it.COMPLETE_DATE,
                    it.COMPLETE_DEAL,
                    it.COMPLETE_DEAL_NAME,
                    it.UpdatedTime,
                    it.UpdatedUserId,
                    it.UpdatedUserName
                }).ExecuteCommandAsync();

                _logger.LogInformation("批次={no} 更新任务完成", batchNo);

                //提取订舱相关联系的邮箱信息
                var bookContactEmailList = _bookingOrderContactRepository.AsQueryable().Where(t => t.BookingId == orderInfo.Id && !string.IsNullOrWhiteSpace(t.Email))
                    .Select(t => t.Email).Distinct().ToList();

                if(bookContactEmailList.Count > 0)
                {
                    string sendTo = string.Join(";", bookContactEmailList.ToArray());

                    string emailSubject = $"换船通知-{orderInfo.MBLNO}";
                    string emailBody = $"提单号为{orderInfo.MBLNO}的订舱已换船<br/>";

                    var sendResult = await MailSendHelper.SendMail(userMail, emailSubject, emailBody, sendTo);

                    _logger.LogInformation("批次={no} 发送邮件完成 {rlt}", batchNo,JSON.Serialize(sendResult));

                    //接受之后重新发送放舱
                }

                result.succ = true;
                result.msg = "操作成功";
            }
            catch (Exception ex)
            {
                throw Oops.Bah("接收换船异常,{0}", ex.Message);
            }
            return result;
        }
        #endregion

        #region 取消换船
        /// <summary>
        /// 取消换船
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/AcceptCancelChangeShip")]
        public async Task<TaskManageOrderResultDto> AcceptCancelChangeShip([FromQuery] string taskPKId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                _logger.LogInformation("批次={no} ids={ids} 获取任务完成", batchNo, taskPKId);

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.ABORT_CHANGE_SHIP.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.ABORT_CHANGE_SHIP.GetDescription()}，不能取消换船");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.STATUS != TaskStatusEnum.Create.ToString())
                    Oops.Oh($"任务状态不是{0}，不能【取消换船】", TaskStatusEnum.Create.GetDescription());

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                if (orderInfo == null)
                    Oops.Oh($"订舱信息获取失败");

                _logger.LogInformation("批次={no} 订舱主键{id}获取订舱完成", batchNo, taskInfo.BOOK_ORDER_NO);

                var userMail = _djyUserMailAccountRepository.AsQueryable().First(x => x.CreatedUserId == orderInfo.CreatedUserId);

                if (userMail == null || string.IsNullOrWhiteSpace(userMail.SmtpServer) || userMail.SmtpPort == 0)
                {
                    Oops.Oh($"发件邮箱未配置,或者配置不完整");
                }

                if (!string.IsNullOrWhiteSpace(taskInfo.RESULT_NOTE))
                    Oops.Oh($"获取换船任务详情失败");

                _logger.LogInformation("批次={no} 获取换船任务详情,{note}", batchNo, taskInfo.RESULT_NOTE);

                var jsonObj = JSON.Deserialize<dynamic>(taskInfo.RESULT_NOTE);

                //获取任务历史
                var lastChangShipTask = await _taskBaseInfoRepository.AsQueryable().Where(t=>t.BOOK_ORDER_NO == taskInfo.BOOK_ORDER_NO && t.TASK_TYPE == TaskBusiTypeEnum.CHANGE_SHIP.ToString())
                    .OrderByDescending(t=>t.CreatedTime).FirstAsync();

                if(lastChangShipTask != null)
                {
                    if (lastChangShipTask.STATUS == TaskStatusEnum.Create.ToString()) //原换船通知未作处理
                    {
                        throw Oops.Bah("本票货存在未处理换船通知，请先结束原换船任务然后结束本任务。");
                    }
                    
                    if (lastChangShipTask.STATUS == TaskStatusEnum.Cancel.ToString()) //原换船任务为结束任务
                    {
                        throw Oops.Bah("未做换船，请点击结束任务。");
                    }

                    if (lastChangShipTask.STATUS == TaskStatusEnum.Complete.ToString()) //原换船通知已经接受
                    {
                        //查询换船历史，恢复换船
                        var lastChangeShip = await _taskChangeShipHisInfoRepository.AsQueryable().Where(t => t.BOOK_ORDER_NO == orderInfo.Id.ToString())
                             .OrderByDescending(t => t.CreatedTime).FirstAsync();

                        if (lastChangeShip == null)
                            throw Oops.Bah("查询换船历史失败");

                        //更新任务状态
                        orderInfo = _bookingOrderRepository.AsQueryable().First(t => t.Id == orderInfo.Id);

                        orderInfo.VESSEL = lastChangeShip.VESSEL_SRC;
                        orderInfo.VOYNO = lastChangeShip.VOYNO_SRC;
                        orderInfo.SHIPAGENCY = lastChangeShip.SHIP_AGENCY_SRC;

                        _logger.LogInformation($"{orderInfo.MBLNO}接受取消换船，从{orderInfo.VESSEL}/{orderInfo.VOYNO} 到 {jsonObj.vessel.ToString()}/{jsonObj.voyno.ToString()}");

                        orderInfo.CreatedTime = DateTime.Now;
                        orderInfo.CreatedUserId = UserManager.UserId;
                        orderInfo.CreatedUserName = UserManager.Name;

                        //更新订舱详情
                        await _bookingOrderRepository.AsUpdateable(orderInfo).UpdateColumns(it => new
                        {
                            it.UpdatedTime,
                            it.UpdatedUserId,
                            it.UpdatedUserName,
                            it.VESSEL,
                            it.VOYNO
                        }).ExecuteCommandAsync();

                        _logger.LogInformation("批次={no} 更新订舱完成", batchNo);

                        taskInfo.STATUS = TaskStatusEnum.Complete.ToString();
                        taskInfo.STATUS_NAME = TaskStatusEnum.Complete.GetDescription();

                        taskInfo.COMPLETE_DATE = DateTime.Now;
                        taskInfo.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                        taskInfo.COMPLETE_DEAL_NAME = TaskCompleteDealEnum.MANUAL.GetDescription();

                        taskInfo.UpdatedTime = DateTime.Now;
                        taskInfo.UpdatedUserId = UserManager.UserId;
                        taskInfo.UpdatedUserName = UserManager.Name;

                        //更新任务表
                        await _taskBaseInfoRepository.AsUpdateable(taskInfo).UpdateColumns(it => new
                        {
                            it.STATUS,
                            it.STATUS_NAME,
                            it.COMPLETE_DATE,
                            it.COMPLETE_DEAL,
                            it.COMPLETE_DEAL_NAME,
                            it.UpdatedTime,
                            it.UpdatedUserId,
                            it.UpdatedUserName
                        }).ExecuteCommandAsync();

                        _logger.LogInformation("批次={no} 更新任务完成", batchNo);

                        //提取订舱相关联系的邮箱信息
                        var bookContactEmailList = _bookingOrderContactRepository.AsQueryable().Where(t => t.BookingId == orderInfo.Id && !string.IsNullOrWhiteSpace(t.Email))
                            .Select(t => t.Email).Distinct().ToList();

                        if (bookContactEmailList.Count > 0)
                        {
                            string sendTo = string.Join(";", bookContactEmailList.ToArray());

                            string emailSubject = $"取消换船通知-{orderInfo.MBLNO}";
                            string emailBody = $"取消换船通知-{orderInfo.MBLNO}\", $\"提单号为{orderInfo.MBLNO}的订舱已取消换船<br/>";

                            var sendResult = await MailSendHelper.SendMail(userMail, emailSubject, emailBody, sendTo);

                            _logger.LogInformation("批次={no} 发送邮件完成 {rlt}", batchNo, JSON.Serialize(sendResult));

                            //接受之后重新发送放舱
                        }
                    }
                }


                result.succ = true;
                result.msg = "操作成功";
            }
            catch (Exception ex)
            {
                throw Oops.Bah("取消换船异常,{0}", ex.Message);
            }
            return result;
        }
        #endregion

        #region 转发电放邮件
        /// <summary>
        /// 转发电放邮件
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <param name="toMail">指定邮件地址</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/SendTelexEmail")]
        public async Task<TaskManageOrderResultDto> SendTelexEmail([FromQuery] string taskPKId, [FromQuery] string toMail)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.TELEX_NOTICE.ToString() || taskInfo.TASK_TYPE != TaskBusiTypeEnum.SEAWAYBILL_DOWN.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.TELEX_NOTICE.GetDescription()}、{TaskBusiTypeEnum.SEAWAYBILL_DOWN.GetDescription()}，不能转发邮件");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                if (orderInfo == null)
                    Oops.Oh($"订舱信息获取失败");


                var userMail = _djyUserMailAccountRepository.AsQueryable().First(x => x.CreatedUserId == orderInfo.CreatedUserId);


                if (userMail == null || string.IsNullOrWhiteSpace(userMail.SmtpServer) || userMail.SmtpPort == 0)
                {
                    Oops.Oh($"发件邮箱未配置,或者配置不完整");
                }

                string emailSubject = string.Empty;
                string emailBody = string.Empty;

                var sendResult = await MailSendHelper.SendMail(userMail, emailSubject, emailBody, toMail);

                if (!sendResult.Key)
                {
                    Oops.Oh(sendResult.Value);
                }
            }
            catch(Exception ex)
            {
                throw Oops.Bah("获取发送下货纸异常,{0}", ex.Message);
            }
            return result;
        }
        #endregion

        #region 发送下货纸
        /// <summary>
        /// 发送下货纸
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <param name="fileRole">文件功能 (9原始)</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/SendShippingOrder")]
        public async Task<TaskManageOrderResultDto> SendShippingOrder([FromQuery] string taskPKId, [FromQuery] string fileRole = "9")
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            /*
             1、查询任务关联的订舱信息。
             2、触发下货纸发送。
             3、发送成功更新任务状态为成功。
             4、查看用户公司是否配置了反馈地址，如果有配置则触发反馈推送，否则显示反馈失败提示。
             5、触发扣费
             */
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                if(taskInfo.TASK_TYPE != TaskBusiTypeEnum.SHIPPING_ORDER.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.SHIPPING_ORDER.GetDescription()}，不能发送下货纸");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                if (orderInfo == null)
                    Oops.Oh($"订舱信息获取失败");

                //推送下货纸业务
                var rtn = await XiahuozhiHelpler.Send(orderInfo.Id, fileRole);

                if (!rtn.Key)
                {
                    throw Oops.Bah($"发送失败：{rtn.Value}");
                }

                //订舱状态写入
                await SaveBookingStatus(orderInfo.Id, "sta_xhz", "下货纸");

                taskInfo.STATUS = TaskStatusEnum.Complete.ToString();
                taskInfo.STATUS_NAME = TaskStatusEnum.Complete.GetDescription();

                taskInfo.COMPLETE_DATE = DateTime.Now;
                taskInfo.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                taskInfo.COMPLETE_DEAL_NAME = TaskCompleteDealEnum.MANUAL.GetDescription();

                taskInfo.UpdatedTime = DateTime.Now;
                taskInfo.UpdatedUserId = UserManager.UserId;
                taskInfo.UpdatedUserName = UserManager.Name;

                //更新任务表
                await _taskBaseInfoRepository.AsUpdateable(taskInfo).UpdateColumns(it => new
                {
                    it.STATUS,
                    it.STATUS_NAME,
                    it.COMPLETE_DATE,
                    it.COMPLETE_DEAL,
                    it.COMPLETE_DEAL_NAME,
                    it.UpdatedTime,
                    it.UpdatedUserId,
                    it.UpdatedUserName
                }).ExecuteCommandAsync();

                await InnerChargeFeeShippingOrder(taskInfo);

                //反馈用户（这里预留，主要考虑是否通过用户配置确定是否需要推送回执）
                await FeedbackXiaHuoZhi("");
            }
            catch(Exception ex)
            {
                throw Oops.Bah("发送下货纸异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 更新订舱的状态
        /// <summary>
        /// 更新订舱的状态
        /// </summary>
        /// <param name="bookingId">订舱主键</param>
        /// <param name="code">状态代码</param>
        /// <param name="name">状态名称</param>
        /// <returns></returns>
        private async Task SaveBookingStatus(long bookingId, string code, string name)
        {
            var bookSta = _bookingStatusRepository.FirstOrDefault(x => x.BookingId == bookingId && x.StaCode == code);

            if (bookSta == null)
            {
                //记录状态
                bookSta = new BookingStatus();
                bookSta.BookingId = bookingId;
                bookSta.StaCode = code;
                bookSta.StaName = name;
                bookSta.StaTime = DateTime.Now;
                await _bookingStatusRepository.InsertAsync(bookSta);
            }
            else
            {
                bookSta.StaTime = DateTime.Now;
                await _bookingStatusRepository.UpdateAsync(bookSta);
            }
        }
        #endregion

        #region 扣费
        /// <summary>
        /// 扣费
        /// </summary>
        /// <param name="taskBaseInfo">任务信息</param>
        /// <param name="isCharge">是否执行扣费 true-执行扣费 false-不执行扣费（主要是符合扣费条件但是由于超时没有得到准确回执）</param>
        /// <returns>返回回执</returns>
        private async Task<TaskManageOrderResultDto> InnerChargeFeeShippingOrder(TaskBaseInfo taskBaseInfo, bool isCharge = true)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto { succ = false };
            try
            {
                decimal balance = 0;
                decimal price = 0;
                decimal total = 0;

                TaskChargesHisInfo model = new TaskChargesHisInfo
                {
                    PK_ID = IDGen.NextID().ToString(),
                    TASK_ID = taskBaseInfo.PK_ID,
                    BEFORE_BALANCE = balance,
                    PRICE = price,
                    BUSI_TYPE = "21",
                    BUSI_TYPE_NAME = String.Empty,
                    SEND_TYPE = "1001",
                    SEND_TYPE_NAME = String.Empty,
                    REMARK = "下货纸",
                    QTY = 1,
                    TOTAL_AMOUNT = total,
                };

                if (!isCharge)
                {
                    model.STATUS = TaskChargeStatusEnum.UNKNOW_RESULT.ToString();
                    model.STATUS_NAME = TaskChargeStatusEnum.UNKNOW_RESULT.GetDescription();
                }

                //写入记录
                await _taskChargesHisInfoRepository.InsertAsync(model);

                result.succ = false;
                result.msg = "扣费失败";
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = ex.Message;
            }

            return result;
        }
        #endregion

        #region 获取订舱详情
        /// <summary>
        /// 获取订舱详情
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetBookingOrderInfo")]
        public async Task<TaskBookingOrderDto> GetBookingOrderInfo([FromQuery]string taskPKId)
        {
            TaskBookingOrderDto model = new TaskBookingOrderDto();

            string batchNo = IDGen.NextID().ToString();
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                if(orderInfo != null)
                {
                    //订舱
                    model = orderInfo.Adapt<TaskBookingOrderDto>();

                    var contaList = await _bookingOrderContaRepository.AsQueryable().Where(x => x.BILLID == orderInfo.Id).ToListAsync();

                    //获取集装箱的主键
                    var ctnArg = contaList.Select(t => t.Id).ToArray();

                    //查询集装箱所有的货物信息
                    var cargoList = await _bookingOrderContaCargoRepository.AsQueryable()
                         .Where(x => ctnArg.Contains(x.CTNID.Value)).ToListAsync();

                    _logger.LogInformation("批次={no} 提取货物明细完成 数量={total}", batchNo, cargoList.Count);

                    if (cargoList.Count > 0)
                    {
                        model.ContaList = contaList.GroupJoin(cargoList, l => l.Id, r => r.CTNID, (l, r) => {
                            var currList = r.ToList();

                            if (currList.Count > 0)
                            {
                                var info = l.Adapt<TaskBookingOrderContaDto>();
                                info.CargoList = currList.Adapt<List<TaskBookingOrderCargoDto>>();

                                return info;
                            }

                            return l.Adapt<TaskBookingOrderContaDto>();

                        }).ToList();
                    }
                    else
                    {
                        model.ContaList = contaList.Adapt<List<TaskBookingOrderContaDto>>();
                    }

                    //任务
                    model.TaskBaseInfo = taskInfo.Adapt<TaskBaseInfoDto>();
                }

            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取订舱详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        #region 下货纸反馈
        /// <summary>
        /// 下货纸反馈
        /// </summary>
        /// <param name="bsno"></param>
        /// <returns></returns>
        private async Task FeedbackXiaHuoZhi(string bsno)
        {
            /*
            var para = commonData.ParamValues.AsNoTracking().FirstOrDefault(x => x.CompId == compid && x.ParaCode == "XHZ_FEEDBACK_URL");
            if (para == null || string.IsNullOrEmpty(para.ItemCode))
            {
                msg = "下货纸反馈地址未配置";
                return false;
            }

            var feedbask = new BackgroundTaskCommon();
            feedbask.GID = Guid.NewGuid().ToString();
            feedbask.Status = BackgroundTaskCommon.StatusCreate;
            feedbask.Type = BackgroundTaskCommon.TypeHttpFeedback;
            feedbask.CreateTime = DateTime.Now;
            feedbask.ParamData = JsonConvert.SerializeObject(new
            {
                url = para.ItemCode,
                method = "POST",
                json = JsonConvert.SerializeObject(new
                {
                    bsno,
                    status
                })
            });
            commonData.BackgroundTaskCommon.Add(feedbask);

            msg = "成功";
            return true;
            */
        }
        #endregion

        #region 获取航次账单详情
        /// <summary>
        /// 获取航次账单详情
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetInvoiceBillInfo")]
        public async Task<TaskInvoiceBillBaseInfo> GetInvoiceBillInfo([FromQuery] string taskPKId)
        {
            TaskInvoiceBillBaseInfo model = new TaskInvoiceBillBaseInfo();

            string batchNo = IDGen.NextID().ToString();
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                if(taskInfo.TASK_TYPE != TaskBusiTypeEnum.INVOICE_BILL_MAIL.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.INVOICE_BILL_MAIL.GetDescription()}");

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                model.TaskId = taskInfo.PK_ID;

                if (orderInfo != null)
                {
                    //订舱
                    model.BookingOrder = orderInfo.Adapt<TaskBookingOrderDto>();
                }

                //获取文件
                var fileList = _taskFileInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID).ToList();

                model.TaskFile = fileList.Adapt<List<TaskManageOrderFileInfo>>();

                var feeList = _taskBillFeeDetailInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID).ToList();

                model.FeeList = feeList.Where(t => t.IS_TOTAL == 0).Select(t=>t.Adapt<TaskInvoiceBillFeeDto>()).ToList();

                var totalUSD = feeList.FirstOrDefault(t => t.IS_TOTAL == 1 && t.FEE_NAME == "TotalUSD" && t.CURRENCY == "USD");

                model.TotalAmountUSD = totalUSD != null ? totalUSD.TOTAL_AMOUNT : 0;

                var totalCNY = feeList.FirstOrDefault(t => t.IS_TOTAL == 1 && t.FEE_NAME == "TotalCNY" && t.CURRENCY == "CNY");

                model.TotalAmountCNY = totalCNY != null ? totalCNY.TOTAL_AMOUNT : 0;

                model.InvoiceBillSendList = new List<TaskInvoiceBillFileHis>();
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取获取航次账单详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        #region 获取单票账单详情
        /// <summary>
        /// 获取单票账单详情
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetTaskPerBillInfo")]
        public async Task<TaskPerBillResultInfo> GetTaskPerBillInfo([FromQuery] string taskPKId)
        {
            TaskPerBillResultInfo model = new TaskPerBillResultInfo();

            string batchNo = IDGen.NextID().ToString();
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.PER_BILL.ToString())
                    Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.PER_BILL.GetDescription()}");

                var orderInfo = _bookingOrderRepository.AsQueryable()
                    .First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                model.TaskId = taskInfo.PK_ID;

                var perBillInfo = _taskPerBillBaseInfoRepository.AsQueryable().First(t => t.TASK_PKID == taskInfo.PK_ID);

                if (perBillInfo == null)
                    Oops.Oh($"单票账单不存在");

                model.TaskPerBillBaseInfoDto = perBillInfo.Adapt<TaskPerBillBaseInfoDto>();

                if (orderInfo != null)
                {
                    //订舱
                    model.BookingOrder = orderInfo.Adapt<TaskBookingOrderDto>();
                }

                //获取文件
                var fileList = _taskFileInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID).ToList();

                model.TaskFile = fileList.Adapt<List<TaskManageOrderFileInfo>>();

                var feeList = _taskBillFeeDetailInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID).ToList();

                model.FeeList = feeList.Where(t => t.IS_TOTAL == 0).Select(t => t.Adapt<TaskPerBillFeeDto>()).ToList();
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取获取单票账单详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        #region 获取提单纸登记记录
        /// <summary>
        /// 获取提单纸登记记录
        /// </summary>
        /// <param name="querySearch">查询条件</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/GetLaraPaperRecordPage")]
        public async Task<SqlSugarPagedList<LaraPaperRecordDto>> GetLaraPaperRecordPageAsync(QueryTaskManageBaseDto querySearch)
        {
            string entityOrderCol = "CreatedTime";

            //这里因为返回给前端的台账数据是DTO，所以这里排序时候需要转换成Entity对应的字段
            if (!string.IsNullOrWhiteSpace(querySearch.SortField))
                entityOrderCol = MapsterExtHelper.GetAdaptProperty<LaraPaperRecordDto, TaskLARAPaperInfo>(querySearch.SortField);

            var entities = await _taskLARAPaperInfoRepository.AsQueryable()
                                     .OrderBy(entityOrderCol + (querySearch.descSort ? " asc " : " desc "))
                                     .ToPagedListAsync(querySearch.PageNo, pageSize: querySearch.PageSize);


            return entities.Adapt<SqlSugarPagedList<LaraPaperRecordDto>>();
        }
        #endregion

        #region 导出LARA提单纸登记记录
        /// <summary>
        /// 导出LARA提单纸登记记录
        /// </summary>
        /// <param name="sortField">排序字段</param>
        /// <param name="pageNo">当前页码</param>
        /// <param name="pageSize">页码容量</param>
        /// <param name="descSort">排序方法,默认降序</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/LaraPaperRecordExport")]
        public async Task<IActionResult> LaraPaperRecordExport([FromQuery] string sortField,[FromQuery] int pageNo = 1, [FromQuery] int pageSize = 30, [FromQuery] bool descSort = true)
        {
            QueryTaskManageBaseDto querySearch = new QueryTaskManageBaseDto
            {
                SortField = sortField,
                PageNo = pageNo,
                PageSize = pageSize,
                descSort = descSort
            };

            string entityOrderCol = "CreatedTime";

            var entities = await _taskLARAPaperInfoRepository.AsQueryable()
                                     .OrderBy(entityOrderCol + (querySearch.descSort ? " asc " : " desc "))
                                     .ToPagedListAsync(querySearch.PageNo, pageSize: querySearch.PageSize);

            if(entities.Items.Count() == 0)
            {
                throw Oops.Oh($"没有可以导出的数据");
            }

            var list = entities.Items.Adapt<List<LaraPaperRecordDto>>();

            //导出Excel文件流
            var ms = ExportXlsLaraPaperRecord(list);

            return new FileStreamResult(ms, "application/vnd.ms-excel") { FileDownloadName = $"{DateTime.Now.ToString("yyyyMMddHHmmss")}_LaraPaperRecord.xls" };
        }
        #endregion

        #region 导出提单纸登记记录生成Excel
        /// <summary>
        /// 导出提单纸登记记录生成Excel
        /// </summary>
        /// <param name="list">LARA提单纸登记记录列表</param>
        /// <returns>返回Excel文件流</returns>
        private MemoryStream ExportXlsLaraPaperRecord(List<LaraPaperRecordDto> list)
        {
            MemoryStream ms = new MemoryStream();

            try
            {
                IWorkbook workbook = new HSSFWorkbook();
                ISheet sheet = workbook.CreateSheet();
                IRow headerRow = sheet.CreateRow(0);
                var headers = new string[] { "打印日期", "提单号", "Paper Number From", "Paper Number To", "Sum", "签单方式", "LARA登记时间", "LARA登记人" };
                for (int i = 0; i < headers.Length; i++)
                {
                    string head = headers[i];
                    var headCell = headerRow.CreateCell(i);
                    headCell.SetCellValue(head);
                }

                int rowIndex = 1;
                foreach (var item in list)
                {
                    IRow dataRow = sheet.CreateRow(rowIndex);
                    var cell0 = dataRow.CreateCell(0);
                    cell0.SetCellValue(item.OriginalDownTime);

                    var cell1 = dataRow.CreateCell(1);
                    cell1.SetCellValue(item.MBLNo);

                    var cell2 = dataRow.CreateCell(2);
                    cell2.SetCellValue(item.NumberFrom);

                    var cell3 = dataRow.CreateCell(3);
                    cell3.SetCellValue(item.NumberTo);

                    var cell4 = dataRow.CreateCell(4);
                    cell4.SetCellValue(item.PageSum);

                    var cell5 = dataRow.CreateCell(5);
                    cell5.SetCellValue(item.IssueTypeName);

                    var cell6 = dataRow.CreateCell(6);
                    cell6.SetCellValue(item.CreatedTime);

                    var cell7 = dataRow.CreateCell(7);
                    cell7.SetCellValue(item.CreatedUserName);

                    rowIndex++;
                }

                workbook.Write(ms, true);
                ms.Flush();
                ms.Position = 0;
            }
            catch (Exception ex)
            {
                throw Oops.Bah("导出提单纸登记记录生成Excel异常,{0}", ex.Message);
            }

            return ms;
        }
        #endregion

        #region 保存SI信息
        /// <summary>
        /// 保存SI信息
        /// </summary>
        /// <param name="model">订舱信息</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/SaveBookingSI")]
        public async Task<TaskManageOrderResultDto> SaveBookingSI(TaskBookingOrderDto model)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            /*
             1、比较原始数据和修改数据内容，记录差异。
             2、更新订舱主信息和集装箱信息。
             3、写入本地历史记录表。
             */
            try
            {
                if (string.IsNullOrWhiteSpace(model.TaskBaseInfo.PKId))
                    throw Oops.Oh($"任务主键TaskBaseInfo.PKId不能为空");

                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == model.TaskBaseInfo.PKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.SI_FEEDBACK.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.SI_FEEDBACK.GetDescription()}");

                //取订舱详情（包含集装箱）
                var bookOrderList = _bookingOrderRepository.EntityContext.Queryable<BookingOrder>()
                        .LeftJoin(_bookingOrderRepository.EntityContext.Queryable<BookingCtn>(),(bk, ctn) => bk.Id == ctn.BILLID)
                        .Where((bk, ctn) => bk.Id == long.Parse(taskInfo.BOOK_ORDER_NO) && bk.TenantId == UserManager.TENANT_ID)
                        .Select((bk, ctn) => new { bk = bk, ctn = ctn }).ToList();

                var orderInfo = bookOrderList.FirstOrDefault().bk;

                List<BookingCtn> orderCtnList = new List<BookingCtn>();

                //这里是左连接查询，解决集装箱为空的情况
                if(bookOrderList.Any(t=>t.ctn.Id > 0))
                    orderCtnList = bookOrderList.Select(t => t.ctn).ToList();

                var mdBookingOrder = model.Adapt<BookingOrder>();

                mdBookingOrder.Id = orderInfo.Id;
                mdBookingOrder.UpdatedTime = DateTime.Now;
                mdBookingOrder.UpdatedUserId = UserManager.UserId;
                mdBookingOrder.UpdatedUserName = UserManager.Name;

                //比对主订舱信息
                var orderDiff = InnerCompare(orderInfo, mdBookingOrder);

                //比对箱信息
                var contaList = model.ContaList.Select(x => x.Adapt<BookingCtn>()).ToList();

                /**/
                //这里参考原有的更新逻辑，只更新了SI回执有的字段信息，其他字段不更新，如果后期有调整可以自行增加更新字段
                await _bookingOrderRepository.AsUpdateable(mdBookingOrder).UpdateColumns(it => new
                {
                    it.UpdatedTime,
                    it.UpdatedUserId,
                    it.UpdatedUserName,
                    it.SHIPPER,
                    it.CONSIGNEE,
                    it.NOTIFYPARTY,
                    it.MARKS,
                    it.DESCRIPTION,
                    it.BLFRT,
                    it.SERVICE,
                    it.ISSUETYPE,
                    it.PORTLOADID,
                    it.PORTLOAD,
                    it.PORTDISCHARGEID,
                    it.PORTDISCHARGE,
                    it.TRANSPORTID,
                    it.TRANSPORT,
                    it.DESTINATIONID,
                    it.DESTINATION,
                    it.PKGS,
                    it.KINDPKGS,
                    it.KGS,
                    it.CBM,
                    it.THIRDPAYADDR,
                    it.SIREMARK
                }).ExecuteCommandAsync();

                var ctnlist = await _bookingOrderContaRepository.AsQueryable().Where(x => x.BILLID == mdBookingOrder.Id).ToListAsync();

                var si2orderCtnList = contaList.GroupJoin(ctnlist, l => l.CNTRNO?.Trim(), r => r.CNTRNO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    if(currInfo == null)
                    {
                        l.BILLID = orderInfo.Id;
                        l.CreatedTime = DateTime.Now;
                        l.CreatedUserId = UserManager.UserId;
                        l.CreatedUserName = UserManager.Name;

                        l.UpdatedTime = l.CreatedTime;
                        l.UpdatedUserId = UserManager.UserId;
                        l.UpdatedUserName = UserManager.Name;
                        return new { OperType = "insert", obj = l };
                    }
                    else
                    {
                        currInfo.Id = l.Id;
                        currInfo.BILLID = l.BILLID;
                        currInfo.UpdatedTime = DateTime.Now;
                        currInfo.UpdatedUserId = UserManager.UserId;
                        currInfo.UpdatedUserName = UserManager.Name;

                        return new { OperType = "update", obj = currInfo };
                    }
                }).ToList();


                var delList = ctnlist.GroupJoin(contaList, l => l.CNTRNO?.Trim(), r => r.CNTRNO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    if (currInfo == null)
                    {
                        l.UpdatedTime = DateTime.Now;
                        l.UpdatedUserId = UserManager.UserId;
                        l.UpdatedUserName = UserManager.Name;
                        return new { OperType = "delete", obj = l };
                    }

                    return new { OperType = string.Empty, obj = l };
                }).Where(t=>t.OperType != string.Empty).ToList();


                if (delList.Count > 0)
                    si2orderCtnList.AddRange(delList);


                if (si2orderCtnList.Count > 0)
                {
                    si2orderCtnList.ForEach(async ctn =>
                    {
                        if (ctn.OperType == "insert")
                        {
                            //插入
                            await _bookingOrderContaRepository.InsertAsync(ctn.obj);
                        }
                        else if (ctn.OperType == "update")
                        {
                            //更新
                            await _bookingOrderContaRepository.AsUpdateable(ctn.obj).UpdateColumns(it => new
                            {
                                it.CTNALL,
                                it.SEALNO,
                                it.PKGS,
                                it.KGS,
                                it.CBM,
                                it.UpdatedTime,
                                it.UpdatedUserId,
                                it.UpdatedUserName,
                            }).ExecuteCommandAsync();
                        }
                        else if (ctn.OperType == "delete")
                        {
                            await _bookingOrderContaRepository.DeleteAsync(x => x.Id == ctn.obj.Id);
                        }
                    });
                }

                result.succ = true;
                result.msg = "保存SI信息成功";
            }
            catch(Exception ex)
            {
                throw Oops.Bah("保存SI信息异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 获取SI反馈信息
        /// <summary>
        /// 获取SI反馈信息
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetSIFeedBackInfo")]
        public async Task<TaskSIFeedBackResultDto> GetSIFeedBackInfo(string taskPKId)
        {
            TaskSIFeedBackResultDto model = new TaskSIFeedBackResultDto();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.SI_FEEDBACK.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.SI_FEEDBACK.GetDescription()}");


                var bookOrderList = _bookingOrderRepository.EntityContext.Queryable<BookingOrder>()
                        .InnerJoin<BookingCtn>((bk, ctn) => bk.Id == ctn.BILLID)
                        .Where((bk, ctn) => bk.Id == long.Parse(taskInfo.BOOK_ORDER_NO) && bk.TenantId == UserManager.TENANT_ID)
                        .Select((bk, ctn) => new { bk = bk, ctn = ctn }).ToList();

                var orderInfo = bookOrderList.FirstOrDefault().bk;

                model.TaskId = taskInfo.PK_ID;

                var siFeedBackList = _taskSISubmittedRepository.EntityContext.Queryable<TaskSIFeedBackInfo>()
                        .InnerJoin<TaskSIFeedBackContaInfo>((si, ctn) => si.PK_ID == ctn.P_PKID)
                        .Where((si, ctn) => si.TASK_PKID == model.TaskId && si.TenantId == UserManager.TENANT_ID)
                        .Select((si, ctn) => new { si = si, ctn = ctn }).ToList();

                if (siFeedBackList.Count == 0)
                    throw Oops.Oh($"SI反馈信息不存在");

                var siFeedBackInfo = siFeedBackList.FirstOrDefault().si;

                var resultInfo = siFeedBackInfo.Adapt<TaskSIFeedBackResultBusiDto>();

                resultInfo.ContaList = siFeedBackList.Select(t => t.ctn.Adapt<TaskSIFeedBackResultContaDto>()).ToList();

                model.BusiInfo = resultInfo;

                if (orderInfo != null)
                {
                    //订舱
                    model.BookingOrder = orderInfo.Adapt<TaskBookingOrderDto>();
                }

                //进行数据比对确认差异字段KEY
                var mainDiff = await InnerCompareMainInfoDiff(orderInfo, siFeedBackInfo);

                model.SICompareOrderKeyList = mainDiff;

                var contaDiff = await InnerCompareContaInfoDiff(bookOrderList.Select(t=>t.ctn).ToList(),
                    siFeedBackList.Select(t=>t.ctn).ToList());

                model.SICompareOrderContaKeyList = contaDiff;
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取获取单票账单详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        private List<TaskCompareResultDto> InnerCompare(object srcModel,object targetModel)
        {
            List<TaskCompareResultDto> list = new List<TaskCompareResultDto>();

            if(srcModel is BookingOrder)
            {
                var srcBK = (BookingOrder)srcModel;
                var targetBK = (BookingOrder)targetModel;

                var bookProps = typeof(BookingOrder).GetProperties();

                list = bookProps.Select(prop =>
                {
                    var bk1Val = prop.GetValue(srcBK);
                    var bk2Val = prop.GetValue(targetBK);

                    if (prop.PropertyType == typeof(string))
                    {
                        string st1 = (bk1Val as string).AdjustString();
                        string st2 = (bk2Val as string).AdjustString();

                        if (st1 != st2)
                        {
                            return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };
                        }

                        return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = false, ValType = prop.PropertyType };
                    }
                    else if (prop.PropertyType == typeof(int?))
                    {
                        var dt1 = bk1Val as int?;
                        var dt2 = bk2Val as int?;

                        if (dt1 != dt2)
                        {
                            return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };
                        }

                        return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };
                    }
                    else if (prop.PropertyType == typeof(decimal?))
                    {
                        var dt1 = bk1Val as decimal?;
                        var dt2 = bk2Val as decimal?;

                        if (dt1 != dt2)
                        {
                            return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };
                        }

                        return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };
                    }

                    if (bk1Val != bk2Val)
                        return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = true, ValType = prop.PropertyType };


                    return new TaskCompareResultDto { Code = prop.Name, SrcVal = bk1Val, TargetVal = bk2Val, IsDiff = false, ValType = prop.PropertyType };
                }).ToList();
            }


            return list;
        }

        #region 比较主信息
        /// <summary>
        /// 比较主信息
        /// </summary>
        /// <param name="bookingOrder">订舱详情</param>
        /// <param name="taskSIFeedBackInfo">SI反馈详情</param>
        /// <returns>返回差异</returns>
        private async Task<List<string>> InnerCompareMainInfoDiff(BookingOrder bookingOrder, TaskSIFeedBackInfo taskSIFeedBackInfo)
        {
            List<string> resultList = new List<string>();

            //需要比对的字段
            var compareField = new string[] { "SHIPPER", "CONSIGNEE", "NOTIFYPARTY", "MARKS", "DESCRIPTION", "BLFRT", "SERVICE", "ISSUETYPE", "PORTLOAD", "PORTDISCHARGE",
                "TRANSPORT", "DESTINATION", "PKGS", "KGS", "CBM", "KINDPKGS", "THIRDPAYADDR" };

            var bookProps = typeof(BookingOrder).GetProperties();
            var feedProps = typeof(TaskSIFeedBackInfo).GetProperties();

            resultList = bookProps.GroupJoin(feedProps, l => l.Name.ToUpper(),
                r => r.Name.ToUpper(), (l, r) =>
            {
                if (compareField.Any(x => x.Equals(l.Name, StringComparison.OrdinalIgnoreCase)))
                {
                    var currList = r.ToList();

                    if (currList.Count > 0)
                    {
                        var si = r.FirstOrDefault();

                        var bkVal = l.GetValue(bookingOrder);
                        var siVal = si.GetValue(taskSIFeedBackInfo);

                        if (l.PropertyType == typeof(string))
                        {
                            string st1 = (bkVal as string).AdjustString();
                            string st2 = (siVal as string).AdjustString();

                            if (!st1.Equals(st2))
                            {
                                return l.Name.ToUpper();
                            }

                            return string.Empty;
                        }
                        else if (l.PropertyType == typeof(int?))
                        {
                            var dt1 = bkVal as int?;
                            var dt2 = siVal as int?;

                            if (!dt1.Equals(dt2))
                            {
                                return l.Name.ToUpper();
                            }

                            return string.Empty;
                        }
                        else if (l.PropertyType == typeof(decimal?))
                        {
                            var dt1 = bkVal as decimal?;
                            var dt2 = siVal as decimal?;

                            if (!dt1.Equals(dt2))
                            {
                                return l.Name.ToUpper();
                            }

                            return string.Empty;
                        }
                    }

                    return string.Empty;
                }

                return string.Empty;

            }).Where(t => !string.IsNullOrWhiteSpace(t)).ToList();

            return resultList;
        }
        #endregion

        #region 比较箱信息
        /// <summary>
        /// 比较箱信息
        /// </summary>
        /// <param name="bookContaList">订舱箱信息</param>
        /// <param name="siContaList">SI反馈箱信息</param>
        /// <returns>返回差异</returns>
        private async Task<List<string>> InnerCompareContaInfoDiff(List<BookingCtn> bookContaList,List<TaskSIFeedBackContaInfo> siContaList)
        {
            List<string> resultList = new List<string>();

            var bookProps = typeof(BookingCtn).GetProperties();
            var feedProps = typeof(TaskSIFeedBackContaInfo).GetProperties();

            resultList = siContaList.GroupJoin(bookContaList, l => l.CONTA_NO, r => r.CNTRNO, (l, r) =>
            {
                var currList = r.ToList();

                if (currList.Count > 0)
                {
                    var bkCtn = currList.FirstOrDefault();

                    if (!l.KGS.Equals(bkCtn.KGS)
                        || !l.PKGS.Equals(bkCtn.PKGS)
                        || !l.SEAL_NO.Equals(bkCtn.SEALNO)
                        || !l.CONTA_TYPE.Equals(bkCtn.CTNALL)
                        || !l.CBM.Equals(bkCtn.CBM))
                    {
                       return l.CONTA_NO;
                    }

                    return String.Empty;
                }

                return l.CONTA_NO;
            }).Where(t => !string.IsNullOrWhiteSpace(t)).ToList();

            return resultList;
        }
        #endregion

        #region 获取VGM比较结果
        /// <summary>
        /// 获取VGM比较结果
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetVGMCompareResult")]
        public async Task<TaskVgmCompareResultDto> GetVGMCompareResult(string taskPKId)
        {
            TaskVgmCompareResultDto model = new TaskVgmCompareResultDto();

            List<TaskVgmCompareDto> list = new List<TaskVgmCompareDto>();
            List<TaskVgmCompareDto> list2 = new List<TaskVgmCompareDto>();
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.VGM_COMPARE.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.VGM_COMPARE.GetDescription()}");
                /*
                var vgmList = _taskVGMFeedBackInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID)
                    .ToList();

                if(vgmList.Count == 0)
                    throw Oops.Oh($"VGM反馈信息不存在");

                var contaList = _bookingOrderContaRepository.AsQueryable().Where(t => t.BILLID == long.Parse(taskInfo.BOOK_ORDER_NO)).ToList();

                list = contaList.GroupJoin(vgmList, l => l.CNTRNO?.Trim(), r => r.CONTA_NO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    TaskVgmCompareDto md = l.Adapt<TaskVgmCompareDto>();

                    md.compareDiffList = new List<string>();

                    if (currInfo != null)
                    {
                        if(l.SEALNO != currInfo.SEAL_NO)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.SealNo));
                        }
                        if (l.CTNCODE != currInfo.CONTA_TYPE)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.ContaType));
                        }
                        if (l.CTNALL != currInfo.CONTA_TYPE_NAME)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.ContaTypeName));
                        }
                        if (l.KGS != currInfo.KGS)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.KGS));
                        }
                        if (l.TAREWEIGHT != currInfo.TAREWEIGHT)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.TareWeight));
                        }
                        if (l.WEIGHKGS != currInfo.WEIGHKGS)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.WeighKGs));
                        }
                        if (l.WEIGHTYPE != currInfo.WEIGHTYPE)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.WeighType));
                        }
                    }
                    else
                    {
                        md.compareDiffList = new List<string> { nameof(TaskVgmCompareDto.ContaNo), 
                            nameof(TaskVgmCompareDto.SealNo),
                            nameof(TaskVgmCompareDto.ContaType),
                            nameof(TaskVgmCompareDto.ContaTypeName),
                            nameof(TaskVgmCompareDto.KGS),
                            nameof(TaskVgmCompareDto.TareWeight),
                            nameof(TaskVgmCompareDto.WeighKGs),
                            nameof(TaskVgmCompareDto.WeighType),
                        };
                    }

                    return md;
                }).ToList();

                model.bookOrderCompareList = list;

                list2 = vgmList.GroupJoin(contaList, l => l.CONTA_NO?.Trim(), r => r.CNTRNO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    TaskVgmCompareDto md = l.Adapt<TaskVgmCompareDto>();

                    md.compareDiffList = new List<string>();

                    if (currInfo != null)
                    {
                        if (l.SEAL_NO != currInfo.SEALNO)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.SealNo));
                        }
                        if (l.CONTA_TYPE != currInfo.CTNCODE)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.ContaType));
                        }
                        if (l.CONTA_TYPE_NAME != currInfo.CTNALL)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.ContaTypeName));
                        }
                        if (l.KGS != currInfo.KGS)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.KGS));
                        }
                        if (l.TAREWEIGHT != currInfo.TAREWEIGHT)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.TareWeight));
                        }
                        if (l.WEIGHKGS != currInfo.WEIGHKGS)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.WeighKGs));
                        }
                        if (l.WEIGHTYPE != currInfo.WEIGHTYPE)
                        {
                            md.compareDiffList.Add(nameof(TaskVgmCompareDto.WeighType));
                        }
                    }
                    else
                    {
                        md.compareDiffList = new List<string> { nameof(TaskVgmCompareDto.ContaNo),
                            nameof(TaskVgmCompareDto.SealNo),
                            nameof(TaskVgmCompareDto.ContaType),
                            nameof(TaskVgmCompareDto.ContaTypeName),
                            nameof(TaskVgmCompareDto.KGS),
                            nameof(TaskVgmCompareDto.TareWeight),
                            nameof(TaskVgmCompareDto.WeighKGs),
                            nameof(TaskVgmCompareDto.WeighType),
                        };
                    }

                    return md;
                }).ToList();

                model.vgmCompareList = list2;
                */
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取VGM比较结果异常,{0}", ex.Message);
            }

            return model;
        }
        #endregion

        #region 更新订舱（VGM比较更新）
        /// <summary>
        /// 更新订舱（VGM比较更新）
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/SaveBookingVGM")]
        public async Task<TaskManageOrderResultDto> SaveBookingVGM(string taskPKId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.VGM_COMPARE.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.VGM_COMPARE.GetDescription()}");

                //取订舱详情（包含集装箱）
                var bookOrderList = _bookingOrderRepository.EntityContext.Queryable<BookingOrder>()
                        .LeftJoin(_bookingOrderRepository.EntityContext.Queryable<BookingCtn>(), (bk, ctn) => bk.Id == ctn.BILLID)
                        .Where((bk, ctn) => bk.Id == long.Parse(taskInfo.BOOK_ORDER_NO) && bk.TenantId == UserManager.TENANT_ID)
                        .Select((bk, ctn) => new { bk = bk, ctn = ctn }).ToList();

                var orderInfo = bookOrderList.FirstOrDefault().bk;

                List<BookingCtn> orderCtnList = new List<BookingCtn>();

                //这里是左连接查询，解决集装箱为空的情况
                if (bookOrderList.Any(t => t.ctn.Id > 0))
                    orderCtnList = bookOrderList.Select(t => t.ctn).ToList();

                /*
                var contaList = _taskVGMFeedBackInfoRepository.AsQueryable().Where(t => t.TASK_PKID == taskInfo.PK_ID).ToList();

                var si2orderCtnList = contaList.GroupJoin(orderCtnList, l => l.CONTA_NO?.Trim(), r => r.CNTRNO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    var contaInfo = l.Adapt<BookingCtn>();

                    if (currInfo == null)
                    {
                        contaInfo.BILLID = orderInfo.Id;
                        contaInfo.CreatedTime = DateTime.Now;
                        contaInfo.CreatedUserId = UserManager.UserId;
                        contaInfo.CreatedUserName = UserManager.Name;

                        contaInfo.UpdatedTime = contaInfo.CreatedTime;
                        contaInfo.UpdatedUserId = UserManager.UserId;
                        contaInfo.UpdatedUserName = UserManager.Name;

                        return new { OperType = "insert", obj = contaInfo };
                    }
                    else
                    {
                        currInfo.Id = contaInfo.Id;
                        currInfo.BILLID = contaInfo.BILLID;
                        currInfo.UpdatedTime = DateTime.Now;
                        currInfo.UpdatedUserId = UserManager.UserId;
                        currInfo.UpdatedUserName = UserManager.Name;

                        return new { OperType = "update", obj = currInfo };
                    }
                }).ToList();


                var delList = orderCtnList.GroupJoin(contaList, l => l.CNTRNO?.Trim(), r => r.CONTA_NO?.Trim(), (l, r) => {
                    var currInfo = r.FirstOrDefault();

                    if (currInfo == null)
                    {
                        l.UpdatedTime = DateTime.Now;
                        l.UpdatedUserId = UserManager.UserId;
                        l.UpdatedUserName = UserManager.Name;
                        return new { OperType = "delete", obj = l };
                    }

                    return new { OperType = string.Empty, obj = l };
                }).Where(t => t.OperType != string.Empty).ToList();


                if (delList.Count > 0)
                    si2orderCtnList.AddRange(delList);


                if (si2orderCtnList.Count > 0)
                {
                    si2orderCtnList.ForEach(async ctn =>
                    {
                        if (ctn.OperType == "insert")
                        {
                            //插入
                            await _bookingOrderContaRepository.InsertAsync(ctn.obj);
                        }
                        else if (ctn.OperType == "update")
                        {
                            //更新
                            await _bookingOrderContaRepository.AsUpdateable(ctn.obj).UpdateColumns(it => new
                            {
                                it.CTNALL,
                                it.SEALNO,
                                it.PKGS,
                                it.KGS,
                                it.CBM,
                                it.UpdatedTime,
                                it.UpdatedUserId,
                                it.UpdatedUserName,
                            }).ExecuteCommandAsync();
                        }
                        else if (ctn.OperType == "delete")
                        {
                            await _bookingOrderContaRepository.DeleteAsync(x => x.Id == ctn.obj.Id);
                        }
                    });
                }
                */
                result.succ = true;
                result.msg = "更新订舱成功";
            }
            catch(Exception ex)
            {
                throw Oops.Bah("更新订舱（VGM比较更新）异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 获取换船详情
        /// <summary>
        /// 获取换船详情
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetChangeShipInfo")]
        public async Task<TaskChangeShipResultDto> GetChangeShipInfo(string taskPKId)
        {
            TaskChangeShipResultDto model = new TaskChangeShipResultDto();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.CHANGE_SHIP.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.CHANGE_SHIP.GetDescription()}");

                BookingOrder bookingOrder = null;

                if (!string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    bookingOrder = _bookingOrderRepository.AsQueryable().First(t=>t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                //这里参考源程序，如果任务没有对应订舱数据则通过主单号匹配一条订舱数据
                if(bookingOrder == null)
                    bookingOrder = _bookingOrderRepository.AsQueryable().First(t => t.MBLNO == taskInfo.MBL_NO && !t.ParentId.HasValue);

                if (bookingOrder == null)
                    throw Oops.Oh($"订舱信息获取失败，MBLNO={taskInfo.MBL_NO}");

                if (string.IsNullOrWhiteSpace(taskInfo.RESULT_NOTE))
                    throw Oops.Oh($"任务反馈详情不存在");

                var rtl = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(taskInfo.RESULT_NOTE);

                model.TaskId = taskInfo.PK_ID;
                model.TaskStatus = taskInfo.STATUS;
                model.TaskStatusName = taskInfo.STATUS_NAME;

                model.Vessel = rtl.vessel.ToString();
                model.Voyno = rtl.voyno.ToString();
                model.ShipAgency = rtl.shipagency == null? rtl.shipagency.ToString():"";
                model.MailUrl = rtl.mail_url.ToString();
                
                model.OriginalVessel = bookingOrder.VESSEL;
                model.OriginalVoyno = bookingOrder.VOYNO;
                model.MBlNo = bookingOrder.MBLNO;

                //获得未处理的任务数量
                model.TotalTask = await _taskBaseInfoRepository.AsQueryable().Where(t => t.CreatedTime < taskInfo.CreatedTime && t.STATUS == TaskStatusEnum.Create.ToString() 
                    && (t.TASK_TYPE == TaskBusiTypeEnum.CHANGE_SHIP.ToString() || t.TASK_TYPE == TaskBusiTypeEnum.ABORT_CHANGE_SHIP.ToString())).CountAsync();
                
            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取换船详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        #region 获取取消换船详情
        /// <summary>
        /// 获取取消换船详情
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/GetAbortChangeShipInfo")]
        public async Task<TaskChangeShipResultDto> GetAbortChangeShipInfo(string taskPKId)
        {
            TaskChangeShipResultDto model = new TaskChangeShipResultDto();

            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

                if (taskInfo == null)
                    throw Oops.Oh($"任务信息获取失败");

                if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    throw Oops.Oh($"任务信息的订舱主键不存在");

                if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.ABORT_CHANGE_SHIP.ToString())
                    throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.ABORT_CHANGE_SHIP.GetDescription()}");

                BookingOrder bookingOrder = null;

                if (!string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                    bookingOrder = _bookingOrderRepository.AsQueryable().First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

                //这里参考源程序，如果任务没有对应订舱数据则通过主单号匹配一条订舱数据
                if (bookingOrder == null)
                    bookingOrder = _bookingOrderRepository.AsQueryable().First(t => t.MBLNO == taskInfo.MBL_NO && !t.ParentId.HasValue);

                if (bookingOrder == null)
                    throw Oops.Oh($"订舱信息获取失败，MBLNO={taskInfo.MBL_NO}");

                if (string.IsNullOrWhiteSpace(taskInfo.RESULT_NOTE))
                    throw Oops.Oh($"任务反馈详情不存在");

                var rtl = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(taskInfo.RESULT_NOTE);

                model.TaskId = taskInfo.PK_ID;
                model.TaskStatus = taskInfo.STATUS;
                model.TaskStatusName = taskInfo.STATUS_NAME;

                model.Vessel = rtl.vessel.ToString();
                model.Voyno = rtl.voyno.ToString();
                model.ShipAgency = rtl.shipagency == null ? rtl.shipagency.ToString() : "";
                model.MailUrl = rtl.mail_url.ToString();

                model.OriginalVessel = bookingOrder.VESSEL;
                model.OriginalVoyno = bookingOrder.VOYNO;
                model.MBlNo = bookingOrder.MBLNO;

                //获得未处理的任务数量
                model.TotalTask = await _taskBaseInfoRepository.AsQueryable().Where(t => t.CreatedTime < taskInfo.CreatedTime && t.STATUS == TaskStatusEnum.Create.ToString()
                    && (t.TASK_TYPE == TaskBusiTypeEnum.CHANGE_SHIP.ToString() || t.TASK_TYPE == TaskBusiTypeEnum.ABORT_CHANGE_SHIP.ToString())).CountAsync();

            }
            catch (Exception ex)
            {
                throw Oops.Bah("获取取消换船详情异常,{0}", ex.Message);
            }
            return model;
        }
        #endregion

        #region 手工批量重新比对BC
        /// <summary>
        /// 手工批量重新比对BC
        /// </summary>
        /// <param name="PKIds">任务主键数组</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/ManualReCompareBC")]
        public async Task<TaskManageOrderResultDto> ManualReCompareBC(string[] PKIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} ids={ids} 手工批量重新比对BC开始", batchNo, string.Join(",", PKIds));

            try
            {
                var taskList = _taskBaseInfoRepository.AsQueryable().Where(t => PKIds.Contains(t.PK_ID)).ToList();

                _logger.LogInformation("批次={no} 获取任务完成，Num={Num}", batchNo, taskList.Count);

                var list = new List<TaskManageOrderResultDto>();

                taskList.ForEach(async tsk =>
                {
                    var rlt = await InnerSingleManualReCompareBC(tsk);

                    list.Add(rlt);
                });


                if (list.Any(t => !t.succ))
                {
                    result.msg = "失败";
                    result.succ = false;
                }
                else
                {
                    result.msg = "成功";
                    result.succ = true;
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("手工批量重新比对BC异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 手工单票重新比对BC
        /// <summary>
        /// 手工单票重新比对BC
        /// </summary>
        /// <param name="model">任务详情</param>
        /// <returns>返回结果</returns>
        private async Task<TaskManageOrderResultDto> InnerSingleManualReCompareBC(TaskBaseInfo model)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            /*
             1、通过任务的报文表获取BC的报文。
             */
            try
            {
                var storeInfo = await _taskStoreMsgInfoRepository.AsQueryable()
                    .Where(t => t.TASK_PKID == model.PK_ID && t.MSG_TYPE == TaskStoreMsgTypeEnum.BC_MSG.ToString()).FirstAsync();

                if(storeInfo == null)
                    throw Oops.Oh("MBL_NO={0},获取{1}报文失败", model.MBL_NO,TaskStoreMsgTypeEnum.BC_MSG.GetDescription());

                var rtl = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(storeInfo.MSG_JSON);

                string msg = string.Empty;
                //2023-02-02 测试过程中发现JSON数据格式有了变化，这里增加兼容
                if(rtl.mesage != null)
                {
                    msg = JSON.Serialize(rtl.mesage);
                }
                else
                {
                    msg = storeInfo.MSG_JSON;
                }


                if (string.IsNullOrWhiteSpace(msg))
                    throw Oops.Oh("MBL_NO={0},解析{1}报文详情异常", model.MBL_NO, TaskStoreMsgTypeEnum.BC_MSG.GetDescription());


                var bookOrderList = _bookingOrderRepository.EntityContext.Queryable<BookingOrder>()
                        .InnerJoin<BookingCtn>((bk, ctn) => bk.Id == ctn.BILLID)
                        .Where((bk, ctn) => bk.Id == long.Parse(model.BOOK_ORDER_NO) && bk.TenantId == UserManager.TENANT_ID)
                        .Select((bk, ctn) => new { bk = bk, ctn = ctn }).ToList();

                //获取订舱详情与BC进行比对
                var orderInfo = bookOrderList.FirstOrDefault().bk;

                List<BookingCtn> ctnList = new List<BookingCtn>();

                if (bookOrderList.Any(t => t.ctn != null))
                    ctnList = bookOrderList.Select(t => t.ctn).ToList();

                if (orderInfo == null)
                    throw Oops.Oh("MBL_NO={0},获取订舱详情失败", model.MBL_NO);

                TaskBCStoreResultInfo bcStoreInfo = JSON.Deserialize<TaskBCStoreResultInfo>(msg);

                //BC比较
                var compareResult = InnerCompareBC(bcStoreInfo,orderInfo, ctnList);

                if(!compareResult.succ)
                {
                    //更新任务的反馈结果
                    model.RESULT_NOTE = compareResult.msg;
                    model.UpdatedTime = DateTime.Now;
                    model.UpdatedUserId = UserManager.UserId;
                    model.UpdatedUserName = UserManager.Name;

                    await _taskBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName,
                        it.RESULT_NOTE,

                    }).ExecuteCommandAsync();
                }
                else
                {
                    //置任务状态为完成
                    model.STATUS = TaskStatusEnum.Complete.ToString();
                    model.STATUS_NAME = TaskStatusEnum.Complete.GetDescription();
                    model.COMPLETE_DATE = DateTime.Now;
                    model.COMPLETE_DEAL = TaskCompleteDealEnum.MANUAL.ToString();
                    model.COMPLETE_DEAL_NAME = TaskCompleteDealEnum.MANUAL.GetDescription();

                    model.UpdatedTime = DateTime.Now;
                    model.UpdatedUserId = UserManager.UserId;
                    model.UpdatedUserName = UserManager.Name;

                    await _taskBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName,
                        it.STATUS,
                        it.STATUS_NAME,
                        it.COMPLETE_DATE,
                        it.COMPLETE_DEAL,
                        it.COMPLETE_DEAL_NAME
                    }).ExecuteCommandAsync();

                    //更新订舱的ETD(记个日志)
                    if (!string.IsNullOrWhiteSpace(bcStoreInfo.ETD))
                    {
                        DateTime etd = DateTime.MinValue;

                        if(DateTime.TryParse(bcStoreInfo.ETD,out etd))
                        {
                            orderInfo.ETD = etd;
                            orderInfo.UpdatedTime = DateTime.Now;
                            orderInfo.UpdatedUserId = UserManager.UserId;
                            orderInfo.UpdatedUserName = UserManager.Name;

                            await _bookingOrderRepository.AsUpdateable(orderInfo).UpdateColumns(it => new
                            {
                                it.UpdatedTime,
                                it.UpdatedUserId,
                                it.UpdatedUserName,
                                it.ETD
                            }).ExecuteCommandAsync();
                        }
                    }
                    //【预留】异步推送后台任务（订舱自动放舱-BookingFangCang）
                    //【预留】异步推送后台任务（下货纸-Xiahuozhi）
                }

                result.succ = true;
                result.msg = "处理成功";
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"手工重新比对BC异常,{ex.Message}";

                //throw Oops.Bah("手工重新比对BC异常,{0}", ex.Message);
            }

            return result;
        }
        #endregion

        #region 单票比对BC
        /// <summary>
        /// 单票比对BC
        /// </summary>
        /// <param name="bcStoreInfo">BC回执详情</param>
        /// <param name="orderInfo">订舱详情</param>
        /// <param name="ctnList">订舱集装箱列表</param>
        /// <returns>返回结果</returns>
        private TaskManageOrderResultDto InnerCompareBC(TaskBCStoreResultInfo bcStoreInfo,BookingOrder orderInfo,List<BookingCtn> ctnList)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto { succ = true};

            try
            {
                List<Tuple<bool, string>> rltTupleList = new List<Tuple<bool, string>>();

                /*
                 迁移过来的注释
                 2021-9-28，需求再变，BC需要再次比对约号
                 2021-7-19 需求修改：BC不需要再对比约号
                 */

                //约号
                if (!string.IsNullOrWhiteSpace(orderInfo.CONTRACTNO))
                {
                    if ((string.IsNullOrWhiteSpace(bcStoreInfo.BJH) || !Regex.IsMatch(orderInfo.CONTRACTNO, $"\\b{bcStoreInfo.BJH.Trim()}\\b"))
                        && (string.IsNullOrWhiteSpace(bcStoreInfo.FWHT) || !Regex.IsMatch(orderInfo.CONTRACTNO, $"\\b{bcStoreInfo.FWHT.Trim()}\\b")))
                    {
                        rltTupleList.Add(new Tuple<bool, string>(false, "约号不一致"));
                    }
                }
                else
                {
                    if (!string.IsNullOrWhiteSpace(bcStoreInfo.BJH) || !string.IsNullOrWhiteSpace(bcStoreInfo.FWHT))
                    {
                        rltTupleList.Add(new Tuple<bool, string>(false, "约号不一致"));
                    }
                }

                #region 集装箱
                //集装箱
                if (bcStoreInfo.CntrTotal != orderInfo.CNTRTOTAL)
                {
                    //集装箱型
                    var ediCtnList = _cache.GetAllMappingCtn().GetAwaiter().GetResult()
                        .Where(t => t.Module.Equals(CONST_MAPPING_MODULE, StringComparison.OrdinalIgnoreCase)
                        && !string.IsNullOrWhiteSpace(t.CarrierCode) && t.CarrierCode.Equals(orderInfo.CARRIERID, StringComparison.OrdinalIgnoreCase)).ToList();

                    var storeCtnList = bcStoreInfo.CntrTotal.Split(new char[] { ';' }).Select(t =>
                     {
                         var currArg = t.Split(new char[] { 'x' });

                         return new { Code = currArg[1]?.Trim(), Num = int.Parse(currArg[0]?.Trim()) };
                     }).GroupBy(t => t.Code)
                     .Select(t =>
                     {
                         return new { Code = t.Key, Num = t.Sum(x => x.Num) };
                     }).ToList();

                    var orderCtnListctnList = ctnList.Select(t =>
                    {
                        var mapCtn = ediCtnList.FirstOrDefault(x => x.Code.Equals(t.CTNCODE));

                        if (mapCtn != null && !string.IsNullOrWhiteSpace(mapCtn.MapCode))
                            return new { Code = mapCtn.MapCode, Num = t.CTNNUM.HasValue ? t.CTNNUM.Value : 1 };

                        return new { Code = t.CTNCODE, Num = t.CTNNUM.HasValue ? t.CTNNUM.Value : 1 };
                    }).GroupBy(t => t.Code)
                     .Select(t =>
                     {
                         return new { Code = t.Key, Num = t.Sum(x => x.Num) };
                     }).ToList();

                    if (storeCtnList.Count != orderCtnListctnList.Count)
                    {
                        rltTupleList.Add(new Tuple<bool, string>(false, "箱型箱量不一致"));
                    }
                    else
                    {
                        var totalList = storeCtnList.GroupJoin(orderCtnListctnList, l => l.Code, r => r.Code, (l, r) =>
                        {
                            var rModel = r.FirstOrDefault();

                            if (rModel == null)
                            {
                                return false;
                            }
                            else
                            {
                                if (l.Num != rModel.Num)
                                    return false;
                            }

                            return true;
                        }).ToList();

                        if (totalList.Any(t => !t))
                        {
                            rltTupleList.Add(new Tuple<bool, string>(false, "箱型箱量不一致"));
                        }
                    }

                }
                #endregion

                //船名
                if (bcStoreInfo.Vessel != orderInfo.VESSEL?.Trim())
                {
                    rltTupleList.Add(new Tuple<bool, string>(false, "船名不一致"));
                }

                //航次
                if (bcStoreInfo.Voyno?.Replace("1MA", "") != orderInfo.VOYNO?.Trim()
                    && bcStoreInfo.Voyno2 != orderInfo.VOYNO?.Trim() && bcStoreInfo.Voyno3 != orderInfo.VOYNO?.Trim())
                {
                    rltTupleList.Add(new Tuple<bool, string>(false, "航次不一致"));
                }

                /*
                 //2021-10-12，增加最小、最大、运输温度，湿度，通风 的比较
                 //2021-11-23，备注中含有NOR，不比较温度湿度等信息

                 2023-02-02 这里补充了一下EDIREMARK的判断，用正则匹配NOR信息。NOR(冻代干集装箱)
                 */
                if (orderInfo.CARGOID == "R" && (string.IsNullOrWhiteSpace(orderInfo.SOREMARK) || !Regex.IsMatch(orderInfo.SOREMARK, "\\bNOR\\b")))
                {
                    //最低温度
                    var compareReult = CompareTemperatureNum(orderInfo.TEMPMIN, bcStoreInfo.TempMin, "temp");

                    if (!compareReult.Item1)
                        rltTupleList.Add(compareReult);

                    //最高温度
                    compareReult = CompareTemperatureNum(orderInfo.TEMPMAX, bcStoreInfo.TempMax, "temp", "最高温度");

                    if (!compareReult.Item1)
                        rltTupleList.Add(compareReult);

                    //运输温度
                    compareReult = CompareTemperatureNum(orderInfo.TEMPSET, bcStoreInfo.TempTransport, "temp", "运输温度");

                    if (!compareReult.Item1)
                        rltTupleList.Add(compareReult);

                    //湿度
                    compareReult = CompareTemperatureNum(orderInfo.HUMIDITY, bcStoreInfo.Humidity, "humidity", "湿度");

                    if (!compareReult.Item1)
                        rltTupleList.Add(compareReult);

                    //通风
                    compareReult = CompareTemperatureNum(orderInfo.REEFERF, bcStoreInfo.VentilationCubicMeter, "vent", "通风");

                    if (!compareReult.Item1)
                        rltTupleList.Add(compareReult);
                }


                /*
                 * 2021-12-3，捷丰要求加卸货港和目的地校验，规则：
                 * A：大简云里卸货港字段‘，’之前的字符和BC里卸货港‘，’之前的字段。
                 * 1.一致，自动发送下货纸
                 * 2.不一致，生成待处理下货纸任务。
                 * B：bc如果有最终交货地 那么要和系统目的港对比；最终交货地空白 就不用对比这个地方
                */
                string orderPortDischarge = orderInfo.PORTDISCHARGE.Split(new char[] { ',' }).FirstOrDefault()?.Trim();
                string storePortDischarge = bcStoreInfo.PortDischargeEName.Split(new char[] { ',' }).FirstOrDefault()?.Trim();

                if (orderPortDischarge != storePortDischarge)
                    rltTupleList.Add(new Tuple<bool, string>(false, "卸货港不一致"));

                string orderDest = orderInfo.DESTINATION.Split(new char[] { ',' }).FirstOrDefault()?.Trim();
                string storeDest = bcStoreInfo.ZZJHD.Split(new char[] { ',' }).FirstOrDefault()?.Trim();

                if (orderDest != storeDest)
                    rltTupleList.Add(new Tuple<bool, string>(false, "目的地不一致"));

                if (rltTupleList.Any(t => !t.Item1))
                {
                    result.succ = false;
                    result.msg = string.Join(";", rltTupleList.Select(t => t.Item2).ToArray());
                }
            }
            catch(Exception ex)
            {
                throw Oops.Bah("{0}单票比对BC异常,{1}",nameof(InnerCompareBC), ex.Message);
            }

            return result;
        }
        #endregion

        #region 对比温度
        /// <summary>
        /// 对比温度
        /// </summary>
        /// <param name="orderTemperature">订舱数值</param>
        /// <param name="storeTemperature">回执数值</param>
        /// <param name="operType">操作类型 temp-温度 humidity-湿度 vent-通风</param>
        /// <param name="showName">显示名称</param>
        /// <returns>返回结果</returns>
        private Tuple<bool, string> CompareTemperatureNum(string orderTemperature,string storeTemperature,string operType = "temp",string showName = "最低温度")
        {
            decimal orderTemp = int.MaxValue;
            decimal storeTemp = int.MaxValue;

            decimal.TryParse(orderTemperature, out orderTemp);

            if (!string.IsNullOrWhiteSpace(storeTemperature))
            {
                if (operType == "temp")
                {
                    decimal.TryParse(Regex.Match(storeTemperature, "(\\-?([0-9]?|[0-9]+)\\.?[0-9]+)(?=C)").Value, out storeTemp);
                }
                else if (operType == "humidity")
                {
                    decimal.TryParse(Regex.Match(storeTemperature, "\\[0-9]+").Value, out storeTemp);
                }
                else if (operType == "vent")
                {
                    decimal.TryParse(storeTemperature, out storeTemp);
                }
            }

            if (storeTemp != int.MaxValue && orderTemp != int.MaxValue)
            {
                if (storeTemp != orderTemp)
                    return new Tuple<bool, string>(false, $"{showName}不一致");
            }
            else
            {
                if (storeTemp != int.MaxValue || orderTemp != int.MaxValue)
                    return new Tuple<bool, string>(false, $"{showName}不一致");
            }

            return new Tuple<bool, string>(true, "");
        }
        #endregion

        #region 下载截单EDI
        /// <summary>
        /// 下载截单EDI
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <param name="orderNo">订单号</param>
        /// <param name="useForwarderCode">是否使用货代代码</param>
        /// <param name="forwarderCode">货代代码</param>
        /// <param name="forwarderName">货代称呼</param>
        /// <param name="fileRole">文件功能 (9原始,1 更新,5 退舱 )</param>
        /// <param name="sendType">发送类型 E-截单</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/DownloadClosingEDI")]
        public async Task<IActionResult> DownloadClosingEDI([FromQuery] string taskPKId, [FromQuery] string orderNo, [FromQuery] bool useForwarderCode,
            [FromQuery] string forwarderCode, [FromQuery] string forwarderName, [FromQuery] string fileRole, [FromQuery] string sendType)
        {
            if (sendType?.ToUpper() != "E")
                throw Oops.Oh($"sendType只接收E-截单");

            var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

            if (taskInfo == null)
                throw Oops.Oh($"任务信息获取失败");

            if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                throw Oops.Oh($"任务信息的订舱主键不存在");

            if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.SI_FEEDBACK.ToString())
                throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.SI_FEEDBACK.GetDescription()}");

            BookingOrder bookingOrder = null;

            if (!string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                bookingOrder = _bookingOrderRepository.AsQueryable().First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

            if (bookingOrder == null)
                throw Oops.Oh($"订舱信息获取失败，MBLNO={taskInfo.MBL_NO}");

            var model = new BookingOrClosingEDIOrderDto
            {
                Id = bookingOrder.Id,
                orderNo = orderNo,
                useForwarderCode = useForwarderCode,
                forwarderCode = forwarderCode,
                forwarderName = forwarderName,
                fileRole = fileRole,
                send = false,
                sendType = sendType
            };

            var bookingOrderService = _namedBookingOrderServiceProvider.GetService<ITransient>(nameof(BookingOrderService));

            var filePath = await bookingOrderService.InnerBookingOrClosingEDI(model);

            var fileInfo = new FileInfo(filePath);

            var result = new FileStreamResult(new FileStream(filePath, FileMode.Open), "application/octet-stream") { FileDownloadName = fileInfo.Name };
            return result;
        }
        #endregion

        #region 发送截单EDI
        /// <summary>
        /// 发送截单EDI
        /// </summary>
        /// <param name="taskPKId">任务主键</param>
        /// <param name="orderNo">订单号</param>
        /// <param name="useForwarderCode">是否使用货代代码</param>
        /// <param name="forwarderCode">货代代码</param>
        /// <param name="forwarderName">货代称呼</param>
        /// <param name="fileRole">文件功能 (9原始,1 更新,5 退舱 )</param>
        /// <param name="sendType">发送类型 E-截单</param>
        /// <returns>返回结果</returns>
        [HttpGet("/TaskManage/SendClosingEDI")]
        public async Task<string> SendClosingEDI([FromQuery] string taskPKId, [FromQuery] string orderNo, [FromQuery] bool useForwarderCode,
            [FromQuery] string forwarderCode, [FromQuery] string forwarderName, [FromQuery] string fileRole, [FromQuery] string sendType)
        {
            if (sendType?.ToUpper() != "E")
                throw Oops.Oh($"sendType只接收E-截单");

            var taskInfo = _taskBaseInfoRepository.AsQueryable().First(t => t.PK_ID == taskPKId);

            if (taskInfo == null)
                throw Oops.Oh($"任务信息获取失败");

            if (string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                throw Oops.Oh($"任务信息的订舱主键不存在");

            if (taskInfo.TASK_TYPE != TaskBusiTypeEnum.SI_FEEDBACK.ToString())
                throw Oops.Oh($"当前任务类型不是{TaskBusiTypeEnum.SI_FEEDBACK.GetDescription()}");

            BookingOrder bookingOrder = null;

            if (!string.IsNullOrWhiteSpace(taskInfo.BOOK_ORDER_NO))
                bookingOrder = _bookingOrderRepository.AsQueryable().First(t => t.Id == long.Parse(taskInfo.BOOK_ORDER_NO));

            if (bookingOrder == null)
                throw Oops.Oh($"订舱信息获取失败，MBLNO={taskInfo.MBL_NO}");

            var model = new BookingOrClosingEDIOrderDto
            {
                Id = bookingOrder.Id,
                orderNo = orderNo,
                useForwarderCode = useForwarderCode,
                forwarderCode = forwarderCode,
                forwarderName = forwarderName,
                fileRole = fileRole,
                send = true,
                sendType = sendType
            };

            var bookingOrderService = _namedBookingOrderServiceProvider.GetService<ITransient>(nameof(BookingOrderService));

            return await bookingOrderService.InnerBookingOrClosingEDI(model);
        }
        #endregion

        #region 计算LARA纸计算页数
        /// <summary>
        /// 计算LARA纸计算页数
        /// </summary>
        /// <param name="model">请求LARA纸详情</param>
        /// <returns>返回结果</returns>
        [HttpPost("/TaskManage/CalcLaraPageNumbers")]
        public async Task<List<LaraPaperRegistPostDto>> CalcLaraPageNumbers(CalcLaraPageNumbersDto model)
        {
            List<LaraPaperRegistPostDto> list = new List<LaraPaperRegistPostDto>();

            /*
             LARA计算方法

             1、判断是否为首次加载，model.moveType为空时表示首次加载，触发InitCalcLaraPageNumbers方法。
             2、如果 model.moveType有值时，判断是调整行位置，根据指定的行位置重新计算编号。
             */
            try
            {
                if(string.IsNullOrWhiteSpace(model.moveType))
                {
                    list = InnerCalcLaraPageNumbers(model,true);
                }
                else
                {
                    list = InnerCalcLaraPageNumbers(model);
                }
            }
            catch (Exception ex)
            {
                throw Oops.Bah("计算LARA纸计算页数异常,{0}", ex.Message);
            }

            return list;
        }
        #endregion

        #region 计算LARA纸
        /// <summary>
        /// 计算LARA纸
        /// </summary>
        /// <param name="model">请求LARA纸详情</param>
        /// <param name="isInit">是否初始化 true-初始化</param>
        /// <returns></returns>
        private List<LaraPaperRegistPostDto> InnerCalcLaraPageNumbers(CalcLaraPageNumbersDto model,bool isInit = false)
        {
            List<LaraPaperRegistPostDto> list = new List<LaraPaperRegistPostDto>();

            //如果判断不是首次加载，需要将移动的行从列表移动到指定位置后，重新计算。
            if(!isInit)
            {
                model.paperList = model.paperList.Select(t =>
                {
                    if (t.SortNo == model.origIndex.Value)
                    {
                        //up
                        if(model.currIndex < model.origIndex)
                        {
                            t.SortNo = (decimal)model.currIndex.Value - 0.1m;
                        }
                        else
                        {
                            t.SortNo = (decimal)model.currIndex.Value + 0.1m;
                        }
                    }

                    return t;
                }).OrderBy(t => t.SortNo)
                .Select((t, idx) =>
                {
                    t.SortNo = (decimal)idx + 1;
                    return t;

                }).ToList();
            }

            var mNumberTo = model.numberTo.TrimStart('0') == "" ? 0 : int.Parse(model.numberTo.TrimStart('0'));

            if (mNumberTo > 0)
            {
                int lastNumberTo = 0;
                int lastNumberFrom = 0;

                model.paperList.OrderBy(t => t.SortNo).ToList().ForEach(t =>
                {
                    LaraPaperRegistPostDto info = new LaraPaperRegistPostDto();

                    info.SortNo = t.SortNo;
                    info.DraftNum = t.DraftNum;
                    info.TaskId = t.TaskId;
                    info.ORDNO = t.ORDNO;
                    info.MBLNO = t.MBLNO;
                    info.ISSUETYPE = t.ISSUETYPE;

                    if (t.SortNo == 1)
                    {
                        lastNumberFrom = mNumberTo + 1;
                        info.NumberFrom = (lastNumberFrom).ToString().PadLeft(9, '0');

                        var currNumberTo = (t.DraftNum * LARA_PARER_DRAFT_VAR) + mNumberTo;

                        info.NumberTo = currNumberTo.ToString().PadLeft(9, '0');
                        info.PageSum = currNumberTo - lastNumberFrom + 1;

                        lastNumberTo = currNumberTo;
                    }
                    else
                    {
                        lastNumberFrom = lastNumberTo + 1;
                        info.NumberFrom = (lastNumberFrom).ToString().PadLeft(9, '0');

                        var currNumberTo = (t.DraftNum * LARA_PARER_DRAFT_VAR) + lastNumberTo;

                        info.NumberTo = currNumberTo.ToString().PadLeft(9, '0');
                        info.PageSum = currNumberTo - lastNumberFrom + 1;

                        lastNumberTo = currNumberTo;
                    }


                    list.Add(info);
                });
            }

            return list;
        }
        #endregion

        /// <summary>
        /// 撤销任务
        /// </summary>
        /// <param name="info">任务详情</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> CancelTaskJob(TaskManageOrderMessageInfo info)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            /*
             1、通过Head.GID检索任务表。
             2、任务不存在提示检索失败。
             3、任务存在判断当前状态已完成、已取消、已挂起不能撤销。
             4、派车任务业务状态是SEND_DISPATCH不能撤销。
             5、更新任务状态、更新派车任务状态。
             6、返回结果
             */
            try
            {
                var taskInfo = _taskBaseInfoRepository.AsQueryable().OrderByDescending(a => a.CreatedTime)
                    .First(t => t.OUT_BUSI_NO == $"{info.Head.SenderId}_{info.Head.GID}");

                if (taskInfo == null)
                    throw Oops.Oh($"任务不存在");

                if(new string[] { TaskStatusEnum.Pending.ToString(),TaskStatusEnum.Cancel.ToString() }
                .Contains(taskInfo.STATUS))
                    throw Oops.Oh($"任务状态是已挂起/已取消的不能撤销");

                var truckInfo = _taskTruckInfoRepository.AsQueryable().First(a => a.TASK_ID == taskInfo.PK_ID);

                if (truckInfo == null)
                    throw Oops.Oh($"派车任务不存在");

                //if(truckInfo.Status == BookingTruckStatus.SEND_DISPATCH.ToString())
                //    throw Oops.Oh($"派车任务状态是已派车不能撤销");

                DateTime nowDate = DateTime.Now;

                truckInfo.Status = BookingTruckStatus.CANCELED.ToString();

                UserTendDto userTendInfo = GetUserTendInfo(info.Main.TaskUserId);

                truckInfo.UpdatedUserId = userTendInfo.userId;
                truckInfo.UpdatedUserName = userTendInfo.userName;
                truckInfo.UpdatedTime = nowDate;

                //更新派车任务
                await _taskTruckInfoRepository.AsUpdateable(truckInfo).UpdateColumns(it => new
                {
                    it.UpdatedUserId,
                    it.Status,
                    it.UpdatedUserName,
                    it.UpdatedTime
                }).ExecuteCommandAsync();

                taskInfo.UpdatedUserId = userTendInfo.userId;
                taskInfo.UpdatedUserName = userTendInfo.userName;
                taskInfo.UpdatedTime = nowDate;
                taskInfo.STATUS = TaskStatusEnum.Cancel.ToString();

                //更新任务
                await _taskBaseInfoRepository.AsUpdateable(taskInfo).UpdateColumns(it => new
                {
                    it.UpdatedUserId,
                    it.STATUS,
                    it.UpdatedUserName,
                    it.UpdatedTime
                }).ExecuteCommandAsync();

                result.succ = true;
                result.msg = "撤销成功";
            }
            catch (Exception ex)
            {
                _logger.LogError("撤销任务异常，原因：{error}", ex.Message);

                throw Oops.Oh($"{ex.Message}");
            }

            return result;
        }

        #region 创建BC任务
        /// <summary>
        /// 创建BC任务
        /// </summary>
        /// <param name="file">文件</param>
        /// <param name="modifyFile">BC变更内容后文件</param>
        /// <param name="jsonData">BC任务详情JSON</param>
        /// <returns>返回回执</returns>
        [HttpPost("/TaskManage/CreateBCTaskJob"), AllowAnonymous, ApiUser(ApiCode = "BCTaskManage")]
        public async Task<TaskManageOrderResultDto> CreateBCTaskJob(IFormFile file, IFormFile modifyFile, [FromForm] string jsonData)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} 接收到创建任务报文 报文={msg}", batchNo, jsonData);

            
            try
            {
                TaskManageOrderMessageInfo info = JSON.Deserialize<TaskManageOrderMessageInfo>(jsonData);

                if(info == null)
                    throw Oops.Bah("jsonData请求内容错误，无法反序列化报文");

                result = await InitTaskJob(info, batchNo, file, modifyFile);
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"请求任务异常,{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 创建DRAFT任务
        /// <summary>
        /// 创建DRAFT任务
        /// </summary>
        /// <param name="file">文件</param>
        /// <param name="modifyFile">DRAFT变更内容后文件</param>
        /// <param name="jsonData">DRAFT任务详情JSON</param>
        /// <returns>返回回执</returns>
        [AllowAnonymous, HttpPost("/TaskManage/CreateDRAFTTaskJob"), ApiUser(ApiCode = "BCTaskManage")]
        public async Task<TaskManageOrderResultDto> CreateDRAFTTaskJob(IFormFile file, IFormFile modifyFile, [FromForm] string jsonData)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} 接收到创建任务报文 报文={msg}", batchNo, jsonData);


            try
            {
                TaskManageOrderMessageInfo info = JSON.Deserialize<TaskManageOrderMessageInfo>(jsonData);

                if (info == null)
                    throw Oops.Bah("jsonData请求内容错误，无法反序列化报文");

                result = await InitTaskJob(info, batchNo, file, modifyFile);
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"请求任务异常,{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 创建截单回执任务
        /// <summary>
        /// 创建截单回执任务
        /// </summary>
        /// <param name="file">文件</param>
        /// <param name="modifyFile">截单回执变更内容后文件</param>
        /// <param name="jsonData">截单回执任务详情JSON</param>
        /// <returns>返回回执</returns>
        [HttpPost("/TaskManage/CreateSISubmittedTaskJob"), AllowAnonymous, ApiUser(ApiCode = "BCTaskManage")]
        public async Task<TaskManageOrderResultDto> CreateSISubmittedTaskJob(IFormFile file, IFormFile modifyFile, [FromForm] string jsonData)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} 接收到创建任务报文 报文={msg}", batchNo, jsonData);


            try
            {
                TaskManageOrderMessageInfo info = JSON.Deserialize<TaskManageOrderMessageInfo>(jsonData);

                if (info == null)
                    throw Oops.Bah("jsonData请求内容错误，无法反序列化报文");

                result = await InitTaskJob(info, batchNo, file, modifyFile);
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"请求任务异常,{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 创建Advisory任务
        /// <summary>
        /// 创建Advisory任务
        /// </summary>
        /// <param name="file">文件</param>
        /// <param name="jsonData">BC任务详情JSON</param>
        /// <returns>返回回执</returns>
        [HttpPost("/TaskManage/CreateAdvisoryTaskJob"), AllowAnonymous, ApiUser(ApiCode = "BCTaskManage")]
        public async Task<TaskManageOrderResultDto> CreateAdvisoryTaskJob(IFormFile file, IFormFile modifyFile, string jsonData)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            string batchNo = IDGen.NextID().ToString();

            _logger.LogInformation("批次={no} 接收到创建任务报文 报文={msg}", batchNo, jsonData);


            try
            {
                TaskManageOrderMessageInfo info = JSON.Deserialize<TaskManageOrderMessageInfo>(jsonData);

                if (info == null)
                    throw Oops.Bah("jsonData请求内容错误，无法反序列化报文");

                result = await InitTaskJob(info, batchNo, file, null);
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"请求任务异常,{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 获取文件类型
        /// <summary>
        /// 获取文件类型
        /// </summary>
        /// <param name="fileName">文件完成路径</param>
        /// <returns>返回文件类型枚举</returns>
        private PrintFileTypeEnum GetFileType(string fileName)
        {
            PrintFileTypeEnum fileType = PrintFileTypeEnum.PDF;

            switch (Path.GetExtension(fileName).ToLower())
            {
                case ".pdf":
                    fileType = PrintFileTypeEnum.PDF;
                    break;
                case ".xlsx":
                    fileType = PrintFileTypeEnum.XLSX;
                    break;
                case ".docx":
                    fileType = PrintFileTypeEnum.DOCX;
                    break;
                case ".xls":
                    fileType = PrintFileTypeEnum.XLS;
                    break;
                case ".doc":
                    fileType = PrintFileTypeEnum.DOC;
                    break;
            }

            return fileType;
        }
        #endregion
    }

    #region 样本业务提取帮助类
    /// <summary>
    /// 样本业务提取帮助类
    /// </summary>
    public static class DraftPaperExtension
    {
        public static int GetPageNum(this string Name)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(Name))
                    return 0;

                string s = Regex.Replace(Name.Substring(Name.LastIndexOf('-') + 1), "\\.[a-zA-Z]+", "");

                return int.Parse(s);
            }
            catch(Exception ex)
            {
                throw Oops.Bah("文件名{0} 取页数异常,{1}", Name, ex.Message);
            }
        }
    }
    #endregion

    #region 整理文本数据
    public static class CompareObjExtension
    {
        /// <summary>
        /// 整理文本数据
        /// </summary>
        /// <param name="str">文本</param>
        /// <returns></returns>
        public static string AdjustString(this string str)
        {
            if (string.IsNullOrWhiteSpace(str))
                return str;

            var rtn = str.Replace("\r\n", "\n").Trim();
            if (rtn.EndsWith("\n"))
            {
                rtn = rtn.Substring(0, rtn.Length - 1);
            }

            return rtn;
        }

        /// <summary>
        /// 文本转换成日期
        /// </summary>
        /// <param name="str">文本</param>
        /// <param name="MemberName">字段名称</param>
        /// <returns>返回日期</returns>
        public static Nullable<DateTime> GetDateTime(this string str,string MemberName)
        {
            if (string.IsNullOrWhiteSpace(str))
                return null;

            DateTime currDate = DateTime.MinValue;

            if (!DateTime.TryParse(str, out currDate))
                throw Oops.Oh("字段{0}={1}转换日期失败，请检查日期格式", MemberName, str);

            return currDate;
        }
    }
    #endregion
}