using DS.Module.Core;
using DS.Module.Core.Data;
using DS.Module.Core.Extensions;
using DS.Module.Core.Log;
using DS.Module.SqlSugar;
using DS.Module.UserModule;
using DS.WMS.Core.Code.Dtos;
using DS.WMS.Core.Code.Entity;
using DS.WMS.Core.Fee.Dtos;
using DS.WMS.Core.Fee.Entity;
using DS.WMS.Core.Info.Dtos;
using DS.WMS.Core.Info.Entity;
using DS.WMS.Core.Invoice.Dtos;
using DS.WMS.Core.Op.Dtos;
using DS.WMS.Core.Op.EDI;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Sys.Dtos;
using DS.WMS.Core.Sys.Entity;
using DS.WMS.Core.Sys.Interface;
using Mapster;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.Extensions.DependencyInjection;
using NPOI.POIFS.Crypt.Dsig;
using SqlSugar;
using System.Collections.Generic;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace DS.WMS.Core.Sys.Method;

public class ClientCommonService : IClientCommonService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly ISqlSugarClient db;
    private readonly IUser user;
    private readonly ISaasDbService saasService;

    /// <summary>
    ///
    /// </summary>
    /// <param name="serviceProvider"></param>
    public ClientCommonService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
        db = _serviceProvider.GetRequiredService<ISqlSugarClient>();
        user = _serviceProvider.GetRequiredService<IUser>();
        saasService = _serviceProvider.GetRequiredService<ISaasDbService>();
    }


    
    /// <summary>
    /// 获取商品下拉列表-客户端
    /// </summary>
    /// <returns></returns>
    public async Task<DataResult<List<CodeGoodsSelectRes>>> GetClientGoodsList(string code ="")
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var list = await tenantDb.Queryable<CodeGoods>()
            .WhereIF(!string.IsNullOrEmpty(code), a => a.GoodsCode.Contains(code))
            .Select<CodeGoodsSelectRes>()
            .ToListAsync();
        return await Task.FromResult(DataResult<List<CodeGoodsSelectRes>>.Success("获取数据成功!", list));
    }
    /// <summary>
    /// 根据id获取往来单位参数信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<DataResult<List<ClientParamRes>>> GetClientParamListById(string id)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = await tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == long.Parse(id) && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToListAsync();
        return await Task.FromResult(DataResult<List<ClientParamRes>>.Success(data));
    }
    /// <summary>
    /// 根据用户ids获取用户邮箱信息
    /// </summary>
    /// <param name="ids"></param>
    /// <returns></returns>
    public async Task<DataResult<List<UserSelectRes>>> GetUseEmailListByIds(long[] ids)
    { 
        var data = await db.Queryable<SysUser>()
             .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && ids.Contains(a.Id))
            .Select<UserSelectRes>()
            .ToListAsync();
        return await Task.FromResult(DataResult<List<UserSelectRes>>.Success(data));
    }

    /// <summary>
    /// 根据类型获取用户下拉列表
    /// </summary>
    /// <returns></returns>
    public async Task<DataResult<List<ApiSelectViewModel>>> GetUserListByCode(string code = "")
    { 
        code = code.ToLower();
        var data = await db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt())
            .WhereIF(code == "operator", a => a.IsOperator == true)
            .WhereIF(code == "doc", a => a.IsVouchingClerk == true)
            .WhereIF(code == "sale", a => a.IsSale == true)
            .WhereIF(code == "custom", a => a.IsCustom == true)
            .WhereIF(code == "finance", a => a.IsFinancialStaff == true)
            .WhereIF(code == "service", a => a.IsCustomerService == true)
            .WhereIF(code == "driver", a => a.IsDriver == true)
            .WhereIF(code == "dispatcher", a => a.IsDispatcher == true)
            .Select(a => new ApiSelectViewModel
            {
                Label = a.UserName,
                Value = a.Id,
            }).ToListAsync();
        return DataResult<List<ApiSelectViewModel>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取工厂信息下拉列表-客户端
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodeFactorySelectRes>> GetFactorySelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var list = tenantDb.Queryable<CodeFactory>()
            .Where(x => x.Status == StatusEnum.Enable)
            .Select<CodeFactorySelectRes>()
            .ToList();
        return DataResult<List<CodeFactorySelectRes>>.Success("获取数据成功!", list);
    }
    #region 根据单位获取数量箱型信息
    /// <summary>
    /// 根据单位获取数量箱型信息
    /// </summary>
    /// <returns></returns>
    public DataResult<UnitSelectInfoRes> GetUnitSelectInfo(UnitSelectInfoReq req)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //var data = new ClientSelectInfoRes(); 
        if (req.BusinessType == BusinessType.OceanShippingExport)
        {
            var info = tenantDb.Queryable<SeaExport>().First(x => x.Id == req.BusinessId);
            if (info.IsNull())
            {
                return DataResult<UnitSelectInfoRes>.Failed("业务信息不存在!");
            }
            var ctns = tenantDb.Queryable<OpCtn>().Where(x => x.BSNO == req.BusinessId.ToString()).ToList();

            var dictvalue = db.Queryable<SysDictData>().InnerJoin<SysDictType>((a, b) => a.TypeId == b.Id)
                 .Where((a, b) => b.Code == "fee_unit").Select((a, b) => a.Value).ToList();
            if (dictvalue.Where(x=>x ==req.Code).Any())
            {
                var data = GetSeaExportUnit(info, req.Code);
                return DataResult<UnitSelectInfoRes>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
            }
            else
            { 
                var codeCtns = tenantDb.Queryable<CodeCtn>().Where(x => x.Status == StatusEnum.Enable).ToList();

                if (codeCtns.Where(x => x.CtnName == req.Code).Any())
                {
                    //var data = GetSeaExportCtnsUnit(ctns, codeCtns, req.Code);
                    var codeCtn = codeCtns.First(x => x.CtnName == req.Code);
                    var ctns1 = ctns.Where(x => x.Ctn == req.Code).ToList();

                    var data = new UnitSelectInfoRes();
                    data.Code = req.Code;
                    data.Quantity = ctns1.Sum(x => x.CtnNum);
                    data.TEU = (int)data.Quantity * (int)codeCtn.TEU;
                    data.CtnTotalNum = ctns.Sum(x => x.CtnNum);

                    return DataResult<UnitSelectInfoRes>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
                }
                else
                {

                    return DataResult<UnitSelectInfoRes>.Failed("没有维护该箱型的集装箱信息!");
                }
            }
             
        }
        else
        {
            return DataResult<UnitSelectInfoRes>.Failed("非法业务类型");
        }
    }
    private UnitSelectInfoRes GetSeaExportUnit(SeaExport seaExport, string code)
    {

        var data = new UnitSelectInfoRes();
        data.Code = code;
        switch (code)
        {
            case "P"://单票
                data.Quantity = 1;
                break;
            case "Z"://重量
                data.Quantity = seaExport.KGS;
                break;
            case "C"://尺码
                data.Quantity = seaExport.CBM;
                break;
            case "J"://件数
                data.Quantity = seaExport.PKGS;
                break;
            case "JF"://计费吨
                data.Quantity = seaExport.KGS/1000> seaExport.CBM? seaExport.KGS/1000: seaExport.CBM;
                break;
            //默认
            default:
                data.Quantity = 0;
                break;
        }

        return data;
    }


    #endregion
    #region 根据类型获取往来单位下拉及业务信息列表
    /// <summary>
    /// 根据类型获取往来单位下拉及业务信息列表
    /// </summary>
    /// <returns></returns>
    public DataResult<ClientSelectInfoRes> GetClientSelectInfoByCode(ClientSelectInfoReq req)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //var data = new ClientSelectInfoRes();
        var code = req.Code.ToLower();
        var list = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt())
            .WhereIF(code == "carrier", (a, b) => b.IsCarrier == true)
            .WhereIF(code == "yard", (a, b) => b.IsYard == true)
            .WhereIF(code == "booking", (a, b) => b.IsBooking == true)
            .WhereIF(code == "truck", (a, b) => b.IsTruck == true)
            .WhereIF(code == "controller", (a, b) => b.IsController == true)
            .WhereIF(code == "custom", (a, b) => b.IsCustom == true)
            .WhereIF(code == "agent", (a, b) => b.IsAgent == true)
            .WhereIF(code == "agentcn", (a, b) => b.IsAgentCn == true)
            .WhereIF(code == "express", (a, b) => b.IsExpress == true)
            .WhereIF(code == "airlines", (a, b) => b.IsAirLines == true)
            .WhereIF(code == "shipper", (a, b) => b.IsShipper == true)
            .WhereIF(code == "shippercn", (a, b) => b.IsShipperCn == true)
            .WhereIF(code == "notifyparty", (a, b) => b.IsNotifyParty == true)
            .WhereIF(code == "warehouse", (a, b) => b.IsWareHouse == true)
            .WhereIF(code == "wharf", (a, b) => b.IsWharf == true)
            .WhereIF(code == "insurer", (a, b) => b.IsInsurer == true)
            .WhereIF(code == "leasing", (a, b) => b.IsLeasing == true)
            .WhereIF(code == "tradingagency", (a, b) => b.IsTradingAgency == true)
            .WhereIF(code == "shipagency", (a, b) => b.IsShipAgency == true)
            .WhereIF(code == "enterprise", (a, b) => b.IsEnterprise == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent,
            }
            ).ToList();

        if (req.BusinessType == BusinessType.OceanShippingExport)
        {
            var info = tenantDb.Queryable<SeaExport>().First(x => x.Id == req.BusinessId);
            if (info.IsNull())
            {
                return DataResult<ClientSelectInfoRes>.Failed("业务信息不存在!");
            }

            var data = GetSeaExportClientInfo(info,code);
            data.ClientList = list;
            return DataResult<ClientSelectInfoRes>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
        }
        else
        {
            return DataResult<ClientSelectInfoRes>.Failed("非法业务类型");
        } 
    }

    private ClientSelectInfoRes GetSeaExportClientInfo(SeaExport seaExport, string code)
    {

        var data = new ClientSelectInfoRes();
        switch (code)
        { 
            case "carrier":
                data.ClientId = seaExport.CarrierId;
                data.ClientName = seaExport.Carrier;
                break;
            case "yard":
                data.ClientId = seaExport.YardId;
                data.ClientName = seaExport.Yard;
                break;
            case "booking":
                data.ClientId = seaExport.ForwarderId;
                data.ClientName = seaExport.Forwarder;
                break;
            case "truck":
                data.ClientId = seaExport.TruckerId;
                data.ClientName = seaExport.Trucker;
                break;
            case "controller":
                data.ClientId = seaExport.CustomerId;
                data.ClientName = seaExport.CustomerName;
                break;
            case "custom":
                data.ClientId = seaExport.CustomserId;
                data.ClientName = seaExport.Customser;
                break;
            case "agent":
                data.ClientId = seaExport.AgentId;
                data.ClientName = seaExport.Agent;
                break;
            case "warehouse":
                data.ClientId = seaExport.WareHouseId;
                data.ClientName = seaExport.WareHouse;
                break;
            case "agentcn":
                break;
            case "express":
                break;
            case "airlines":
                break;
            case "wharf":
                break;
            case "insurer":
                break;
            case "leasing":
                break;
            case "enterprise":
                data.ClientId = (long)seaExport.EnterpriseId;
                data.ClientName = seaExport.Enterprise;
                break;
            case "shipper":
                data.ClientId = (long)seaExport.ShipperId;
                data.ClientName = seaExport.Shipper;
                break;
            case "shippercn":
                data.ClientId = (long)seaExport.ShipperCnId;
                data.ClientName = seaExport.ShipperCn;
                break;
            case "notifyparty":
                data.ClientId = (long)seaExport.NotifyPartyId;
                data.ClientName = seaExport.NotifyParty;
                break;
            case "tradingagency":
                break;
            case "shipagency":
                data.ClientId = seaExport.ShipAgencyId;
                data.ClientName = seaExport.ShipAgency;
                break;
            //默认
            default:
                break;
        }

        return data;
    }

    #endregion

    #region 获取往来单位下拉集合列表
    /// <summary>
    /// 获取往来单位下拉集合列表
    /// </summary>
    /// <returns></returns>
    public async Task<DataResult<List<ClientSelectMultiRes>>> GetMultiClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

        var data = new List<ClientSelectMultiRes>();

        var carrier = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsBooking == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            })
             .Mapper(it =>
             {
                 it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToList();
             })
            .ToListAsync();
        data.Add(new ClientSelectMultiRes("carrier", carrier));

        var yard = await tenantDb.Queryable<InfoClient>()
         .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
         .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsYard == true)
         .Select((a, b) => new ClientSelectRes
         {
             Id = a.Id,
             CodeName = a.CodeName,
             ShortName = a.ShortName,
             EnShortName = a.EnShortName,
             BLContent = a.BLContent
         }
         )
          .Mapper(it =>
          {
              it.ClientParams = tenantDb.Queryable<InfoClientParam>()
              .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
              .Select<ClientParamRes>()
              .ToList();
          }).ToListAsync();
        data.Add(new ClientSelectMultiRes("yard", yard));

        var booking = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsBooking == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("booking", booking));

        var truck = await tenantDb.Queryable<InfoClient>()
           .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
           .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsTruck == true)
           .Select((a, b) => new ClientSelectRes
           {
               Id = a.Id,
               CodeName = a.CodeName,
               ShortName = a.ShortName,
               EnShortName = a.EnShortName,
               BLContent = a.BLContent
           }
           ).Mapper(it =>
           {
               it.ClientParams = tenantDb.Queryable<InfoClientParam>()
               .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
               .Select<ClientParamRes>()
               .ToList();
           }).ToListAsync();
        data.Add(new ClientSelectMultiRes("truck", truck));

        var controller = await tenantDb.Queryable<InfoClient>()
          .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
          .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsController == true)
          .Select((a, b) => new ClientSelectRes
          {
              Id = a.Id,
              CodeName = a.CodeName,
              ShortName = a.ShortName,
              EnShortName = a.EnShortName,
              BLContent = a.BLContent
          }
          ).Mapper(it =>
          {
              it.ClientParams = tenantDb.Queryable<InfoClientParam>()
              .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
              .Select<ClientParamRes>()
              .ToList();
          }).ToListAsync();
        data.Add(new ClientSelectMultiRes("controller", controller));

        var custom = await tenantDb.Queryable<InfoClient>()
          .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
          .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsCustom == true)
          .Select((a, b) => new ClientSelectRes
          {
              Id = a.Id,
              CodeName = a.CodeName,
              ShortName = a.ShortName,
              EnShortName = a.EnShortName,
              BLContent = a.BLContent
          }
          ).Mapper(it =>
          {
              it.ClientParams = tenantDb.Queryable<InfoClientParam>()
              .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
              .Select<ClientParamRes>()
              .ToList();
          }).ToListAsync();
        data.Add(new ClientSelectMultiRes("custom", custom));

        var agent = await tenantDb.Queryable<InfoClient>()
         .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
         .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAgent == true)
         .Select((a, b) => new ClientSelectRes
         {
             Id = a.Id,
             CodeName = a.CodeName,
             ShortName = a.ShortName,
             EnShortName = a.EnShortName,
             BLContent = a.BLContent
         }
         ).Mapper(it =>
         {
             it.ClientParams = tenantDb.Queryable<InfoClientParam>()
             .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
             .Select<ClientParamRes>()
             .ToList();
         }).ToListAsync();
        data.Add(new ClientSelectMultiRes("agent", agent));

        var agentcn = await tenantDb.Queryable<InfoClient>()
           .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
           .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAgentCn == true)
           .Select((a, b) => new ClientSelectRes
           {
               Id = a.Id,
               CodeName = a.CodeName,
               ShortName = a.ShortName,
               EnShortName = a.EnShortName,
               BLContent = a.BLContent
           }
           ).Mapper(it =>
           {
               it.ClientParams = tenantDb.Queryable<InfoClientParam>()
               .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
               .Select<ClientParamRes>()
               .ToList();
           }).ToListAsync();
        data.Add(new ClientSelectMultiRes("agentcn", agentcn));

        var express = await tenantDb.Queryable<InfoClient>()
           .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
           .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsExpress == true)
           .Select((a, b) => new ClientSelectRes
           {
               Id = a.Id,
               CodeName = a.CodeName,
               ShortName = a.ShortName,
               EnShortName = a.EnShortName,
               BLContent = a.BLContent
           }
           ).Mapper(it =>
           {
               it.ClientParams = tenantDb.Queryable<InfoClientParam>()
               .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
               .Select<ClientParamRes>()
               .ToList();
           }).ToListAsync();
        data.Add(new ClientSelectMultiRes("express", express));

        var airlines = await tenantDb.Queryable<InfoClient>()
             .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
             .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAirLines == true)
             .Select((a, b) => new ClientSelectRes
             {
                 Id = a.Id,
                 CodeName = a.CodeName,
                 ShortName = a.ShortName,
                 EnShortName = a.EnShortName,
                 BLContent = a.BLContent
             }
             ).Mapper(it =>
             {
                 it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToList();
             }).ToListAsync();
        data.Add(new ClientSelectMultiRes("airlines", airlines));

        var shipper = await tenantDb.Queryable<InfoClient>()
           .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
           .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsShipper == true)
           .Select((a, b) => new ClientSelectRes
           {
               Id = a.Id,
               CodeName = a.CodeName,
               ShortName = a.ShortName,
               EnShortName = a.EnShortName,
               BLContent = a.BLContent
           }
           ).Mapper(it =>
           {
               it.ClientParams = tenantDb.Queryable<InfoClientParam>()
               .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
               .Select<ClientParamRes>()
               .ToList();
           }).ToListAsync();
        data.Add(new ClientSelectMultiRes("shipper", shipper));

        var shippercn = await tenantDb.Queryable<InfoClient>()
          .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
          .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsShipperCn == true)
          .Select((a, b) => new ClientSelectRes
          {
              Id = a.Id,
              CodeName = a.CodeName,
              ShortName = a.ShortName,
              EnShortName = a.EnShortName,
              BLContent = a.BLContent
          }
          ).Mapper(it =>
          {
              it.ClientParams = tenantDb.Queryable<InfoClientParam>()
              .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
              .Select<ClientParamRes>()
              .ToList();
          }).ToListAsync();
        data.Add(new ClientSelectMultiRes("shippercn", shippercn));

        var notifyparty = await tenantDb.Queryable<InfoClient>()
             .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
             .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsNotifyParty == true)
             .Select((a, b) => new ClientSelectRes
             {
                 Id = a.Id,
                 CodeName = a.CodeName,
                 ShortName = a.ShortName,
                 EnShortName = a.EnShortName,
                 BLContent = a.BLContent
             }
             ).Mapper(it =>
             {
                 it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToList();
             }).ToListAsync();
        data.Add(new ClientSelectMultiRes("notifyparty", notifyparty));


        var warehouse = await tenantDb.Queryable<InfoClient>()
             .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
             .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsWareHouse == true)
             .Select((a, b) => new ClientSelectRes
             {
                 Id = a.Id,
                 CodeName = a.CodeName,
                 ShortName = a.ShortName,
                 EnShortName = a.EnShortName,
                 BLContent = a.BLContent
             }
             ).Mapper(it =>
             {
                 it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToList();
             }).ToListAsync();
        data.Add(new ClientSelectMultiRes("warehouse", warehouse));


        var wharf = await tenantDb.Queryable<InfoClient>()
             .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
             .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsWharf == true)
             .Select((a, b) => new ClientSelectRes
             {
                 Id = a.Id,
                 CodeName = a.CodeName,
                 ShortName = a.ShortName,
                 EnShortName = a.EnShortName,
                 BLContent = a.BLContent
             }
             ).Mapper(it =>
             {
                 it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                 .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                 .Select<ClientParamRes>()
                 .ToList();
             }).ToListAsync();
        data.Add(new ClientSelectMultiRes("wharf", wharf));

        var insurer = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsInsurer == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("insurer", insurer));

        var leasing = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsLeasing == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("leasing", leasing));

        var tradingagency = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsTradingAgency == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("tradingagency", tradingagency));

        var shipagency = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsShipAgency == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("shipagency", shipagency));

        var enterprise = await tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsEnterprise == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent
            }
            ).Mapper(it =>
            {
                it.ClientParams = tenantDb.Queryable<InfoClientParam>()
                .Where(x => x.CustomerId == it.Id && x.Status == StatusEnum.Enable)
                .Select<ClientParamRes>()
                .ToList();
            }).ToListAsync();
        data.Add(new ClientSelectMultiRes("enterprise", enterprise));

        return await Task.FromResult(DataResult<List<ClientSelectMultiRes>>.Success(data));
    }
    #endregion

    /// <summary>
    /// 提取汇率信息
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    public DataResult<BusinessCurrencyExchangeRes> GetBusinessCurrencyExchangeInfo(BusinessCurrencyExchangeReq req)
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

        DateTime rateDate;

        var data = new BusinessCurrencyExchangeRes();

        var opConfig = tenantDb.Queryable<CodeConfig>().Where(x => x.Status == StatusEnum.Enable && x.Code == "ExchangeRateType").First();
        if (opConfig.IsNotNull())
        {
            #region 根据分公司配置参数
            if (req.BusinessType == BusinessType.OceanShippingExport)
            {
                var order = tenantDb.Queryable<SeaExport>().First(x => x.Id == req.BusinessId);
                if (opConfig.Value == "ETD")
                {
                    if (order.ETD.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期不能为空!");
                    }
                    var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && order.ETD >= x.StartDate && order.ETD <= x.EndDate);
                    if (feeRate.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期在币别设置的汇率不存在!");
                    }
                    feeRate.Adapt(data);
                    return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                }
                else if (opConfig.Value == "AccountDate")
                {
                    if (order.AccountDate.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间不能为空!");
                    }
                    //var accountDateTime = DateTime.Parse(order.AccountDate +"-01");

                    if (DateTime.TryParse(order.AccountDate + "-01", out rateDate))
                    {
                        // 转换成功，可以使用date变量
                        var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && rateDate >= x.StartDate && rateDate <= x.EndDate);
                        if (feeRate.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间在币别设置的汇率不存在!");
                        }
                        feeRate.Adapt(data);
                        return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                    }
                    else
                    {
                        // 转换失败，处理错误情况
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间不正确!");
                    }

                }
                else if (opConfig.Value == "CreateTime")
                {
                    if (order.CreateTime.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单录入时间不能为空!");
                    }

                    var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && order.CreateTime >= x.StartDate && order.CreateTime <= x.EndDate);
                    if (feeRate.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单录入时间在币别设置的汇率不存在!");
                    }
                    feeRate.Adapt(data);
                    return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                }
                else
                {
                    return DataResult<BusinessCurrencyExchangeRes>.Failed("非法参数类型，请联系管理员!");
                }


            }
            else
            {
                return DataResult<BusinessCurrencyExchangeRes>.Failed("非法业务类型，请联系管理员!");
            }

            #endregion
        }
        else
        {
            #region 根据系统配置参数
            var sysConfig = tenantDb.Queryable<SysConfig>().Where(x => x.Status == StatusEnum.Enable && x.Code == "ExchangeRateType").First();
            if (sysConfig.IsNotNull())
            {
                if (req.BusinessType == BusinessType.OceanShippingExport)
                {
                    var order = tenantDb.Queryable<SeaExport>().First(x => x.Id == req.BusinessId);
                    if (sysConfig.Value == "ETD")
                    {
                        if (order.ETD.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期不能为空!");
                        }
                        var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && order.ETD >= x.StartDate && order.ETD <= x.EndDate);
                        if (feeRate.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期在币别设置的汇率不存在!");
                        }
                        feeRate.Adapt(data);
                        return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                    }
                    else if (sysConfig.Value == "AccountDate")
                    {
                        if (order.AccountDate.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间不能为空!");
                        }
                        //var accountDateTime = DateTime.Parse(order.AccountDate +"-01");

                        if (DateTime.TryParse(order.AccountDate + "-01", out rateDate))
                        {
                            // 转换成功，可以使用date变量
                            var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && rateDate >= x.StartDate && rateDate <= x.EndDate);
                            if (feeRate.IsNull())
                            {
                                return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间在币别设置的汇率不存在!");
                            }
                            feeRate.Adapt(data);
                            return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                        }
                        else
                        {
                            // 转换失败，处理错误情况
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单会计期间不正确!");
                        }

                    }
                    else if (sysConfig.Value == "CreateTime")
                    {
                        if (order.CreateTime.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单录入时间不能为空!");
                        }

                        var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && order.CreateTime >= x.StartDate && order.CreateTime <= x.EndDate);
                        if (feeRate.IsNull())
                        {
                            return DataResult<BusinessCurrencyExchangeRes>.Failed("订单录入时间在币别设置的汇率不存在!");
                        }
                        feeRate.Adapt(data);
                        return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                    }
                    else
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("非法参数类型，请联系管理员!");
                    }


                }
                else
                {
                    return DataResult<BusinessCurrencyExchangeRes>.Failed("非法业务类型，请联系管理员!");
                }
            }
            else
            {
                //无系统参数按开船日期取汇率
                if (req.BusinessType == BusinessType.OceanShippingExport)
                {
                    var order = tenantDb.Queryable<SeaExport>().First(x => x.Id == req.BusinessId);
                    if (order.ETD.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期不能为空!");
                    }
                    var feeRate = tenantDb.Queryable<FeeCurrencyExchange>().First(x => x.CurrencyCode == req.CurrencyCode && order.ETD >= x.StartDate && order.ETD <= x.EndDate);
                    if (feeRate.IsNull())
                    {
                        return DataResult<BusinessCurrencyExchangeRes>.Failed("订单开船日期在币别设置的汇率不存在!");
                    }
                    feeRate.Adapt(data);
                    return DataResult<BusinessCurrencyExchangeRes>.Success(data);
                }
                else
                {
                    return DataResult<BusinessCurrencyExchangeRes>.Failed("非法业务类型，请联系管理员!");
                }
            }
            #endregion
        }

    }
    /// <summary>
    /// 获取揽货人信息
    /// </summary>
    /// <returns></returns>
    public DataResult<List<SaleSelectListRes>> GetSaleList()
    {
        var list = db.Queryable<SysUser>().Where(x => x.Status == StatusEnum.Enable.ToEnumInt() && x.IsSale == true)
           .Select<SaleSelectListRes>()
           .ToList();
        if (list.Count > 0)
        {
            foreach (var item in list)
            {
                var orgs = db.Queryable<SysOrgUser>().Filter(null, true)
                            .LeftJoin<SysOrg>((a, b) => a.OrgId == b.Id)
                            .Where(a => a.UserId == item.Id)
                            .Select((a, b) => new OrgList
                            {
                                OrgId = (long)a.OrgId,
                                OrgName = b.OrgName
                            })
                            .ToList();
                item.SaleOrgList = orgs;
            }
        }

        return DataResult<List<SaleSelectListRes>>.Success(list, MultiLanguageConst.DataQuerySuccess); ;
    }


    /// <summary>
    /// 获取审核日志列表
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<DataResult<List<AuditLogListRes>>> GetAuditLogList(string id)
    {
        var data = await saasService.GetLogDb().Queryable<SysLogAudit>().Filter(null, true)
            .Where(a => a.KeyId == long.Parse(id))
            .Select<AuditLogListRes>()
            .ToListAsync();
        return await Task.FromResult(DataResult<List<AuditLogListRes>>.Success(data, MultiLanguageConst.DataQuerySuccess));
    }
    /// <summary>
    /// 获取币别信息下拉选择
    /// </summary>
    /// <returns></returns>
    public DataResult<List<FeeCurrencySelectRes>> GetFeeCurrencySelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<FeeCurrency>()
            .Where(x => x.Status == StatusEnum.Enable)
            .Select<FeeCurrencySelectRes>()
            .ToList();
        return DataResult<List<FeeCurrencySelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取费用代码下拉选择
    /// </summary>
    /// <returns></returns>
    public DataResult<List<FeeCodeSelectRes>> GetFeeCodeSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<FeeCode>()
            .Where(x => x.Status == StatusEnum.Enable)
            .Select<FeeCodeSelectRes>()
            .ToList();
        return DataResult<List<FeeCodeSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 根据类型获取往来单位下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetClientListByCode(string code = "")
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

        code = code.ToLower();
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt())
            .WhereIF(code == "carrier", (a, b) => b.IsCarrier == true)
            .WhereIF(code == "yard", (a, b) => b.IsYard == true)
            .WhereIF(code == "booking", (a, b) => b.IsBooking == true)
            .WhereIF(code == "truck", (a, b) => b.IsTruck == true)
            .WhereIF(code == "controller", (a, b) => b.IsController == true)
            .WhereIF(code == "custom", (a, b) => b.IsCustom == true)
            .WhereIF(code == "agent", (a, b) => b.IsAgent == true)
            .WhereIF(code == "agentcn", (a, b) => b.IsAgentCn == true)
            .WhereIF(code == "express", (a, b) => b.IsExpress == true)
            .WhereIF(code == "airlines", (a, b) => b.IsAirLines == true)
            .WhereIF(code == "shipper", (a, b) => b.IsShipper == true)
            .WhereIF(code == "shippercn", (a, b) => b.IsShipperCn == true)
            .WhereIF(code == "notifyparty", (a, b) => b.IsNotifyParty == true)
            .WhereIF(code == "warehouse", (a, b) => b.IsWareHouse == true)
            .WhereIF(code == "wharf", (a, b) => b.IsWharf == true)
            .WhereIF(code == "insurer", (a, b) => b.IsInsurer == true)
            .WhereIF(code == "leasing", (a, b) => b.IsLeasing == true)
            .WhereIF(code == "tradingagency", (a, b) => b.IsTradingAgency == true)
            .WhereIF(code == "shipagency", (a, b) => b.IsShipAgency == true)
            .WhereIF(code == "enterprise", (a, b) => b.IsEnterprise == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName,
                BLContent = a.BLContent,
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取所有往来单位下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetAllClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt())
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取船公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetCarrierClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsCarrier == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取场站下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetYardClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsYard == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取订舱公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetBookingClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsBooking == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取车队下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetTruckClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsTruck == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取委托单位下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetControllerClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsController == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取报关行下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetCustomClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsCustom == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取代理(国外)下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetAgentClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAgent == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取代理(国内)下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetAgentCnClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAgentCn == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取快递公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetExpressClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsExpress == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取航空公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetAirLinesClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsAirLines == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取发货人下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetShipperClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsShipper == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取收货人下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetConsigneeClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsConsignee == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取通知人下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetNotifyPartyClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsNotifyParty == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取仓库下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetWareHouseClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsWareHouse == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取码头下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetWharfClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsWharf == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取保险公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetInsurerClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsInsurer == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取租箱公司下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetLeasingClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsLeasing == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取贸易代理下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetTradingAgencyClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsTradingAgency == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取船代下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetShipAgencyClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsShipAgency == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取经营单位下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<ClientSelectRes>> GetEnterpriseClientList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<InfoClient>()
            .InnerJoin<InfoClientTag>((a, b) => a.Id == b.ClientId)
            .Where((a, b) => a.Status == StatusEnum.Enable.ToEnumInt() && b.IsEnterprise == true)
            .Select((a, b) => new ClientSelectRes
            {
                Id = a.Id,
                CodeName = a.CodeName,
                ShortName = a.ShortName,
                EnShortName = a.EnShortName
            }
            ).ToList();
        return DataResult<List<ClientSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取签单方式下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<IssueTypeSelectRes>> GetIssueTypeSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodeIssueType>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<IssueTypeSelectRes>().ToList();
        return DataResult<List<IssueTypeSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取集装箱下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodeCtnSelectRes>> GetCtnSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodeCtn>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<CodeCtnSelectRes>().ToList();
        return DataResult<List<CodeCtnSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取包装类型下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodePackageSelectRes>> GetPackageSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodePackage>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<CodePackageSelectRes>().ToList();
        return DataResult<List<CodePackageSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取船名下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodeVesselSelectRes>> GetVesselSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodeVessel>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<CodeVesselSelectRes>().ToList();
        return DataResult<List<CodeVesselSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取航次下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodeVoynoSelectRes>> GetVoynoSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodeVoyno>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<CodeVoynoSelectRes>().ToList();
        return DataResult<List<CodeVoynoSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取运输条款下拉列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<CodeServiceSelectRes>> GetServiceSelectList()
    {
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        var data = tenantDb.Queryable<CodeService>()
            .Where(a => a.Status == StatusEnum.Enable)
            .Select<CodeServiceSelectRes>().ToList();
        return DataResult<List<CodeServiceSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取部门列表
    /// </summary>
    /// <param name="orgId">机构id</param>
    /// <returns></returns>
    public DataResult<List<DeptSelectRes>> GetDeptList(string orgId = "")
    {
        var list = db.Queryable<SysOrg>()
            .WhereIF(orgId.IsNotEmptyOrNull(), a => a.ParentId == long.Parse(orgId))
            .Where(a => a.Status == StatusEnum.Enable && a.IsDepartment == true)
            .Select<DeptSelectRes>()
            .ToList();
        return DataResult<List<DeptSelectRes>>.Success("获取数据成功!", list);
    }
    /// <summary>
    /// 获取操作员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetOperatorUserList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsOperator == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取单证员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetVouchingClerkList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsVouchingClerk == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取销售员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetSaleUserList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsSale == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取报关员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetCustomUserList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsCustom == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取财务员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetFinancialStaffList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsFinancialStaff == true)
           .Select<UserSelectRes>()
           .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取客服列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetCustomerServiceList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsCustomerService == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    /// 获取司机列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetDiverList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsDriver == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }
    /// <summary>
    /// 获取派车调度人员列表
    /// </summary>
    /// <returns></returns>
    public DataResult<List<UserSelectRes>> GetDispatcherList()
    {
        var data = db.Queryable<SysUser>()
            .Where(a => a.Status == StatusEnum.Enable.ToEnumInt() && a.IsDispatcher == true)
            .Select<UserSelectRes>()
            .ToList();
        return DataResult<List<UserSelectRes>>.Success("获取数据成功!", data, MultiLanguageConst.DataQuerySuccess);
    }

    #region 用户高级查询条件设置

    /// <summary>
    /// 获取用户高级查询条件设置
    /// </summary>
    /// <param name="permissionId"></param>
    /// <param name="tagNo"></param>
    /// <returns></returns>
    public DataResult<SysQuerySet> GetUserQuerySet(string permissionId, int tagNo = 0)
    {
        var info = db.Queryable<SysQuerySet>()
            .Where(x => x.UserId == long.Parse(user.UserId) && x.PermissionId == long.Parse(permissionId)&& x.TagNo == tagNo).First();

        return DataResult<SysQuerySet>.Success(info);
    }

    /// <summary>
    /// 更新用户高级查询条件设置
    /// </summary>
    /// <param name="req"></param>
    /// <returns></returns>
    public DataResult UpdateUserQuerySet(UserQuerySetUpdateReq req)
    {
        var info = db.Queryable<SysQuerySet>()
            .Where(x => x.UserId == long.Parse(user.UserId) && x.PermissionId == req.PermissionId).First();

        if (info.IsNull())
        {
            var entity = new SysQuerySet
            {
                UserId = long.Parse(user.UserId),
                PermissionId = req.PermissionId,
                Content = req.Content
            };
            db.Insertable(entity).ExecuteCommand();
        }
        else
        {
            info.Content = req.Content;
            db.Updateable(info).ExecuteCommand();
        }

        return DataResult.Successed("更新成功");
    }

    #endregion

    /// <summary>
    /// 获取模块新增信息
    /// </summary>
    /// <param name="id">权限模块id</param>
    /// <returns></returns>
    public async Task<DataResult<FormSetCreateRes>> GetFormSetCreateInfoAsync(string id)
    {
        var res = new FormSetCreateRes();
        var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //判断有没有自己设置的模板
        var ownSet = await tenantDb.Queryable<CodeFormSet>()
            .Where(x => x.PermissionId == long.Parse(id) && x.CreateBy == long.Parse(user.UserId))
            .Select<FormSetCreateRes>()
            .FirstAsync();

        if (ownSet != null)
        {
            return await Task.FromResult(DataResult<FormSetCreateRes>.Success(ownSet));
        }
        else
        {

            var publicSet = await tenantDb.Queryable<CodeFormSet>()
                .Where(x => x.PermissionId == long.Parse(id))
                .Select<FormSetCreateRes>()
                .FirstAsync();
            if (publicSet != null)
            {
                return await Task.FromResult(DataResult<FormSetCreateRes>.Success(publicSet));
            }
            else
            {
                return await Task.FromResult(DataResult<FormSetCreateRes>.Failed(MultiLanguageConst.FormSetNotExist));
            }
        }
    }
}