using Cowain.Bake.Common;
using Cowain.Bake.Common.Core;
using Cowain.Bake.Common.Enums;
using Cowain.Bake.Model;
using Cowain.Bake.Model.Entity;
using Cowain.Bake.Model.Models;
using Prism.Ioc;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using Unity;
namespace Cowain.Bake.BLL
{
    public class PalletInfoService : ServiceBase
    {
        public PalletInfoService(IUnityContainer unityContainer) : base(unityContainer)
        {

        }
        public List<TPalletInfo> GetAll()
        {
            using (var Context = new BakingEntities())
            {
                var palletList = Context.Set<TPalletInfo>().OrderBy(x => x.Id).OrderByDescending(x => x.PalletCode).ToList();
                if (palletList == null)
                {
                    return null;
                }

                return palletList;
            }
        }

        public TPalletInfo GetPalletInfo(string PalletCode)
        {
            using (var Context = new BakingEntities())
            {
                return Context.Set<TPalletInfo>().Where(x => x.PalletCode == PalletCode).FirstOrDefault();
            }
        }
        public int UpdateWaterValue(int palletId, int palletstaus, string waterValue)
        {
            using (var Context = new BakingEntities())
            {
                var pallet = Context.Set<TPalletInfo>().Where(x => x.Id == palletId).FirstOrDefault();
                if (null == pallet)
                {
                    LogHelper.Instance.Error("修改托盘水含量数据失败！");
                    return 0;
                }
                pallet.PalletStatus = palletstaus;
                pallet.WaterValue = waterValue;  
                Context.Entry(pallet).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
        public List<MoveInfoEntity> GetMoveInfo()
        {
            using (var Context = new BakingEntities())
            {
                var tt = (from sd in Context.Set<TCavityInfo>()
                          join p in Context.Set<TPalletInfo>() on sd.PalletId equals p.Id
                          where sd.Name != "AGV"
                          orderby sd.Name
                          select new MoveInfoEntity
                          {
                              Name = sd.Name,
                              PalletStatus = p.PalletStatus,
                              PalletCode = p.PalletCode,
                              BatteryQty = p.BatteryQty,
                              BeginBakingTime = p.BakingBeginTime,
                              BakingOverTime = p.BakingOverTime
                          }).ToList();
                return tt;
            }
        }

        public List<TPalletInfo> Query(DateTime startTime, DateTime endTime, string palletCode)
        {
            using (var Context = new BakingEntities())
            {

                if (string.IsNullOrEmpty(palletCode))
                {
                    string sql = $"SELECT * FROM TPalletInfo WHERE ScanTime > '{startTime}' AND ScanTime < '{endTime}' UNION ALL " +
                        $"SELECT * FROM TPalletInfoHistory WHERE ScanTime > '{startTime}' AND ScanTime < '{endTime}' order by ScanTime DESC";
                    return Context.Database.SqlQuery<TPalletInfo>(sql).ToList();
                }
                else
                {
                    string sql = $"SELECT * FROM TPalletInfo WHERE ScanTime > '{startTime}' AND ScanTime < '{endTime}' AND PalletCode='{palletCode}' UNION ALL " +
                       $"SELECT * FROM TPalletInfoHistory WHERE ScanTime > '{startTime}' AND ScanTime < '{endTime}' AND PalletCode='{palletCode}' order by ScanTime DESC";
                    return Context.Database.SqlQuery<TPalletInfo>(sql).ToList();
                }
   
            }
        }

        public TPalletInfo GetRobotPallet()
        {
            using (var Context = new BakingEntities())
            {
                return (from pi in Context.Set<TPalletInfo>()
                        join ci in Context.Set<TCavityInfo>() on pi.Id equals ci.PalletId
                        where ci.Name == "AGV"
                        select pi).FirstOrDefault();
            }
        }

        public int PalletInfoToHistory(int virtualId, int palletStatus, int batteryStauts, int stationType, int number)
        {
            using (var Context = new BakingEntities())
            {
                return Context.Database.ExecuteSqlCommand($"call ProcPalletInfoToHistory({virtualId},{palletStatus},{batteryStauts},{stationType},{number})");
            }
        }

        public TPalletInfo GetPalletInfoByBatteryVirtualId(int? palletVirtualId)
        {
            using (var Context = new BakingEntities())
            {
                string sql = $"SELECT * FROM TPalletInfo WHERE VirtualId = {palletVirtualId} UNION ALL SELECT * FROM TPalletInfoHistory WHERE VirtualId = {palletVirtualId}; ";
                return Context.Database.SqlQuery<TPalletInfo>(sql).FirstOrDefault();
            }
        }

        public TPalletInfo GetPalletInfoOrHistory(int batteryVirtualId)
        {
            using (var Context = new BakingEntities())
            {
                TBatteryInfo batteryInfo = Context.Set<TBatteryInfo>().Where(x => x.Id == batteryVirtualId).FirstOrDefault();

                if (null == batteryInfo)
                {
                    LogHelper.Instance.Fatal($"没有找到电芯虚拟ID:{batteryVirtualId}的夹具!");
                    return null;
                }

                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.VirtualId == batteryInfo.PalletVirtualId).FirstOrDefault();
                if (palletInfo == null)
                {
                    TPalletInfoHistory palletInfoHistory = Context.Set<TPalletInfoHistory>().Where(x => x.VirtualId == batteryInfo.PalletVirtualId).FirstOrDefault();
                    if (palletInfoHistory != null)
                    {
                        palletInfo = new TPalletInfo
                        {
                            VirtualId = palletInfoHistory.VirtualId,
                            Id = palletInfoHistory.Id,
                            PalletCode = palletInfoHistory.PalletCode,
                            PalletStatus = palletInfoHistory.PalletStatus,
                            BakingPosition = palletInfoHistory.BakingPosition,
                            LoadingPosition = palletInfoHistory.LoadingPosition,
                            UnLoadingPosition = palletInfoHistory.UnLoadingPosition,
                            BatteryQty = palletInfoHistory.BatteryQty,
                            BakingCount = palletInfoHistory.BakingCount,
                            LoadingBegingTime = palletInfoHistory.LoadingBegingTime,
                            LoadingOverTime = palletInfoHistory.LoadingOverTime,
                            InStoveTime = palletInfoHistory.InStoveTime,
                            BakingBeginTime = palletInfoHistory.BakingBeginTime,
                            BakingOverTime = palletInfoHistory.BakingOverTime,
                            OutStoveTime = palletInfoHistory.OutStoveTime,
                            UnLoadingBegingTime = palletInfoHistory.UnLoadingBegingTime,
                            UnLoadingOverTime = palletInfoHistory.UnLoadingOverTime,
                            JobNum = palletInfoHistory.JobNum,
                            ScanTime = palletInfoHistory.ScanTime,
                            CreateTime = palletInfoHistory.CreateTime,
                            LastFlag = palletInfoHistory.LastFlag,
                            WaterValue = palletInfoHistory.WaterValue,
                            UnLoadingCoolTemp = palletInfoHistory.UnLoadingCoolTemp
                        };
                    }
                }
                return palletInfo;
            }
        }
        public int UpdateVirtualId(int VirtualId, string palletCode = "")
        {
            using (var Context = new BakingEntities())
            {
                var palletOld = Context.Set<TPalletInfo>().Where(x => x.PalletCode == palletCode).ToList().FirstOrDefault(); //当前夹具
                var palletNew = Context.Set<TPalletInfo>().Where(x => x.VirtualId == VirtualId).ToList().FirstOrDefault();  //将要绑定的夹具

                if (palletNew != null)
                {
                    if (palletOld.VirtualId == palletNew.VirtualId)
                    {
                        return 0;
                    }

                    //表示这个虚拟码绑定过托盘,将之前所绑定的信息转移到当前托盘
                    palletOld.VirtualId = palletNew.VirtualId;
                    palletOld.BakingBeginTime = palletNew.BakingBeginTime;
                    palletOld.BakingOverTime = palletNew.BakingOverTime;
                    palletOld.BakingPosition = palletNew.BakingPosition;
                    palletOld.BatteryQty = palletNew.BatteryQty;
                    palletOld.JobNum = palletNew.JobNum;
                    palletOld.LastFlag = palletNew.LastFlag;
                    palletOld.LoadingBegingTime = palletNew.LoadingBegingTime;
                    palletOld.LoadingOverTime = palletNew.LoadingOverTime;
                    palletOld.LoadingPosition = palletNew.LoadingPosition;
                    palletOld.PalletStatus = palletNew.PalletStatus;
                    palletOld.ScanTime = palletNew.ScanTime;
                    palletOld.WaterValue = palletNew.WaterValue;

                    palletNew.VirtualId = 0;
                    palletNew.BatteryQty = 0;
                    palletNew.JobNum = null;
                    palletNew.LastFlag = false;
                    palletNew.PalletStatus = (int)EPalletStatus.BlankOver;
                    palletNew.ScanTime = null;
                    palletNew.WaterValue = "";
                }
                else
                {
                    //没绑定的就将电芯信息绑定
                    palletOld.VirtualId = VirtualId;
                }

                return Context.SaveChanges();
            }
        }
        public TPalletInfo GetPalletInfo(int palletId)
        {
            using (var Context = new BakingEntities())
            {
                return Context.Set<TPalletInfo>().Where(x => x.Id == palletId).FirstOrDefault();
            }
        }

        public TPalletInfo GetPalletInfoByVirtualId(int virtualid)
        {
            using (var Context = new BakingEntities())
            {
                return Context.Set<TPalletInfo>().Where(x => x.VirtualId == virtualid).FirstOrDefault();
            }
        }

        public bool SetUnBinding(int palletId)
        {
            using (var Context = new BakingEntities())
            {
                var pallet = Context.Set<TPalletInfo>().Where(x => x.Id == palletId).FirstOrDefault();
                
                if (null == pallet)
                {
                    return false;
                }

                pallet.VirtualId = 0;
                pallet.BakingPosition = 0;
                pallet.LoadingPosition = 0;
                pallet.UnLoadingPosition = 0;
                pallet.BatteryQty = 0;
                pallet.BakingCount = 0;
                pallet.LastFlag = false;

                pallet.LoadingBegingTime = null;
                pallet.LoadingOverTime = null;
                pallet.InStoveTime = null;
                pallet.BakingBeginTime = null;
                pallet.BakingOverTime = null;
                pallet.OutStoveTime = null;
                pallet.UnLoadingBegingTime = null;
                pallet.UnLoadingOverTime = null;
                pallet.WaterValue = null;
                pallet.JobNum = "";
                return Context.SaveChanges() > 0 ? true : false;
            }
        }
        public int UpdateOutStoveTime(int id)
        {
            using (var Context = new BakingEntities())
            {
                int[] status = new int[] { (int)EPalletStatus.BakeOver, (int)EPalletStatus.WaitTest, (int)EPalletStatus.TestOK }; //烘烤后出炉才要记录时间
                var pallet = Context.Set<TPalletInfo>().Where(x => x.Id == id && status.Contains(x.PalletStatus)).FirstOrDefault(); 
                if (pallet == null)
                {
                    return 0;
                }

                pallet.OutStoveTime = DateTime.Now;
                Context.Entry(pallet).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
        public int UpdateNowJobNum(int? virtualid)
        {
            using (var Context = new BakingEntities())
            {
                TProductionInformation productionInformation = Context.Set<TProductionInformation>().Where(x => x.CurrentProduct == true).FirstOrDefault();

                var pallet = Context.Set<TPalletInfo>().Where(x => x.VirtualId == virtualid).FirstOrDefault(); 
                if (pallet == null)
                {
                    LogHelper.Instance.Error("修改托盘工单失败！");
                    return 0;
                }

                pallet.JobNum = productionInformation.JobNum;
                Context.Entry(pallet).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }

        public int ModifyBatteryQty(int palletId, int num = 1)
        {
            using (var Context = new BakingEntities())
            {
                var pallet = Context.Set<TPalletInfo>().Where(x => x.Id == palletId).FirstOrDefault();
                if (pallet == null)
                {
                    LogHelper.Instance.Error($"托盘托盘条码:{pallet.BatteryQty},修改夹具中的电芯数据失败！");
                    return 0;
                }

                if (pallet.BatteryQty <= 0 && num < 0)
                {
                    LogHelper.Instance.Error($"托盘条码:{pallet.BatteryQty}中的电芯数据失败,夹具中的电芯数为0", true);
                    return 0;
                }

                pallet.BatteryQty += num;
                Context.Entry(pallet).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
        /// <summary>
        /// 开始烘烤时
        /// </summary>
        /// <param name="palletId"></param>
        /// <param name="stationDatailId"></param>
        /// <returns></returns>
        public int UpdateStartBakingInfo(List<ExCavityInfoModel> cavitys)
        {
            List<int> palletIds = cavitys.Select(x => x.PalletId).ToList(); //修改夹具状态
            palletIds.RemoveAll(x => x == 0);
            using (var Context = new BakingEntities())
            {
                List<TPalletInfo> pallets = Context.Set<TPalletInfo>().Where(x => palletIds.Contains(x.Id)).ToList();//.ForEach(x => x.PalletStatus = status);

                pallets.ForEach(p =>
                {
                    if (1 == p.Id) //防呆 不修改新夹具状态
                    {
                        LogHelper.Instance.GetCurrentClassError($"错误修改新夹具状态:{(int)EPalletStatus.Bake}！");
                    }
                    else
                    {
                        p.PalletStatus = (int)EPalletStatus.Bake;
                        ++p.BakingCount;
                        ++p.TotalBakingCount;
                        p.BakingBeginTime = DateTime.Now;
                        p.BakingOverTime = null;
                        p.OutStoveTime = null;
                        p.UnLoadingBegingTime = null;
                        p.UnLoadingOverTime = null;
                        p.BakingPosition =  cavitys.Where(x=>x.PalletId == p.Id).FirstOrDefault().Id;
                    }
                });

                //Context.Entry(pallets).State = EntityState.Modified; //会报错
                return Context.SaveChanges();
            }
        }

        public int UpdateBakingPos(string palletCode, int cavityId)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.PalletCode == palletCode).FirstOrDefault();
                if (null == palletInfo)
                {
                    LogHelper.Instance.Error($"修改夹具的烘烤位置失败！夹具号:{palletCode}，位置:{cavityId}");
                    return 0;
                }
                palletInfo.BakingPosition = cavityId;
                Context.Entry(palletInfo).State = EntityState.Modified;
                return Context.SaveChanges();
            }
        }

        public int UpdateBakingOverTime(int[] palletIds)
        {
            int status = 0;
            using (var Context = new BakingEntities())
            {
                List<TPalletInfo> pallets = Context.Set<TPalletInfo>().Where(x => palletIds.Contains(x.Id)).ToList(); //托盘Id不能为0
                TPalletInfo pallet = pallets.Where(x => !string.IsNullOrEmpty(x.JobNum)).FirstOrDefault();            //去掉有夹具，但没有电芯
                if (null == pallet)
                {
                    LogHelper.Instance.Error($"烘烤完成后，查找工单失败！{string.Join(",", palletIds)}");
                    return 0;
                }

                pallets.ForEach(p =>
                {
                    var proceParamModel = _unityContainer.Resolve<ProductionInformationService>().GetProductionInformation(pallet.JobNum);
                    if (proceParamModel != null)
                    {
                        if (proceParamModel.DummyRule == (int)DummyPlaceRule.EVERY_STOVE_NOT_PLACED_ANY)//每个炉子均不放假电芯
                        {
                            //status = (int)EPalletStatus.TestOK;
                            status = (int)EPalletStatus.BakeOver;
                        }
                        else
                        {
                            if (_unityContainer.Resolve<BLL.BatteryInfoService>().IsPalletDummy(p.VirtualId))//不带水烘烤结束后直接变为待测水含量
                            {
                                status = (int)EPalletStatus.BakeOver;//status只改变一次所以要重新赋值，防止不带水的在左边，将status改变为待测水含量；两个都会是待测水含量
                            }
                            else
                            {
                                status = (int)EPalletStatus.BakeOver;
                                //status = (int)EPalletStatus.WaitTest;//这个要理解，如果是带水的夹具，就是烘烤完成，直接搬下料，如果是不带水的，就是待水含量测试，不能去下料，等测试结果
                            }
                        }

                        if (1 == p.Id) //防呆 不修改新夹具状态
                        {
                            LogHelper.Instance.GetCurrentClassError("错误修改新夹具状态！");
                        }
                        else
                        {
                            p.PalletStatus = status;
                            p.BakingOverTime = DateTime.Now;
                        }
                    }
                });

                return Context.SaveChanges();
            }
        }

        public int UpdatePalletStatus(int[] palletIds, int status)  
        {
            using (var Context = new BakingEntities())
            {
                List<TPalletInfo> pallets = Context.Set<TPalletInfo>().Where(x => palletIds.Contains(x.Id)).ToList();//.ForEach(x => x.PalletStatus = status);
      
                pallets.ForEach(p =>
                {
                    if (1 == p.Id) //防呆 不修改新夹具状态
                    {
                        LogHelper.Instance.GetCurrentClassError($"错误修改新夹具状态:{status}！");
                    }
                    else
                    {
                        p.PalletStatus = status;
                    }
                });
                      
                return Context.SaveChanges();
            }
        }

        //先找到这一层，再找自己（这样那怕是在下料也没有关系）
        public int UpdateDummyLayerValue(int bakingPosition, int status, string waterValue, int palletId) //下料要解锁烤箱的
        {
            List<int> result = null;
            string palletIds = "";
            using (var Context = new BakingEntities())
            {
                TCavityInfo bakingMachine = Context.Set<TCavityInfo>().Where(m => m.Id == bakingPosition).FirstOrDefault();

                if (bakingMachine != null)
                {
                    result = (from m in Context.Set<TCavityInfo>()
                              join p in Context.Set<TPalletInfo>() on m.PalletId equals p.Id into ms
                              from p in ms.DefaultIfEmpty()
                              where m.StationId == bakingMachine.StationId && m.LayerType == bakingMachine.LayerType
                              && m.PalletId != 0 && p.PalletStatus == (int)EPalletStatus.WaitTest
                              select p.Id).ToList();
                }

                if (null == result || 0 == result.Count())
                {
                    palletIds = palletId.ToString();
                }
                else
                {
                    result.RemoveAll(x => x == 1);   // 把所有 1 一次性清掉
                    if (1 == palletId)
                    {
                        LogHelper.Instance.Fatal("测试水含量中有为1的夹具");
                        return 0;
                    }

                    if (!result.Contains(palletId))
                    {
                        result.Add(palletId); //表示夹具不在烤箱里
                    }
                    palletIds = string.Join(",", result);
                }

                string sql = $"UPDATE TPalletInfo set PalletStatus = {status},WaterValue='{waterValue}' WHERE Id IN ({palletIds});";
                return Context.Database.ExecuteSqlCommand(sql);
            }
        }

        public int UpdateUnLoadingBegingTime(int id)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.Id == id).FirstOrDefault();
                if (null == palletInfo)
                {
                    LogHelper.Instance.Debug($"记录下料时间失败");
                    return 0;
                }
                LogHelper.Instance.Debug($"记录下料时间成功!托盘ID:{id},虚拟ID:{palletInfo.VirtualId}");
                palletInfo.UnLoadingBegingTime = DateTime.Now;
                Context.Entry(palletInfo).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }

        public int UpdateUnLoadingOverTime(int id)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.Id == id).FirstOrDefault();
                if (null == palletInfo)
                {
                    return 0;
                }

