using Apache.NMS.ActiveMQ.Commands;
using MailKit.Search;
using Newtonsoft.Json;
using Org.BouncyCastle.Crypto;
using Rhea.Common;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Tiger.Business.SqlSugarHepler;
using Tiger.IBusiness;
using Tiger.Model;
using Tiger.Model.DTO;
using Tiger.Model.Entitys.MES;
using Tiger.Model.Entitys.WMS.DTOS;

namespace Tiger.Business.WMS
{
    /// <summary>
    ///
    /// </summary>
    public class MaterialInfoBusiness : BizSqlsugar, IMaterialInfoBusiness
    {
        /// <summary>
        /// 最大插入数
        /// </summary>
        public const int MaxCount = 1000;

        /// <summary>
        /// T100接口URL
        /// </summary>
        public string t100Url { get; set; } = @"http://172.18.8.11/wstopprd/ws/r/awsp920";

        /// <summary>
        ///
        /// </summary>
        public readonly ITrasferInfoBusiness _transferBus;

        /// <summary>
        ///
        /// </summary>
        public readonly IOtherOutInfoBusiness _otherBus;

        /// <summary>
        ///
        /// </summary>
        public readonly IProductInputBusiness _inputBus;

        /// <summary>
        ///
        /// </summary>
        /// <param name="transferBus"></param>
        /// <param name="otherBus"></param>
        /// <param name="inputBus"></param>
        public MaterialInfoBusiness(ITrasferInfoBusiness transferBus, IOtherOutInfoBusiness otherBus, IProductInputBusiness inputBus)
        {
            _transferBus = transferBus;
            _otherBus = otherBus;
            _inputBus = inputBus;
        }

