EPLAN_PROD_Plugin/Sinvo.EplanHpD.Plugin.WPFUI/ViewModel/WireCheck/MainViewModel.Check.cs

using Sinvo.EplanHpD.Plugin.WPFUI.Enum;
using Sinvo.EplanHpD.Plugin.WPFUI.Models;
using Sinvo.EplanHpD.Plugin.WPFUI.Utils;
using System;
using System.Collections.Generic;
using System.IO.Packaging;
using System.Linq;

namespace Sinvo.EplanHpD.Plugin.WPFUI.ViewModel
{
    public partial class MainViewModel
    {
        public void CheckAll(IEnumerable<StuffedDataModel> datas)
        {
            datas.AsParallel().WithDegreeOfParallelism(4).ForAll(item =>
            {
                if (item == null) return;
                item.IsError = false;
                item.ErrorCount = 0;
                item.CheckedMsg = "";
                try
                {
                    ValidateItem(item);

                }
                catch (Exception ex)
                {
                    SetItemError(item, ex.Message);
                }

                item.IsChecked = true;
            });

            OnPropertyChanged(nameof(StuffedData));
        }

        private void ValidateItem(StuffedDataModel item)
        {
            CheckWireErpNr(item);
            CheckRequiredFields(item);
            //if (IsUseDiscoloration)
            {
                CheckImprint(item);
            }
            if (IsRequireCe)
            {
                CheckCeCompliance(item);
            }
            CheckNumberTube(item);
            CheckInsulation(item);
            CheckTerminals(item);
            CheckDPETerminals(item);
            CheckDuplicateModel(item);

            CheckImprintStartsWith(item);
        }
        /// <summary>
        /// 检查印记内容前缀
        /// </summary>
        /// <param name="item"></param>
        public void CheckImprintStartsWith(StuffedDataModel item)
        {
            if (item.Imprint.StartsWith("w_0"))
            {
                SetItemError(item, "印记内容不符合规范！\r\n");
            }
        }
        /// <summary>
        /// 检查地排端子
        /// </summary>
        /// <param name="item"></param>
        public void CheckDPETerminals(StuffedDataModel item)
        {
            // 地排只检查4.0线径以下的
            if (double.TryParse(item.CrossSection, out double crossSection))
                if (item.Imprint.StartsWith("D-PE") && crossSection <= 4.0)
                {
                    var D_PECanUsedTerminals = GetD_PECanUsedTerminal(item.WireModel);
                    if (D_PECanUsedTerminals.All(terminal =>
                    terminal.TerminalSpec != item.FrontTerminalModel
                    && terminal.TerminalSpec != item.RearTerminalModel)
                        )
                    {
                        SetItemError(item, "D-PE线未匹配到正确的端子！\r\n");
                    }
                }
        }

