ProductionSystem/ProductionSystem_Service/ProtocolDetailConfigService.cs

using ProductionSystem_Log;
using ProductionSystem_Model.DbModel.Para;
using ProductionSystem_Model.DbModel.Protocol;
using ProductionSystem_Model.DbModel.System;
using ProductionSystem_Model.Enum;
using ProductionSystem_Model.ViewModel;
using ProductionSystem_Model.ViewModel.Response.Protocol;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;

namespace ProductionSystem_Service
{
    public class ProtocolDetailConfigService : DbContext
    {
        /// <summary>
        /// 查询所有CAN/LIN协议配置明细表
        /// </summary>
        /// <returns></returns>
        public ISugarQueryable<T_Protocol_Detail_Config> QueryProtocolDetailConfigs()
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryProtocolDetailConfigs时异常");
                return null;
            }
        }

        /// <summary>
        /// 查询有效CAN/LIN协议配置明细表
        /// </summary>
        /// <returns></returns>
        public ISugarQueryable<T_Protocol_Detail_Config> QueryActiveProtocolDetailConfigs()
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>().Where(m => m.IsActive);
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryActiveProtocolDetailConfigs时异常");
                return null;
            }
        }

        /// <summary>
        /// 根据Id查询CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T_Protocol_Detail_Config QueryProtocolDetailConfigById(string id)
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>().First(m => m.Id == id);
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryProtocolDetailConfigById时异常");
                return null;
            }
        }

        /// <summary>
        /// 根据通讯协议编码查询有效CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<T_Protocol_Detail_Config> QueryActiveProtocolDetailConfigByProtocolConfigCode(string protocolConfigCode)
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>().Where(m => m.ProtocolConfigCode == protocolConfigCode).OrderBy(m => m.SortIndex).ToList();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryActiveProtocolDetailConfigByProtocolConfigCode时异常");
                return null;
            }
        }

        /// <summary>
        /// 根据通讯协议编码查询通讯配置明细信息及配置的值用于报文分析
        /// </summary>
        /// <param name="protocolConfigCode">通讯协议编码</param>
        /// <param name="paraCategoryCode">工序编码</param>
        /// <returns></returns>
        public List<ProtocolDetailInfo> QueryActiveProtocolInfoByProtocolConfigCode(string protocolConfigCode, string paraCategoryCode, string productType)
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>()
                         .LeftJoin<T_Protocol_Detail_Para>((a, b) => a.MsgCode == b.MsgCode && b.ParaCategoryCode == paraCategoryCode && a.IsActive && b.IsActive)
                         .LeftJoin<T_ParaConfig>((a, b, c) => b.ParaCategoryCode == c.ParaCategory && b.ParaCode == c.ParaCode && c.ProductType == productType && c.IsActive)
                         .Where((a, b, c) => a.ProtocolConfigCode == protocolConfigCode)
                         .Select((a, b, c) => new ProtocolDetailInfo
                         {
                             ProductType = c.ProductType,
                             ParaCategoryCode = b.ParaCategoryCode,
                             ProtocolConfigCode = a.ProtocolConfigCode,
                             MsgType = a.MsgType,
                             MsgId = a.MsgId,
                             MsgCode = a.MsgCode,
                             MsgName = a.MsgName,
                             ReadRate = a.ReadRate,
                             StartBit = a.StartBit,
                             MsgLen = a.MsgLen,
                             ResolvePrecision = a.ResolvePrecision,
                             Offset = a.Offset,
                             ParaCode = b.ParaCode,
                             target_val = c.TargetVal,
                             Formula = a.Formula,
                             WriteVal = a.WriteVal,
                             SortIndex = a.SortIndex,
                             MsgSortIndex = a.MsgSortIndex,
                             ReciveMsgFormat = a.ReciveMsgFormat,
                             Msg=a.Msg,
                             IsActive=a.IsActive
                         }).OrderBy(a => a.SortIndex).ToList();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryActiveProtocolInfoByProtocolConfigCode时异常");
                return null;
            }
        }

        /// <summary>
        /// 根据报文编码查询有效CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="msgCode">明细报文编码</param>
        /// <returns></returns>
        public T_Protocol_Detail_Config QueryActiveProtocolDetailConfigByCode(string msgCode)
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>().First(m => m.MsgCode == msgCode && m.IsActive);
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryActiveProtocolDetailConfigByCode时异常");
                return null;
            }
        }

        /// <summary>
        /// 查询表中最大的排序索引
        /// </summary>
        /// <returns></returns>
        public int QueryProtocolDetailConfigMaxSortIndex()
        {
            try
            {
                return db.Queryable<T_Protocol_Detail_Config>().Max(m => m.SortIndex);
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下QueryProtocolDetailConfigMaxSortIndex时异常");
                return 0;
            }
        }

        /// <summary>
        /// 新增CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="t_Protocol_Detail_Config"></param>
        /// <returns></returns>
        public int AddProtocolDetailConfig(T_Protocol_Detail_Config t_Protocol_Detail_Config)
        {
            try
            {
                return db.Insertable(t_Protocol_Detail_Config).ExecuteCommand();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下AddProtocolDetailConfig时异常");
                return -1;
            }
        }

        /// <summary>
        /// 新增CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="t_Protocol_Detail_Config"></param>
        /// <returns></returns>
        public int AddProtocolDetailConfigs(List<T_Protocol_Detail_Config> t_Protocol_Detail_Configs)
        {
            try
            {
                return db.Insertable(t_Protocol_Detail_Configs).ExecuteCommand();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下AddProtocolDetailConfigs时异常");
                return -1;
            }
        }

        /// <summary>
        /// 修改CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="t_Protocol_Detail_Config"></param>
        /// <returns></returns>
        public int UpdateProtocolDetailConfig(T_Protocol_Detail_Config t_Protocol_Detail_Config)
        {
            try
            {
                return db.Updateable(t_Protocol_Detail_Config).ExecuteCommand();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下UpdateProtocolDetailConfig时异常");
                return -1;
            }
        }

        /// <summary>
        /// 根据Id更新通讯协议明细表的状态
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="isActive"></param>
        /// <returns></returns>
        public (bool isOk, string msg) UpdateProtocolDetailConfigStatus(string id, bool? isActive = true)
        {
            try
            {
                var row = db.Updateable<T_Protocol_Detail_Config>()
                            .SetColumns(c => c.IsActive == isActive)
                            .SetColumns(c => c.UpdatedTime == DateTime.Now)
                            .SetColumns(c => c.UpdatedBy == CurrentUser.UserName)
                            .Where(m => m.Id == id)
                            .ExecuteCommand();
                return (row > 0, row > 0 ? "操作成功！" : "操作失败！");
            }
            catch (Exception ex)
            {
                var errorMsg = $"执行ProtocolDetailConfigService下UpdateProtocolDetailConfigStatus时异常：{ex.Message}";
                LogHelper.Error(ex, errorMsg);
                return (false, errorMsg);
            }
        }

        /// <summary>
        /// 根据报文编码物理删除CAN/LIN协议配置明细表
        /// </summary>
        /// <param name="msgCode"></param>
        /// <param name="msgType"></param>
        /// <returns></returns>
        public int DoDelProtocolDetailConfigByMsgCode(string msgCode, string msgType)
        {
            try
            {
                return db.Deleteable<T_Protocol_Detail_Config>().Where(m => m.MsgCode == msgCode && m.MsgType == msgType).ExecuteCommand();
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex, "执行ProtocolDetailConfigService下DoDelProtocolDetailConfigByMsgCode时异常");
                return -1;
            }
        }
    }
}