完善工位界面

leiqunqing

2026-01-19 ba8aa925e7901381ceb394adb53eca8723d1c4c5

 ´úÂë¹ÜÀí/WIDESEAWCS_Server/WIDESEAWCS_Server/WIDESEAWCS_BasicInfoService/BoxingDetailService.cs

@@ -1,22 +1,40 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_DTO.BasicInfo;
using WIDESEAWCS_Model.Models;

namespace WIDESEAWCS_BasicInfoService
{
    public class BoxingDetailService : ServiceBase<Dt_BoxingDetail, IRepository<Dt_BoxingDetail>>, IBoxingDetailService
    {
        public BoxingDetailService(IRepository<Dt_BoxingDetail> BaseDal) : base(BaseDal)

        private readonly IBoxingService _boxingService;
        private readonly IFormulaService _formulaService;
        private readonly IFormulaDetailService _formulaDetailService;
        private readonly IUnitOfWorkManage _unitOfWorkManage;

        public BoxingDetailService(
            IRepository<Dt_BoxingDetail> BaseDal,
            IFormulaService formulaService,
            IBoxingService boxingService,
            IFormulaDetailService formulaDetailService,
            IUnitOfWorkManage unitOfWorkManage
            ) : base(BaseDal)
        {
            _formulaService = formulaService;
            _boxingService = boxingService;
            _formulaDetailService = formulaDetailService;
            _unitOfWorkManage = unitOfWorkManage;
        }

        public IRepository<Dt_BoxingDetail> Repository => BaseDal;


        /// <summary>
        /// æ¯”较零件是否齐全
@@ -30,26 +48,249 @@
            {
                return false;
            }

            List<string> BoxingIdList = new List<string>();
            List<string> FormulaIdList = new List<string>();

            for (int i = 0; i < boxingDetails.Count; i++)
            {
                BoxingIdList.Add(boxingDetails[i].ComponentCode);
                FormulaIdList.Add(formulaDetails[i].ComponentCode);
            List<string> BoxingIdList = boxingDetails.Select(x => x.ComponentCode).ToList();
            List<string> FormulaIdList = formulaDetails.Select(x => x.ComponentCode).ToList();
            return !BoxingIdList.Except(FormulaIdList).Any() && !FormulaIdList.Except(BoxingIdList).Any();
            }
            BoxingIdList.Sort();
            FormulaIdList.Sort();

            for (int i = 0; i < BoxingIdList.Count; i++)

        /// <summary>
        /// æ£€æŸ¥é›¶ä»¶
        /// </summary>
        /// <param name="boxingDetails"></param>
        /// <param name="formulaDetails"></param>
        /// <returns></returns>
        public string IsComponentCodesEqual(List<string> boxingDetails, List<string> formulaDetails)
            {
                if (BoxingIdList[i] != FormulaIdList[i])
            // å¤„理null集合，规避空指针异常
            var boxList = boxingDetails ?? new List<string>();
            var formulaList = formulaDetails ?? new List<string>();

            var validBoxCodes = boxList.Where(code => !string.IsNullOrEmpty(code)).ToList();
            var validFormulaCodes = formulaList.Where(code => !string.IsNullOrEmpty(code)).ToList();

            foreach (var group in validBoxCodes.GroupBy(code => code))
                {
                    return false;
                string componentCode = group.Key;
                int boxCount = group.Count();
                int formulaCount = validFormulaCodes.Count(code => code == componentCode);

                if (formulaCount == 0 || formulaCount < boxCount)
                {
                    return componentCode;
                }
            }
            return true;
            return null;
        }


