yuxingheng/009_DI-Elec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
009_DI-Elec/Learun.Application.Web/AppApi/IOModuleApiController.cs

2065 lines
98 KiB
C#
Raw Normal View History

从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using DocumentFormat.OpenXml.Drawing.Spreadsheet;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
using DocumentFormat.OpenXml.Math;
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
using DocumentFormat.OpenXml.Spreadsheet;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using Learun.Application.Organization;
using Learun.Application.TwoDevelopment.ZZDT_EC;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
using Learun.Application.TwoDevelopment.ZZDT_EC.Frame;
using Learun.Cache.Base;
using Learun.Cache.Factory;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using Learun.Loger;
using Learun.Util;
using Learun.Util.SqlSugar;
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
using log4net.Config;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using Microsoft.Practices.ObjectBuilder2;
using Newtonsoft.Json;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
using NPOI.POIFS.Crypt;
using NPOI.SS.Formula.Functions;
using OfficeOpenXml;
using OfficeOpenXml.Style;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using Org.BouncyCastle.Bcpg.OpenPgp;
using Pipelines.Sockets.Unofficial.Arenas;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
using SqlSugar;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using System;
using System.Collections.Generic;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
using System.Data.Entity.Infrastructure;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using System.Diagnostics;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
using System.IO;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using System.Linq;
using System.Web.Http;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
using System.Windows;
using System.Windows.Input;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
using static Learun.Application.TwoDevelopment.ZZDT_EC.IO_WorkFlowService;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
using static Learun.Application.Web.Areas.ZZDT_EC.Controllers.ec_objecttypeController;
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
namespace Learun.Application.Web.AppApi
{
/// <summary>
/// IO模块（By YuXH）
/// </summary>
[HandlerApiLogin(FilterMode.Ignore)]
public class IOModuleApiController : WebApiControllerBase
{
#region 模块对象
private ec_CableBLL ec_CableBLL = new ec_CableBLL();
private ec_PanelBLL ec_PanelBLL = new ec_PanelBLL();
private ec_PanelStripBLL ec_PanelStripBLL = new ec_PanelStripBLL();
private ec_PanelStripTermBLL ec_PanelStripTermBLL = new ec_PanelStripTermBLL();
private ec_PanelChannelBLL ec_PanelChannelBLL = new ec_PanelChannelBLL();
#endregion
#region 信号相关
#endregion
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// <summary>
/// 根据模板自动创建端子排
/// </summary>
/// <param name="projId"></param>
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
/// <param name="panelObj"></param>
/// <param name="seq"></param>
/// <param name="TSname"></param>
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// <param name="iOType"></param>
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
private ec_PanelStripEntity CreatePanelStripByProfile2(string projId, ec_PanelEntity panelObj, int seq, GlobalEnum.IOType iOType)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
TEMP
2025-09-28 10:43:45 +08:00
var setTb = ProjectSugar.TableName<ec_projectSettingsEntity>(projId);
var allSettings = SqlSugarHelper.Db.Queryable<ec_projectSettingsEntity>().AS(setTb).ToList();
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
allSettings = allSettings.FindAll(x => x.SettingName.StartsWith(GlobalObject.projSetting_IOCardProfile + iOType.ToString()));
TEMP
2025-09-28 10:43:45 +08:00
//IO_CardProfile
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//IO_CardProfile_DO_TermNoPerCh
//IO_CardProfile_DO_CHNoPerStrip
//IO_CardProfile_DO_ChNamePrefix
//IO_CardProfile_DO_ChNameStartIndex
var sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_TermNoPerCh";
var TermNoPerCh = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_CHNoPerStrip";
var CHNoPerStrip = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
sName = GlobalObject.projSetting_IOCardProfile + iOType.ToString() + "_ChNamePrefix";
var ChNamePrefix = allSettings.FirstOrDefault(x => x.SettingName == sName)?.SettingValue;
if (int.TryParse(TermNoPerCh, out int iTermNoPerCh))
{
//err
}
if (int.TryParse(CHNoPerStrip, out int iCHNoPerStrip))
{
//err
}
var newTs = new ec_PanelStripEntity()
{
IO_TYPE = iOType.ToString(),
PanelID = panelObj.PanelID,
Panel_Strip_Seq = seq,
StripName = "TS_" + iOType.ToString() + "_" + seq,
TagNumber = "CreatePanelStripByProfile2"
};
newTs.Create();
for (int i = 0; i < iCHNoPerStrip; i++)
{
var newCh = new ec_PanelChannelEntity()
{
ChannelName = ChNamePrefix + (i + 1).ToString(),
Channel_Seq = i + 1,
StripID = newTs.StripID,
};
newCh.Create();
newTs.Channels.Add(newCh);
}
return newTs;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
/// <summary>
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
/// 找到某一个预分配箱子 附近的某一个箱子。且io类型能匹配上
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
/// <param name="curPanelId"/>
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
/// <param name="frameLists"/>
/// <param name="allPanel"/>
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
/// <param name="allPanelProps">所有柜子的属性</param>
/// <param name="IOTypeOnCable">Digital,4-20mA,10v,pt100,pulse</param>
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
/// </summary>
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
private ec_PanelEntity FindPanelNearby(ec_CableEntity cableObj, List<FrameBll.FrameList> frameLists, List<ec_PanelEntity> allPanel,
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
Dictionary<string, List<ec_enginedata_propertyEntity>> allPanelProps, string IOTypeOnCable)
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
{
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
var curPanelId = cableObj.PanelID;
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
double GetPanelXYDistance2Target(string panelId, double targetX, double targetY)
{
var nearPanel = allPanel.FirstOrDefault(x => x.PanelID == panelId);
var nearPanelProps = allPanelProps[nearPanel.EngineerDataID];
var X = nearPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_Frame)?.PropertyValue;
X = X.Split(new string[] { GlobalObject.enum_separator }, StringSplitOptions.None)[0];//插件端对于下拉列表 都是 name || nameEN
var validFrme2 = frameLists.FirstOrDefault(f => f.Num == X);
if (validFrme2 == null)
{
return -1;//无效的肋位号导致的
}
var XValue = validFrme2.Value;
if (XValue < 400)//null也没事
{
// 小于400，我几乎可以认为此时肋位号用的是m这个单位。因为如果用的是mm，400mm的肋位号似乎也太小了。
XValue = 1000 * XValue; // 转成mm
}
if (double.TryParse(nearPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_FrameOff)?.PropertyValue,
out double XOffValue))
{
}
else
{
return -1;//无效的x off导致的
}
if (double.TryParse(nearPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_YOff)?.PropertyValue,
和布置图获取值有关代码更新
2025-09-22 15:42:18 +08:00
out double YOffValue))
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
}
else
{
return -1;//无效的y off导致的
}
var distance = Math.Sqrt(Math.Pow(targetX - XValue - XOffValue, 2) + Math.Pow(targetY - YOffValue, 2));
return distance;
}
var curPanel = allPanel.FirstOrDefault(x => x.PanelID == curPanelId);
var curPanelProps = allPanelProps[curPanel.EngineerDataID];
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
//当前预分配的箱子的位置
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
var AssignPanelX = curPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_Frame)?.PropertyValue;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
AssignPanelX = AssignPanelX.Split(new string[] { GlobalObject.enum_separator }, StringSplitOptions.None)[0];//插件端对于下拉列表 都是 name || nameEN
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
var validFrme = frameLists.FirstOrDefault(X => X.Num == AssignPanelX);
if (validFrme == null)
{
return null;//无效的肋位号导致的
}
var AssignPanelXValue = validFrme.Value;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
if (AssignPanelXValue < 400)//null也没事
{
// 小于400，我几乎可以认为此时肋位号用的是m这个单位。因为如果用的是mm，400mm的肋位号似乎也太小了。
AssignPanelXValue = 1000 * AssignPanelXValue; // 转成mm
}
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
if (double.TryParse(curPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_FrameOff)?.PropertyValue,
out double AssignPanelXOffValue))
{
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
else
{
return null;//无效的x off导致的
}
if (double.TryParse(curPanelProps.FirstOrDefault(x => x.PropertyName == GlobalObject.propName_YOff)?.PropertyValue,
和布置图获取值有关代码更新
2025-09-22 15:42:18 +08:00
out double AssignPanelYValue))
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
else
{
return null;//无效的y off导致的
}
double minDistance = 0.1; ec_PanelEntity nearestPanel = null;
foreach (var panel in allPanel.Where(x => x.PanelID != curPanelId))
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
{
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
#region io
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
var IOMatched = true;
var IOsOnPanel = panel.allowedIOTypes.Split(',').ToList();
//剩下的感觉都可以是set上的参数？
foreach (var set in cableObj.Sets)
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
#region 判断下io匹配程度
var setNew = ec_CableBLL.SetIOMatchPanel(cableObj.PreAssignIOType, set, IOsOnPanel);
if (IOsOnPanel.Contains(setNew.IOType.ToString()))
{
setNew.IOTypeMatch = true;
}
else
{
setNew.IOTypeMatch = false; IOMatched = false;
//不匹配
break;
}
#endregion
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
#endregion
if (IOMatched)
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
//如果io匹配了，再找附近的
#region distance
//拿到每一个的xy属性
//然后和预分配箱子进行对比
var DISTANCE = GetPanelXYDistance2Target(panel.PanelID, AssignPanelXValue + AssignPanelXOffValue, AssignPanelYValue);
if (0.1 == minDistance && DISTANCE > 0)
{
minDistance = DISTANCE; nearestPanel = panel;
}
else if (DISTANCE < minDistance && DISTANCE > 0)
{
minDistance = DISTANCE; nearestPanel = panel;
}
#endregion
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
return nearestPanel;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
}
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
/// <summary>
/// IO分配主界面查询，查询所有的位置 - 采集箱 - 模块 - 通道
/// </summary>
/// <param name="projectId"></param>
/// <returns></returns>
public IHttpActionResult GetPanelTree(string projectId)
{
//2023 05 22，从用户所在的role的lr base authorize里去查
//UserInfo userInfo = LoginUserInfo.Get();
//UserRelationIBLL userRelationIBLL = new UserRelationBLL();
//var roles = userRelationIBLL.GetObjectIds(userInfo.userId, 1, projectId);
var stopWatch = new Stopwatch();
var Locations = GetLocList(projectId);
if (Locations == null)
{
return Fail("系统设置中找不到“系统柜位置”这一项内容。联系管理员");
}
var ec_PanelStripTermService = new ec_PanelStripTermBLL();
var ec_WireTerminalService = new ec_WireTerminalService();
var ec_Wire_GroupService = new ec_Wire_GroupBLL();
stopWatch.Start();
var Panels = ec_PanelBLL.GetList("{ProjectId:\"" + projectId + "\"}").OrderBy(x => x.TagNumber).ToList();
stopWatch.Stop();
this.Logger.Info($"Panel查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
var Strips = ec_PanelStripBLL.GetList("{ProjectId:\"" + projectId + "\"}").OrderBy(x => x.Panel_Strip_Seq).OrderBy(x => x.StripName);
stopWatch.Stop();
this.Logger.Info($"Strip查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
var Channels = ec_PanelChannelBLL.GetList("{ProjectId:\"" + projectId + "\"}");
stopWatch.Stop();
this.Logger.Info($"Channel查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
var AllTerms = ec_PanelStripTermService.GetList("{ProjectId:\"" + projectId + "\"}");
stopWatch.Stop();
this.Logger.Info($"Term查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
var AllWTs = ec_WireTerminalService.GetList("{ProjectId:\"" + projectId + "\"}", true);
stopWatch.Stop();
this.Logger.Info($"WireTerminal查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
var AllSignals = ec_Wire_GroupService.GetList("{ProjectId:\"" + projectId + "\"}", true);
stopWatch.Stop();
this.Logger.Info($"Signals查询 {stopWatch.ElapsedMilliseconds}" + "\r\n");
stopWatch.Start();
List<TreeModel> treeList = new List<TreeModel>();
foreach (var Loc in Locations)
{
TreeModel nodeCatalogue = new TreeModel();
nodeCatalogue.id = Loc.DataItemDetailID;
nodeCatalogue.text = Loc.DataItemName;
nodeCatalogue.value = Loc.DataItemName;
nodeCatalogue.nodeType = "0";
nodeCatalogue.showcheck = false;
nodeCatalogue.checkstate = 0;
nodeCatalogue.isexpand = false;
nodeCatalogue.parentId = Loc.UpDataItemDetailID;
nodeCatalogue.NodeExtData = Loc;
treeList.Add(nodeCatalogue);
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
var listPanel = Panels.Where(x => x.Panel_Loc_ID == Loc.DataItemDetailID && x.systempanel == GlobalEnum.specialType.系统柜.ToString()).ToList();
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
if (listPanel != null && listPanel.Count > 0)
{
foreach (var Panel in listPanel)
{
TreeModel nodeFile = new TreeModel();
nodeFile.id = Panel.PanelID;
nodeFile.text = Panel.TagNumber;
nodeFile.value = Panel.EngineerDataID;
nodeFile.nodeType = "1";
nodeFile.showcheck = false;
nodeFile.checkstate = 0;
nodeFile.isexpand = false;
nodeFile.parentId = Panel.Panel_Loc_ID; //后面会根据变为tree
nodeFile.NodeExtData = Panel;
//判断下是不是有效的类型
treeList.Add(nodeFile);
var StripsInPanel = Strips.Where(x => x.PanelID == Panel.PanelID).ToList();
if (StripsInPanel != null && StripsInPanel.Count > 0)
{
//StripsInPanel = StripsInPanel.OrderBy(x => x.Panel_Strip_Seq).ToList();
foreach (var Strip in StripsInPanel)
{
#region 带上汇总信息
var ChannelsInStrip = Channels.Where(x => x.StripID == Strip.StripID).ToList();//("{ProjectId:\"" + projectId + "\",StripID:\"" + Strip.StripID + "\",PanelID:\"" + Strip.PanelID + "\"}");
//Strip.Channels = ChannelsInStrip.ToList();
foreach (var Channel in ChannelsInStrip)
{
var Terms = AllTerms.Where(x => x.StripID == Strip.StripID && x.ChannelID == Channel.ChannelID).ToList();//ec_PanelStripTermService.GetList("{ProjectId:\"" + projectId + "\",StripID:\"" + Strip.StripID + "\",ChannelID:\"" + Channel.ChannelID + "\"}");
//wire termianl
var conns = AllWTs.Where(x => Terms.Select(y => y.TermID).ToList().Contains(x.TermID)).ToList(); //.GetList(("{ProjectId:\"" + projectId + "\",PanelID:\"" + Strip.PanelID + "\",StripID:\"" + Strip.StripID + "\"}"));
bool bUsed = false;
if (conns != null && conns.Count() > 0)
{
bUsed = true;
}
//foreach (ec_PanelStripTermEntity term in Terms)
//{
// var conn = conns.FirstOrDefault(x => x.TermID == term.TermID);
// if (conn != null)
// {
// bUsed = true;
// break;
// }
//}
if (bUsed)
{
//wire group
var signal = AllSignals.FirstOrDefault(x => x.ChannelID == Channel.ChannelID);//.GetList("{ProjectId:\"" + projectId + "\",StripID:\"" + Strip.StripID + "\",ChannelID:\"" + Channel.ChannelID + "\"}").FirstOrDefault();
if (signal != null)
{
Strip.ChannelsUsed += 1;
}
else
{
Strip.ChannelsUsedNoSignal += 1;
}
}
else
{
Strip.ChannelsSpared += 1;
}
}
#endregion
TreeModel nodeStrip = new TreeModel();
nodeStrip.id = Strip.StripID;
nodeStrip.text = Strip.StripName;
nodeStrip.value = Strip.Panel_Strip_Seq;
nodeStrip.nodeType = "1";
nodeStrip.showcheck = false;
nodeStrip.checkstate = 0;
nodeStrip.isexpand = false;
nodeStrip.parentId = Strip.PanelID;
nodeStrip.NodeExtData = Strip;
treeList.Add(nodeStrip);
}
}
}
}
}
stopWatch.Stop();
this.Logger.Info($"循环位置耗时 {stopWatch.ElapsedMilliseconds}" + "\r\n");
return Success(treeList.ToTree());
}
/// <summary>
/// 根据ID拿。只查询ec panel表本身
/// </summary>
/// <param name="PanelID"></param>
/// <param name="projId"></param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetPanel(string PanelID, string projId)
{
var res = ec_PanelBLL.GetEntity(projId, PanelID);
return Success(res);
}
/// <summary>
/// 根据EngineerDataID拿。包括set wire，以及from to信息
/// </summary>
/// <param name="EngineerDataID"></param>
/// <param name="projId"></param>
/// <param name="OnlySelf"></param>
/// <param name="PreAssign"></param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetCableByEngID(string EngineerDataID, string projId, bool OnlySelf = false, bool PreAssign = false)
{
if (PreAssign)
{
var res = ec_CableBLL.GetCablePreAssign(projId, EngineerDataID);
return Success(res);
}
else
{
var res = ec_CableBLL.GetCableByEngID(projId, EngineerDataID, OnlySelf);
return Success(res);
}
}
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
ICache redisObj = CacheFactory.CaChe();
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
/// <summary>
/// 导出分配结果
/// </summary>
/// <param name="projectId"></param>
/// <param name="flg">是否为真实结果。step2时为false，step3后为true</param>
[HttpGet]
public void AutoAssignCable2Channel_ResExport(string projectId, bool flg)
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
ICache redisObj = CacheFactory.CaChe();
var cablesNeedAssigned = redisObj.Read<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projectId, CacheId.IOModule_AutoAssign2Ch);
var PanelAssigned = redisObj.Read<List<ec_PanelEntity>>("IOModule_AutoAssign2ChByPanel_" + projectId, CacheId.IOModule_AutoAssign2Ch);
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var bytes = new byte[] { };
try
{
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
using (var package = new ExcelPackage())//新建
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var sheet = package.Workbook.Worksheets.Add("已经分配的");
sheet.Cells[1, 1].Value = "电缆位号";
sheet.Cells[1, 2].Value = "电缆对";
sheet.Cells[1, 3].Value = "信号类型";
sheet.Cells[1, 4].Value = "预分配箱子";
sheet.Cells[1, 5].Value = "实际分配箱子";
sheet.Cells[1, 6].Value = "实际分配端子排";
sheet.Cells[1, 7].Value = "备注";
int rowIdx = 2;
#region ByCable
foreach (var cable in cablesNeedAssigned)
{
sheet.Cells[rowIdx, 1].Value = cable.TagNumber;
rowIdx++;
foreach (var set in cable.Sets)
{
sheet.Cells[rowIdx, 2].Value = set.CableSetName;
sheet.Cells[rowIdx, 7].Value = set.ConnectionInfo;
rowIdx++;
}
rowIdx = rowIdx + 2;
}
#endregion
#region ByPanel
sheet = package.Workbook.Worksheets.Add("模块视角");
sheet.Cells[1, 1].Value = "采集箱位号";
sheet.Cells[1, 2].Value = "模块名字";
sheet.Cells[1, 3].Value = "IO类型";
sheet.Cells[1, 4].Value = "通道名字";
sheet.Cells[1, 5].Value = "通道顺序";
sheet.Cells[1, 6].Value = "关联电缆";
sheet.Cells[1, 7].Value = "关联Set";
sheet.Cells[1, 8].Value = "关联信号";
sheet.Cells[1, 9].Value = "备注";
rowIdx = 2;
foreach (var p in PanelAssigned)
{
var newTS = p.strips.FindAll(x => x.Channels.Any(y => !string.IsNullOrEmpty(y.ConnectionInfo)));
foreach (var ts in newTS)
{
foreach (var ch in ts.Channels)
{
sheet.Cells[rowIdx, 1].Value = p.TagNumber;
sheet.Cells[rowIdx, 2].Value = ts.StripName;
sheet.Cells[rowIdx, 3].Value = ts.IO_TYPE;
sheet.Cells[rowIdx, 4].Value = ch.ChannelName;
sheet.Cells[rowIdx, 5].Value = ch.Channel_Seq;
sheet.Cells[rowIdx, 6].Value = ch.assignCable;
sheet.Cells[rowIdx, 7].Value = ch.assignCableSet;
sheet.Cells[rowIdx, 8].Value = ch.ConnectionInfo;
rowIdx++;
}
}
rowIdx = rowIdx + 2;
}
#endregion
package.Save();
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
bytes = package.GetAsByteArray();
}
}
catch (Exception ex)
{
log4net.LogManager.GetLogger("ERROR").Error("ec_PanelChannelBLL，IOModuleExportExcel 监控系统表导出" + ex.Message + ex.StackTrace);
bytes = System.Text.Encoding.UTF8.GetBytes(ex.Message + ex.StackTrace);
}
var stream = new MemoryStream(bytes);
FileDownHelper.DownLoad(stream, $"自动分配结果{DateTime.Now.ToString("yyyyMMddHHmmss")}.xlsx");//自动化平台导出excel
}
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
/// <summary>
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
/// 自动分配通道(点表信号自动分配)。
///
1
2025-09-16 09:51:40 +08:00
/// </summary>
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
/// <param name="projId"></param>
/// <param name="AcceptNearbyPanel"></param>
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
/// <param name="CableIds">需要分配的电缆cableid,不是enginedataId，逗号分开</param>
1
2025-09-16 09:51:40 +08:00
/// <returns></returns>
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
[HttpPost]
public IHttpActionResult AutoAssignCable2Channel_step1(string projId, bool AcceptNearbyPanel, [FromBody] List<string> CableIds)
1
2025-09-16 09:51:40 +08:00
{
#region 数据准备
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
var frameBll = new FrameBll();
var allFrames = frameBll.GetFrameList(projId);
1
2025-09-16 09:51:40 +08:00
var cbll = new ec_CableBLL();
var panelTable = ProjectSugar.TableName<ec_PanelEntity>(projId);
var stripTable = ProjectSugar.TableName<ec_PanelStripEntity>(projId);
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
var tagTable = ProjectSugar.TableName<ec_enginedataEntity>(projId);
var propTable = ProjectSugar.TableName<ec_enginedata_propertyEntity>(projId);
var typeTable = ProjectSugar.TableName<ec_objecttypeEntity>(projId);
1
2025-09-16 09:51:40 +08:00
#endregion
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
#region 先要知道有哪些待分配的信号 端子排
if (CableIds == null || CableIds.Count == 0)
{
return Success("OK");
}
var cablesNeedAssigned = cbll.GetCablesPreAssign(projId, CableIds, true);
cablesNeedAssigned = cablesNeedAssigned.Where(x => CableIds.Contains(x.CableID)).ToList();
1
2025-09-16 09:51:40 +08:00
#endregion
//涉及到哪些箱子
09 25
2025-09-26 11:04:02 +08:00
List<ec_PanelEntity> allPanel = SqlSugarHelper.Db.Queryable<ec_PanelEntity>().AS(panelTable).
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
InnerJoin<ec_enginedataEntity>((a, b) => a.EngineerDataID == b.EngineDataID).AS<ec_enginedataEntity>(tagTable).
InnerJoin<ec_objecttypeEntity>((a, b, c) => b.ObjectTypeID == c.ObjectTypeID).AS<ec_objecttypeEntity>(typeTable).
Where((a, b, c) => c.specialType == GlobalEnum.specialType.系统柜).
09 25
2025-09-26 11:04:02 +08:00
Select((a, b, c) => new ec_PanelEntity
{
allowedIOTypes = a.allowedIOTypes,
DefaultBreakerType = a.DefaultBreakerType,
EngineerDataID = a.EngineerDataID,
MaxStripNumber = a.MaxStripNumber,
ObjectTypeName = c.ObjectTypeName,
PanelID = a.PanelID,
Panel_Loc_ID = a.Panel_Loc_ID,
TagNumber = b.TagNumber,
}).
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
ToList();//这里要过滤一下，根据object type里的specialType，而不是所有的panel
var allPanelProp = SqlSugarHelper.Db.Queryable<ec_enginedata_propertyEntity>().AS(propTable)
.Where(x => allPanel.Select(xx => xx.EngineerDataID).Contains(x.EngineDataID))
.ToList().GroupBy(x => x.EngineDataID).ToDictionary(x => x.Key, x => x.ToList());
var panelsNeed = allPanel.Where(x => cablesNeedAssigned.Select(xx => xx.PanelID).Contains(x.PanelID)).ToList();//用户指定的预分配的箱子
1
2025-09-16 09:51:40 +08:00
var stripsNeed = SqlSugarHelper.Db.Queryable<ec_PanelStripEntity>().AS(stripTable).
Where(x => panelsNeed.Select(xx => xx.PanelID).Contains(x.PanelID)).
ToList();
#region 1.1判断(信号预分配选择的采集箱可能并没有该电缆需要的信号类型)
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
var cablesNotMatchIO = cablesNeedAssigned.Where(x => x.IOTypesNotMatchedList.Count > 0).ToList(); // GetCablesPreAssign 查询时已经处理过io是否匹配了
1
2025-09-16 09:51:40 +08:00
if (cablesNotMatchIO != null && cablesNotMatchIO.Count > 0)
{
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
if (AcceptNearbyPanel)//允许进行
1
2025-09-16 09:51:40 +08:00
{
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
//有不匹配的，但是用户允许继续
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
//如果选是，则在之后的自动分配过程中会自动寻找匹配的采集箱，原则上从就近的开始找，如果没有匹配的采集箱，则提示“未找到具有XX类型的采集箱，请新增后再次分配，是否取消自动分配进程？”
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
foreach (var cable in cablesNotMatchIO)
{
自动分配（就近找采集箱逻辑完成）
2025-09-22 15:44:15 +08:00
var nearPanel = FindPanelNearby(cable, allFrames, allPanel, allPanelProp, cable.PreAssignIOType);
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
cable.AssignedPanel = nearPanel;
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
var cableNotFoundNearPanel = cablesNotMatchIO.FindAll(x => x.AssignedPanel == null);
if (cableNotFoundNearPanel != null && cableNotFoundNearPanel.Count > 0)
{
redisObj.Remove("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch);
redisObj.Write<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, cablesNeedAssigned, CacheId.IOModule_AutoAssign2Ch);
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
return Fail($"在电缆{string.Join(",", cableNotFoundNearPanel.Select(x => x.TagNumber))}附近未找到具有IO类型匹配的采集箱，请新增后再次分配，是否取消自动分配进程？");
//之后插件端进行选择。
//如果不想新增，则选择否，继续自动分配，没有分配到的信号在备注上填写由于何种原因没有被分配，弹出未被分配的信号列表供查看。
//也就是这里要等所有循环结束后才能return结果，而不是目前一个nearByFound = false时就退出了。
}
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
1
2025-09-16 09:51:40 +08:00
}
else
{
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
//如果选否，则不继续自动分配，中断进程，等添加完正确的模块后再继续自动分配
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
var cableNamesNotMatched = string.Join(",", cablesNotMatchIO.Select(x => x.TagNumber).ToList());
var panelIOMissing = new List<string>();
foreach (ec_CableEntity cableNotMatchIO in cablesNotMatchIO)
{
panelIOMissing.Add(cableNotMatchIO.PanelID + "缺失IO: " + string.Join(",", cableNotMatchIO.IOTypesNotMatchedList));
}
return Fail($"预分配结果中，以下电缆【{cableNamesNotMatched}】的IO类型和其预分配采集箱的IO类型无法匹配。等添加完正确的模块后再继续自动分配。\r\n" +
$"需要添加的正确模块有：{string.Join(",", panelIOMissing)}");
1
2025-09-16 09:51:40 +08:00
}
}
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
else
{
//没有不匹配的，可以继续进行
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
}
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
//必要的数据存入redis，以便后续步骤使用
redisObj.Remove("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch);
redisObj.Write<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, cablesNeedAssigned, CacheId.IOModule_AutoAssign2Ch);
1
2025-09-16 09:51:40 +08:00
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
return Success("OK");
1
2025-09-16 09:51:40 +08:00
#endregion
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
}
/// <summary>
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
/// 根据step1的初步采集箱判断情况，来进行分配预览。
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
/// </summary>
/// <param name="projId"></param>
/// <returns></returns>
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
[HttpPost]
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
public IHttpActionResult AutoAssignCable2Channel_step2(string projId)
{
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
ICache redisObj = CacheFactory.CaChe();
var cablesNeedAssigned = redisObj.Read<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch);
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
var signalTb = ProjectSugar.TableName<ec_Wire_GroupEntity>(projId);
var allSignals = SqlSugarHelper.Db.Queryable<ec_Wire_GroupEntity>().AS(signalTb).ToList();
TEMP
2025-09-28 10:43:45 +08:00
var connTb = ProjectSugar.TableName<ec_WireTerminalEntity>(projId);
var termTb = ProjectSugar.TableName<ec_PanelStripTermEntity>(projId);
var allConnedTerms = SqlSugarHelper.Db.Queryable<ec_WireTerminalEntity>().AS(connTb)
.InnerJoin<ec_PanelStripTermEntity>((a, b) => a.TermID == b.TermID).AS<ec_PanelStripTermEntity>(termTb)
.Select((a, b) => b.ChannelID).Distinct().ToList();
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//包括2部分，1是已经被信号占用的通道，2是已经被接线端子占用的通道
var allUsedCHBySignalOrSet = allSignals.Where(x => !string.IsNullOrEmpty(x.ChannelID)).Select(x => x.ChannelID).Distinct().ToList();
allUsedCHBySignalOrSet.AddRange(allConnedTerms);
09 25
2025-09-26 11:04:02 +08:00
//??这里有问题。通道是否被占用，需要看signal和set双重（在io分配界面）
//1. 信号有， 电缆set有，占了
//2.信号no，电缆set有，占了
//3.信号有，电缆setno，没占
//4.信号no，电缆setno，没占
1
2025-09-18 09:30:10 +08:00
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
//1.2 流程图 分组原则为同一信号类型、同一系统的为一组
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var cablesGrouped = cablesNeedAssigned.OrderBy(x => x.AssignedPanel?.PanelID).ThenBy(x => x.PreAssignIOType).ThenBy(x => x.System).ToList();
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
var cNotPanel = cablesGrouped.FindAll(x => x.AssignedPanel == null);
cablesGrouped = cablesNeedAssigned.FindAll(x => x.AssignedPanel != null);
//cablesGrouped = cablesGrouped.Where(x => x.Sets != null && x.Sets.Count() > 0 && x.AssignedPanel != null).ToList();//过滤掉没有set的，或者没有找到箱子的
//cablesGrouped = cablesGrouped.Where(x => x.Sets.Where(xx => !string.IsNullOrEmpty(xx.PreAssignGroup_Desc)).Count() > 0).ToList();//过滤掉set没有分配信号的
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var allPanelIds = cablesGrouped.Select(x => x.AssignedPanel).Select(x => x.PanelID).Distinct().ToList();
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
var stripBll = new ec_PanelStripBLL();
09 25
2025-09-26 11:04:02 +08:00
var allStrips = stripBll.GetList("{ProjectId:\"" + projId + "\"}", OnlySelf: false)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
.Where(x => allPanelIds.Contains(x.PanelID))
.GroupBy(x => x.PanelID)
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
.ToDictionary(x => x.Key, x => x.ToList());//带出strip下的channel
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var PanelResultPreview = new List<ec_PanelEntity>();//为了看by panel的预览情况，有时候光by cable看不出问题
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
foreach (var c in cNotPanel)
{
foreach (var set in c.Sets)
{
set.ConnectionInfo = "err：没有找到合适的采集箱";
}
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
foreach (var curPanelId in allPanelIds)
1
2025-09-18 09:30:10 +08:00
{
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
int newTSSeq = 10001;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var existedStrips = allStrips[curPanelId];//已经存在的所有模块
var cablesOnThisPanel = cablesGrouped.Where(x => x.AssignedPanel.PanelID == curPanelId).ToList();
if (cablesOnThisPanel == null || cablesOnThisPanel.Count == 0) continue;//next panel
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
var lastUsedStrip = (ec_PanelStripEntity)null;
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var lastUsedPanel = new ec_PanelEntity();
lastUsedPanel.strips = allStrips[curPanelId];//已经存在的所有模块
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
foreach (var cable in cablesOnThisPanel)
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
//1.2.2 分组原则为同一信号类型、同一系统的为一组，系统属性从电缆的from端上的设备中取设备的系统，同组的优先放到同一个箱子的同一个模块里面，
//如果一组放完后发现模块还有多余的通道可以放则下一个系统继续从这个模块开始分配。
//???总感觉这句话，总结后：可以无脑用上一个模块，直到模块满了再用下一个模块。
#region 判断是否是同一组
//bool sameGroup = true;
//if (lastCableSystemAndIOType != cable.System + cable.PreAssignIOType)
//{
// sameGroup = false;//换组了
//}
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
#endregion
09 25
2025-09-26 11:04:02 +08:00
//1.2 流程图 读取有提前选好箱子的信号
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
var setsSpared = cable.Sets.Where(x => string.IsNullOrEmpty(x.PreAssignGroup_Desc) || string.IsNullOrEmpty(x.PreAssignInOrOut)).ToList();
09 25
2025-09-26 11:04:02 +08:00
var setsIn = cable.Sets.Where(x => !string.IsNullOrEmpty(x.PreAssignGroup_Desc) && x.PreAssignInOrOut == SWS.Share.Enum.inOrOut.输入.ToString()).ToList();
var setsOut = cable.Sets.Where(x => !string.IsNullOrEmpty(x.PreAssignGroup_Desc) && x.PreAssignInOrOut == SWS.Share.Enum.inOrOut.输出.ToString()).ToList();
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
#region 1.2.4 同一根电缆，如果带公共端的报警信号，必须接到一个模块里面
if (cable.PreAssignIOType.ToLower() == GlobalEnum.signalType.Digital.ToString().ToLower())
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
{
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
if (setsIn.Count > 0 && setsOut.Count > 0)
{
foreach (var set in setsIn)
{
set.ConnectionInfo = "err：digital类型的电缆，无法同时配置输入和输出。";
}
foreach (var set in setsOut)
{
set.ConnectionInfo = "err：digital类型的电缆，无法同时配置输入和输出。";
}
continue;
//from cjj 25 09 23 wechat:一根电缆可能会出现既有输入也有输出，如果碰到就放到两个端子排里面，公共端不会出现一个输出，一个输入的
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
#endregion
09 25
2025-09-26 11:04:02 +08:00
#region inputNew
TEMP
2025-09-28 10:43:45 +08:00
if (setsIn.Count > 0)
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var resIn = AutoAssignCore(GlobalEnum.inOrOut.输入, setsIn);
TEMP
2025-09-28 10:43:45 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#endregion
09 25
2025-09-26 11:04:02 +08:00
#region output
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
else if (setsOut.Count > 0)
TEMP
2025-09-28 10:43:45 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var resOut = AutoAssignCore(GlobalEnum.inOrOut.输出, setsOut);
09 25
2025-09-26 11:04:02 +08:00
TEMP
2025-09-28 10:43:45 +08:00
}
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
else
{
//all zero
foreach (var set in cable.Sets.Where(x => !setsSpared.Select(c => c.CableSetID).Contains(x.CableSetID)))
{
set.ConnectionInfo = "err：信号描述为空";
}
foreach (var set in setsSpared)
{
set.ConnectionInfo = "err：电缆无任一set被分配";
}
}
09 25
2025-09-26 11:04:02 +08:00
TEMP
2025-09-28 10:43:45 +08:00
#endregion
09 25
2025-09-26 11:04:02 +08:00
//in 和 out都会执行这个
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
bool AutoAssignCore(GlobalEnum.inOrOut inOrOut, List<ec_CableSetEntity> sets)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
09 25
2025-09-26 11:04:02 +08:00
GlobalEnum.IOType ioTypeOnC = default;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
switch (cable.PreAssignIOType.ToLower())
{
case "digital":
//数字量
09 25
2025-09-26 11:04:02 +08:00
if (inOrOut == GlobalEnum.inOrOut.输入)
{
ioTypeOnC = GlobalEnum.IOType.DI;
}
else
{
ioTypeOnC = GlobalEnum.IOType.DO;
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
break;
case "4~20ma":
//模拟量4-20mA
09 25
2025-09-26 11:04:02 +08:00
if (inOrOut == GlobalEnum.inOrOut.输入)
{
ioTypeOnC = GlobalEnum.IOType.AI;
}
else
{
ioTypeOnC = GlobalEnum.IOType.AO;
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
break;
case "10v":
09 25
2025-09-26 11:04:02 +08:00
ioTypeOnC = GlobalEnum.IOType.TenVolt;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
break;
case "pt100":
09 25
2025-09-26 11:04:02 +08:00
ioTypeOnC = GlobalEnum.IOType.PT100;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
break;
case "pulse":
09 25
2025-09-26 11:04:02 +08:00
ioTypeOnC = GlobalEnum.IOType.PULSE;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
break;
default:
//通讯类 485 422啥的
09 25
2025-09-26 11:04:02 +08:00
return false;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
TEMP
2025-09-28 10:43:45 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var matchedStrips = existedStrips.Where(x => x.IO_TYPE == ioTypeOnC.ToString()).ToList();//这个电缆下符合的模块
TEMP
2025-09-28 10:43:45 +08:00
if (matchedStrips != null && lastUsedStrip != null && lastUsedStrip.IO_TYPE == ioTypeOnC.ToString())
{
//1.2.2 优先使用上一个模块，直到模块满了再用下一个模块。
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
matchedStrips.Remove(lastUsedStrip);
matchedStrips.Insert(0, lastUsedStrip);//？？？？？？？
TEMP
2025-09-28 10:43:45 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (matchedStrips == null || matchedStrips.Count == 0)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#region NewTS
//1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);//当前采集箱无模块，需要新建
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
matchedStrips.Add(newTS);
#endregion
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
string PanelName = cable.AssignedPanel.TagNumber;//当前电缆预分配的箱子名称
if (sets.Count == 0) return false;
09 25
2025-09-26 11:04:02 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//1.2 流程图 箱子里是否已经存在端子排（io匹配）
List<ec_PanelChannelEntity> usedChs = new List<ec_PanelChannelEntity>();
List<ec_PanelChannelEntity> notUsedChs = new List<ec_PanelChannelEntity>();
09 25
2025-09-26 11:04:02 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#region 1.2 流程图 按规则先放几个信号进去（放不下就延到下一个模块）
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
#region old
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//if (cable.Sets.Count > 10)
//{
// //另外如果电缆对数大于10对，即像12 * 2 * 0.75这种，无论它预分配了多少根电缆对，永远预留4个以下的空白通道。意思就是一个模块里面够4个或4个以上空白通道就留4个空白通道，如果不够4个就留4个以下即可。
// #region FindNextAvailableTS（可能多个）
// //还分2种情况判断模块是否符合：
// //case1，. 占满可用通道后，还剩至少一个预分配的set和spared的set。 //这种时候要spared不用考虑
// //case2，. 占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set。 //这种时候要确保spared也能放下
// bool NeedNextTS = false;
// do
// {
// #region FindNextAvailableTS
// var availableTS = new List<ec_PanelStripEntity>();
// foreach (var TS in matchedStrips)
// {
// var allCh = TS.Channels;
// //被占用的(wt里有或者信号里或有），或者被锁定的，都算占用
// usedChs = allCh.Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// notUsedChs = allCh.Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// if (notUsedChs.Count < sets.Count)
// {
// //case1，能顺利接完，set还有多
// //这种时候不需要考虑spared
// }
// else
// {
// //case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
// //想办法留出4个
// //这种时候要确保spared也能放下
// if (notUsedChs.Count < sets.Count + setsSpared.Count)
// {
// //放不下，换下一个模块
// continue;
// }
// var sparedSetFor10 = notUsedChs.Count - sets.Count - setsSpared.Count;//16-9-5=2
// if (sparedSetFor10 > 4)
// {
// //固定流出后面4个，相当于不要了
// var last4 = allCh.Skip(allCh.Count - 4).ToList();
// usedChs = allCh.Take(allCh.Count - 4).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(last4);
// notUsedChs = allCh.Take(allCh.Count - 4).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// else
// {
// //不够4个，就留多少是多少
// var lastN = allCh.Skip(allCh.Count - sparedSetFor10).ToList();
// usedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(lastN);
// notUsedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// }
// //1.2 流程图 空的通道数够不够
// double sparedRate = notUsedChs.Count * 1.0 / allCh.Count * 1.0;
// if (sparedRate < 0.05)
// {
// //没有空闲通道 next
// //或者空闲通道不够放下这个电缆的所有set
// }
// else
// {
// TS.Channels = allCh.OrderBy(X => X.Channel_Seq).ToList();//不能像之前一样过滤掉，否则下一个电缆进来时，总数就不对了。
// TS.ChannelsSpared = notUsedChs.Count;
// TS.ChannelsUsed = usedChs.Count;
// availableTS.Add(TS);//所有5%以上空闲通道的模块
// break;
// }
// }
// #endregion
// #region NewTS
// if (availableTS.Count() == 0)
// {
// //1.2 流程图 根据信号数里自动新建端子排，端子排通道数里根据箱子模板中的默认值获得
// var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);
// //matchedStrips.Add(newTS);
// var allCh = newTS.Channels;
// notUsedChs = newTS.Channels.ToList();
// newTS.ChannelsSpared = notUsedChs.Count;
// newTS.ChannelsUsed = 0;
// usedChs = new List<ec_PanelChannelEntity>();//新建的没有被占用的
// availableTS.Add(newTS);
// if (notUsedChs.Count < sets.Count)
// {
// //case1，能顺利接完，set还有多
// //这种时候不需要考虑spared
// }
// else
// {
// //case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
// //想办法留出4个
// //这种时候要确保spared也能放下
// if (notUsedChs.Count < sets.Count + setsSpared.Count)
// {
// //放不下，换下一个模块
// continue;
// }
// var sparedSetFor10 = notUsedChs.Count - sets.Count - setsSpared.Count;//16-9-5=2
// if (sparedSetFor10 > 4)
// {
// //固定流出后面4个，相当于不要了
// var last4 = allCh.Skip(allCh.Count - 4).ToList();
// usedChs = allCh.Take(allCh.Count - 4).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(last4);
// notUsedChs = allCh.Take(allCh.Count - 4).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// else
// {
// //不够4个，就留多少是多少
// var lastN = allCh.Skip(allCh.Count - sparedSetFor10).ToList();
// usedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
// usedChs.AddRange(lastN);
// notUsedChs = allCh.Take(allCh.Count - sparedSetFor10).Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
// }
// }
// }
// #endregion
// lastUsedStrip = availableTS.Last();
// if (notUsedChs.Count < sets.Count)
// {
// //case1，分配完后，还有多的set和可能的spared
// //先这部分填完
// //到5%为止的数量
// var countOnThisTS = Math.Round(0.5 + notUsedChs.Count * 0.95);
// for (int i = 0; i < countOnThisTS; i++)
// {
// var set = sets[i];
// var ch = notUsedChs[i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// ch.FakeGroupDesc = set.PreAssignGroup_Desc;
// ch.FakeSignalType = set.IOType.ToString();
// ch.lock_flg = 1;
// set.IsConned = true;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// //set会剩
// NeedNextTS = true;
// }
// else
// {
// //case2，分配完后，没有多的set了，可能还有spared
// //上面已经判断过了，确保spared也是够的
// var countMin = Math.Min(sets.Count, notUsedChs.Count);
// for (int i = 0; i < countMin; i++)
// {
// var set = sets[i];
// var ch = notUsedChs[i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
// }
// ch.FakeGroupDesc = set.PreAssignGroup_Desc;
// ch.FakeSignalType = set.IOType.ToString();
// ch.lock_flg = 1;
// set.IsConned = true;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// #region spared
// for (int i = 0; i < setsSpared.Count(); i++)
// {
// var set = setsSpared[i];
// var ch = notUsedChs[countMin + i];
// if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
// }
// else
// {
// set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
// }
// ch.FakeGroupDesc = "预留";
// ch.lock_flg = 1;
// //更新全局已使用通道
// allUsedCHBySignalOrSet.Add(ch.ChannelID);
// }
// NeedNextTS = false;
// #endregion
// }
// sets = sets.Where(x => !x.IsConned).ToList();//移除已经分配过的set
// } while (NeedNextTS);
// #endregion
//}
//else
//{
//5%的空白通道
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
#endregion
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#region FindNextAvailableTS（可能多个）
//还分2种情况判断模块是否符合：
//case1，. 占满可用通道后，还剩至少一个预分配的set和spared的set。 //这种时候要spared不用考虑
//case2，. 占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set。 //这种时候要确保spared也能放下
//case3, 刚好，只有spared可能多
bool NeedNextTS = false;
#region FindNextAvailableTS
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var trueAvailableChs = 0;
var sparedButCanNotUsedChs = 0;//需要特意预留的通道，
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
int idx = 0;
while (idx < matchedStrips.Count)
{
NeedNextTS = false;
var TS = matchedStrips[idx];
var allCh = TS.Channels;
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
if (allCh.Count == 0)
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
{
NeedNextTS = true;
//同时又是最后一个了
if (idx == matchedStrips.Count - 1)
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);//当前ts无ch，需要新建
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (newTS.Channels.Count() < setsSpared.Count + 1)//1代表至少要放一个set
{
//有问题了 panel的io模板，估计会导致无限循环了
break;
}
matchedStrips.Add(newTS);
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
idx++; continue;//本模块没有一个ch，否则后面 5% 会除以0
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//被占用的(wt里有或者信号里或有），或者被锁定的，都算占用
usedChs = allCh.Where(x => allUsedCHBySignalOrSet.Contains(x.ChannelID) || x.lock_flg == 1).ToList();
notUsedChs = allCh.Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
trueAvailableChs = 0;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var ChNeedConn = 0;
var SparedNeedConn = 0;
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
//分3种情况，确认具体要接的ch个数和是否需要下一个ts
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
if (cable.CableClass.ToLower() == SWS.Share.Enum.cableClass.homerun.ToString())
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
//1.2.3（2） 如果模块是通讯信号（像RS485这种就是通讯信号），则不用管预留空白通道这个事情，看到有空的通道就放。
#region 可用通道（通讯）
trueAvailableChs = notUsedChs.Count;
#endregion
if (trueAvailableChs < sets.Count)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//case1，能顺利接完，set还有多,还要再do循环一次,多余的set和spared都要放到下一个模块
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
NeedNextTS = true;
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
ChNeedConn = trueAvailableChs; SparedNeedConn = 0;
09 25
2025-09-26 11:04:02 +08:00
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
else if (trueAvailableChs == sets.Count)
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
{
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//case3,刚好，只有spared可能多
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
ChNeedConn = trueAvailableChs;
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
SparedNeedConn = 0; //homerun不用考虑预留一个set去配合后续的spared
}
else
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
{
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
ChNeedConn = sets.Count;
SparedNeedConn = 0;
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
}
}
else
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
#region 可用通道(非通讯）
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//1.2 流程图 空的通道数够不够
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
if (cable.Sets.Count > 10)
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
//1.2.3 空白通道原则，另外如果电缆对数大于10对，即像12*2*0.75这种，无论它预分配了多少根电缆对，永远预留4个以下的空白通道。
if (notUsedChs.Count < 4)
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
//可以认为这个ts不可用了
trueAvailableChs = 0;
sparedButCanNotUsedChs = notUsedChs.Count;
notUsedChs.ForEach(x => x.lock_flg = 1);//全部标记为不可用
}
else
{
//all 16，used 7，notused9， 砍去4，
// 1. 计算起始索引
int startIndex = Math.Max(0, notUsedChs.Count - 4);
// 2. 计算要截取的数量（从起始索引到末尾的元素数）
int takeCount = notUsedChs.Count - startIndex;
// 3. 截取最后4个元素
var lastFour = notUsedChs.GetRange(startIndex, takeCount);//最后4个给不可用，并且这4个也要被标记为不能使用
lastFour.ForEach(x => x.lock_flg = 1);//标记为不可用
usedChs.AddRange(lastFour);
notUsedChs = allCh.Where(x => !usedChs.Select(c => c.ChannelID).Contains(x.ChannelID)).ToList();
trueAvailableChs = notUsedChs.Count;
sparedButCanNotUsedChs = 4;
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
else
{
//5%
double sparedRate = notUsedChs.Count * 1.0 / allCh.Count * 1.0;
if (sparedRate < 0.05)
{
NeedNextTS = true;
trueAvailableChs = 0;
sparedButCanNotUsedChs = notUsedChs.Count;
notUsedChs.ForEach(x => x.lock_flg = 1);//全部标记为不可用
}
else
{
sparedButCanNotUsedChs = allCh.Count - FindMaxNumberChannel(allCh.Count);
// 1. 计算起始索引
int startIndex = Math.Max(0, notUsedChs.Count - sparedButCanNotUsedChs);
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
// 2. 计算要截取的数量（从起始索引到末尾的元素数）
int takeCount = notUsedChs.Count - startIndex;
// 3. 截取最后4个元素
var lastFour = notUsedChs.GetRange(startIndex, takeCount);//最后4个给不可用，并且这4个也要被标记为不能使用
lastFour.ForEach(x => x.lock_flg = 1);//标记为不可用
trueAvailableChs = notUsedChs.Count - sparedButCanNotUsedChs;//真正能用的（没接过的，然后去掉5%）
}
}
#endregion
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
if (trueAvailableChs < sets.Count)
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
{
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//case1，能顺利接完，set还有多,还要再do循环一次,多余的set和spared都要放到下一个模块
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
NeedNextTS = true;
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
ChNeedConn = trueAvailableChs; SparedNeedConn = 0;
}
else if (trueAvailableChs == sets.Count)
{
//case3,刚好，只有spared可能多
if (setsSpared.Count > 0)
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
if (sets.Count == 1)
{
//避免死循环
ChNeedConn = 1;
NeedNextTS = false;
SparedNeedConn = trueAvailableChs - 1;
}
else
{
//自己的感觉（非客户word需求里的原话）：spared不能自己单独占用一个模块
NeedNextTS = true;
ChNeedConn = trueAvailableChs - 1;//留一个给spared
SparedNeedConn = 0;
}
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
}
else
{
ChNeedConn = trueAvailableChs; SparedNeedConn = 0;
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
}
else
{
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//maxCh > sets.Count
//case2,占满可用通道后（或者没占满通道，预分配set已经没了），只剩下spared的set
if (setsSpared.Count == 0)
{
//ok
ChNeedConn = sets.Count; SparedNeedConn = 0;
}
//这种时候要确保spared也能放下
else if (trueAvailableChs < sets.Count + setsSpared.Count)
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
if (sets.Count == 1)
{
//避免死循环
ChNeedConn = 1;
NeedNextTS = false;
SparedNeedConn = trueAvailableChs - 1;
}
else
{
//自己的感觉（非客户word需求里的原话）：spared不能自己单独占用一个模块
ChNeedConn = sets.Count - 1;//留一个给spared。如果sets.COUNT只有1个，这种情况就会死循环了
NeedNextTS = true;
SparedNeedConn = 0;
}
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
}
else
{
//ok,set和spared都能放下
ChNeedConn = sets.Count;
SparedNeedConn = setsSpared.Count;
}
09 25
2025-09-26 11:04:02 +08:00
}
}
TEMP
2025-09-28 10:43:45 +08:00
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//到这里，说明本模块至少都是可用的
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
TS.Channels = allCh.OrderBy(X => X.Channel_Seq).ToList();//不能像之前一样过滤掉，否则下一个电缆进来时，总数就不对了。
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
lastUsedStrip = TS;
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#region conn
for (int i = 0; i < ChNeedConn; i++)
09 25
2025-09-26 11:04:02 +08:00
{
TEMP
2025-09-28 10:43:45 +08:00
var set = sets[i];
var ch = notUsedChs[i];
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
ch.assignCable = cable.TagNumber;
ch.assignCableSet = set.CableSetName + " / " + set.CableSetSeq;
ch.ConnectionInfo = $"信号：{set.PreAssignGroup_Desc}/信号类型：{set.PreAssignIOTypeDetail}/传感器：{set.PreAssignSensorCode}";
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
}
else
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}";
}
ch.FakeGroupDesc = set.PreAssignGroup_Desc;
ch.FakeSignalType = set.IOType.ToString();
ch.lock_flg = 1;
set.IsConned = true;
TEMP
2025-09-28 10:43:45 +08:00
//更新全局已使用通道
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
allUsedCHBySignalOrSet.Add(ch.ChannelID);
09 25
2025-09-26 11:04:02 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#endregion
#region spared
for (int i = 0; i < SparedNeedConn; i++)
09 25
2025-09-26 11:04:02 +08:00
{
TEMP
2025-09-28 10:43:45 +08:00
var set = setsSpared[i];
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
var ch = notUsedChs[ChNeedConn + i];
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
ch.assignCable = cable.TagNumber;
ch.assignCableSet = set.CableSetName + " / " + set.CableSetSeq + "/冗余";
ch.ConnectionInfo = $"信号：{set.PreAssignGroup_Desc}/信号类型：{set.PreAssignIOTypeDetail}/传感器：{set.PreAssignSensorCode}";
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (lastUsedStrip.TagNumber == "CreatePanelStripByProfile2")
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(自动创建){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
}
else
{
set.ConnectionInfo = $"采集箱：{PanelName}/模块(端子排)：(原本存在){lastUsedStrip.StripName}/通道：{ch.ChannelName}/冗余";
}
ch.lock_flg = 1;
TEMP
2025-09-28 10:43:45 +08:00
//更新全局已使用通道
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
allUsedCHBySignalOrSet.Add(ch.ChannelID);
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
#endregion
#region 预留空白通道
if (sparedButCanNotUsedChs > 0)
{
Console.WriteLine("");
}
09 25
2025-09-26 11:04:02 +08:00
#endregion
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
//shi否要继续
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
TS.ChannelsSpared = notUsedChs.Where(x => x.lock_flg != 1).Count();
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
TS.ChannelsUsed = allCh.Count - TS.ChannelsSpared;// usedChs.Count + (notUsedChs.Where(x => x.lock_flg == 1).Count());
//var xx = lastUsedPanel.strips;
#region panel record
if (ChNeedConn > 0 || SparedNeedConn > 0)
{
//记录本模块被使用过
var idx2 = lastUsedPanel.strips.FindIndex(ts => ts.StripID == lastUsedStrip.StripID);
if (idx2 != -1)
{
lastUsedPanel.strips[idx2] = lastUsedStrip;
}
else
{
lastUsedPanel.strips.Add(lastUsedStrip);
}
}
#endregion
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (NeedNextTS)
{
sets = sets.Where(x => !x.IsConned ?? false).ToList();//移除已经分配过的set
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
//同时又是最后一个了
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (idx == matchedStrips.Count - 1)
{
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
var newTS = CreatePanelStripByProfile2(projId, cable.AssignedPanel, newTSSeq++, ioTypeOnC);//还有set需要接，需要新建
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (newTS.Channels.Count() < setsSpared.Count + 1)//1代表至少要放一个set
{
//有问题了 panel的io模板，估计会导致无限循环了
break;
}
matchedStrips.Add(newTS);
}
idx++; continue;// 需要下一个模块接着放本电缆
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
// 手动递增索引，避免无限循环
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
}
else
增加了homerun的分配逻辑（不需要考虑预留空白）
2025-10-01 23:35:57 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
break;
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
}
#endregion
09 25
2025-09-26 11:04:02 +08:00
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
#endregion
//}
#endregion
09 25
2025-09-26 11:04:02 +08:00
return true;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
09 25
2025-09-26 11:04:02 +08:00
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
PanelResultPreview.Add(lastUsedPanel);
1
2025-09-18 09:30:10 +08:00
}
新增布置图细分图例，下拉菜单会被遮住
2025-10-10 09:44:02 +08:00
//必要的数据存入redis，以便后续步骤使用
redisObj.Remove("IOModule_AutoAssign2Ch_" + projId, CacheId.IOModule_AutoAssign2Ch);
redisObj.Write<List<ec_CableEntity>>("IOModule_AutoAssign2Ch_" + projId, cablesNeedAssigned, CacheId.IOModule_AutoAssign2Ch);
redisObj.Remove("IOModule_AutoAssign2ChByPanel_" + projId, CacheId.IOModule_AutoAssign2Ch);
redisObj.Write<List<ec_PanelEntity>>("IOModule_AutoAssign2ChByPanel_" + projId, PanelResultPreview, CacheId.IOModule_AutoAssign2Ch);
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
1
2025-09-18 09:30:10 +08:00
return Success(cablesNeedAssigned);
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
}
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// <summary>
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
/// 找到满足5%空闲通道的最大数
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// </summary>
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
/// <param name="ChCount">模块的所有通道数</param>
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// <returns></returns>
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
/// <exception cref="ArgumentException"></exception>
/// <exception cref="InvalidOperationException"></exception>
static int FindMaxNumberChannel(int ChCount)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
if (ChCount < 1)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
throw new ArgumentException("模块数量必须大于等于1", nameof(ChCount));
}
09 25
2025-09-26 11:04:02 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
// 从A-1开始向下寻找
for (int i = 0; i < ChCount; i++)
{
// 检查是否大于5%
if ((double)i / ChCount < 0.05 && (double)(i + 1) / ChCount > 0.05)
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
{
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
return ChCount - i;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
}
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
return ChCount;
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
}
重写自动分配的逻辑
2025-10-01 00:18:02 +08:00
完善自动分配（就近找采集箱)
2025-09-22 13:45:53 +08:00
/// <summary>
/// 根据step2的预分配结果，进行实际的分配，修改数据库。
/// </summary>
/// <param name="projId"></param>
/// <param name="cables">传入有效的cable即可，未成功分配的cable不需要</param>
/// <returns></returns>
[HttpPost]
public IHttpActionResult AutoAssignCable2Channel_step3(string projId, [FromBody] List<ec_CableEntity> cables)
{
//大原则：同一根电缆的信号不能跨采集箱，跨模块可以。
return Success(cables);
1
2025-09-16 09:51:40 +08:00
}
/// <summary>
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
/// 把电缆分配到空余的模块的通道上。
/// </summary>
/// <param name="projId"></param>
/// <param name="execute"></param>
/// <returns></returns>
[HttpPost]
public IHttpActionResult AssignCable2Channel(string projId, bool execute = false)
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var cableIds = asyncContent.ToObject<List<string>>();
return Success("res");
}
/// <summary>
/// 查询所有需要预分配的电缆
/// </summary>
/// <param name="projId"></param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetCablePreAssignPreview(string projId)
{
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
var bll = new ec_CableBLL();
开始弄自动分配的step2（step1里还有查找周边采集箱函数）
2025-09-18 00:04:25 +08:00
var res = bll.GetCablesPreAssign(projId, null);
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
增加了自动分配的step1和step2
2025-09-16 10:18:32 +08:00
return Success(res);
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
}
/// <summary>
/// 查询所有的电缆
/// </summary>
/// <param name="projId"></param>
/// <param name="homerun">true或false</param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetCables(string projId, bool homerun = true)
{
var res = ec_CableBLL.GetCables(projId, homerun);//这有个问题 如果一开始不知道要关联到那个通道 就不会有ec cable出来
return Success(res);
}
/// <summary>
/// PanelStrip参考库
/// </summary>
/// <param name="projId"></param>
/// <param name="OnlySelf">false时，带上下面的通道和端子。true时，就是返回端子排自己</param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetPanelStrips(string projId, bool OnlySelf = false)
{
var res = ec_PanelStripBLL.GetList("{ProjectId:\"" + projId + "\",OnlySelf:\"" + OnlySelf + "\"}");
return Success(res);
}
/// <summary>
/// 在IO分配界面，从左侧目录树中选择一个“端子排”后，进行查询
/// </summary>
/// <param name="StripID"></param>
/// <param name="projId"></param>
/// <param name="OnlySelf">false时，带上下面的通道和端子。true时，就是返回端子排自己</param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetPanelStrip(string StripID, string projId, bool OnlySelf = false, bool HaveChannel = true)
{
var res = ec_PanelStripBLL.GetEntity(projId, StripID, OnlySelf, HaveChannel);
return Success(res);
}
/// <summary>
/// 新增或者修改。
/// 新建相当于强行，因为正常流程是和engineerdata一起新建出来的。
/// 改的话，只是改location和端子排数量这些。常规属性依旧通过objectTypeAPI去做
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
/// <returns></returns>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanel(ec_PanelEntity entity, string projId)
{
try
{
ec_PanelBLL.SaveEntity(projId, entity.PanelID, entity);
return Success("OK");
}
catch (System.Exception E)
{
return Fail(E.Message);
}
}
/// <summary>
/// SaveConnections 专用
/// </summary>
private class Connections
{
public string ID { get; set; }
public List<ec_WireTerminalEntity> Conns { get; set; }
}
/// <summary>
/// 处理 接线关系，同时对cableset和wire的个别属性进行修改
/// </summary>
/// <param name="projId"></param>
/// <returns></returns>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SaveConnections(string projId)
{
try
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var entity = asyncContent.ToObject<Connections>();
var res = entity.Conns;
new ec_WireTerminalBLL().SaveConnections(projId, ref res);
return Success(res);
}
catch (System.Exception E)
{
return Fail(E.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="projId"></param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetConnections(string projId, string ID)
{
try
{
var res = new ec_WireTerminalService().GetEntity(projId, ID);
return Success(res);
}
catch (System.Exception E)
{
return Fail(E.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
/// <returns></returns>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SaveCable(ec_CableEntity entity, string projId)
{
try
{
if (!string.IsNullOrEmpty(entity.CableID))
{
ec_CableBLL.SaveEntity(projId, entity.CableID, entity);
}
return Success("OK");
}
catch (System.Exception E)
{
return Fail(E.Message);
}
}
/// <summary>
基本完成了自动分配逻辑
2025-09-24 18:39:10 +08:00
/// 通过预设模式，批量创建端子排 通道 端子。此时strip数里 set数里已经根据profile给定好了。
/// </summary>
从svn迁移 25 08 13（v159）
2025-08-13 11:14:39 +08:00
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult CreatePanelStripByProfile(string projId)
{
try
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var entity = asyncContent.ToObject<ec_PanelStripEntity>();
string NewID = "";
ec_PanelStripBLL.SaveEntity(projId, "", entity, out NewID);
var res = ec_PanelStripBLL.GetEntity(projId, NewID);
return Success(res);
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
///// <summary>
///// 通过预设模式，批量创建端子排 端子(不需要了，因为预设模式只有对IO有通道的那边才有用)
///// </summary>
///// <param name="entity"></param>
///// <param name="projId"></param>
//[HttpPost]
//[HandlerApiLogin(FilterMode.Enforce)]
//public IHttpActionResult CreatePanelStripByProfileNoChannel(string projId, ec_PanelStripEntity entity)
//{
// try
// {
// string NewID = "";
// ec_PanelStripBLL.SaveEntity(projId, "", entity, out NewID, false);
// var res = ec_PanelStripBLL.GetEntity(projId, NewID);
// return Success(res);
// }
// catch (System.Exception e)
// {
// return Fail(e.Message);
// }
//}
/// <summary>
/// GetCableByEngID先去判断这个cable是否已经有了IO Module这边的记录
/// 电缆-端子连接，从图面上选择一个电缆对象
/// </summary>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult CreateCableByProfile(string projId)
{
try
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var entity = asyncContent.ToObject<ec_CableEntity>();
ec_CableBLL.SaveEntity(projId, entity.CableID, entity);
var res = ec_CableBLL.GetCableByEngID(projId, entity.EngineerDataID);
return Success(res);
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 批量保存电缆的set wire 名字等
/// </summary>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SaveCables(string projId)
{
try
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var entitys = asyncContent.ToObject<List<ec_CableEntity>>();
foreach (var entity in entitys)
{
ec_CableBLL.SaveEntity(projId, entity.CableID, entity);
}
return Success(entitys);
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 创建、修改 端子排和端子（一般是为非监测设备的端子排）
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanelStripNoChannel(string projId, ec_PanelStripEntity entity)
{
try
{
string NewID = "";
ec_PanelStripBLL.SaveEntity(projId, entity.StripID, entity, out NewID, false);
var res = ec_PanelStripBLL.GetEntity(projId, NewID, false, false);
return Success(res);
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 保存端子排 通道 端子的信息（不管信号和接线关系）。
/// 迁移通道也是这里。
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanelStrip(string projId, ec_PanelStripEntity entity)
{
XmlConfigurator.Configure();
var log = log4net.LogManager.GetLogger("Debug"); //参数就是config里logger节点的名字
try
{
//var asyncContent = Request.Content.ReadAsStringAsync().Result;
//var entity = asyncContent.ToObject<ec_PanelStripEntity>();
ec_PanelStripBLL.SaveEntity(projId, entity.StripID, entity, out string NewID);
var res = ec_PanelStripBLL.GetEntity(projId, NewID);
return Success(res);
}
catch (System.Exception e)
{
log.Debug($"★★★{DateTime.Now.ToString()}★★★{e}★★★");
return Fail(e.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanelStripTerm(ec_PanelStripTermEntity entity, string projId)
{
try
{
ec_PanelStripTermBLL.SaveEntity(projId, entity.TermID, entity);
return Success("OK");
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanelChannel(ec_PanelChannelEntity entity, string projId)
{
try
{
var newId = ec_PanelChannelBLL.SaveEntity(projId, entity.ChannelID, entity);
foreach (var term in entity.Terms)
{
ec_PanelStripTermBLL.SaveEntity(projId, term.TermID, term);
}
var res = ec_PanelChannelBLL.GetEntity(projId, newId);
return Success(res);
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 调端子排所属Panel
/// </summary>
/// <param name="StripID">端子排ID</param>
/// <param name="PanelID">PanelID</param>
/// <param name="ProjectId">项目ID</param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SwitchPanelStrip(string StripID, string PanelID, string ProjectId)
{
try
{
ec_PanelStripBLL.SwitchPanelStrip(StripID, PanelID, ProjectId);
return Success("OK");
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 调换电缆的from/to信息
/// </summary>
/// <param name="CableID">Cable的工程ID</param>
/// <param name="ProjectId">项目ID</param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SwitchCableFromTo(string ProjectId)
{
try
{
var asyncContent = Request.Content.ReadAsStringAsync().Result;
var entityCol = asyncContent.ToObject<List<string>>();
var res = new ec_enginedata_relService().SwitchCableFromTo(entityCol, ProjectId);
if (res)
{
return Success("OK");
}
else
{
return Fail("From/To 交换出现问题。");
}
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 比如 移动通道时，进行保存
/// </summary>
/// <param name="entity"></param>
/// <param name="projId"></param>
/// <returns></returns>
[Obsolete]
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult SavePanelChannels(List<ec_PanelChannelEntity> entitys, string projId)
{
try
{
foreach (var entity in entitys)
{
var newId = ec_PanelChannelBLL.SaveEntity(projId, entity.ChannelID, entity);
foreach (var term in entity.Terms)
{
ec_PanelStripTermBLL.SaveEntity(projId, term.TermID, term);
}
}
return Success("OK");
}
catch (System.Exception e)
{
return Fail(e.Message);
}
}
/// <summary>
/// 根据某个数据字典的编号来。默认有个id=1的枚举
/// </summary>
/// <param name="ProjectId"></param>
/// <returns></returns>
private List<ec_dataitemdetailEntity> GetLocList(string ProjectId)
{
var ec_dataitemBLL = new ec_dataitemBLL();
var settings = new ec_projectSettingsBLL();
var ListFlg = settings.GetEntity(GlobalObject.projSetting_enumlist_IORackPosition, ProjectId);
if (ListFlg != null)
{
List<ec_dataitemdetailEntity> frameLists = new List<ec_dataitemdetailEntity>();
frameLists.Add(new ec_dataitemdetailEntity() { DataItemName = "默认", DataItemCode = "默认", DataItemDetailID = "1", UpDataItemDetailID = "", DataItemID = "" }); //{ Name = "默认", Desc = "默认", Id = "1", ParentID = "" });
var ListName = ec_dataitemBLL.GetList("{ProjectId:\"" + ProjectId + "\",keyword:\"" + ListFlg.SettingValue + "\"}").FirstOrDefault();
if (ListName == null)
{
return null;
}
else
{
frameLists[0].DataItemID = ListName.DataItemID;
}
var res = ec_dataitemBLL.GetDetailList(ListFlg.SettingValue, "", ProjectId, false); //区域
foreach (var item in res)
{
//frameLists.Add(new ec_dataitemdetailEntity()
//{
// Name = item.DataItemName,
// ParentID = item.UpDataItemDetailID,
// Desc = item.DataItemCode,
// Id = item.DataItemDetailID,
// DataItemId = item.DataItemID
//});
frameLists.Add(item);
}
return frameLists;
}
else
{
return null;
}
}
/// <summary>
/// 位置。缺省都放到“默认”下
/// </summary>
/// <param name="ProjectId"></param>
/// <returns></returns>
[HttpGet]
public IHttpActionResult GetLocationList(string ProjectId)
{
var RES = GetLocList(ProjectId);
if (RES != null)
{
return Success(RES);
}
else
{
return Fail("未找到合适的数据字典，可以当做位置");
}
}
/// <summary>
/// 根据id来删除
/// </summary>
/// <param name="keyValue"></param>
/// <param name="ProjectId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult DeletePanel(string PanelID, string ProjectId)
{
new ec_enginedataBLL().DeleteEntity(PanelID, ProjectId);
return Success("删除成功！");
}
/// <summary>
/// 根据id来删除
/// </summary>
/// <param name="CableID"></param>
/// <param name="ProjectId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult DeleteCableProfile(string CableID, string ProjectId)
{
ec_CableBLL.DeleteEntity(ProjectId, CableID);
return Success("OK");
}
/// <summary>
/// 根据id来删除
/// </summary>
/// <param name="keyValue"></param>
/// <param name="ProjectId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult DeletePanelStrip(string StripID, string ProjectId)
{
ec_PanelStripBLL.DeleteEntity(ProjectId, StripID);
return Success("删除成功！");
}
/// <summary>
/// 根据id来删除
/// </summary>
/// <param name="ChannelID"></param>
/// <param name="ProjectId"></param>
[HttpPost]
[HandlerApiLogin(FilterMode.Enforce)]
public IHttpActionResult DeletePanelChannel(string ChannelID, string ProjectId)
{
ec_PanelChannelBLL.DeleteEntity(ProjectId, ChannelID);
return Success("OK");
}
}
/// <summary>
///
/// </summary>
//public class Panel_Location
//{
/// <summary>
///
/// </summary>
//public string ParentID { get; set; }
/// <summary>
///
/// </summary>
//public string Id { set; get; }
/// <summary>
/// 所在数据字典的ID
/// </summary>
// public string DataItemId { set; get; }
/// <summary>
///
/// </summary>
//public string Name { get; set; }
/// <summary>
/// 数据字典里的code
/// </summary>
//public string Desc { get; set; }
//}
}
Reference in New Issue Copy Permalink