        /// <summary>
        /// 从T100获取物料信息数据
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public int GetMaterialFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("物料信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 创建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO(),
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyyMMdd"),
                            enddt = input.enddt?.ToString("yyyyMMdd")
                        }
                    }
                }
            };

            #endregion 创建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterT100>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterT100>>>(response.Message);
                Logger.Scheduler.Info($"物料信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
            }

            #endregion 发起请求

            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条数据正在等待同步。。。");

            var dataModel = new List<BAS_ITEM>();
            if (!result.payload.std_data.parameter.IsNullOrEmpty() && result.payload.std_data.parameter?.@return.Count() > 0)
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    dataModel.Add(new BAS_ITEM()
                    {
                        AUTH_ORG = input.site,
                        ITEM_CODE = item.imaf001,
                        ITEM_NAME = item.imaal003,
                        ITEM_VER = item.imaal004,
                        UNIT = item.imaf053,
                        ITEM_TYPE = item.imaa004,
                        SPEC = item.imaa004_desc,
                        IS_ACTIVE = "Y",
                        DLVY_TYPE = 1,
                        ENABLE_FIFO = "Y",
                        CTRL_MODE = "0",
                        REMARK = "WMS"
                    });
                }
            }

            Logger.Scheduler.Info($"数据正在同步。。。");

            int sql = 0;
            if (dataModel.Any())
            {
                var db = Business.Biz.Db;
                var lst = dataModel.Select(i => i.ITEM_CODE).Distinct().ToList();

                #region 查询重复数据

                var hostorydata = db.Queryable<BAS_ITEM>().Where(i => lst.Contains(i.ITEM_CODE)).ToList();// 获取旧数据

                #endregion 查询重复数据

                var res = hostorydata.Select(i => i.ITEM_CODE).Distinct().ToList();// 获取重复的物料编号
                var needinsertCode = lst.Except(res);// 取差集
                var needUpdate = dataModel.Where(i => res.Contains(i.ITEM_CODE)).ToList();// 需要更新的数据
                var needInsert = dataModel.Where(i => needinsertCode.Contains(i.ITEM_CODE)).ToList();// 需要插入的数据

                foreach (var item in needUpdate)
                {
                    item.ID = hostorydata.Where(i => i.ITEM_CODE == item.ITEM_CODE).FirstOrDefault()?.ID;
                }

                if (needInsert is { Count: > 0 })
                {
                    sql += InsertDataTable(needInsert, db);// 数据插入 数量超过1000时，自动切换为限量插入
                }
                if (needUpdate is { Count: > 0 })
                {
                    sql += UpdateDataTable(needUpdate, db);
                }
            }
            Logger.Scheduler.Info($"数据同步已完成。。。");
            return sql;
        }

        /// <summary>
        /// 从T100获取送检单信息
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public int GetInspectionNoFromT100()
        {
            var DB = Biz.Db;
            var dataList = DB.Queryable<BIZ_ERP_IQC>().Where(i => i.QCSTATUS == 2 && !string.IsNullOrWhiteSpace(i.ERP_BILL_CODE)).ToList();
            Logger.Scheduler.Info("送检单信息开始同步。。。数据检查进行中。。。");
            if (!dataList.Any())
            {
                Logger.Scheduler.Info("未能查询到有效的送检单号，请确认！");
                //throw new Exception($"未能查询到有效的送检单号，请确认！");
            }

            var dataLst = new List<BIZ_ERP_IQC>();// 返回数据集合

            foreach (var item in dataList)
            {
                #region 创建请求实体

                var model = new BodyDTO<PayLoad<Std_Data<ParameterInspectionDTO>>>()
                {
                    host = new HostDTO(),
                    datakey = new DataKey()
                    {
                        EntId = "88",
                        //CompanyId = "XCSJ"
                        CompanyId = item.AUTH_ORG
                    },
                    service = new ServiceDTO()
                    {
                        name = "wms_erp_wms_getqc"
                    },
                    payload = new PayLoad<Std_Data<ParameterInspectionDTO>>()
                    {
                        std_data = new Std_Data<ParameterInspectionDTO>()
                        {
                            parameter = new ParameterInspectionDTO()
                            {
                                qcbadocno = item.ERP_BILL_CODE
                            }
                        }
                    }
                };

                #endregion 创建请求实体

                #region 发起请求

                var result = new T100ActionResult<resultStd_data<ParameterInspectionT100>>();
                try
                {
                    var requestJson = JsonConvert.SerializeObject(model);
                    var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                    result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterInspectionT100>>>(response.Message);
                    Logger.Scheduler.Info($"送检单信息同步提交Json: {requestJson}，返回Json: {response.Message}");
                }
                catch (Exception ex)
                {
                    Logger.Scheduler.Info(ex.Message.ToString());
                    //throw new Exception(ex.Message.ToString());
                }

                #endregion 发起请求

                if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
                {
                    foreach (var itemData in result.payload.std_data.parameter.@return)
                    {
                        var entity = item;
                        entity.QCRESULT = itemData.qcba022;
                        entity.RECEIVEQTY = itemData.qcba023;
                        entity.REJECTQTY = itemData.qcba027;

                        dataLst.Add(entity);
                    }
                }
            }
            if (dataLst.Any())
            {
                DI.Resolve<IiWMS>().GetQcReq(dataLst);
            }

            return dataLst.Count();
        }

        /// <summary>
        /// 其他出库单定时推送给T100过账
        /// </summary>
        /// <returns></returns>
        public int GetOtherOutInfoToT100(InputDTO input)
        {
            var DB = Biz.Db;
            var dataList = DB.Queryable<BIZ_ERP_OTH_OUT>().Where(i => i.STATUS == BIZ_WMS_TRANSFER.STATUSs.COMPLETE.GetValue() && string.IsNullOrWhiteSpace(i.ERP_BILL_CODE) && i.AUTH_ORG == input.site).ToList();

            Logger.Scheduler.Info("其他出库单信息开始推送。。。数据检查进行中。。。");
            if (!dataList.Any())
            {
                Logger.Scheduler.Info("调未能查询到有效的其他出库单号，同步结束");
                return 0;
            }

            var billcodeLst = dataList.Select(i => i.BILLCODE).Distinct().ToList();
            var detailData = DB.Queryable<BIZ_ERP_OTH_OUT_DTL>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取明细数据

            Logger.Scheduler.Info("其他出库单信息开始推送。。。");
            foreach (var data in dataList)
            {
                var detailLst = detailData.Where(i => i.BILLCODE == data.BILLCODE).ToList();
                var details = new List<OtheroutInfoDTO>();
                foreach (var detail in detailLst)
                {
                    details.Add(new OtheroutInfoDTO()
                    {
                        inbbseq = detail.BILLLINE,
                        inbb001 = detail.ITEM_CODE,
                        inbb011 = detail.QTY > detail.PRQTY ? detail.PRQTY : detail.QTY
                    });
                }

                #region 创建请求实体

                var model = new BodyDTO<PayLoad<Std_Data<OtherOutInfoParameterDTO>>>()
                {
                    host = new HostDTO(),
                    datakey = new DataKey()
                    {
                        EntId = "88",
                        CompanyId = input.site
                    },
                    service = new ServiceDTO() { name = "wms_gen_aint301" },
                    payload = new PayLoad<Std_Data<OtherOutInfoParameterDTO>>()
                    {
                        std_data = new Std_Data<OtherOutInfoParameterDTO>()
                        {
                            parameter = new OtherOutInfoParameterDTO()
                            {
                                inbadocno = data.BILLCODE,
                                inba002 = data.BILLDATE.ToString("yyyy/MM/dd"),
                                detail = details
                            }
                        }
                    }
                };

                #endregion 创建请求实体

                #region 发起请求

                var result = new T100ActionResult<resultStd_data<ParameterTransferInfoT100>>();
                try
                {
                    var requestJson = JsonConvert.SerializeObject(model);
                    var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                    result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTransferInfoT100>>>(response.Message);
                    Logger.Scheduler.Info($"其他出库单推送T100并过账时提交Json: {requestJson}，返回Json: {response.Message}");
                }
                catch (Exception ex)
                {
                    Logger.Scheduler.Info(ex.Message.ToString());
                    //throw new Exception(ex.Message.ToString());
                }

                #endregion 发起请求

                if (!string.IsNullOrWhiteSpace(result.payload.std_data?.parameter?.docno))
                {
                    data.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;// 更新单号
                }
                if (result.payload.std_data?.execution.code == "S" && string.IsNullOrWhiteSpace(data.ERP_BILL_CODE))
                {
                    data.ERP_BILL_CODE = "T100返回信息已过账";
                }
            }
            DB.Updateable<BIZ_ERP_OTH_OUT>(dataList).ExecuteCommand();// 数据更新
            Logger.Scheduler.Info("其他出库单信息推送完成");

            return dataList.Count();
        }

        /// <summary>
        /// 销售出库单定时推送给T100过账
        /// </summary>
        /// <returns></returns>
        public int PutSaleOutInfoToT100(InputDTO input)
        {
            var DB = Biz.Db;
            var dataList = DB.Queryable<BIZ_ERP_SALE_OUT>().Where(i => i.STATUS == BIZ_WMS_TRANSFER.STATUSs.COMPLETE.GetValue() && string.IsNullOrWhiteSpace(i.ERP_BILL_CODE) && i.AUTH_ORG == input.site).ToList();// 获取符合条件的销售出库单数据

            Logger.Scheduler.Info("销售出库单信息开始推送。。。数据检查进行中。。。");
            if (!dataList.Any())
            {
                Logger.Scheduler.Info("调未能查询到有效的销售出库单号，同步结束");
                return 0;
            }

            var billcodeLst = dataList.Select(i => i.BILLCODE).Distinct().ToList();
            var detailData = DB.Queryable<BIZ_ERP_SALE_OUT_DTL>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取明细数据

            Logger.Scheduler.Info("销售出库单信息开始推送。。。");
            foreach (var data in dataList)
            {
                var detailLst = detailData.Where(i => i.BILLCODE == data.BILLCODE).ToList();
                var details = new List<SaleoutInfoDTO>();
                foreach (var detail in detailLst)
                {
                    details.Add(new SaleoutInfoDTO()
                    {
                        xmdlseq = "1",
                        xmdl001 = detail.BILLCODE,
                        xmdl002 = detail.BILLLINE,
                        xmdl008 = detail.ITEM_CODE,
                        xmdl018 = detail.QTY,
                        xmdl014 = detail.WAREHOUSECODE,
                        xmdl015 = "",
                        xmdl016 = "",
                        xmdl051 = ""
                    });
                }

                #region 创建请求实体

                var model = new BodyDTO<PayLoad<Std_Data<SaleInfoDTO>>>()
                {
                    host = new HostDTO(),
                    datakey = new DataKey()
                    {
                        EntId = "88",
                        CompanyId = input.site
                    },
                    service = new ServiceDTO()
                    {
                        name = "wms_gen_axmt540"
                    },
                    payload = new PayLoad<Std_Data<SaleInfoDTO>>()
                    {
                        std_data = new Std_Data<SaleInfoDTO>()
                        {
                            parameter = new SaleInfoDTO()
                            {
                                xmdkdocno = "2424",
                                xmdkdocdt = data.BILLDATE.ToString("yyyy/MM/dd"),
                                xmdk001 = DateTime.Now.ToString("yyyy/MM/dd"),
                                xmdk003 = data.CREATE_USER,
                                xmdk004 = "",
                                xmdk005 = data.BILLCODE,
                                xmdk007 = data.SUPPLIER_CODE,
                                detail = details
                            }
                        }
                    }
                };

                #endregion 创建请求实体

                #region 发起请求

                var result = new T100ActionResult<resultStd_data<ParameterTransferInfoT100>>();
                try
                {
                    var requestJson = JsonConvert.SerializeObject(model);
                    var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                    result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTransferInfoT100>>>(response.Message);
                    Logger.Scheduler.Info($"销售出库单推送T100并过账时提交Json: {requestJson}，返回Json: {response.Message}");
                }
                catch (Exception ex)
                {
                    Logger.Scheduler.Info($"销售出库单同步失败，失败原因：{ex.Message.ToString()}");
                    return 0;
                }

                #endregion 发起请求

                if (!string.IsNullOrWhiteSpace(result.payload.std_data?.parameter?.docno))
                {
                    data.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;// 更新单号
                }
                if (result.payload.std_data?.execution.code == "S" && string.IsNullOrWhiteSpace(data.ERP_BILL_CODE))
                {
                    data.ERP_BILL_CODE = "T100返回信息已过账";
                }
            }
            DB.Updateable<BIZ_ERP_SALE_OUT>(dataList).ExecuteCommand();// 数据更新
            Logger.Scheduler.Info("销售出库单信息推送完成");

            return dataList.Count();
        }

        /// <summary>
        /// 过账调拨单定时推送给T100
        /// </summary>
        /// <returns></returns>
        public int GetTrasferInfoToT100(InputDTO input)
        {
            var DB = Biz.Db;
            //var jobData = DB.Queryable<TSK_JOB>().Where(i => i.JobName == "ProductInputInfoFromT100").First();// 获取定时任务内容
            //if (!jobData.IsNullOrEmpty() && jobData.ISRUNNING == 1)
            //{
            //    Logger.Scheduler.Info("调拨定时任务正在执行中，本次任务已主动终止！");
            //    return -1;
            //}
            //else
            //{
            //    jobData.ISRUNNING = 1;
            //    DB.Updateable(jobData).ExecuteCommand();// 如果当前定时任务不在执行中的状态，则在开始执行前，设定为执行中
            //}

            var dataList = DB.Queryable<BIZ_WMS_TRANSFER>().
                Where(i => i.STATUS == BIZ_WMS_TRANSFER.STATUSs.FINISHED.GetValue() && string.IsNullOrWhiteSpace(i.ERP_BILL_CODE) && i.AUTH_ORG == input.site)
                .ToList();

            Logger.Scheduler.Info("调拨单信息开始推送。。。数据检查进行中。。。");
            if (!dataList.Any())
            {
                Logger.Scheduler.Info("调未能查询到有效的调拨单号，同步结束");
                return 0;
            }

            var billcodeLst = dataList.Select(i => i.BILLCODE).Distinct().ToList();

            var detailData = DB.Queryable<BIZ_WMS_TRANSFER_DTL>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取明细数据
            var returnData = DB.Queryable<BIZ_ERP_PROD_RETURN>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取退料表头数据
            var returnDetailData = DB.Queryable<BIZ_ERP_PROD_RETURN_DTL>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取退料表头数据

            Logger.Scheduler.Info("调拨单信息开始推送。。。");
            foreach (var data in dataList)
            {
                var detailLst = detailData.Where(i => i.BILLCODE == data.BILLCODE).ToList();
                var details = new List<TrasferDetailDTO>();
                foreach (var detail in detailLst)
                {
                    details.Add(new TrasferDetailDTO()
                    {
                        indd101 = detail.SOURCECODE,
                        inddseq = detail.BILLLINE,
                        indd002 = detail.ITEM_CODE,
                        indd022 = detail.OUTWAREHOUSECODE,
                        indd023 = "",
                        indd024 = detail.BATCH_NO_IN,
                        indd103 = detail.OUTQTY.ToString(),
                        indd032 = detail.INWAREHOUSECODE,
                        indd033 = ""
                    });
                }

                #region 创建请求实体

                var model = new BodyDTO<PayLoad<Std_Data<ParameterTrasferInfoDTO>>>()
                {
                    host = new HostDTO(),
                    datakey = new DataKey()
                    {
                        EntId = "88",
                        CompanyId = input.site
                    },
                    service = new ServiceDTO() { name = "wms_gen_aint330" },
                    payload = new PayLoad<Std_Data<ParameterTrasferInfoDTO>>()
                    {
                        std_data = new Std_Data<ParameterTrasferInfoDTO>()
                        {
                            parameter = new ParameterTrasferInfoDTO()
                            {
                                indcdocno = "1201",
                                indcdocdt = DateTime.Now.ToString("yyyy/MM/dd"),
                                indc004 = "L16225", //detailLst[0].CREATE_USER,
                                indc008 = data.SOURCECODE,
                                detail = details
                            }
                        }
                    }
                };

                #endregion 创建请求实体

                #region 发起请求

                var result = new T100ActionResult<resultStd_data<ParameterTransferInfoT100>>();
                try
                {
                    var requestJson = JsonConvert.SerializeObject(model);
                    var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                    result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTransferInfoT100>>>(response.Message);
                    Logger.Scheduler.Info($"调拨单主动过账提交Json: {requestJson}，返回Json: {response.Message}");
                    var orderType = "领料单";
                    if (model.payload.std_data.parameter.indc008.ToString().Substring(0, 2) == "TU")
                    {
                        orderType = "退料单";
                    }
                    if (result.payload.std_data?.execution.code != "0")
                    {
                        //大于5次就不发邮件
                        if (data.HANDLED < 6)
                        {
                            Work.DoAsync(() =>
                            {
                                MailServiceApi _IMailServiceApi = new MailServiceApi();
                                _IMailServiceApi.SendMail(new MailBodyEntity
                                {
                                    MailTextBody = $"Hi All，<br/><br/>&nbsp;&nbsp;&nbsp;&nbsp;{orderType}[{model.payload.std_data.parameter.indc008}]调拨主动过账失败，<br/> T100返回消息：{result.payload.std_data.execution.description}",
                                    MailBodyType = "Html",
                                    MailFilePath = null,
                                    Recipients = Biz.SysParam.Params.Where(q => q.PRMG_CODE == "PickingEmailGroup").Select(q => q.PARAM_VALUE).ToList(), // new List<string> {  "ben.lin@tigerclouds.com", "dyfang@sharetronic.com", "dianzicang@sharetronic.com" },
                                    Cc = new List<string>(),
                                    Sender = "WMS Email Admin",
                                    SenderAddress = "xcerp@sharetronic.com",
                                    Subject = $"{orderType}[{model.payload.std_data.parameter.indc008}]调拨主动过账失败",
                                    Body = ""
                                },
                                new SendServerConfigurationEntity
                                {
                                    SmtpHost = "mail.sharetronic.com",
                                    SmtpPort = 25,
                                    SenderAccount = "xcerp@sharetronic.com",
                                    SenderPassword = "sha66666",
                                    MailEncoding = "utf-8",
                                    IsSsl = false
                                });
                                //保存到数据库
                                var db = Biz.Db;
                                var dbTran = db.UseTran(() =>
                                {
                                    data.HANDLED++;
                                    data.HANDLED_DATE = DateTime.Now;
                                    db.Updateable(data, "EmailUser").UpdateColumns(t => new { t.HANDLED, t.HANDLED_DATE }).ExecuteCommand();
                                });
                                if (!dbTran.IsSuccess)
                                {
                                    Logger.Scheduler.Info($"调拨单异常状态保存出错，报错内容：{dbTran.ErrorException.Message}");
                                }
                            });
                        }
                    }
                }
                catch (Exception ex)
                {
                    Logger.Scheduler.Info($"调拨单创单过账失败，<br/> T100返回消息：{result.payload.std_data.execution.description}<br/>报错内容：{ex.Message}");
                    //throw new Exception(ex.Message.ToString());
                }

                #endregion 发起请求

                var res = returnData.Where(i => i.BILLCODE == data.BILLCODE).FirstOrDefault();
                var retuendetailData = returnDetailData.Where(i => i.BILLCODE == data.BILLCODE).ToList();

                if (!string.IsNullOrWhiteSpace(result.payload.std_data?.parameter?.docno))
                {
                    data.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;// 更新单号
                    foreach (var item in detailLst)
                    {
                        item.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;
                    }
                    DB.Updateable(detailLst).ExecuteCommand();

                    foreach (var item in retuendetailData)
                    {
                        item.BILLCODE = result.payload.std_data?.parameter?.docno;
                    }
                    DB.Updateable(retuendetailData).ExecuteCommand();

                    if (!res.IsNullOrEmpty())
                    {
                        res.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;// 更新退料表单号
                        DB.Updateable(res).ExecuteCommand();// 数据更新
                    }
                }
                if (result.payload.std_data?.execution.code == "S" && string.IsNullOrWhiteSpace(data.ERP_BILL_CODE))
                {
                    data.ERP_BILL_CODE = "T100返回信息已过账";// 更新单号
                }
                Logger.Scheduler.Info($"调拨单号: {data.BILLCODE}，T100返回单号: {result.payload.std_data?.parameter?.docno}");
                DB.Updateable(data).ExecuteCommand();// 数据更新
            }
            Logger.Scheduler.Info("调拨单信息推送完成");

            var jobData = DB.Queryable<TSK_JOB>().Where(i => i.JobName == "TrasferInfoToT100").First();// 获取定时任务内容
            if (!jobData.IsNullOrEmpty())
            {
                jobData.ISRUNNING = 0;
                jobData.LASTRUNTIME = DateTime.Now;
                DB.Updateable(jobData).ExecuteCommand();// 如果当前定时任务不在执行中的状态，则在开始执行前，设定为执行中
            }

            return dataList.Count();
        }

        /// <summary>
        /// 过账调拨单定时推送给T100——直接过账
        /// </summary>
        /// <returns></returns>
        public int GetTrasferInfoToT100Plan2(InputDTO input)
        {
            var DB = Biz.Db;
            var dataList = DB.Queryable<BIZ_WMS_TRANSFER>().Where(i => i.STATUS == BIZ_WMS_TRANSFER.STATUSs.COMPLETE.GetValue() && string.IsNullOrWhiteSpace(i.ERP_BILL_CODE) && i.AUTH_ORG == input.site).ToList();

            Logger.Scheduler.Info("直接过账调拨单信息开始推送。。。数据检查进行中。。。");
            if (!dataList.Any())
            {
                Logger.Scheduler.Info("调未能查询到有效的调拨单号，同步结束");
                return 0;
            }

            var billcodeLst = dataList.Select(i => i.BILLCODE).Distinct().ToList();
            var detailData = DB.Queryable<BIZ_WMS_TRANSFER_DTL>().Where(i => billcodeLst.Contains(i.BILLCODE)).ToList();// 获取明细数据

            Logger.Scheduler.Info("调拨单信息开始推送。。。");
            foreach (var data in dataList)
            {
                var detailLst = detailData.Where(i => i.BILLCODE == data.BILLCODE).ToList();
                var details = new List<TrasferDetailDTO>();
                foreach (var detail in detailLst)
                {
                    details.Add(new TrasferDetailDTO()
                    {
                        inddseq = detail.BILLLINE,
                        indd103 = detail.OUTQTY.ToString(),
                    });
                }

                #region 创建请求实体

                var model = new BodyDTO<PayLoad<Std_Data<ParameterTrasferInfoDTO>>>()
                {
                    host = new HostDTO(),
                    datakey = new DataKey()
                    {
                        EntId = "88",
                        CompanyId = input.site
                    },
                    service = new ServiceDTO() { name = "wms_gen_aint330S" },
                    payload = new PayLoad<Std_Data<ParameterTrasferInfoDTO>>()
                    {
                        std_data = new Std_Data<ParameterTrasferInfoDTO>()
                        {
                            parameter = new ParameterTrasferInfoDTO()
                            {
                                indcdocno = data.BILLCODE,
                                indc022 = DateTime.Now.ToString("yyyy/MM/dd"),
                                detail = details
                            }
                        }
                    }
                };

                #endregion 创建请求实体

                #region 发起请求

                var result = new T100ActionResult<resultStd_data<ParameterTransferInfoT100>>();
                try
                {
                    var requestJson = JsonConvert.SerializeObject(model);
                    var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                    result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTransferInfoT100>>>(response.Message);
                    Logger.Scheduler.Info($"调拨单过账提交Json: {requestJson}，调拨单号：{data.BILLCODE}，返回Json: {response.Message}");
                }
                catch (Exception ex)
                {
                    Logger.Scheduler.Info($"调拨单直接过账失败，<br/> T100返回消息：{result.payload.std_data.execution.description}<br/>报错内容：{ex.Message}");
                    //throw new Exception(ex.Message.ToString());
                }

                #endregion 发起请求

                var Result = string.Empty;
                if (!string.IsNullOrWhiteSpace(result.payload.std_data?.parameter?.docno))
                {
                    Result = result.payload.std_data?.parameter?.docno;
                    data.ERP_BILL_CODE = result.payload.std_data?.parameter?.docno;// 更新单号
                    Logger.Scheduler.Info($"调拨单号：{data.BILLCODE}对应的T100返回单号：{result.payload.std_data?.parameter?.docno}已更新");
                }
                if (result.payload.std_data?.execution.code == "S" && string.IsNullOrWhiteSpace(data.ERP_BILL_CODE))
                {
                    data.ERP_BILL_CODE = "T100返回信息已过账";
                    Result = "T100返回信息已过账";
                    Logger.Scheduler.Info($"调拨单号：{data.BILLCODE}对应的T100返回信息：{"T100返回信息已过账"}已更新");
                }
                if (!string.IsNullOrWhiteSpace(Result))
                {
                    DB.Updateable(data).ExecuteCommand();// 数据更新
                }
            }
            Logger.Scheduler.Info("调拨单信息推送完成");

            return dataList.Count();
        }

        /// <summary>
        /// 从T100获取调拨单信息
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public int GetTrasferInfoFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("调拨单信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 创建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO()
                {
                    name = "wms_erp_wms_gettransm"
                },
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyy-MM-dd"),
                            enddt = input.enddt?.ToString("yyyy-MM-dd")
                        }
                    }
                }
            };

            #endregion 创建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterTrasferT100>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTrasferT100>>>(response.Message);
                Logger.Scheduler.Info($"调拨单头表信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
                //throw new Exception(ex.Message.ToString());
            }

            #endregion 发起请求

            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条数据正在等待同步。。。");

            var masterData = new List<BIZ_WMS_TRANSFER>();
            var detailData = new List<BIZ_WMS_TRANSFER_DTL>();
            if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    #region 循环调用T10调拨单信息明细数据接口

                    var detail = new BodyDTO<PayLoad<Std_Data<ParameterTrasferInfoDetailDTO>>>()
                    {
                        host = new HostDTO(),
                        datakey = new DataKey()
                        {
                            EntId = "88",
                            CompanyId = input.site
                        },
                        service = new ServiceDTO()
                        {
                            name = "wms_erp_wms_gettransd"
                        },
                        payload = new PayLoad<Std_Data<ParameterTrasferInfoDetailDTO>>()
                        {
                            std_data = new Std_Data<ParameterTrasferInfoDetailDTO>()
                            {
                                parameter = new ParameterTrasferInfoDetailDTO()
                                {
                                    indddocno = item.indcdocno
                                }
                            }
                        }
                    };

                    #region 主数据填充

                    var transferData = new BIZ_WMS_TRANSFER()
                    {
                        ID = Guid.NewGuid().ToString("N"),
                        AUTH_ORG = input.site,
                        BILLCODE = item.indcdocno,
                        BILLDATE = item.indcdocdt.ToDateTime(),
                        CREATE_USER = "T100-" + item.indc004
                    };

                    #endregion 主数据填充

                    var detailResult = new T100ActionResult<resultStd_data<ParameterTrasferDetail>>();// 采购单明细数据

                    #endregion 循环调用T10调拨单信息明细数据接口

                    #region 从T100获取明细数据

                    try
                    {
                        var requestJson = JsonConvert.SerializeObject(detail);
                        var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                        detailResult = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterTrasferDetail>>>(response.Message);
                        Logger.Scheduler.Info($"调拨单明细表信息同步提交Json: {requestJson}，返回Json: {response.Message}");
                    }
                    catch (Exception ex)
                    {
                        Logger.Scheduler.Info(ex.Message.ToString());
                        //throw new Exception(ex.Message.ToString());
                    }

                    #endregion 从T100获取明细数据

                    #region 明细实体填充

                    if (detailResult.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
                    {
                        foreach (var ser in detailResult.payload.std_data.parameter?.@return)
                        {
                            detailData.Add(new BIZ_WMS_TRANSFER_DTL()
                            {
                                BILLCODE = ser.indddocno,
                                BILLLINE = ser.inddseq.ToString(),
                                ITEM_CODE = ser.indd002,
                                UNITCODE = ser.indd006,
                                PRQTY = ser.indd103,
                                AUTH_ORG = input.site,
                                OUTWAREHOUSECODE = ser.indd022,
                                INWAREHOUSECODE = ser.indd032
                            });
                            transferData.INWAREHOUSECODE = ser.indd032;
                            transferData.OUTWAREHOUSECODE = ser.indd022;
                        }
                    }

                    #endregion 明细实体填充

                    masterData.Add(transferData);
                }
            }
            var inputdto = new List<TrasferInfoDTO>();

            #region 请求实体构建

            foreach (var item in masterData)
            {
                var detaildatas = detailData.Where(i => i.BILLCODE == item.BILLCODE).ToList();
                var detaildto = new List<TrasferInfoDetailDTO>();
                foreach (var detailitem in detaildatas)
                {
                    detaildto.Add(new TrasferInfoDetailDTO()
                    {
                        BILLCODE = detailitem.BILLCODE,
                        BILLLINE = Convert.ToInt32(detailitem.BILLLINE),
                        LINESTATUS = detailitem.LINESTATUS.ToString(),
                        OUTQTY = detailitem.OUTQTY,
                        ITEM_CODE = detailitem.ITEM_CODE,
                        UNITCODE = detailitem.UNITCODE,
                        PRQTY = detailitem.PRQTY,
                        OUTWAREHOUSECODE = detailitem.OUTWAREHOUSECODE,
                        INWAREHOUSECODE = detailitem.INWAREHOUSECODE,
                        CREATE_TIME = DateTime.Now
                    });
                }
                inputdto.Add(new TrasferInfoDTO()
                {
                    AUTH_ORG = input.site,
                    BILLCODE = item.BILLCODE,
                    BILLDATE = item.BILLDATE,
                    OUTWAREHOUSECODE = item.OUTWAREHOUSECODE,
                    INWAREHOUSECODE = item.INWAREHOUSECODE,
                    CREATE_TIME = item.CREATE_TIME,
                    details = detaildto
                });
            }

            #endregion 请求实体构建

            _transferBus.SaveTrasferInfo(inputdto);

            Logger.Scheduler.Info($"{detailData.Count()}  条调拨单明细数据正在等待同步。。。");

            return 0;
        }

        /// <summary>
        /// 从T100获取出库单信息
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public int GetOtherOutInfoFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("出库单信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 创建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO()
                {
                    name = "wms_erp_wms_getmiscissm"
                },
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyy-MM-dd"),
                            enddt = input.enddt?.ToString("yyyy-MM-dd")
                        }
                    }
                }
            };

            #endregion 创建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterOutherOutT100>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterOutherOutT100>>>(response.Message);
                Logger.Scheduler.Info($"出库单头表信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
            }

            #endregion 发起请求

            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条数据正在等待同步。。。");

            var masterData = new List<BIZ_ERP_OTH_OUT>();
            var detailData = new List<BIZ_ERP_OTH_OUT_DTL>();
            if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    #region 循环调用T100出库单明细数据接口

                    var detail = new BodyDTO<PayLoad<Std_Data<ParameterOtherOutInfoDetailDTO>>>()
                    {
                        host = new HostDTO(),
                        datakey = new DataKey()
                        {
                            EntId = "88",
                            CompanyId = input.site
                        },
                        service = new ServiceDTO()
                        {
                            name = "wms_erp_wms_getmiscissd"
                        },
                        payload = new PayLoad<Std_Data<ParameterOtherOutInfoDetailDTO>>()
                        {
                            std_data = new Std_Data<ParameterOtherOutInfoDetailDTO>()
                            {
                                parameter = new ParameterOtherOutInfoDetailDTO()
                                {
                                    inbbdocno = item.inbadocno
                                }
                            }
                        }
                    };

                    #region 主数据填充

                    var transferData = new BIZ_ERP_OTH_OUT()
                    {
                        ID = Guid.NewGuid().ToString("N"),
                        AUTH_ORG = input.site,
                        BILLCODE = item.inbadocno,
                        BILLDATE = item.inbadocdt.ToDateTime(),
                        CREATE_USER = "T100-" + item.inba003
                    };

                    #endregion 主数据填充

                    var detailResult = new T100ActionResult<resultStd_data<ParameterOutherOutDetail>>();// 出库单明细数据

                    #endregion 循环调用T100出库单明细数据接口

                    #region 从T100获取明细数据

                    try
                    {
                        var requestJson = JsonConvert.SerializeObject(detail);
                        var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                        detailResult = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterOutherOutDetail>>>(response.Message);
                        Logger.Scheduler.Info($"出库单明细信息同步提交Json: {requestJson}，返回Json: {response.Message}");
                    }
                    catch (Exception ex)
                    {
                        Logger.Scheduler.Info(ex.Message.ToString());
                    }

                    #endregion 从T100获取明细数据

                    #region 明细实体填充

                    if (detailResult.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
                    {
                        foreach (var ser in detailResult.payload.std_data.parameter?.@return)
                        {
                            detailData.Add(new BIZ_ERP_OTH_OUT_DTL()
                            {
                                AUTH_ORG = input.site,
                                BILLCODE = ser.inbbdocno,
                                BILLLINE = ser.inbbseq.ToString(),
                                ITEM_CODE = ser.inbb001,
                                UNITCODE = ser.inbb010,
                                QTY = ser.inbb011,
                                PRQTY = ser.inbb011,
                                WAREHOUSECODE = ser.inbb007
                            });
                        }
                    }

                    #endregion 明细实体填充

                    masterData.Add(transferData);
                }
            }
            var inputdto = new List<otherOutInfoDTO>();

            #region 请求实体构建

            foreach (var item in masterData)
            {
                var detaildatas = detailData.Where(i => i.BILLCODE == item.BILLCODE).ToList();
                var detaildto = new List<DetailDTO>();
                foreach (var detailitem in detaildatas)
                {
                    detaildto.Add(new DetailDTO()
                    {
                        AUTH_ORG = input.site,
                        BILLCODE = detailitem.BILLCODE,
                        BILLLINE = Convert.ToInt32(detailitem.BILLLINE),
                        LINESTATUS = detailitem.LINESTATUS,
                        ITEM_CODE = detailitem.ITEM_CODE,
                        UNITCODE = detailitem.UNITCODE,
                        PRQTY = detailitem.PRQTY,
                        WAREHOUSECODE = detailitem.WAREHOUSECODE,
                        CREATE_TIME = DateTime.Now,
                        CREATE_USER = item.CREATE_USER
                    });
                }
                inputdto.Add(new otherOutInfoDTO()
                {
                    AUTH_ORG = input.site,
                    BILLCODE = item.BILLCODE,
                    BILLDATE = item.BILLDATE,
                    CREATE_USER = item.CREATE_USER,
                    CREATE_TIME = item.CREATE_TIME,
                    Details = detaildto
                });
            }

            #endregion 请求实体构建

            Logger.Scheduler.Info($"{detailData.Count()}  条出库单明细数据正在等待同步。。。");

            _otherBus.SaveOthOutInfo(inputdto);

            Logger.Scheduler.Info($"数据同步已完成。。。");

            return 0;
        }

        /// <summary>
        /// 数据检查
        /// </summary>
        /// <param name="input"></param>
        /// <exception cref="Exception"></exception>
        public void CheckData(InputDTO input)
        {
            if (string.IsNullOrWhiteSpace(input.site))
            {
                Logger.Scheduler.Info($"厂区不允许为空！");
                //throw new Exception($"厂区不允许为空！");
            }
            //if (!input.startdt.HasValue || !input.enddt.HasValue)
            //{
            //    throw new Exception($"起止时间不允许为空！");
            //}
        }

        /// <summary>
        /// 从T100获取采购单信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int GetPurchaseInfoFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("采购单信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 获取采购单主数据DTO

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO()
                {
                    name = "wms_erp_wms_getpurd"
                },
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyyMMdd"),
                            enddt = input.enddt?.ToString("yyyyMMdd")
                        }
                    }
                }
            };

            #endregion 获取采购单主数据DTO

            var result = new T100ActionResult<resultStd_data<ParameterPurchaseInfo>>();// 采购单主数据

            #region 从T100获取主数据

            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterPurchaseInfo>>>(response.Message);
                Logger.Scheduler.Info($"采购单提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
            }
            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条采购单数据正在等待同步。。。");
            var masterData = new List<BIZ_ERP_PO>();// 采购单主数据表
            var detailData = new List<BIZ_ERP_PO_DTL>();// 采购单明细数据表

            #endregion 从T100获取主数据

            if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    #region 循环调用T100采购单明细数据接口

                    var detail = new BodyDTO<PayLoad<Std_Data<ParameterPurchaseDTO>>>()
                    {
                        host = new HostDTO(),
                        datakey = new DataKey()
                        {
                            EntId = "88",
                            CompanyId = input.site
                        },
                        service = new ServiceDTO()
                        {
                            name = "wms_erp_wms_getpurd_d"
                        },
                        payload = new PayLoad<Std_Data<ParameterPurchaseDTO>>()
                        {
                            std_data = new Std_Data<ParameterPurchaseDTO>()
                            {
                                parameter = new ParameterPurchaseDTO()
                                {
                                    pmdldocno = item.pmdldocno
                                }
                            }
                        }
                    };

                    #region 主数据填充

                    var uid = Guid.NewGuid().ToString("N");
                    masterData.Add(new BIZ_ERP_PO()
                    {
                        ID = uid,
                        AUTH_ORG = input.site,
                        BILLCODE = item.pmdldocno,
                        BILLDATE = item.pmdldocdt.ToDateTime(),
                        BILLTYPE = Convert.ToInt32(item.pmdldoctype),
                        //STATUS = Convert.ToInt32(item.pmdlstus), // 状态无法转换
                        CURRENCY = item.pmdl015,
                        EXCHANGERATE = item.pmdl016.ToDecimal(),
                        PURDEPTCODE = item.pmdl003,
                        PUREMPLOYEECODE = item.pmdl002,
                        SUPPLIERCODE = item.pmdl004,
                        REMARK = item.pmdl044
                    });

                    #endregion 主数据填充

                    var detailResult = new T100ActionResult<resultStd_data<ParameterPurchaseDetail>>();// 采购单明细数据

                    #endregion 循环调用T100采购单明细数据接口

                    #region 从T100获取明细数据

                    try
                    {
                        var requestJson = JsonConvert.SerializeObject(detail);
                        var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                        detailResult = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterPurchaseDetail>>>(response.Message);
                    }
                    catch (Exception ex)
                    {
                        Logger.Scheduler.Info(ex.Message.ToString());
                    }

                    #endregion 从T100获取明细数据

                    #region 明细实体填充

                    if (detailResult.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
                    {
                        foreach (var ser in detailResult.payload.std_data.parameter?.@return)
                        {
                            detailData.Add(new BIZ_ERP_PO_DTL()
                            {
                                BILLID = uid,
                                BILLCODE = ser.pmdndocno,
                                BILLLINE = ser.pmdnseq.ToString(),
                                MATERIALCODE = ser.pmdn001,
                                UNITCODE = ser.pmdn006,
                                //LINESTATUS = ser.pmdn007,
                                //PRQTY = ser.
                                QTY = ser.pmdn007,
                                PROMISEDATE = ser.pmdn012.ToDateTime(),
                                REMARK = ser.pmdn050,
                                AUTH_ORG = input.site
                            });
                        }
                    }

                    #endregion 明细实体填充
                }
            }
            Logger.Scheduler.Info($"{detailData.Count()}  条采购单明细数据正在等待同步。。。");

            #region 数据添加

            int sql = 0;
            //var db = Business.Biz.Db;
            var db = Biz.DataSource["WMS57"].Client;
            if (masterData.Any())
            {
                var lst = masterData.Select(i => new { i.BILLCODE, i.BILLDATE, i.BILLTYPE }).Distinct().ToList();

                //var exp = Expressionable.Create<BIZ_ERP_PO>();// 创建表达式树
                //var expDetail = Expressionable.Create<BIZ_ERP_PO_DTL>();// 创建表达式树

                #region 主表数据同步

                #region 查询重复数据

                //foreach (var item in lst)
                //{
                //    exp.Or(i => i.BILLCODE == item.BILLCODE && i.BILLDATE == item.BILLDATE && i.BILLTYPE == item.BILLTYPE);// 追加条件
                //    expDetail.Or(i => i.BILLCODE == item.BILLCODE);// 追加条件
                //}
                Logger.Scheduler.Info($"数据正在同步中。。。");
                var oldbillcodes = masterData.Select(i => i.BILLCODE).Distinct().ToList();
                var hostorydata = db.Queryable<BIZ_ERP_PO>().Where(i => oldbillcodes.Contains(i.BILLCODE) && i.AUTH_ORG == input.site).ToList();// 获取旧数据

                #endregion 查询重复数据

                var masterLst = hostorydata.Select(i => i.BILLCODE).Distinct().ToList();
                var needInsert = masterData.Where(i => !masterLst.Contains(i.BILLCODE)).ToList();// 需要插入的数据
                //var needUpdate = hostorydata.Except(masterData).ToList();// 需要更新的数据
                var needUpdate = masterData.Where(i => masterLst.Contains(i.BILLCODE)).ToList();// 需要更新的数据
                foreach (var item in needUpdate)
                {
                    item.ID = hostorydata.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.ID;
                    //item.AUTH_ORG = input.site;
                    //item.BILLCODE = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.BILLCODE;
                    //item.BILLDATE = (masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.BILLDATE).ToDateTime();
                    //item.BILLTYPE = Convert.ToInt32(masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.BILLTYPE);
                    //item.CURRENCY = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.CURRENCY;
                    //item.EXCHANGERATE = (masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.EXCHANGERATE).ToDecimal();
                    //item.PURDEPTCODE = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.PURDEPTCODE;
                    //item.PUREMPLOYEECODE = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.PUREMPLOYEECODE;
                    //item.SUPPLIERCODE = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.SUPPLIERCODE;
                    //item.REMARK = masterData.Where(i => i.BILLCODE == item.BILLCODE).FirstOrDefault()?.REMARK;
                }

                if (needInsert is { Count: > 0 })
                {
                    sql += BizSqlsugar.InsertDataTable(needInsert, db);
                }
                if (needUpdate is { Count: > 0 })
                {
                    var needUpdate1 = needUpdate.Where(i => !string.IsNullOrWhiteSpace(i.BILLCODE)).ToList();
                    sql += BizSqlsugar.UpdateDataTable(needUpdate1, db);
                }

                #endregion 主表数据同步

                #region 明细表数据同步

                //var detailCode = needUpdate.Select(i => i.BILLCODE).Distinct().ToList();
                var hostoryDetailData = db.Queryable<BIZ_ERP_PO_DTL>().Where(i => masterLst.Contains(i.BILLCODE)).ToList();// 获取旧数据

                if (hostoryDetailData is { Count: > 0 })
                {
                    db.Deleteable(hostoryDetailData).ExecuteCommand();// 清理旧的明细数据，插入新的明细数据
                }

                if (detailData.Any())
                {
                    //sql = db.Insertable(detailData).ExecuteCommand();
                    sql += BizSqlsugar.InsertDataTable(detailData, db);
                }

                #endregion 明细表数据同步
            }

            #endregion 数据添加

            Logger.Scheduler.Info($"数据同步已完成。。。");
            return sql;
        }

        /// <summary>
        /// 从T100获取客户信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int GetCustomerInfoFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("客户信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 构建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO()
                {
                    name = "wms_erp_wms_getcust"
                },
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyyMMdd"),
                            enddt = input.enddt?.ToString("yyyyMMdd")
                        }
                    }
                }
            };

            #endregion 构建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterCustomerDTO>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterCustomerDTO>>>(response.Message);
                Logger.Scheduler.Info($"客户信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
            }
            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条客户数据正在等待同步。。。");

            #endregion 发起请求

            #region 实体填充

            var insertData = new List<BAS_CUSTOMER>();
            if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    insertData.Add(new BAS_CUSTOMER()
                    {
                        CUST_CODE = item.pmab001,
                        CUST_NAME_CN = item.pmaal003
                    });
                }
            }

            #endregion 实体填充

            Logger.Scheduler.Info($"数据正在同步中。。。");
            int sql = 0;
            if (insertData.Any())
            {
                var db = Business.Biz.Db;
                //var lst = insertData.Select(i => new { i.CUST_CODE, i.CUST_NAME_CN }).Distinct().ToList();

                //var exp = Expressionable.Create<BAS_CUSTOMER>();// 创建表达式树

                #region 查询重复数据

                //foreach (var item in lst)
                //{
                //    exp.Or(i => i.CUST_CODE == item.CUST_CODE && i.CUST_NAME_CN == item.CUST_NAME_CN);// 追加条件
                //}
                var hostorydata = db.Queryable<BAS_CUSTOMER>().Where(i => i.CREATE_TIME >= input.startdt).ToList();// 获取旧数据

                #endregion 查询重复数据

                var res = hostorydata.Select(i => i.CUST_CODE).Distinct().ToList();
                var needInsert = insertData.Where(i => !res.Contains(i.CUST_CODE)).ToList(); // 需要插入的数据
                var needUpdate = insertData.Where(i => res.Contains(i.CUST_CODE)).ToList();// 需要更新的数据
                foreach (var item in needUpdate)
                {
                    item.ID = hostorydata.Where(i => i.CUST_CODE == item.CUST_CODE).FirstOrDefault()?.ID;
                }

                if (needInsert is { Count: > 0 })
                {
                    sql += BizSqlsugar.InsertDataTable(needInsert, db);
                }
                if (needUpdate is { Count: > 0 })
                {
                    sql += BizSqlsugar.UpdateDataTable(needUpdate, db);
                }
            }
            Logger.Scheduler.Info($"数据同步已完成。。。");
            return sql;
        }

        /// <summary>
        /// 从T100获取仓库代码信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int GetWarehouseCodeInfoFromT100(InputDTO input)
        {
            Logger.Scheduler.Info("仓库信息开始同步。。。数据检查进行中。。。");
            CheckData(input);

            #region 构建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = input.site
                },
                service = new ServiceDTO()
                {
                    name = "wms_erp_wms_getwh"
                },
                payload = new PayLoad<Std_Data<ParameterDTO>>()
                {
                    std_data = new Std_Data<ParameterDTO>()
                    {
                        parameter = new ParameterDTO()
                        {
                            site = input.site,
                            startdt = input.startdt?.ToString("yyyyMMdd"),
                            enddt = input.enddt?.ToString("yyyyMMdd")
                        }
                    }
                }
            };

            #endregion 构建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterWarehouseCodeDTO>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterWarehouseCodeDTO>>>(response.Message);
                Logger.Scheduler.Info($"仓库信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info(ex.Message.ToString());
            }
            Logger.Scheduler.Info($"发起请求。。。{result.payload.std_data.parameter?.@return.Count()}  条仓库信息正在等待同步。。。");

            #endregion 发起请求

            #region 实体填充

            var insertData = new List<WMS_WAREHOUSE>();
            if (result.payload.std_data.parameter != null && result.payload.std_data.parameter.@return.Any())
            {
                foreach (var item in result.payload.std_data.parameter.@return)
                {
                    insertData.Add(new WMS_WAREHOUSE()
                    {
                        ORG_CODE = input.site,
                        WH_CODE = item.inaa001,
                        WH_NAME = item.inayl003,
                        AUTH_ORG = input.site
                    });
                }
            }

            #endregion 实体填充

            Logger.Scheduler.Info($"数据正在同步中。。。");
            int sql = 0;
            if (insertData.Any())
            {
                var db = Business.Biz.Db;
                var codelst = insertData.Select(i => i.WH_CODE).Distinct().ToList();

                #region 查询重复数据

                var hostorydata = db.Queryable<WMS_WAREHOUSE>().Where(i => codelst.Contains(i.WH_CODE)).ToList();// 获取旧数据

                #endregion 查询重复数据

                var res = hostorydata.Select(i => i.WH_CODE).Distinct().ToList();
                var needInsert = insertData.Where(i => !res.Contains(i.WH_CODE)).ToList(); // 需要插入的数据

                var newwhcode = insertData.Select(i => i.WH_CODE).Distinct().ToList();
                var needupdatecode = res.Intersect(newwhcode);// 需要更新的仓库代码
                var needUpdate = hostorydata.Where(i => needupdatecode.Contains(i.WH_CODE)).ToList();// 需要更新的数据
                foreach (var item in needUpdate)
                {
                    var newdata = insertData.Where(i => i.WH_CODE == item.WH_CODE).FirstOrDefault();
                    var newOrg = newdata?.ORG_CODE;
                    if (item.ORG_CODE != newOrg)
                    {
                        item.ORG_CODE += "," + newOrg;
                    }
                    item.WH_NAME = newdata.WH_NAME;
                    item.AUTH_ORG = input.site;
                }

                if (needInsert is { Count: > 0 })
                {
                    sql += BizSqlsugar.InsertDataTable(needInsert, db);
                }
                if (needUpdate is { Count: > 0 })
                {
                    sql += BizSqlsugar.UpdateDataTable(needUpdate, db);
                }
            }
            Logger.Scheduler.Info($"数据同步已完成。。。");
            return sql;
        }

        /// <summary>
        /// 从MES获取成品入库信息
        /// </summary>
        /// <returns></returns>
        public int ProductInputInfoFromT100()
        {
            Logger.Scheduler.Info($"成品入库同步开始。。。");

            var db = Biz.DataSource["MES"].Client;
            var ytdb = Biz.DataSource["YTMES"].Client;
            var DB = Biz.DataSource["WMS57"].Client;
            var data = db.Queryable<C_Stock_Pallet_T>().Where(i => i.STOCK_NO.Contains("-")).ToList();// 所有的成品入库单
            var ytdata = ytdb.Queryable<C_Stock_Pallet_T>().Where(i => i.STOCK_NO.Contains("-")).ToList();// 所有的成品入库单
            data.AddRange(ytdata);
            if (!data.Any())
            {
                Logger.Scheduler.Info($"未能查询到成品入库单号，同步结束。。。");
                return -1;
            }
            //var data1 = data?.Where(i => i.UP_FLAG == 1).Select(i => i.STOCK_NO).Distinct().ToList();// 所有已经过账的单号
            var data2 = data?.Where(i => i.UP_FLAG == 0).Select(i => i.STOCK_NO).Distinct().ToList();// 所有未过账的单号

            var stocknoList = data2;//.Except(data1).ToList(); // 单号集合

            var sourceData1 = db.Queryable<C_Stock_Info_t>().Where(i => stocknoList.Contains(i.STOCK_NO)).ToList();
            var ytsourceData1 = ytdb.Queryable<C_Stock_Info_t>().Where(i => stocknoList.Contains(i.STOCK_NO)).ToList();
            sourceData1.AddRange(ytsourceData1);

            var sourceData2 = db.Queryable<R_Wip_Tracking_T>().Where(i => stocknoList.Contains(i.STOCK_NO))
                .Select(i => new MESDTO()
                {
                    Stock_No = i.STOCK_NO,
                    SERIAL_NUMBER = i.SERIAL_NUMBER,
                    CARTON_NO = i.CARTON_NO,
                    PALLET_NO = i.PALLET_NO,
                    IN_STATION_TIME = i.IN_STATION_TIME,
                    Model_Name = i.MODEL_NAME
                }).ToList();
            var ytsourceData2 = ytdb.Queryable<R_Wip_Tracking_T>().Where(i => stocknoList.Contains(i.STOCK_NO))
                .Select(i => new MESDTO()
                {
                    Stock_No = i.STOCK_NO,
                    SERIAL_NUMBER = i.SERIAL_NUMBER,
                    CARTON_NO = i.CARTON_NO,
                    PALLET_NO = i.PALLET_NO,
                    IN_STATION_TIME = i.IN_STATION_TIME,
                    Model_Name = i.MODEL_NAME
                }).ToList();
            sourceData2.AddRange(ytsourceData2);

            var wmsstocknoData = DB.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => stocknoList.Contains(i.BILLCODE) && i.PRQTY != i.INSTOCKQTY).ToList();
            var wmsstocknoList = wmsstocknoData.Select(i => i.BILLCODE).Distinct().ToList();

            int sqn = 0;
            foreach (var stockno in wmsstocknoList)
            {
                var palletnoList = sourceData2.Where(i => i.Stock_No == stockno).Select(i => i.PALLET_NO).Distinct().ToList();
                foreach (var palletno in palletnoList)
                {
                    var palletnoData = sourceData2.Where(i => i.Stock_No == stockno && i.PALLET_NO == palletno).ToList();
                    var detail = new List<ProductInputDetailDTO>();

                    #region 明细数据

                    foreach (var item in palletnoData)
                    {
                        sqn++;
                        detail.Add(new ProductInputDetailDTO()
                        {
                            SN = item.SERIAL_NUMBER,
                            Unit = sourceData1.FirstOrDefault(i => i.STOCK_NO.ToLower() == stockno.ToLower())?.UNIT,
                            Carton = item.CARTON_NO,
                            Pallet = item.PALLET_NO,
                            Location = sourceData1.FirstOrDefault(i => i.STOCK_NO.ToLower() == stockno.ToLower())?.WMS_LOC.ToUpper().Replace(" ", ""),
                            ProdDate = item.IN_STATION_TIME
                        });
                    }

                    #endregion 明细数据

                    #region 构建请求实体

                    var WarehouseCode = sourceData1.Where(i => i.STOCK_NO == stockno && !string.IsNullOrWhiteSpace(i.AREA)).ToList()[0].AREA;

                    var model = new ProductInputDTO()
                    {
                        UserCode = sourceData1.Where(i => i.STOCK_NO == stockno && !string.IsNullOrWhiteSpace(i.EMP_NO)).ToList()[0].EMP_NO,
                        WorkOrder = stockno,
                        WarehouseCode = sourceData1.Where(i => i.STOCK_NO == stockno && !string.IsNullOrWhiteSpace(i.AREA)).ToList()[0].AREA,
                        ITEM_MODEL = sourceData2.Where(i => i.Stock_No == stockno && !string.IsNullOrWhiteSpace(i.Model_Name)).ToList()[0].Model_Name,
                        ItemCode = sourceData1.Where(i => i.STOCK_NO == stockno && !string.IsNullOrWhiteSpace(i.KP_NO)).ToList()[0].KP_NO,
                        details = detail
                    };

                    #endregion 构建请求实体

                    var updateData = data.Where(i => i.STOCK_NO == stockno && i.PALLET_NO == palletno).ToList();// 记录表中对应的数据记录
                    try
                    {
                        var msg = _inputBus.GetProductInputInfo(model);
                    }
                    catch (Exception ex)
                    {
                        foreach (var item in updateData)
                        {
                            item.UP_MSG = ex.Message.ToString();
                            item.UP_TIME = DateTime.Now;
                        }
                        db.Updateable(updateData).WhereColumns(i => new { i.PALLET_NO }).ExecuteCommand();
                        if (stockno.Contains("YT"))
                        {
                            ytdb.Updateable(updateData).WhereColumns(i => new { i.PALLET_NO }).ExecuteCommand();
                        }
                        Logger.Scheduler.Info($"数据同步失败，单号：{stockno}\t栈板号：{palletno}，失败原因：{ex.Message.ToString()}。。。");
                        //UpdateDataTable(updateData, db);
                        continue;
                    }

                    foreach (var item in updateData)
                    {
                        item.UP_FLAG = 1;
                        item.UP_TIME = DateTime.Now;
                    }
                    if (updateData.Count > 0)
                    {
                        if (stockno.Contains("YT"))
                        {
                            ytdb.Updateable(updateData).WhereColumns(i => new { i.PALLET_NO }).ExecuteCommand();
                        }
                        else
                        {
                            db.Updateable(updateData).WhereColumns(i => new { i.PALLET_NO }).ExecuteCommand();
                        }

                        //UpdateDataTable(updateData, db);
                    }
                    Logger.Scheduler.Info($"数据同步成功，单号：{stockno}\t栈板号：{palletno}。。。");
                }
            }

            var jobData = DB.Queryable<TSK_JOB>().Where(i => i.JobName == "ProductInputInfoFromT100").First();// 获取定时任务内容
            if (!jobData.IsNullOrEmpty())
            {
                jobData.ISRUNNING = 0;
                jobData.LASTRUNTIME = DateTime.Now;
                DB.Updateable(jobData).ExecuteCommand();// 如果当前定时任务不在执行中的状态，则在开始执行前，设定为执行中
            }

            return sqn;
        }

        /// <summary>
        /// 获取物料信息数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<List<MaterialDTO>> GetMaterialInfo(MaterialDTO input)
        {
            var db = Biz.DataSource["WMS57"].Client;
            var data = await db.Queryable<BAS_ITEM>()
                .WhereIF(!input.ITEM_CODE.IsNullOrEmpty(), i => i.ITEM_CODE.ToLower().Contains(input.ITEM_CODE.ToLower()))
                .WhereIF(!string.IsNullOrWhiteSpace(input.ITEM_NAME), i => i.ITEM_NAME.Contains(input.ITEM_NAME))
                .Select<MaterialDTO>().ToListAsync();

            return data;
        }

        /// <summary>
        /// 更新有效期/预存期
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public int UpdateTime(MaterialDTO input)
        {
            CheckTimeData(input);
            var db = Biz.DataSource["WMS57"].Client;

            var data = db.Queryable<BAS_ITEM>()
                .WhereIF(!input.ITEM_CODE.IsNullOrEmpty(), i => i.ITEM_CODE.ToLower().Contains(input.ITEM_CODE.ToLower()))
                .WhereIF(!string.IsNullOrWhiteSpace(input.ITEM_NAME), i => i.ITEM_NAME.Contains(input.ITEM_NAME))
                .Select(i => new MaterialDTO()
                {
                    Id = i.ID.SelectAll()
                }).ToList();

            foreach (var item in data)
            {
                item.VALIDITY_DAYS = input.VALIDITY_DAYS;
                item.DepositDays = input.DepositDays;
            }

            var ids = data.Select(i => i.Id).Distinct().ToList();
            var res = db.Updateable<BAS_ITEM>(i => new BAS_ITEM() { VALIDITY_DAYS = input.VALIDITY_DAYS, DepositDays = input.DepositDays }).Where(i => ids.Contains(i.ID)).ExecuteCommand();
            return res;
        }

        /// <summary>
        /// 数据检查
        /// </summary>
        /// <param name="input"></param>
        public void CheckTimeData(MaterialDTO input)
        {
            if (input.DepositDays.IsNullOrEmpty() || input.VALIDITY_DAYS.IsNullOrEmpty())
            {
                throw new Exception($"有效天数/预存天数不可为空！");
            }
        }

        /// <summary>
        /// 物料超期预警
        /// </summary>
        /// <returns></returns>
        public int MaterialExtended()
        {
            var DB = Biz.DataSource["WMS57"].Client;

            #region 获取所有的条码有效期信息

            var data = DB.Queryable<WMS_ITEM, BAS_ITEM>((a, b) => new object[]
            {
                JoinType.Left, a.ITEM_CODE == b.ITEM_CODE
            }).Where((a, b) => b.VALIDITY_DAYS != 0 && a.STATUS <= 40)
            .Select((a, b) => new MaterialInfoDTO()
            {
                AUTH_ORG = a.AUTH_ORG,
                SN = a.SN,
                Item_Code = a.ITEM_CODE,
                PROD_DATE = a.PROD_DATE,
                VALIDITY_DAYS = b.VALIDITY_DAYS,
                DepositDays = b.DepositDays,
                PostponeDays = a.PostponeDays
            }).ToList();

            #endregion 获取所有的条码有效期信息

            //var sdaf = data.Where(i => i.PROD_DATE?.AddDays(i.VALIDITY_DAYS.ToDouble()).AddDays(-30).AddDays(i.PostponeDays.ToDouble()) <= DateTime.Now).ToList();

            //var orgs = data.Select(i => i.AUTH_ORG).Distinct().ToList();
            //foreach (var item in orgs)
            //{
            //    var count = data.Where(i => i.AUTH_ORG == item).Count();// 每个据点的总数量
            //}

            var msg = new List<string>();
            //var dic = new List<MaterialInfoDTO>();
            int sqn = 0;
            foreach (var item in data)
            {
                // 生产日期 + 有效期 - 30（提前30天预警） + 延期时长   超过了当前日期，就表示需要预警
                if (item.PROD_DATE?.AddDays(item.VALIDITY_DAYS.ToDouble()).AddDays(-30) <= DateTime.Now)
                {
                    sqn++;
                    var days = 30 - ((DateTime.Now - item.PROD_DATE?.AddDays(item.VALIDITY_DAYS.ToDouble()).AddDays(-30)).Value.Days);// 计算剩余有效期天数
                    var ms = $"条码：{item.SN}，物料编号：{item.Item_Code}，生产日期：{item.PROD_DATE}，有效期{item.VALIDITY_DAYS}，有效天数还剩{days}<br/>";
                    msg.Add(ms);
                    //dic.Add(item);
                }
            }

            if (msg.Any())
            {
                Work.DoAsync(() =>
                {
                    MailServiceApi _IMailServiceApi = new MailServiceApi();
                    _IMailServiceApi.SendMail(new MailBodyEntity
                    {
                        MailTextBody = "以下物料预超期，请及时处理！<br/><br/>" + string.Join(" ", msg),
                        MailBodyType = "Html",
                        MailFilePath = null,
                        Recipients = Biz.SysParam.Params.Where(q => q.PRMG_CODE == "MaterialExtended").Select(q => q.PARAM_VALUE).ToList(),
                        Cc = new List<string>(),
                        Sender = "WMS Email Admin",
                        SenderAddress = "xcerp@sharetronic.com",
                        Subject = $"物料有效期剩余不足30天！",
                        Body = ""
                    },
                    new SendServerConfigurationEntity
                    {
                        SmtpHost = "mail.sharetronic.com",
                        SmtpPort = 25,
                        SenderAccount = "xcerp@sharetronic.com",
                        SenderPassword = "sha66666",
                        MailEncoding = "utf-8",
                        IsSsl = false
                    });
                });
            }
            return sqn;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        public List<OverdueDTO> OverdueData(OverdueDTO input)
        {
            var DB = Biz.DataSource["WMS57"].Client;
            var data = DB.Queryable<WMS_ITEM, BAS_ITEM>((a, b) => new object[]
            {
                JoinType.Left, a.ITEM_CODE == b.ITEM_CODE
            }).WhereIF(!string.IsNullOrWhiteSpace(input.Sn), (a, b) => a.SN.ToLower().Contains(input.Sn.ToLower()) || a.CARTON_NO.ToLower().Contains(input.Sn.ToLower()) || a.PALLET_NO.ToLower().Contains(input.Sn.ToLower()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.TransNo), (a, b) => a.TRANS_NO.ToLower().Contains(input.TransNo.ToLower()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ItemCode), (a, b) => a.ITEM_CODE.ToLower().Contains(input.ItemCode.ToLower()))
            .Where((a, b) => a.IsAllowOverdue == "N")
            .Select((a, b) => new OverdueDTO()
            {
                Sn = a.SN,
                TransNo = a.TRANS_NO,
                ItemCode = a.ITEM_CODE,
                VALIDITY_DAYS = b.VALIDITY_DAYS,
                DepositDays = b.DepositDays
            }).ToList();

            return data;
        }

        /// <summary>
        /// 单号状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public int GetOrderStatus(OrderStatusDTO input)
        {
            var DB = Biz.DataSource["WMS57"].Client;
            if (input.Status.IsNullOrEmpty() || input.OrderNo.IsNullOrEmpty() || input.OrderType.IsNullOrEmpty())
            {
                return 0;
            }
            var num = 0;
            if (input.Status == "S")
            {
                if (input.OrderType == "0")
                {
                    var data = DB.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == input.OrderNo).First();
                    if (data != null)
                    {
                        data.STATUS = BIZ_ERP_PROD_IN.STATUSs.COMPLETE.GetValue();
                        num = DB.Updateable(data).ExecuteCommand();
                    }
                }
                else if (input.OrderType == "1")
                {
                    var data = DB.Queryable<BIZ_ERP_PROD_OUT>().Where(i => i.BILLCODE == input.OrderNo).First();
                    if (data != null)
                    {
                        data.STATUS = BIZ_ERP_PROD_OUT.STATUSs.COMPLETE.GetValue();
                        num = DB.Updateable(data).ExecuteCommand();
                    }
                }
            }
            return num;
        }

    }
}