        /// <summary>
        /// 检查线材料号
        /// </summary>
        /// <param name="item"></param>
        public void CheckWireErpNr(StuffedDataModel item)
        {
            try
            {
                var wireInfos = ExcelHelper.GetWireInfo(item.WireModel);
                if (wireInfos != null && wireInfos.Count() == 1)
                {
                    var wireInfo = wireInfos.First();
                    if (wireInfo != null)
                    {
                        if (wireInfo.WireMaterialCode != item.WireCode)
                        {
                            SetItemError(item, "线材料号错误！\r\n");

                        }
                    }
                }
                else if (wireInfos.Count() > 1)
                {
                    SetItemError(item, "该型号线材存在重复编码！\r\n");
                }
                else
                {
                    SetItemError(item, "该型号线材不存在配对表中！\r\n");

                }
            }
            catch (Exception ex)
            {
                SetItemError(item, ex.Message);
            }

        }
        /// <summary>
        /// 检查号码管
        /// </summary>
        /// <param name="item"></param>
        private void CheckNumberTube(StuffedDataModel item)
        {
            if (string.IsNullOrEmpty(item.NumberTubeSpec))
            {
                SetItemError(item, "未匹配到正确的号码管！\r\n");
            }
        }
        /// <summary>
        /// 检查必填项
        /// </summary>
        /// <param name="item"></param>
        private void CheckRequiredFields(StuffedDataModel item)
        {
            try
            {
                if (string.IsNullOrEmpty(item.RearTerminalMaterialCode))
                {
                    SetItemError(item, "后端子物料编码为空\r\n");
                }
                if (string.IsNullOrEmpty(item.FrontTerminalMaterialCode))
                {
                    SetItemError(item, "前端子物料编码为空\r\n");
                }
                if (string.IsNullOrEmpty(item.WireColor))
                {
                    SetItemError(item, "线色不符合规范\r\n");
                }
                if (string.IsNullOrEmpty(item.WireCode))
                {
                    SetItemError(item, "线材编码为空\r\n");
                }
                if (string.IsNullOrEmpty(item.Imprint))
                {
                    SetItemError(item, "印记(线号)内容为空\r\n");
                }
                 
            }
            catch (Exception ex)
            {
                SetItemError(item, ex.Message);
            }
        }
        /// <summary>
        /// 检查是否全部使用CE认证物料
        /// </summary>
        /// <param name="item"></param>
        private void CheckCeCompliance(StuffedDataModel item)
        {
            if (item.WireModel.IndexOf("-CE", StringComparison.OrdinalIgnoreCase) < 0)
            {
                SetItemError(item, "未使用CE认证物料！\r\n");
            }
            if (item.FrontTerminalModel.IndexOf("-CE", StringComparison.OrdinalIgnoreCase) < 0)
            {
                SetItemError(item, "前端子未使用CE认证端子！\r\n");
            }
            if (item.RearTerminalModel.IndexOf("-CE", StringComparison.OrdinalIgnoreCase) < 0)
            {
                SetItemError(item, "后端子未使用CE认证端子！\r\n");
            }
        }
        /// <summary>
        /// 检查变色套（绝缘软套）大小与是否使用了变色管
        /// </summary>
        /// <param name="item"></param>
        public void CheckInsulation(StuffedDataModel item)
        {
            if (item.Insulation != null && item.Insulation.Specification != null)
            {
                var match = Consts.regex.Match(item.WireModel);
                if (!string.IsNullOrEmpty(match?.Value) && match != null)
                {
                    var itemWireDiameter = double.Parse(match.Value.Replace("RV", ""));
                    var insMatch = Consts.dRegex.Match(item.Insulation.Specification);
                    if (!string.IsNullOrEmpty(insMatch.Value))
                    {
                        if (itemWireDiameter < 1.5d)
                        {
                            if (insMatch.Value != "V-1.5")
                            {
                                SetItemError(item, "变色套（绝缘软套）大小与线径不匹配！");
                            }
                        }
                        else
                        {
                            var insDiameter = double.Parse(insMatch.Value.Replace("V-", ""));
                            if (Math.Abs(insDiameter - itemWireDiameter) > 0)
                            {
                                SetItemError(item, "变色套（绝缘软套）大小与线径不匹配！");
                            }
                        }
                    }
                    else
                    {
                        SetItemError(item, "变色套（绝缘软套）未匹配到大小！");
                    }
                }
                else
                {
                    SetItemError(item, "未匹配到线材大小！");
                }
            }
            else
            {
                if (CheckUseDiscoloration(item.Imprint))
                {
                    SetItemError(item, "未匹配到变色套（绝缘软套）！");

                }
            }
        }
        /// <summary>
        /// 检查引用的端子
        /// </summary>
        /// <param name="item"></param>
        public void CheckTerminals(StuffedDataModel item)
        {
            var canUsedTerminals = GetCanUsedTerminal(item.WireModel);
            if (canUsedTerminals != null && canUsedTerminals.Any())
            {
                var terminals = canUsedTerminals.Where(it => !string.IsNullOrEmpty(it.TerminalSpec) && !string.IsNullOrEmpty(it.TerminalMaterialCode));

                if (terminals.All(it => it.TerminalSpec != item.FrontTerminalModel))
                {
                    SetItemError(item, "前端子不在可选列表中！\r\n");
                    if (item.FrontTerminalModel.Contains("/"))
                    {
                        SetItemError(item, "后端子存在错误的斜杠(/)！\r\n");
                    }
                }
                if (terminals.All(it => it.TerminalMaterialCode != item.FrontTerminalMaterialCode))
                {
                    SetItemError(item, "前端子料号不正确，不在可选列表中！\r\n");

                }
                if (terminals.All(it => it.TerminalSpec != item.RearTerminalModel))
                {
                    SetItemError(item, "后端子不在可选列表中！\r\n");
                    if (item.RearTerminalModel.Contains("/"))
                    { 
                        SetItemError(item, "后端子存在错误的斜杠(/)！\r\n");
                    }
                }
                if (terminals.All(it => it.TerminalMaterialCode != item.RearTerminalMaterialCode))
                {
                    SetItemError(item, "后端子料号不正确，不在可选列表中！\r\n");
                }
            }
            else if (!string.IsNullOrEmpty(item.FrontTerminalModel) || !string.IsNullOrEmpty(item.RearTerminalModel))
            {
                SetItemError(item, "该型号无可用端子！\r\n");
            }
        }
        /// <summary>
        /// 检查重复
        /// </summary>
        /// <param name="item"></param>
        private void CheckDuplicateModel(StuffedDataModel item)
        {
            if (StuffedData?.Count(it => it != null && it.Model == item.Model) > 1)
            {
                if (string.IsNullOrEmpty(item.WireLength))
                {
                    SetItemError(item, $"线长度获取异常！\r\n");
                }
                else
                {
#if DEBUG
                    //var newModel = $"RV-{item.WireColor}-1x{item.CrossSection}-{item.WireLength + 5}-16×N2-{item.WireNumber}";
                    var newModel = GenWireModel(item.WireColor, item.CrossSection, $"{double.Parse(item.WireLength) + 5}_add_5", item.WireNumber);
#else
                    var newModel = GenWireModel(item.WireColor, item.CrossSection, $"{double.Parse(item.WireLength) + 5}", item.WireNumber);
#endif
                    if (StuffedData.Any(it => it.Model == newModel))
                    {
                        //var newModel2 = $"RV-{item.WireColor}-1x{item.CrossSection}-{item.WireLength + 10}-16×N2-{item.WireNumber}";
#if DEBUG
                        var newModel2 = GenWireModel(item.WireColor, item.CrossSection, $"{double.Parse(item.WireLength) + 10}_add_10", item.WireNumber);
#else
                        var newModel2 = GenWireModel(item.WireColor, item.CrossSection, $"{double.Parse(item.WireLength) + 10}", item.WireNumber);
#endif
                        if (StuffedData.Any(it => it.Model == newModel2))
                            SetItemError(item, $"{item.Model} 该型号存在重复！\r\n");
                        else
                        {
                            item.WireLength = $"{double.Parse(item.WireLength) + 10}";
                            item.Model = newModel2;
                        }
                    }
                    else
                    {
                        item.WireLength = $"{double.Parse(item.WireLength) + 5}";
                        item.Model = newModel;
                    }
                }
            }
        }
        /// <summary>
        /// 将一项设置为异常
        /// </summary>
        /// <param name="item"></param>
        /// <param name="errorMsg"></param>
        private void SetItemError(StuffedDataModel item, string errorMsg)
        {
            if (!errorMsg.EndsWith("\r\n"))
                errorMsg += "\r\n";

            item.IsError = true;
            item.ErrorCount += 1;
            item.CheckedMsg += errorMsg;
        }
        /// <summary>
        /// 获取可使用的端子
        /// </summary>
        /// <param name="wireModel"></param>
        /// <returns></returns>
        private List<TerminalModel> GetCanUsedTerminal(string wireModel)
        {
            var result = ExcelHelper.GetWireTerminalMappingTable(wireModel);
            var terminals = new List<TerminalModel>();
            var excelModels = result as ExcelModel[] ?? result.ToArray();
            if (!excelModels.Any()) return terminals;
            foreach (var item in excelModels)
            {
                if (!string.IsNullOrEmpty(item.ForkTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.ForkTerminalMaterialCode,
                        TerminalSpec = item.ForkTerminal
                    });
                if (!string.IsNullOrEmpty(item.FlatTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.FlatTerminalMaterialCode,
                        TerminalSpec = item.FlatTerminal
                    });
                if (!string.IsNullOrEmpty(item.PinTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.PinTerminalMaterialCode,
                        TerminalSpec = item.PinTerminal
                    });
                if (!string.IsNullOrEmpty(item.OTypeTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.OTypeTerminalMaterialCode,
                        TerminalSpec = item.OTypeTerminal
                    });
                if (!string.IsNullOrEmpty(item.YTypeTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.YTypeTerminalMaterialCode,
                        TerminalSpec = item.YTypeTerminal
                    });
            }
            return terminals;
        }
        /// <summary>
        /// 检查地线可以用的端子
        /// </summary>
        /// <param name="wireModel"></param>
        /// <returns></returns>
        private List<TerminalModel> GetD_PECanUsedTerminal(string wireModel)
        {
            // 获取D-PE前缀的可用端子
            var resultWithPrefix = ExcelHelper.GetWireTerminalMappingTable(wireModel, "D-PE");
            // 获取不包含前缀的端子
            //var resultWithoutPrefix = ExcelHelper.GetWireTerminalMappingTable(wireModel);
            var terminals = new List<TerminalModel>();
            // 转换
            var withPrefixExcelModels = resultWithPrefix as List<ExcelModel> ?? resultWithPrefix.ToList();
            List<ExcelModel> withoutPrefixExcelModels = [];//resultWithoutPrefix as List<ExcelModel> ?? resultWithoutPrefix.ToList();
            // 合并
            var excelModels = withPrefixExcelModels.Concat(withoutPrefixExcelModels);
            if (!excelModels.Any()) return terminals;
            foreach (var item in excelModels)
            {
                if (!string.IsNullOrEmpty(item.ForkTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.ForkTerminalMaterialCode,
                        TerminalSpec = item.ForkTerminal
                    });
                if (!string.IsNullOrEmpty(item.FlatTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.FlatTerminalMaterialCode,
                        TerminalSpec = item.FlatTerminal
                    });
                if (!string.IsNullOrEmpty(item.PinTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.PinTerminalMaterialCode,
                        TerminalSpec = item.PinTerminal
                    });
                if (!string.IsNullOrEmpty(item.OTypeTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.OTypeTerminalMaterialCode,
                        TerminalSpec = item.OTypeTerminal
                    });
                if (!string.IsNullOrEmpty(item.YTypeTerminal))
                    terminals.Add(new TerminalModel
                    {
                        TerminalMaterialCode = item.YTypeTerminalMaterialCode,
                        TerminalSpec = item.YTypeTerminal
                    });
            }
            return terminals;
        }
        /// <summary>
        /// 检查变色套是否使用正确的颜色
        /// </summary>
        /// <param name="item"></param>
        private void CheckImprint(StuffedDataModel item)
        {
            var imprintConditions = new List<(string Prefix, WireFlagType? FlagType, string Color)>
                {
                    ("L1", WireFlagType.Dual, "褐色"),
                    ("R", WireFlagType.Single, "褐色"),
                    ("L1", WireFlagType.Mix, "褐色"),
                    ("R", WireFlagType.Mix, "褐色"),

                    ("L2", WireFlagType.Dual, "黑色"),
                    ("S", WireFlagType.Single, "黑色"),
                    ("L2", WireFlagType.Mix, "黑色"),
                    ("S", WireFlagType.Mix, "黑色"),

                    ("L3", WireFlagType.Dual, "灰色"),
                    ("T", WireFlagType.Single, "灰色"),
                    ("L3", WireFlagType.Mix, "灰色"),
                    ("T", WireFlagType.Mix, "灰色"),

                    ("PE", null, "绿色"),
                    ("D-PE", null, "绿色")
                };

            foreach (var condition in imprintConditions)
            {
                CheckImprintCondition(item, condition.Prefix, condition.FlagType, condition.Color);
            }
        }
        private void CheckImprintCondition(StuffedDataModel item, string imprintPrefix, WireFlagType? flagType, string expectedColor)
        {
            if (item.Imprint.StartsWith(imprintPrefix) && (flagType == null || FlagType == flagType))
            {
                if (string.IsNullOrEmpty(item.DiscolorationDesc) || item.Insulation == null || string.IsNullOrEmpty(item.Insulation.MaterialCode))
                {
                    SetItemError(item, "变色管信息为空！\r\n");
                }
                else
                {
                    // 获取变色管颜色
                    var discolorationDesc = Consts.regexParenthesesContent.Match(item.DiscolorationDesc).Value;

                    if (string.IsNullOrEmpty(discolorationDesc))
                    {
                        SetItemError(item, "变色管信息为空！\r\n");
                    }
                    else if (!discolorationDesc.Equals(expectedColor))
                    {
                        if (imprintPrefix == "D-PE")
                        {
                            if ((item.WireColor == "GNYE" && discolorationDesc != "绿色"))
                            {
                                SetItemError(item, $"变色管颜色有误，应该使用{expectedColor}！\r\n");
                            }
                        }
                        else
                        {

                            SetItemError(item, $"变色管颜色有误，应该使用{expectedColor}！\r\n");
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 检查是否使用变色套
        /// </summary>
        /// <param name="imprint"></param>
        /// <returns></returns>
        private bool CheckUseDiscoloration(string imprint)
        {
            var imprintConditions = new List<(string Prefix, WireFlagType? FlagType)>
                {
                    ("L1", WireFlagType.Dual),
                    ("R", WireFlagType.Single ),
                    ("L1", WireFlagType.Mix ),
                    ("R", WireFlagType.Mix ),

                    ("L2", WireFlagType.Dual ),
                    ("S", WireFlagType.Single ),
                    ("L2", WireFlagType.Mix ),
                    ("S", WireFlagType.Mix ),

                    ("L3", WireFlagType.Dual ),
                    ("T", WireFlagType.Single ),
                    ("L3", WireFlagType.Mix ),
                    ("T", WireFlagType.Mix ),

                    ("PE", null )
                };
            // 检查印记是否按照规范开头
            foreach (var condition in imprintConditions)
            {
                if (imprint.StartsWith(condition.Prefix) && (condition.FlagType == null || FlagType == condition.FlagType))
                {
                    return true;
                }
            }
            return false;
        }
    }
}