using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using MES.Service.DB;
|
using MES.Service.Modes;
|
using MES.Service.Dto.webApi;
|
using System.Data;
|
|
namespace MES.Service.service
|
{
|
public class MesReturnwareManager : Repository<MesReturnware>
|
{
|
|
|
private readonly MesReturnwareDetailsManager ReturnwareDetailsManager = new();
|
//当前类已经继承了 Repository 增、删、查、改的方法
|
|
//这里面写的代码不会给覆盖,如果要重新生成请删除 MesReturnwareManager.cs
|
|
|
public bool SaveList(List<ErpReturn> ReturnWare)
|
{
|
var result = ReturnWare.Select(Save).ToList();
|
return result.All(b => b);
|
}
|
|
public bool Save(ErpReturn ReturnWare)
|
{
|
var ReturnWares = ReturnWare.ErpReturnWares;
|
var mesReturnWares = MapErptoMesReturnware(ReturnWares);
|
var ErpReturnWareDetails = MapErptoMesReturnwareDetails(ReturnWare.ErpReturnWareDetailss);
|
|
return UseTransaction(db =>
|
{
|
switch (ReturnWares.Type)
|
{
|
case "3":
|
return UpdateData(db, mesReturnWares, ErpReturnWareDetails) ? 1 : 0;
|
case "2":
|
case "4":
|
return SaveOrUpdateData(db, mesReturnWares, ErpReturnWareDetails)
|
? 1
|
: 0;
|
default:
|
throw new NotImplementedException(
|
$"type没有{ReturnWares.Type}这个类型");
|
}
|
}) > 0;
|
}
|
|
private bool SaveOrUpdateData(SqlSugarScope db, MesReturnware mesReturnware,
|
List<MesReturnwareDetails> mesReturnwareDetails)
|
{
|
|
|
if (mesReturnware.ReturnNo != null && mesReturnware.ReturnType != null)
|
{
|
|
db.Deleteable<MesReturnware>()
|
.Where(it => it.ReturnNo == mesReturnware.ReturnNo &&
|
it.ReturnType == mesReturnware.ReturnType)
|
.ExecuteCommand();
|
|
};
|
|
|
if (mesReturnwareDetails.Count > 0)
|
{
|
|
// var mesWomcab = mesWomcabs.Select(s => new { CAB001 = s.Cab001, CAB002 = s.Cab002, CAB003 = s.Cab003 }).ToList();
|
var mesReturnwareDetail = mesReturnwareDetails.Select(s => new { ReturnwareNo = s.ReturnNo, ReturnwareType = s.ReturnType }).ToList();
|
|
|
/*db.Deleteable<Womcab>()
|
.Where(it => mesWomcab
|
.Any(p => p.CAB001 == it.Cab001
|
&& p.CAB002 == it.Cab002
|
&& p.CAB003 == it.Cab003))
|
.ExecuteCommand();*/
|
db.Deleteable<MesReturnwareDetails>()
|
.Where(it => mesReturnwareDetail
|
.Any(p => p.ReturnwareNo == it.ReturnNo
|
&& p.ReturnwareType == it.ReturnType))
|
.ExecuteCommand();
|
|
};
|
|
|
// var orUpdate = db.Insertable(mesOutware).ExecuteCommand();
|
//var baOrUpdate = db.Insertable(mesOutwareDetails).ExecuteCommand();
|
|
|
var orUpdate = base.Insert(mesReturnware);
|
var baOrUpdate = ReturnwareDetailsManager.InsertRange(mesReturnwareDetails);
|
|
if (orUpdate && baOrUpdate)
|
{
|
// 保存成功后，调用存储过程生成检验单
|
GenerateInspectionOrder(db, mesReturnware, mesReturnwareDetails);
|
return true;
|
}
|
throw new NotImplementedException("插入或更新失败");
|
|
|
}
|
|
private bool UpdateData(SqlSugarScope db, MesReturnware mesReturnware,
|
List<MesReturnwareDetails> mesReturnwareDetails)
|
{
|
//根据单别和单号进行删除
|
var update = db.Deleteable<MesReturnware>()
|
.Where(it => it.ReturnNo == mesReturnware.ReturnNo &&
|
it.ReturnType == mesReturnware.ReturnType)
|
.ExecuteCommand() > 0;
|
|
|
//var mesWomcab = mesWomcabs.Select(s => new { CAB001 = s.Cab001, CAB002 = s.Cab002, CAB003 = s.Cab003 }).ToList();
|
var mesReturnwareDetail = mesReturnwareDetails.Select(s => new { ReturnwareNo = s.ReturnNo, ReturnwareType = s.ReturnType }).ToList();
|
|
|
|
//var insertOrUpdate = db.Deleteable<Womcab>().Where(it => mesWomcab.Any(p => p.CAB001 == it.Cab001 && p.CAB002 == it.Cab002 && p.CAB003 == it.Cab003)).ExecuteCommand() > 0;
|
var insertOrUpdate = db.Deleteable<MesReturnwareDetails>().Where(it => mesReturnwareDetail.Any(p => p.ReturnwareNo == it.ReturnNo && p.ReturnwareType == it.ReturnType)).ExecuteCommand() > 0;
|
|
|
if (update && insertOrUpdate)
|
{
|
// 更新成功后，调用存储过程生成检验单
|
GenerateInspectionOrder(db, mesReturnware, mesReturnwareDetails);
|
return true;
|
}
|
throw new NotImplementedException("更新失败");
|
}
|
|
private MesReturnware MapErptoMesReturnware(ErpReturnWare dto)
|
{
|
|
|
|
var entity = new MesReturnware
|
{
|
ReturnType = dto.ReturnType,
|
ReturnNo = dto.ReturnNo,
|
CustNo = dto.CustNo,
|
BillDate = dto.BillDate,
|
BusinessBy = dto.BusinessBy,
|
WorkshopCenterCode = dto.WorkCode,
|
Remarks = dto.Remarks,
|
CreateBy = dto.CreateBy,
|
CreateDate = dto.CreateDate,
|
Type = dto.Type,
|
Over=dto.Over ?? 0
|
};
|
|
|
|
return entity;
|
}
|
|
private List<MesReturnwareDetails> MapErptoMesReturnwareDetails(List<ErpReturnWareDetails> dtoList)
|
{
|
var returnwareList = new List<MesReturnwareDetails>();
|
|
foreach (var dto in dtoList)
|
{
|
var ReturnwareDetails = new MesReturnwareDetails
|
{
|
|
|
ItemNo = dto.ItemNo,
|
ItemName = dto.ItemName,
|
ItemModel = dto.ItemModel,
|
Quantity = dto.Quantity,
|
Type = dto.Type,
|
DepotCode = dto.DepotCode,
|
ReturnType = dto.ReturnType,
|
ReturnNo = dto.ReturnNo,
|
ReturnOrder = dto.ReturnOrder,
|
OrderType = dto.OrderType,
|
OrderNumber = dto.OrderNumber,
|
OrderNo = dto.OrderNo,
|
ActualQuantity = dto.ActQuantity,
|
CustItemNo = dto.CustItemNo,
|
CustItemName = dto.CustItemName,
|
CustItemModel = dto.CustItemModel,
|
Remarks=dto.Remarks
|
|
};
|
|
|
|
returnwareList.Add(ReturnwareDetails);
|
}
|
|
return returnwareList;
|
}
|
|
|
public bool Delete(YFDelete data)
|
{
|
return UseTransaction(db =>
|
{
|
// 在删除前，先获取要删除的退货通知单明细，用于后续重新计算销售订单状态
|
var returnDetailsToDelete = db.Queryable<MesReturnwareDetails>()
|
.Where(it => it.ReturnNo == data.FBillNo && it.ReturnType == data.FBillTypeID)
|
.ToList();
|
|
// 先删除退货通知单明细
|
var detailsDeleted = db.Deleteable<MesReturnwareDetails>()
|
.Where(it => it.ReturnNo == data.FBillNo &&
|
it.ReturnType == data.FBillTypeID)
|
.ExecuteCommand() > 0;
|
|
// 再删除退货通知单主表
|
var mainDeleted = db.Deleteable<MesReturnware>()
|
.Where(it => it.ReturnNo == data.FBillNo &&
|
it.ReturnType == data.FBillTypeID)
|
.ExecuteCommand() > 0;
|
|
if (detailsDeleted && mainDeleted)
|
{
|
// 删除成功后，调用存储过程删除对应的检验单
|
DeleteInspectionOrder(db, data.FBillTypeID, data.FBillNo);
|
|
// 重新计算并更新相关销售订单的over状态（与生成时逻辑相同）
|
if (returnDetailsToDelete.Any())
|
{
|
UpdateSalesOrderOverStatusAfterDelete(db, returnDetailsToDelete);
|
}
|
|
return 1;
|
}
|
|
throw new NotImplementedException("删除失败");
|
}) > 0;
|
}
|
|
/// <summary>
|
/// 调用存储过程生成检验单
|
/// </summary>
|
/// <param name="mesReturnware">退货通知单主表</param>
|
/// <param name="mesReturnwareDetails">退货通知单明细表</param>
|
private void GenerateInspectionOrder(SqlSugarScope db, MesReturnware mesReturnware, List<MesReturnwareDetails> mesReturnwareDetails)
|
{
|
try
|
{
|
// 定义输入参数
|
var inputParam1 = new SugarParameter("P_RETURN_TYPE", mesReturnware.ReturnType ?? "");
|
var inputParam2 = new SugarParameter("P_RETURN_NO", mesReturnware.ReturnNo ?? "");
|
|
// 定义输出参数
|
var outParam1 = new SugarParameter("P_RESULT", null, true);
|
var outParam2 = new SugarParameter("P_MESSAGE", null, true);
|
|
// 使用 SqlSugar 执行存储过程
|
db.Ado.ExecuteCommand("BEGIN SP_GEN_RETURN_INSP(:P_RETURN_TYPE,:P_RETURN_NO,:P_RESULT,:P_MESSAGE); END;",
|
inputParam1, inputParam2, outParam1, outParam2);
|
|
// 获取输出参数的值
|
int result = int.Parse((string)outParam1.Value);
|
string message = outParam2.Value == DBNull.Value ? string.Empty : (string)outParam2.Value;
|
|
if (result != 1)
|
{
|
// 记录警告日志，但不影响退货通知单的保存
|
Console.WriteLine($"生成检验单警告: {message}");
|
}
|
else
|
{
|
Console.WriteLine($"生成检验单成功: {message}");
|
|
// 生成检验单成功后，更新相关销售订单的over字段
|
UpdateSalesOrderOverStatus(db, mesReturnwareDetails);
|
}
|
}
|
catch (Exception ex)
|
{
|
// 记录错误日志，但不影响退货通知单的保存
|
Console.WriteLine($"生成检验单时发生错误: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 更新销售订单的over状态
|
/// 使用统一逻辑：ORDER_QUANTITY + GIFT_QUANTITY + 退货数量 = DELIVERED_QUANTITY + DELIVERED_GIFT_QUANTITY + XTCH
|
/// </summary>
|
/// <param name="db">数据库连接</param>
|
/// <param name="mesReturnwareDetails">退货通知单明细列表</param>
|
private void UpdateSalesOrderOverStatus(SqlSugarScope db, List<MesReturnwareDetails> mesReturnwareDetails)
|
{
|
try
|
{
|
// 获取所有需要更新的订单信息（去重）
|
var orderUpdates = mesReturnwareDetails
|
.Where(detail => !string.IsNullOrEmpty(detail.OrderNo) && !string.IsNullOrEmpty(detail.OrderType))
|
.Select(detail => new { detail.OrderNo, detail.OrderType })
|
.Distinct()
|
.ToList();
|
|
foreach (var orderInfo in orderUpdates)
|
{
|
// 获取该订单的所有明细
|
var orderDetails = db.Queryable<MesSalesOrderDetail>()
|
.Where(it => it.OrderId == orderInfo.OrderNo && it.OrderType == orderInfo.OrderType)
|
.ToList();
|
|
if (!orderDetails.Any())
|
{
|
Console.WriteLine($"未找到销售订单明细 {orderInfo.OrderType}-{orderInfo.OrderNo}，跳过更新");
|
continue;
|
}
|
|
// 检查每个订单明细是否完成
|
bool allCompleted = true;
|
|
foreach (var orderDetail in orderDetails)
|
{
|
// 查找匹配的退货明细：通过ORDER_TYPE, ORDER_ID, LINE_NUMBER, PRODUCT_CODE进行匹配
|
var matchingReturnDetails = mesReturnwareDetails
|
.Where(detail => detail.OrderType == orderDetail.OrderType &&
|
detail.OrderNo == orderDetail.OrderId &&
|
detail.OrderNumber == orderDetail.OrderNumber &&
|
detail.ItemNo == orderDetail.ProductCode)
|
.ToList();
|
|
// 计算匹配的退货数量
|
var returnQuantity = matchingReturnDetails.Sum(x => (x.Quantity ?? 0) + (x.ActualQuantity ?? 0));
|
|
// 计算订单总数量：ORDER_QUANTITY + GIFT_QUANTITY + 销售退货通知单中的数量
|
var orderTotal = (orderDetail.OrderQuantity ?? 0) +
|
(orderDetail.GiftQuantity ?? 0) +
|
returnQuantity;
|
|
// 计算已交付总数量：DELIVERED_QUANTITY + DELIVERED_GIFT_QUANTITY + XTCH(销退出货数量)
|
var deliveredTotal = (orderDetail.DeliveredQuantity ?? 0) +
|
(orderDetail.DeliveredGiftQuantity ?? 0) +
|
(orderDetail.Xtch ?? 0);
|
|
// 如果订单总数量不等于已交付总数量，则该明细未完成
|
if (orderTotal != deliveredTotal)
|
{
|
allCompleted = false;
|
Console.WriteLine($"订单明细 {orderDetail.ProductCode} 未完成: 订单总数量={orderTotal}, 已交付总数量={deliveredTotal} (订单:{orderDetail.OrderQuantity ?? 0} + 赠品:{orderDetail.GiftQuantity ?? 0} + 退货:{returnQuantity} = 已交付:{orderDetail.DeliveredQuantity ?? 0} + 已交付赠品:{orderDetail.DeliveredGiftQuantity ?? 0} + 销退出货:{orderDetail.Xtch ?? 0})");
|
break;
|
}
|
}
|
|
// 根据是否全部完成设置over值
|
decimal overValue = allCompleted ? 1 : 0;
|
|
// 更新MES_SALES_ORDER表的over字段
|
var updateCount = db.Updateable<MesSalesOrder>()
|
.SetColumns(it => it.Over == overValue)
|
.Where(it => it.OrderId == orderInfo.OrderNo && it.OrderType == orderInfo.OrderType)
|
.ExecuteCommand();
|
|
if (updateCount > 0)
|
{
|
Console.WriteLine($"成功更新销售订单 {orderInfo.OrderType}-{orderInfo.OrderNo} 的over状态为{overValue} ({(allCompleted ? "已完成" : "未完成")})");
|
}
|
else
|
{
|
Console.WriteLine($"未找到销售订单 {orderInfo.OrderType}-{orderInfo.OrderNo}，跳过更新");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
// 记录错误日志，但不影响退货通知单的保存
|
Console.WriteLine($"更新销售订单over状态时发生错误: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 删除退货通知单后重新计算并更新相关销售订单的over状态
|
/// 使用与生成时相同的逻辑：ORDER_QUANTITY + GIFT_QUANTITY + 退货数量 = DELIVERED_QUANTITY + DELIVERED_GIFT_QUANTITY + XTCH
|
/// </summary>
|
/// <param name="db">数据库连接</param>
|
/// <param name="deletedReturnDetails">已删除的退货通知单明细列表</param>
|
private void UpdateSalesOrderOverStatusAfterDelete(SqlSugarScope db, List<MesReturnwareDetails> deletedReturnDetails)
|
{
|
try
|
{
|
// 获取所有需要重新计算的订单信息（去重）
|
var orderUpdates = deletedReturnDetails
|
.Where(detail => !string.IsNullOrEmpty(detail.OrderNo) && !string.IsNullOrEmpty(detail.OrderType))
|
.Select(detail => new { detail.OrderNo, detail.OrderType })
|
.Distinct()
|
.ToList();
|
|
foreach (var orderInfo in orderUpdates)
|
{
|
// 获取该订单的所有明细
|
var orderDetails = db.Queryable<MesSalesOrderDetail>()
|
.Where(it => it.OrderId == orderInfo.OrderNo && it.OrderType == orderInfo.OrderType)
|
.ToList();
|
|
if (!orderDetails.Any())
|
{
|
Console.WriteLine($"未找到销售订单明细 {orderInfo.OrderType}-{orderInfo.OrderNo}，跳过更新");
|
continue;
|
}
|
|
// 检查每个订单明细是否完成
|
bool allCompleted = true;
|
|
foreach (var orderDetail in orderDetails)
|
{
|
// 查找所有匹配的退货明细（包括其他未删除的退货通知单）
|
// 通过ORDER_TYPE, ORDER_ID, LINE_NUMBER, PRODUCT_CODE进行匹配
|
var matchingReturnDetails = db.Queryable<MesReturnwareDetails>()
|
.Where(detail => detail.OrderType == orderDetail.OrderType &&
|
detail.OrderNo == orderDetail.OrderId &&
|
detail.OrderNumber == orderDetail.OrderNumber &&
|
detail.ItemNo == orderDetail.ProductCode)
|
.ToList();
|
|
// 计算匹配的退货数量
|
var returnQuantity = matchingReturnDetails.Sum(x => (x.Quantity ?? 0) + (x.ActualQuantity ?? 0));
|
|
// 计算订单总数量：ORDER_QUANTITY + GIFT_QUANTITY + 销售退货通知单中的数量
|
var orderTotal = (orderDetail.OrderQuantity ?? 0) +
|
(orderDetail.GiftQuantity ?? 0) +
|
returnQuantity;
|
|
// 计算已交付总数量：DELIVERED_QUANTITY + DELIVERED_GIFT_QUANTITY + XTCH(销退出货数量)
|
var deliveredTotal = (orderDetail.DeliveredQuantity ?? 0) +
|
(orderDetail.DeliveredGiftQuantity ?? 0) +
|
(orderDetail.Xtch ?? 0);
|
|
// 如果订单总数量不等于已交付总数量，则该明细未完成
|
if (orderTotal != deliveredTotal)
|
{
|
allCompleted = false;
|
Console.WriteLine($"删除退货通知单后，订单明细 {orderDetail.ProductCode} 未完成: 订单总数量={orderTotal}, 已交付总数量={deliveredTotal} (订单:{orderDetail.OrderQuantity ?? 0} + 赠品:{orderDetail.GiftQuantity ?? 0} + 退货:{returnQuantity} = 已交付:{orderDetail.DeliveredQuantity ?? 0} + 已交付赠品:{orderDetail.DeliveredGiftQuantity ?? 0} + 销退出货:{orderDetail.Xtch ?? 0})");
|
break;
|
}
|
}
|
|
// 根据是否全部完成设置over值
|
decimal overValue = allCompleted ? 1 : 0;
|
|
// 更新MES_SALES_ORDER表的over字段
|
var updateCount = db.Updateable<MesSalesOrder>()
|
.SetColumns(it => it.Over == overValue)
|
.Where(it => it.OrderId == orderInfo.OrderNo && it.OrderType == orderInfo.OrderType)
|
.ExecuteCommand();
|
|
if (updateCount > 0)
|
{
|
Console.WriteLine($"删除退货通知单后，成功更新销售订单 {orderInfo.OrderType}-{orderInfo.OrderNo} 的over状态为{overValue} ({(allCompleted ? "已完成" : "未完成")})");
|
}
|
else
|
{
|
Console.WriteLine($"删除退货通知单后，未找到销售订单 {orderInfo.OrderType}-{orderInfo.OrderNo}，跳过更新");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
// 记录错误日志，但不影响退货通知单的删除
|
Console.WriteLine($"删除退货通知单后更新销售订单over状态时发生错误: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 调用存储过程删除检验单
|
/// </summary>
|
/// <param name="db">数据库连接</param>
|
/// <param name="returnType">退货单别</param>
|
/// <param name="returnNo">退货单号</param>
|
private void DeleteInspectionOrder(SqlSugarScope db, string returnType, string returnNo)
|
{
|
try
|
{
|
// 定义输入参数
|
var inputParam1 = new SugarParameter("P_RETURN_TYPE", returnType ?? "");
|
var inputParam2 = new SugarParameter("P_RETURN_NO", returnNo ?? "");
|
|
// 定义输出参数
|
var outParam1 = new SugarParameter("P_RESULT", null, true);
|
var outParam2 = new SugarParameter("P_MESSAGE", null, true);
|
|
// 使用 SqlSugar 执行存储过程
|
db.Ado.ExecuteCommand("BEGIN SP_DEL_RETURN_INSP(:P_RETURN_TYPE,:P_RETURN_NO,:P_RESULT,:P_MESSAGE); END;",
|
inputParam1, inputParam2, outParam1, outParam2);
|
|
// 获取输出参数的值
|
int result = int.Parse((string)outParam1.Value);
|
string message = outParam2.Value == DBNull.Value ? string.Empty : (string)outParam2.Value;
|
|
if (result != 1)
|
{
|
// 记录警告日志，但不影响退货通知单的删除
|
Console.WriteLine($"删除检验单警告: {message}");
|
}
|
else
|
{
|
Console.WriteLine($"删除检验单成功: {message}");
|
}
|
}
|
catch (Exception ex)
|
{
|
// 记录错误日志，但不影响退货通知单的删除
|
Console.WriteLine($"删除检验单时发生错误: {ex.Message}");
|
}
|
}
|
|
|
}
|
}
|