        /// <summary>
        /// æ·»åŠ /修改组盘信息（一体化接口：传工装板编号存在则修改，不存在则新增）
        /// </summary>
        /// <param name="toolingBoardSubmitDto"></param>
        /// <returns></returns>
        public WebResponseContent SaveToolingBoardNo(ToolingBoardSubmitDto toolingBoardSubmitDto)
        {
            using (var uow = _unitOfWorkManage.CreateUnitOfWork())
            {
                try
                {
                    // 1. å‚数校验
                    if (toolingBoardSubmitDto == null)
                    {
                        return WebResponseContent.Instance.Error("提交参数不能为空");
                    }
                    string palletCode = toolingBoardSubmitDto.ToolingBoardNo?.Trim();
                    string productCode = toolingBoardSubmitDto.FinishedProductCode?.Trim();
                    if (string.IsNullOrWhiteSpace(palletCode))
                    {
                        return WebResponseContent.Instance.Error("工装板编号不能为空");
                    }
                    if (string.IsNullOrWhiteSpace(productCode))
                    {
                        return WebResponseContent.Instance.Error("成品编码不能为空");
                    }

                    // 2. æŸ¥è¯¢æˆå“é…æ–¹ä¿¡æ¯
                    Dt_Formula formulaModel = _formulaService.Repository.QueryFirst(x => x.ProductCode == productCode);
                    if (formulaModel == null)
                    {
                        return WebResponseContent.Instance.Error("无成品配方，请核对成品编码");
                    }

                    List<Dt_FormulaDetail> dt_FormulaDetails = _formulaDetailService.Repository.QueryData(x => x.FormulaId == formulaModel.Id && x.IsScanned == 1);
                    List<string> Codelist = dt_FormulaDetails.Select(x => x.ComponentCode).ToList();
                    string IsCode = IsComponentCodesEqual(toolingBoardSubmitDto.PartsList, Codelist);
                    if (IsCode != null) 
                    {
                        return WebResponseContent.Instance.Error($"物料【{IsCode}】错误，请核对物料编号");
                    }


                    // 3. æ ¸å¿ƒåˆ¤æ–­ï¼šæ ¹æ®å·¥è£…板编号查询是否存在【新增/修改】的主表数据
                    Dt_Boxing existBoxinModel = _boxingService.Repository.QueryFirst(x => x.PalletCode == palletCode);
                    if (existBoxinModel == null)
                    {
                        #region æ–°å¢žé€»è¾‘ - åŽŸé€»è¾‘优化版
                        Dt_Boxing dt_boxin = new Dt_Boxing()
                        {
                            PalletCode = palletCode,
                            ProductCode = productCode,
                            ProductName = formulaModel.ProductName.Trim(),
                            Creater = "admin",
                            CreateDate = DateTime.Now
                        };
                        int newBoxingId = _boxingService.Repository.AddData(dt_boxin);  


                        // æ‰¹é‡æ·»åŠ æ˜Žç»†è¡¨æ•°æ®
                        if (toolingBoardSubmitDto.PartsList != null && toolingBoardSubmitDto.PartsList.Count > 0)
                        {
                            List<Dt_BoxingDetail> detailList = new List<Dt_BoxingDetail>();
                            foreach (string ComponentCode in toolingBoardSubmitDto.PartsList)
                            {
                                if (string.IsNullOrWhiteSpace(ComponentCode)) continue;
                                string ComponentCodeTrim = ComponentCode.Trim();

                                Dt_FormulaDetail formulaDetail = _formulaDetailService.Repository.QueryFirst(x => x.FormulaId == formulaModel.Id && x.ComponentCode == ComponentCodeTrim);
                                if (formulaDetail == null)
                                {
                                    return WebResponseContent.Instance.Error($"配方中无此物料【{ComponentCodeTrim}】，请核对物料编号");
                                }

                                Dt_BoxingDetail detailModel = new Dt_BoxingDetail()
                                {
                                    BoxingId = newBoxingId,
                                    ComponentCode = ComponentCodeTrim,
                                    ComponentName = formulaDetail.ComponentName,
                                    Creater = "admin",
                                    CreateDate = DateTime.Now
                                };
                                detailList.Add(detailModel);
                            }
                            if (detailList.Count > 0)
                            {
                                BaseDal.AddData(detailList);
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        #region ä¿®æ”¹é€»è¾‘ - æ–°å¢žæ ¸å¿ƒé€»è¾‘
                        // 1. æ›´æ–°ä¸»è¡¨æ•°æ®
                        existBoxinModel.ProductCode = productCode;
                        existBoxinModel.ProductName = formulaModel.ProductName.Trim();
                         existBoxinModel.Modifier = "admin";
                        existBoxinModel.ModifyDate = DateTime.Now;
                        _boxingService.Repository.UpdateData(existBoxinModel);

                        int boxingId = existBoxinModel.Id;

                        // 2. åˆ é™¤è¯¥ç»„盘下的【原有全部明细表数据】
                        List<Dt_BoxingDetail> oldDetailList = BaseDal.QueryData(x => x.BoxingId == boxingId);
                        if (oldDetailList != null && oldDetailList.Count > 0)
                        {
                            BaseDal.DeleteData(oldDetailList);
                        }

                        // 3. é‡æ–°æ’入修改后的明细表数据
                        if (toolingBoardSubmitDto.PartsList != null && toolingBoardSubmitDto.PartsList.Count > 0)
                        {
                            List<Dt_BoxingDetail> detailList = new List<Dt_BoxingDetail>();
                            foreach (string ComponentCode in toolingBoardSubmitDto.PartsList)
                            {
                                if (string.IsNullOrWhiteSpace(ComponentCode)) continue;
                                string ComponentCodeTrim = ComponentCode.Trim();

                                Dt_FormulaDetail formulaDetail = _formulaDetailService.Repository.QueryFirst(x => x.FormulaId == formulaModel.Id && x.ComponentCode == ComponentCodeTrim);
                                if (formulaDetail == null)
                                {
                                    return WebResponseContent.Instance.Error($"配方中无此物料【{ComponentCodeTrim}】，请核对物料名称");
                                }

                                Dt_BoxingDetail detailModel = new Dt_BoxingDetail()
                                {
                                    BoxingId = boxingId,
                                    ComponentCode = ComponentCodeTrim,
                                    ComponentName = formulaDetail.ComponentName,
                                    Creater = "admin",
                                    CreateDate = DateTime.Now
                                };
                                detailList.Add(detailModel);
                            }
                            if (detailList.Count > 0)
                            {
                                BaseDal.AddData(detailList);
                            }
                        }
                        #endregion
                    }
                    uow.Commit();
                    string msg = existBoxinModel == null ? "组盘信息新增成功！" : "组盘信息修改成功！";
                    return WebResponseContent.Instance.OK(msg);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"保存工装板组盘信息异常：{ex.Message}，堆栈：{ex.StackTrace}");
                    return WebResponseContent.Instance.Error($"提交失败：{ex.Message}");
                }
            }
        }



        /// <summary>
        /// èŽ·å–成品编号和零件编号
        /// </summary>
        /// <param name="palletCode"></param>
        /// <returns></returns>
        public WebResponseContent GetProductAndPartsByBoardNo(string palletCode)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(palletCode))
                {
                    return WebResponseContent.Instance.OK("查询成功", new
                    {
                        finishedProductCode = "",
                        partsList = Enumerable.Repeat("", 10).ToList()
                    });
                }
                Dt_Boxing dt_Boxing = _boxingService.Repository.QueryFirst(x => x.PalletCode == palletCode);
                if (dt_Boxing == null)
                {
                    return WebResponseContent.Instance.OK("未查询到该工装板对应的成品信息", new
                    {
                        finishedProductCode = "",
                        partsList = Enumerable.Repeat("", 10).ToList()
                    });
                }
                List<Dt_BoxingDetail> dt_BoxingDetails = BaseDal.QueryData(x => x.BoxingId == dt_Boxing.Id)?.ToList() ?? new List<Dt_BoxingDetail>();
                // å–零件编号
                List<string> partsList = dt_BoxingDetails.Select(d => d.ComponentCode).ToList();
                List<string> resultPartsList = new List<string>();
                for (int i = 0; i < 10; i++)
                {
                    if (i < partsList.Count)
                    {
                        resultPartsList.Add(partsList[i] ?? "");
                    }
                    else
                    {
                        resultPartsList.Add("");
                    }
                }
                return WebResponseContent.Instance.OK("零件编号列表查询成功", new
                {
                    finishedProductCode = dt_Boxing.ProductCode ?? "",
                    partsList = resultPartsList
                });
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"查询零件编号列表异常：{ex.Message}");
            }
        }
    }
}