添加项目文件。

SamplePre.ProcessBll/BLL/SOPManagerBll.cs

@@ -0,0 +1,518 @@
+using DataDAL;
+using Models.Const;
+using Models.Ext;
+using Models.Models;
+using Newtonsoft.Json;
+using SamplePre.Common;
+using SamplePre.DAL;
+using SamplePre.DAL.DBContext;
+using SamplePre.Models;
+using SamplePre.Models.Ext;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using static System.Collections.Specialized.BitVector32;
+
+namespace SamplePre.ProcessBll.BLL
+{
+    public class SOPManagerBll
+    {
+
+        SOPDal sopDal = new SOPDal();
+
+        public List<sys_action_parm_map_ext> GetActionParmById(string actionID)
+        {
+
+            var result = DBFactory.Instance.Queryable<sys_action_parm_map>()
+                   .LeftJoin<sys_parm>((a, b) => a.parm_id == b.id)
+                   .Where((a, b) => a.process_id == actionID && b.title != null)
+                   .Select((a, b) => new sys_action_parm_map_ext
+                   {
+                       id = a.id,
+                       process_id = a.process_id,
+                       parm_id = a.parm_id,
+                       title = b.title,
+                       unit = b.unit,
+                       data_type = b.data_type,
+                       data_value = b.data_value,
+                       plc_type = b.plc_type
+
+
+                   })
+                   .ToList();
+
+
+            //List<sys_action_parm_map_ext> paramsList = standardDal.GetProcess_parm_mapByProcessId(actionID);
+            return result;//paramsList;
+        }
+
+
+        public List<sys_standard_action_parm_ext> GetStrandActionParamByStrandId(string standId)
+        {        
+
+            var result = DBFactory.Instance.Queryable<sys_standard_action_parm>()
+                .LeftJoin< sys_action >((a,b)=>a.action_id == b.id)
+                .LeftJoin< sys_parm >((a,b,c)=>a.parm_id == c.id)
+                .Where((a,b,c)=>a.standard_id == standId)
+                .OrderBy((a,b,c)=>a.action_seqno)
+                .Select((a,b,c)=> new sys_standard_action_parm_ext {
+                     id = a.id,
+                     standard_id = a.standard_id,
+                     action_id = a.action_id,
+                     action_seqno = a.action_seqno,
+                     parm_id  = a.parm_id,
+                     parm_seqno = a.parm_seqno,
+                     standard_process_id = a.standard_process_id,
+                     data_value = a.data_value,
+                     action_name = b.action_name,
+                     title = c.title,
+                     unit = c.unit,
+                     data_type  = c.data_type,
+                     plc_type = c.plc_type
+                })
+                .ToList();
+
+
+            //List<sys_standard_action_parm_ext> paramsList = sopDal.GetStrandActionParamByStrandId(standId);
+            return result; //paramsList;
+        }
+
+        /// <summary>
+        /// 删除动作下的参数配置
+        /// </summary>
+        /// <param name="standId"></param>
+        /// <param name="actionId"></param>
+        /// <param name="seqno"></param>
+        public int removeActionParmByActionId(string standId, string actionId, int seqno)
+        {
+
+            var val = DBFactory.Instance.Deleteable<sys_standard_action_parm>(p => p.standard_id == standId && p.action_id == actionId && p.action_seqno == seqno)
+                        .ExecuteCommand();
+            return val;
+            //sopDal.removeActionParmByActionId(standId, actionId, seqno);
+        }
+
+        /// <summary>
+        /// 删除动作下的参数配置byid
+        /// </summary>
+        /// <param name="standId"></param>
+        /// <param name="actionId"></param>
+        /// <param name="seqno"></param>
+        public int removeActionParmByParamId(string standId, string actionId, int seqno,string paramId)
+        {
+
+            var val = DBFactory.Instance.Deleteable<sys_standard_action_parm>(p => p.standard_id == standId && p.action_id == actionId && p.action_seqno == seqno && p.parm_id == paramId)
+                        .ExecuteCommand();
+            return val;
+            //sopDal.removeActionParmByActionId(standId, actionId, seqno);
+        }
+
+
+
+        public int updateStandardActionParm(sys_standard_action_parm item)
+        {
+            //sopDal.updateStandardActionParm(item);
+            
+            int val = DBFactory.Instance.Updateable<sys_standard_action_parm>()
+                .SetColumns(p=> new sys_standard_action_parm() { data_value = item.data_value })
+                .Where(p=>p.id == item.id)
+                .ExecuteCommand();
+
+            return val;
+        }
+
+        public bool IsExisAction(string actionId)
+        {
+
+            List<sys_standard_action_parm> data = DBFactory.Instance.Queryable<sys_standard_action_parm>().Where(p => p.action_id == actionId).ToList();
+
+            return data.Count() > 0 ? true : false;
+
+        }
+
+  
+
+        public List<sys_standard_action_ext> QueryStandardActionByStandardId(string standId)
+        {
+           
+            var result = DBFactory.Instance.Queryable<sys_standard_action>().
+                LeftJoin<sys_action>((a, b) => a.process_id == b.id).
+                Where((a, b) => a.standard_id == standId).
+                Select((a, b) => new sys_standard_action_ext {
+                        id = a.id,
+                        standard_id = a.standard_id,
+                        process_id = a.process_id,
+                        process_no = a.process_no,
+                        action_name = b.action_name,
+                        remark = b.remark
+                     }).ToList();
+
+
+            return result;//standardDal.QueryStandardActionByStandardId(standId);
+        }
+
+
+
+        /// <summary>
+        /// 更新动作序号
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        public int UpdateActionSeqno(sys_standard_action_ext action)
+        {
+            // return sopDal.UpdateActionSeqno(action);
+            
+            var _db = DBFactory.Instance;
+
+            try
+            {
+                _db.BeginTran();
+                var val = _db.Updateable<sys_standard_action>()
+                                 .SetColumns(it => new sys_standard_action() { process_no = action.new_action_seqno })
+                                 .Where(p => p.standard_id == action.standard_id && p.process_id == action.process_id && p.process_no == action.process_no)
+                                 .ExecuteCommand();
+
+
+                ////参数里的动作顺序           
+                var val2 = _db.Updateable<sys_standard_action_parm>()
+                                        .SetColumns(it => new sys_standard_action_parm() { action_seqno = action.new_action_seqno })
+                                        .Where(p => p.standard_id == action.standard_id && p.action_id == action.process_id && p.action_seqno == action.process_no)
+                                        .ExecuteCommand();
+
+                _db.CommitTran();
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+                LoggerHelper.Logger.Error(ex.Message);
+                return -1;
+            }
+          
+            return 1;
+        }
+
+        /// <summary>
+        /// 删除标准，及标准下的所有配置
+        /// </summary>
+        /// <param name="iD"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        public int DelStandardActionParamByStandId(string standardId)
+        {
+
+            var _db = DBFactory.Instance;
+
+            try
+            {
+                _db.BeginTran();
+
+                _db.Deleteable<sys_standard>().Where(p => p.id == standardId).ExecuteCommand();
+                _db.Deleteable<sys_standard_action>().Where(p => p.standard_id == standardId).ExecuteCommand();
+                _db.Deleteable<sys_standard_action_parm>().Where(p => p.standard_id == standardId).ExecuteCommand();
+
+                _db.CommitTran();
+
+               
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+                LoggerHelper.Logger.Error(ex.Message);
+                return -1;
+            }
+
+            return 1;
+            //return sopDal.DelStandardActionParamByStandId(iD);
+        }
+
+        /// <summary>
+        /// 获取标准下的动作，动作中包含参数的预览
+        /// </summary>
+        /// <param name="standID"></param>
+        /// <returns></returns>
+        public List<sys_standard_action_ext> QueryStandardProcessByStandardId(string standID)
+        {
+            return sopDal.QueryStandardProcessByStandardId(standID);
+        }
+
+
+        /// <summary>
+        /// 保存标准动作表、动作参数表
+        /// </summary>
+        /// <param name="action"></param>
+        /// <returns></returns>
+        public int SaveStandardAction_param(sys_standard_action action)
+        {
+            //return standardDal.Save_standard_process_map(procemodel);
+            
+            var _db = DBFactory.Instance;
+
+            try
+            {
+                _db.BeginTran();
+                //保存标准动作
+                _db.Insertable<sys_standard_action>(action).ExecuteCommand();
+
+
+                //保存标准动作参数表
+                //获取动作下的参数
+                List<sys_action_parm_map_ext> paramList = GetActionParmById(action.process_id);
+                List<sys_standard_action_parm> new_parms = new List<sys_standard_action_parm>();
+                foreach (var item in paramList)
+                {
+                    //保存标准动作参数表
+                    sys_standard_action_parm parmmodel = new sys_standard_action_parm()
+                    {
+                        id = Guid.NewGuid().ToString(),
+                        standard_id = action.standard_id,
+                        action_id = action.process_id,
+                        action_seqno = action.process_no,
+                        parm_id = item.parm_id,
+                        data_value = item.data_value,
+                        parm_seqno = item.id
+                    };
+                    new_parms.Add(parmmodel);
+                }
+                _db.Insertable<sys_standard_action_parm>(new_parms).ExecuteCommand();
+
+                _db.CommitTran();
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+                LoggerHelper.Logger.Error(ex.Message);
+                return -1;
+            }
+
+          
+            return 1;
+        }
+
+
+        /// <summary>
+        /// sop导出
+        /// </summary>
+        /// <param name="sysStandardId"></param>
+        public void ExprotSop(string sysStandardId ,string filePath)
+        {
+            //标准信息
+            sys_standard sysStandard = DBFactory.Instance.Queryable<sys_standard>().Where(p=>p.id == sysStandardId).Single();
+
+            //标准动作信息
+            List<sys_standard_action> standardActions = DBFactory.Instance.Queryable<sys_standard_action>().Where(p => p.standard_id == sysStandardId).ToList();
+
+            //标准动作信息
+            List<sys_standard_action_parm> standardActionsParams = DBFactory.Instance.Queryable<sys_standard_action_parm>().Where(p => p.standard_id == sysStandardId).ToList();
+
+
+            SopDataInfo sopDataInfo = new SopDataInfo();
+            sopDataInfo.sysStandard = sysStandard;
+            sopDataInfo.sysStandActions = standardActions;
+            sopDataInfo.sysStandardActionParms = standardActionsParams;
+
+
+            // 2. 序列化：格式化易读、保留中文
+            string jsonStr = JsonConvert.SerializeObject(sopDataInfo);
+
+            // 3. 写入TXT文件
+            File.WriteAllText(filePath, jsonStr);
+
+
+        }
+
+        /// <summary>
+        /// 导入SOP
+        /// </summary>
+        /// <param name="selectFilePath"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        public bool ImportSop(string selectFilePath)
+        {
+
+            string fileContent = File.ReadAllText(selectFilePath, System.Text.Encoding.UTF8);
+
+            SopDataInfo sopDataInfo = JsonConvert.DeserializeObject<SopDataInfo>(fileContent);
+
+            var _db = DBFactory.Instance;
+            
+            try
+            {
+                //开始事务
+                _db.BeginTran();
+
+                //标准
+                sopDataInfo.sysStandard.id = Guid.NewGuid().ToString();
+                sopDataInfo.sysStandard.standard_name = sopDataInfo.sysStandard.standard_name + "_imp";
+                DBFactory.Instance.Insertable<sys_standard>(sopDataInfo.sysStandard).ExecuteCommand();
+
+               
+                //标准动作
+                foreach (var item in sopDataInfo.sysStandActions)
+                {
+                    item.id = Guid.NewGuid().ToString();
+                    item.standard_id = sopDataInfo.sysStandard.id;
+                }
+                DBFactory.Instance.Insertable<sys_standard_action>(sopDataInfo.sysStandActions).ExecuteCommand();
+                //标准动作参数
+                foreach (var item in sopDataInfo.sysStandardActionParms)
+                {
+                    item.id = Guid.NewGuid().ToString();
+                    item.standard_id = sopDataInfo.sysStandard.id;
+                }
+                DBFactory.Instance.Insertable<sys_standard_action_parm>(sopDataInfo.sysStandardActionParms).ExecuteCommand();
+
+                //提交事务
+                _db.CommitTran();
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+
+                LoggerHelper.Logger.Error(ex.Message);
+                return false;
+            }
+
+          
+            return true;
+        }
+
+        /// <summary>
+        /// 获取左侧标准树
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public List<TreeListItem> GetStandardData()
+        {
+            List<TreeListItem> treeListItems = new List<TreeListItem>();
+
+            //获取样本
+            List<sys_dict> yangbens = SystemConst.dictDatas.Where(p => p.class_id == 3).ToList(); //sopBll.QueryGyData(); //standardDal.QueryGyData();
+
+            foreach (var item in yangbens)
+            {
+                treeListItems.Add(new TreeListItem() { ID = item.id, DisplayText = item.data_value, ParentID = "0" });
+            }
+
+            //获取标准
+            List<sys_standard> SopList = QueryAllGyStandards(); //standardDal.QueryAllGyStandards();
+            foreach (var item in SopList)
+            {
+                treeListItems.Add(new TreeListItem() { ID = item.id, DisplayText = item.standard_name, ParentID = item.sample_id });
+            }
+
+            return treeListItems;
+        }
+
+        /// <summary>
+        /// 获取所有标准
+        /// </summary>
+        /// <returns></returns>
+        public List<sys_standard> QueryAllGyStandards()
+        {
+            List<sys_standard> data = DBFactory.Instance.Queryable<sys_standard>().ToList();
+            return data;
+        }
+
+        /// <summary>
+        /// 获取动作字典
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public List<sys_action_ext> QuerySysAction()
+        {
+            var result = DBFactory.Instance.Queryable<sys_action>()
+                   .LeftJoin<sys_dict>((a, s) => a.action_unit == s.id)
+                   .Where((a, s) => s.class_id == 2)
+                   .Select((a, s) => new sys_action_ext
+                   {
+                       id = a.id,
+                       action_name = a.action_name,
+                       action_unit = a.action_unit,
+                       action_adress = a.action_adress,
+                       plc_type = a.plc_type,
+                       remark = a.remark,
+                       action_unitname = s.data_value
+                   })
+                   .ToList();
+
+
+            return result;
+        }
+
+        /// <summary>
+        /// 移除标准的动作
+        /// </summary>
+        /// <param name="id"></param>
+        public void removeStandAction(sys_standard_action_ext sysStandardAction)
+        {
+            //移除动作
+            var _db = DBFactory.Instance;
+
+            try
+            {
+                _db.BeginTran();
+
+                var va11 = _db.Deleteable<sys_standard_action>(p => p.id == sysStandardAction.id).ExecuteCommand();
+
+                //移除动作下的参数配置
+                var val2 = _db.Deleteable<sys_standard_action_parm>(p => p.standard_id == sysStandardAction.standard_id
+                                                                   && p.action_id == sysStandardAction.process_id
+                                                                   && p.action_seqno == sysStandardAction.process_no).ExecuteCommand();
+                _db.CommitTran();
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+                LoggerHelper.Logger.Error(ex.Message);
+               
+            }
+          
+        }
+
+        /// <summary>
+        /// 保存动作参数配置
+        /// </summary>
+        /// <param name="actionParms"></param>
+        /// <returns></returns>
+        public int SaveStandardActionParam(List<sys_standard_action_parm> actionParms)
+        {
+            int val = DBFactory.Instance.Insertable<sys_standard_action_parm>(actionParms).ExecuteCommand();
+
+            return val;
+        }
+
+        public int SaveStandardCopy(sys_standard new_sysStandard, List<sys_standard_action> newStandActions, List<sys_standard_action_parm> sysStandardActionParms)
+        {
+            var _db = DBFactory.Instance;
+
+            try
+            {
+                _db.BeginTran();
+
+                _db.Insertable<sys_standard>(new_sysStandard).ExecuteCommand();
+
+                _db.Insertable<sys_standard_action>(newStandActions).ExecuteCommand();
+
+                _db.Insertable<sys_standard_action_parm>(sysStandardActionParms).ExecuteCommand();
+
+                _db.CommitTran();
+            }
+            catch (Exception ex)
+            {
+                _db.RollbackTran();
+
+                LoggerHelper.Logger.Error(ex.Message);
+                return -1;
+            }
+           
+
+            return 1;
+        }
+    }
+}