leiqunqing
2026-01-19 ba8aa925e7901381ceb394adb53eca8723d1c4c5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
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
    {
 
        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>
        /// 比较零件是否齐全
        /// </summary>
        /// <param name="boxingDetails"></param>
        /// <param name="formulaDetails"></param>
        /// <returns></returns>
        public bool IsComponentCodesEqual(List<Dt_BoxingDetail> boxingDetails, List<Dt_FormulaDetail> formulaDetails)
        {
            if (boxingDetails == null || formulaDetails == null || boxingDetails.Count != formulaDetails.Count)
            {
                return false;
            }
            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();
        }
 
 
        /// <summary>
        /// 检查零件
        /// </summary>
        /// <param name="boxingDetails"></param>
        /// <param name="formulaDetails"></param>
        /// <returns></returns>
        public string IsComponentCodesEqual(List<string> boxingDetails, List<string> formulaDetails)
        {
            // 处理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))
            {
                string componentCode = group.Key;
                int boxCount = group.Count();
                int formulaCount = validFormulaCodes.Count(code => code == componentCode);
 
                if (formulaCount == 0 || formulaCount < boxCount)
                {
                    return componentCode;
                }
            }
            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}");
            }
        }
    }
}