WMSPrjInstance/HH-0103_ShuangQianLunTai.git

using HH.WCS.Mobox3.DoubleCoin.models;
using HH.WCS.Mobox3.DoubleCoin.util;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HH.WCS.Mobox3.DoubleCoin.wms
{
    public class SpecHelper
    {
 
        /// <summary>
        /// 获取静置时间
        /// </summary>
        /// <param name="spec"></param>
        /// <returns></returns>
        public static int GetWaitTime(string spec)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var specConfig = db.Queryable<TN_TN_SPE>().First(o => o.S_SPE == spec);
                if (specConfig != null)
                {
                    return specConfig.N_STANDING_TIME ?? 1;
                }
                else
                {
                    return 1;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("获取静置时间失败", ex);
                return 1;
            }
        }
 
        /// <summary>
        /// 获取过期时间
        /// </summary>
        /// <param name="spec"></param>
        /// <returns></returns>
        public static int GetExportTime(string spec)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var specConfig = db.Queryable<TN_TN_SPE>().First(o => o.S_SPE == spec);
                if (specConfig != null)
                {
                    return specConfig.N_EXPIRE_TIME ?? 1;
                }
                else
                {
                    return 1;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("获取过期时间失败", ex);
                return 1;
            }
        }
 
        /// <summary>
        /// 插入设备生产明细
        /// </summary>
        public static void InsertEquipProDetail(TN_EquipProDetail model)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var log = JsonConvert.SerializeObject(model);
                if (model != null)
                {
                    model.EXPIRATION = System.DateTime.Now.AddHours(GetExportTime(model.SPEC));
 
                    if (db.Insertable<TN_EquipProDetail>(model).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"插入设备生产明细成功，{log}");
                    }
                    else
                    {
                        LogHelper.Info($"插入设备生产明细失败，{log}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("插入设备生产明细失败", ex);
            }
        }
 
 
        /// <summary>
        /// 插入部件用料明细
        /// </summary>
        /// <param name="model"></param>
        public static void InsertComponentDetail(TN_Component_Detail model)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var log = JsonConvert.SerializeObject(model);
                if (model != null)
                {
                    model.OUTAREATIME = System.DateTime.Now;
                    model.TYPE = "满托出库上线";
 
                    if (db.Insertable<TN_Component_Detail>(model).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"插入部件用料明细成功，{log}");
                    }
                    else
                    {
                        LogHelper.Info($"插入部件用料明细失败，{log}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("插入部件用料明细失败", ex);
            }
        }
 
        /// <summary>
        /// 更新部件用料明细
        /// </summary>
        public static void UpdateComponentDetail(string taskNo)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var target  = db.Queryable<TN_Component_Detail>().First(o => o.TASKNO == taskNo);
 
                if (target != null)
                {
                    target.ENDTIME = System.DateTime.Now;
 
                    if (db.Updateable<TN_Component_Detail>(target).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"更新部件用料明细成功，{taskNo}");
                    }
                    else
                    {
                        LogHelper.Info($"更新部件用料明细失败，{taskNo}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("更新部件用料明细失败", ex);
            }
        }
 
 
        /// <summary>
        /// 插入回炉料明细
        /// </summary>
        /// <param name="model"></param>
        public static void InsertRemeltDetail(TN_RemeltDetail model)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var log = JsonConvert.SerializeObject(model);
                if (model != null)
                {
                    model.REMELTTIME = System.DateTime.Now;
 
                    if (db.Insertable<TN_RemeltDetail>(model).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"插入回炉料明细成功，{log}");
                    }
                    else
                    {
                        LogHelper.Info($"插入回炉料明细失败，{log}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("插入回炉料明细失败", ex);
            }
        }
 
        /// <summary>
        /// 更新回炉料明细
        /// </summary>
        public static void UpdateRemeltDetail(string taskNo)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var target = db.Queryable<TN_RemeltDetail>().First(o => o.TASKNO == taskNo);
 
                if (target != null)
                {
                    target.ENDTIME = System.DateTime.Now;
 
                    if (db.Updateable<TN_RemeltDetail>(target).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"更新回炉料明细成功，{taskNo}");
                    }
                    else
                    {
                        LogHelper.Info($"更新回炉料明细失败，{taskNo}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("更新回炉料明细失败", ex);
            }
        }
 
 
        /// <summary>
        /// 插入余料回库明细
        /// </summary>
        /// <param name="model"></param>
        public static void InsertSurplusDetail(TN_SurplusDetail model)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var log = JsonConvert.SerializeObject(model);
                if (model != null)
                {
                    model.REMELTTIME = System.DateTime.Now;
 
                    if (db.Insertable<TN_SurplusDetail>(model).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"插入余料回库明细成功，{log}");
                    }
                    else
                    {
                        LogHelper.Info($"插入余料回库明细失败，{log}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("插入余料回库明细失败", ex);
            }
        }
 
        /// <summary>
        /// 更新余料回库明细
        /// </summary>
        public static void UpdateSurplusDetail(string taskNo)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var target = db.Queryable<TN_SurplusDetail>().First(o => o.TASKNO == taskNo);
 
                if (target != null)
                {
                    target.ENDTIME = System.DateTime.Now;
 
                    if (db.Updateable<TN_SurplusDetail>(target).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"更新余料回库明细成功，{taskNo}");
                    }
                    else
                    {
                        LogHelper.Info($"更新余料回库明细失败，{taskNo}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("更新余料回库明细失败", ex);
            }
        }
 
        /// <summary>
        /// 重置终点货位，只针对去线边的货品和去原材料产线的空托
        /// </summary>
        /// <param name="tN_Task"></param>
        internal static void RestEndLoc(TN_Task tN_Task)
        {
            try
            {
                if (
                    tN_Task.S_END_AREA == Settings.Areas[2] || tN_Task.S_TYPE.Contains("满托出库上线") ||
                    Settings.ProductionLines.Select(a=>a.PointIn).ToList().Contains(tN_Task.S_END_LOC) ||
                    tN_Task.S_TYPE.Contains("线边空托上线")
                    )
                {
                    var db = new SqlHelper<object>().GetInstance();
 
                    using (var tran = db.Ado.UseTran())
                    {
                        var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == tN_Task.S_END_LOC);
                        if (endLoc != null)
                        {
                            endLoc.N_CURRENT_NUM = 0;
                            endLoc.N_LOCK_STATE = 0;
                            endLoc.S_LOCK_STATE = "无";
 
                            if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new { it.N_CURRENT_NUM, it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand() > 0)
                            {
                                LogHelper.Info($"更新终点货位成功，{JsonConvert.SerializeObject(endLoc)}");
                            }
                            else
                            {
                                LogHelper.Info($"更新终点货位失败，{JsonConvert.SerializeObject(endLoc)}");
                                tran.RollbackTran();
                                return;
                            }
 
                            var locCnt = db.Queryable<TN_Loc_Container>().First(a => a.S_CNTR_CODE == tN_Task.S_CNTR_CODE);
 
                            if (locCnt != null)
                            {
                                
                                if (db.Deleteable<TN_Loc_Container>(locCnt).ExecuteCommand() > 0)
                                {
                                    LogHelper.Info($"删除货位容器绑定关系成功，{JsonConvert.SerializeObject(locCnt)}");
                                }
                                else
                                {
                                    LogHelper.Info($"删除货位容器绑定关系失败，{JsonConvert.SerializeObject(locCnt)}");
                                    tran.RollbackTran();
                                    return;
                                }
 
                                var cgInfo = db.Queryable<TN_CG_Detail>().First(a => a.S_CNTR_CODE == tN_Task.S_CNTR_CODE);
 
                                if (cgInfo != null)
                                {
                                    if (db.Deleteable<TN_CG_Detail>(cgInfo).ExecuteCommand() > 0)
                                    {
                                        LogHelper.Info($"删除容器货品明细成功，{JsonConvert.SerializeObject(cgInfo)}");
                                    }
                                    else
                                    {
                                        LogHelper.Info($"删除容器货品明细失败，{JsonConvert.SerializeObject(cgInfo)}");
                                        tran.RollbackTran();
                                        return;
                                    }
                                }
 
                                var cnt = db.Queryable<TN_Container>().First(it => it.S_CODE == cgInfo.S_CNTR_CODE);
                                if (cnt != null)
                                {
                                    if (db.Deleteable<TN_Container>(cnt).ExecuteCommand() > 0)
                                    {
                                        LogHelper.Info($"删除容器成功，{JsonConvert.SerializeObject(cnt)}");
                                    }
                                    else
                                    {
                                        LogHelper.Info($"删除容器失败，{JsonConvert.SerializeObject(cnt)}");
                                        tran.RollbackTran();
                                        return;
                                    }
                                }
                            }
                        }
 
                        tran.CommitTran();
                        LogHelper.Info($"重置终点货位，成功，{JsonConvert.SerializeObject(tN_Task)}");
                        return;
                    }
                }
                else
                {
                    LogHelper.Info($"当前任务终点货位不是去线边，不需要重置终点货位，{JsonConvert.SerializeObject(tN_Task)}");
                    return;
                }
 
              
            }
            catch (Exception ex)
            {
                LogHelper.Error("重置终点货位，只针对去线边的货品 失败", ex);
            }
        }
 
        /// <summary>
        /// 更新余料回库明细
        /// </summary>
        public static void UpdateSurplusDetail(string taskNo,float weight)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var target = db.Queryable<TN_SurplusDetail>().First(o => o.TASKNO == taskNo);
 
                if (target != null)
                {
                    target.WEIGHT = weight;
                    if (db.Updateable<TN_SurplusDetail>(target).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"更新余料回库明细成功，{taskNo}");
                    }
                    else
                    {
                        LogHelper.Info($"更新余料回库明细失败，{taskNo}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("更新余料回库明细失败", ex);
            }
        }
 
        /// <summary>
        /// 插入WMS库存明细
        /// </summary>
        /// <param name="model"></param>
        public static void InsertInventoryM(TN_InventoryM model)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var log = JsonConvert.SerializeObject(model);
 
                if (model != null)
                {
                    model.EXPIRATION = System.DateTime.Now.AddHours(GetExportTime(model.SPEC));
                    if (db.Storageable<TN_InventoryM>(model).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"插入WMS库存明细成功，{log}");
                    }
                    else
                    {
                        LogHelper.Info($"插入WMS库存明细失败，{log}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("插入WMS库存明细失败", ex);
            }
        }
 
        /// <summary>
        /// 更新WMS库存明细的入库时间
        /// </summary>
        public static void UpdateInventoryM_RuKu(string cntId)
        {
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var target = db.Queryable<TN_CG_Detail>().First(a => a.S_CNTR_CODE == cntId);
                if (target != null)
                {
                    var targetM = db.Queryable<TN_InventoryM>().First(a => a.S_ID == target.S_ID || a.RFID == cntId);
 
                    if (targetM != null)
                    {
                        targetM.INAREATIME = System.DateTime.Now;
                        if(db.Updateable<TN_InventoryM>(targetM).UpdateColumns(it => new { it.INAREATIME }).ExecuteCommand() > 0)
                        {
                            LogHelper.Info($"更新WMS库存明细的入库时间，成功，容器号：{cntId}");
                        }
                        else
                        {
                            LogHelper.Info($"更新WMS库存明细的入库时间，失败，容器号：{cntId}");
                        }
                    }
                    else
                    {
                        LogHelper.Info($"更新WMS库存明细的入库时间，失败，容器号：{cntId}，TN_InventoryM为空");
                    }
                }
                else
                {
                    LogHelper.Info($"更新WMS库存明细的入库时间，失败，容器号：{cntId}，TN_CG_Detail为空");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("更新WMS库存明细的入库时间失败", ex);
            }
        }
 
        /// <summary>
        /// 删除WMS库存明细
        /// </summary>
        public static void DeleteInventoryM(TN_Task taskTn)
        {
            try
            {
                if (taskTn.S_START_AREA == Settings.Areas[1] || taskTn.S_TYPE.Contains("满托出库上线")) //不是从满托缓存库区移出就不删除
                {
                    var db = new SqlHelper<object>().GetInstance();
 
                    if (db.Deleteable<TN_InventoryM>().Where(it => it.S_ID == taskTn.S_ID || it.RFID == taskTn.S_CNTR_CODE).ExecuteCommand() > 0)
                    {
                        LogHelper.Info($"删除WMS库存明细，成功，物料主键：{taskTn.S_ID}，容器号：{taskTn.S_CNTR_CODE}");
                    }
                    else
                    {
                        LogHelper.Info($"删除WMS库存明细，失败，物料主键：{taskTn.S_ID}，容器号：{taskTn.S_CNTR_CODE}");
                    }
                }
                else
                {
                    LogHelper.Info($"不是从满托缓存库区搬出的货位，不需要删除库存明细，物料主键：{taskTn.S_ID}，容器号：{taskTn.S_CNTR_CODE}");
                    return;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("删除WMS库存明细", ex);
            }
        }
 
        /// <summary>
        /// 计算时间差
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <returns></returns>
        public static int CalculateDaysDifference(DateTime start, DateTime end)
        {
            try
            {
                // 计算总时间差
                TimeSpan difference = end - start;
 
                // 如果差值为负（end早于start），返回0
                if (difference.TotalDays < 0)
                {
                    return 0;
                }
 
 
                // 获取总小时数（包括小数部分）
                double totalHours = difference.TotalHours;
 
                // 向上取整
                return (int)Math.Ceiling(totalHours);
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
    }
}