                palletInfo.UnLoadingOverTime = DateTime.Now;
                Context.Entry(palletInfo).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
        /// <summary>
        /// 解除调度锁时判断这个位置的托盘是否还在机台上并且是待测水含量
        /// </summary>
        public TCavityInfo GetBakingStationPallet(int bakingStation)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.BakingPosition == bakingStation).Where(p => p.PalletStatus == (int)EPalletStatus.WaitTest).FirstOrDefault();
                if (null != palletInfo)
                {
                    TCavityInfo stationDetail = Context.Set<TCavityInfo>().Where(x => x.PalletId == palletInfo.Id).FirstOrDefault();
                    return stationDetail;
                }
                return null;
            }
        }

        public int SetJobNum(string stationName, string jobNum)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = (from a in Context.Set<TCavityInfo>()
                                          join b in Context.Set<TPalletInfo>() on a.PalletId equals b.Id
                                          where a.Name == stationName
                                          select b).FirstOrDefault();  //将托盘号绑定到AGV
                if (null == palletInfo)
                {
                    LogHelper.Instance.Warn($"设置工单的工站:{stationName}没有夹具, 导致设置失败！");
                    return 0;
                }
                palletInfo.JobNum = jobNum;
                Context.Entry(palletInfo).State = EntityState.Modified;
                return Context.SaveChanges();
            }
        }

        public TPalletInfo GetPalletInfoByStation(string stationName)
        {
            using (var Context = new BakingEntities())
            {
                var palletInfo = (from a in Context.Set<TCavityInfo>()
                                  join b in Context.Set<TPalletInfo>() on a.PalletId equals b.Id
                                  where a.Name == stationName
                                  select b).FirstOrDefault();  //将托盘号绑定到AGV

                if (null != palletInfo)
                {
                    if (0 == palletInfo.Id) //托盘ID=0，也是NULL
                    {
                        return null;
                    }
                }

                return palletInfo;
            }
        }

        public int UpdatePalletStatus(int palletId, int status)
        {
            using (var Context = new BakingEntities())
            {
                var pallet = Context.Set<TPalletInfo>().Where(x => x.Id == palletId).FirstOrDefault();

                if (pallet == null
                    || 1 == pallet.Id)
                {
                    LogHelper.Instance.Error($"修改夹具状态失败! 夹具ID={pallet.Id}");
                    return 0;
                }

                pallet.PalletStatus = status;  
                Context.Entry(pallet).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
        //public List<string> GetPalletCodeWithBindingInfo()
        //{
        //    string sql = $@"SELECT CONCAT(ti.PalletCode,'@',IF(td.Name IS NOT NULL,'已绑定','未绑定'))
        //        PalletCodeWithBindingInfo
        //         FROM TPalletInfo ti
        //        LEFT JOIN TCavityInfo td ON td.PalletId=ti.Id;";
        //    var table = GetDataTable(sql);
        //    List<string> palletInfo = new List<string>();
        //    foreach (DataRow item in table.Rows)
        //    {
        //        palletInfo.Add(item[0].ToString());
        //    }
        //    return palletInfo;
        //} 

        public int LoadingUpdatePalletStatus(int virtualId, int status, int batteryQty, bool Clealine) 
        {
            using (var Context = new BakingEntities())
            {
                var palletInfo = Context.Set<TPalletInfo>().Where(x => x.VirtualId == virtualId).FirstOrDefault();

                if (null == palletInfo || 1 == palletInfo.Id)
                {
                    LogHelper.Instance.Warn($"上料完成，修改夹具状态失败!夹具ID={palletInfo}");
                    return 0;
                }

                palletInfo.BatteryQty = batteryQty;
                palletInfo.PalletStatus = status;
                palletInfo.LoadingOverTime = DateTime.Now;
                palletInfo.LastFlag = Clealine;
                Context.Entry(palletInfo).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }

        public TPalletInfo GetPalletCode(int cavityId)
        {
            using (var Context = new BakingEntities())
            {
                return (from s in Context.Set<TCavityInfo>()
                    join p in Context.Set<TPalletInfo>() on s.PalletId equals p.Id
                    where s.Id == cavityId
                    select p).FirstOrDefault(); 
            }
        }

        public int SetPalletStatus(int type, int number, int status)
        {
            using (var Context = new BakingEntities())
            {
                var palletInfo = (from ci in Context.Set<TCavityInfo>()
                        join s in Context.Set<TStation>() on ci.StationId equals s.Id into cs
                        from s in cs.DefaultIfEmpty()            // 左连接 Scores
                        join pi in Context.Set<TPalletInfo>() on ci.PalletId equals pi.Id into cp
                        from pi in cp.DefaultIfEmpty()           // 左连接 Parents
                        where s.Type == type && ci.Column == number
                      select pi).FirstOrDefault();


                //var palletInfo =  (from s in Context.Set<TCavityInfo>()
                //        join p in Context.Set<TPalletInfo>() on s.PalletId equals p.Id
                //        where s.StationId == stationId && s.Column== number
                //        select p).FirstOrDefault();
                if (null == palletInfo)
                {
                    LogHelper.Instance.Error($"查找夹具失败{type}，{number}");
                    return 0;
                }
                palletInfo.PalletStatus = status;
                Context.Entry(palletInfo).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }


        //托盘绑定防呆  

        public int BindingPallet(string palletCode, int status, int stationType, int number)
        {
            using (var Context = new BakingEntities())
            {
                return Context.Database.SqlQuery<int>($"call ProcBindPallet('{palletCode}',{status},{stationType},{number})").FirstOrDefault();
            }
        }
        public int UpdateLast(string palletCode, string lastSting)
        {
            using (var Context = new BakingEntities())
            {
                TPalletInfo palletInfo = Context.Set<TPalletInfo>().Where(x => x.PalletCode == palletCode).FirstOrDefault();
                if (null == palletInfo)
                {
                    return 0;
                }
                bool last = false;
                if (lastSting == EPalletLast.YesLast.GetDescription())
                {
                    last = true;
                }
                palletInfo.LastFlag = last;
                Context.Entry(palletInfo).State = System.Data.Entity.EntityState.Modified;
                return Context.SaveChanges();
            }
        }
    }
}