using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Hh.Mes.Common.config;
using Hh.Mes.Common.log;
using Infrastructure;
using SqlSugar;
using WebRepository;
using WebRepository.DomainSugars;
using WebRepository.EnumEntitys;
using Hh.Mes.Service.Repository;
namespace Hh.Mes.Service.Material
{
public class NestingService : RepositorySqlSugar<inventory>
{
#region 属性
/// <summary>
/// 切割工单主表
/// </summary>
public List<cutter_head_work_order> OriginalCutterHeadWorkOrders { get; set; } = new List<cutter_head_work_order>();
/// <summary>
/// 切割工单子表
/// </summary>
public List<cutter_detail_work_order> OriginalCutterDetailWorkOrders { get; set; } = new List<cutter_detail_work_order>();
/// <summary>
/// 原材料 （原数据）
/// </summary>
public List<inventory> OriginalInventorys { get; set; } = new List<inventory>();
/// <summary>
/// 记录套料中明细工单 状态
/// </summary>
public List<cutter_detail_work_order> UpdateCutterDetails { get; set; } = new List<cutter_detail_work_order>();
/// <summary>
/// 记录配料单已套料的
/// </summary>
public List<api_material_demand_footer> MaterialDemandFooters { get; set; } = new List<api_material_demand_footer>();
/// <summary>
/// 记录使用中库存 修改库存状态
/// </summary>
public List<inventory> UpdateInventorys { get; set; } = new List<inventory>();
public List<Record> Records { get; set; } = new List<Record>();
/// <summary>
/// 记录使用的工单 用于数据筛选
/// </summary>
public List<int> CuttingDetailId { get; set; } = new List<int>();
public TotalModel TotalData { get; set; } = new TotalModel();
#endregion
#region PC页面
/// <summary>
/// 废料长度
/// </summary>
public dynamic CuttingWasteLength()
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
return GetDictionaryDictValue("废料长度", "CuttingWasteLength");
}, catchRetrunValue: "catchRetrunValue");
}
/// <summary>
/// 下料尺寸数据
/// </summary>
public dynamic GetInventorys()
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
OriginalInventorys = Context.Queryable<inventory>().Where(x => x.useState == (int)InventoryPlanStatus.初始 && x.status == InventoryStatus.良品).ToList();
if (OriginalInventorys.Count == 0) return ReturnTableData("原材料无", -1);
return ReturnTableData("", 0, OriginalInventorys, OriginalInventorys.Count);
}, catchRetrunValue: "catchRetrunValue");
}
/// <summary>
/// 导入下料数据
/// </summary>
public dynamic GetCutterInfo()
{
OriginalCutterDetailWorkOrders = Context.Queryable<cutter_detail_work_order>().Where(x => x.State == (int)EnumCutBodyStatus.发布).ToList();
if (OriginalCutterDetailWorkOrders.Count == 0) return ReturnTableData("切割工单明细查询无数据", -1);
return ReturnTableData("", 0, OriginalCutterDetailWorkOrders, OriginalCutterDetailWorkOrders.Count);
}
/// <summary>
/// 套料计算
/// </summary>
public dynamic NestingCalculation()
{
OriginalInventorys = Context.Queryable<inventory>().Where(x => x.useState == (int)InventoryPlanStatus.初始 && x.status == InventoryStatus.良品).ToList();
if (OriginalInventorys.Count == 0) return ReturnTableData("原材料库存查询无数据状态", -1);
OriginalCutterHeadWorkOrders = Context.Queryable<cutter_head_work_order>().Where(x => x.State == (int)EnumCutHeadStatus.发布 || x.State == (int)EnumCutHeadStatus.部分套料).ToList();
if (OriginalCutterHeadWorkOrders.Count == 0) return ReturnTableData("切割工单头查询无数据状态：【发布或者已套料】", -1);
OriginalCutterDetailWorkOrders = Context.Queryable<cutter_detail_work_order>().Where(x => x.State == (int)EnumCutBodyStatus.发布).ToList();
if (OriginalCutterDetailWorkOrders.Count == 0) return ReturnTableData("切割工单明细查询无数据状态：【发布或者已套料】", -1);
var DetailMaterialCode = OriginalCutterDetailWorkOrders.Select(x => x.MaterialCode).Distinct().ToList();
//如果工单中所有需要的物料，一个都不在库存中，那就提示报错返回
foreach (var item in DetailMaterialCode)
{
if (OriginalInventorys.Any(x => x.materialCode == item))
break;
if (item == DetailMaterialCode[DetailMaterialCode.Count - 1])
return ReturnTableData("没有切割工单所需的物料库存！", -1);
}
var inventories = new List<inventory>();
inventories.AddRange(OriginalInventorys);
var cutDetail = new List<cutter_detail_work_order>();
cutDetail.AddRange(OriginalCutterDetailWorkOrders);
var cuttingWasteLength = GetDictionaryDictValue("废料长度", "CuttingWasteLength");
#region 切割计算
decimal loss = 0;
//记录切割方案
List<SchemeOperation> schemes = new List<SchemeOperation>();
var CutterList = new List<List<cutter_detail_work_order>>();
#region 数据筛选 通过切割工单的图纸以及切割工单明细的页码 进行分组操作。 LineNo,ShopDesignDrawingNo
foreach (var order in OriginalCutterHeadWorkOrders.OrderBy(x => x.LineNo).ThenBy(x => x.ShopDesignDrawingNo))
{
//先添加 相同的切割工单
var cutters = cutDetail.Where(t => t.headKeys == order.keys).OrderBy(x => x.CuttingLength).ToList();
CutterList.Add(cutters);
var count = cutters.Count;
Records.Add(new Record() { Guid = order.keys, Count = count, EidtCount = count });
}
#endregion
#region 计算
foreach (var Cutters in CutterList.OrderByDescending(x => x.Sum(t => t.CuttingLength)))
{
bool isok = false;
//跳过 防止报错为null
if (Cutters.Count == 0) continue;
var LineCode = OriginalCutterHeadWorkOrders.FirstOrDefault(x => x.keys == Cutters.FirstOrDefault().headKeys).LineCode;
var inventorys = inventories.Where(x => x.materialCode == Cutters.FirstOrDefault().MaterialCode && x.lineCode == LineCode).OrderBy(x => x.pipeLength).ToList();
if (inventorys.Count == 0) continue;
#region 不需要切割 查找直接匹配管材
//套料过的切割工单明细
var WorkOrderList = new List<cutter_detail_work_order>();
foreach (var Cutter in Cutters)
{
//找出相同的 刚好匹配
var Equalinventory = inventorys.FirstOrDefault(x => x.pipeLength == Cutter.CuttingLength);
if (Equalinventory != null)
{
Equalinventory.pipeLength = 0;
Cutter.PipeSN = Equalinventory.pipeSN;
//添加套料计划头
var cut_plan_head = new cut_plan_head();
cut_plan_head.PipeLength = Convert.ToDecimal(Equalinventory.pipeLength);
cut_plan_head.OldSN = Equalinventory.oldSN ?? Equalinventory.pipeSN;
cut_plan_head.PipeSN = Equalinventory.pipeSN;
cut_plan_head.MaterialCode = Equalinventory.materialCode;
cut_plan_head.InventoryId = Equalinventory.id;
cut_plan_head.LineCode = Equalinventory.lineCode;
cut_plan_head.State = (int)CutPlanExcuteStatus.初始;
cut_plan_head.createBy = sysUser?.Account;
cut_plan_head.createTime = DateTime.Now;
var cutPlanDetail = AddCutPlanDetail(Cutter, 0, true);
var scheme = schemes.Where(x => x.CutPlanHead.InventoryId == Equalinventory.id).FirstOrDefault();
WorkOrderList.Add(Cutter);
//如果管材没有套料，就添加套料头和明细，否则就添加找到的套料的明细
if (scheme == null)
{
scheme = new SchemeOperation();
scheme.CutPlanHead = cut_plan_head;
scheme.CutPlanDetails.Add(cutPlanDetail);
schemes.Add(scheme);
}
else
{
scheme.CutPlanDetails.Add(cutPlanDetail);
}
}
}
foreach (var WorkOrder in WorkOrderList)
{
Cutters.Remove(WorkOrder);
}
#endregion
//统计次数
var CuttersCount = Cutters.Count;
if (CuttersCount == 0) continue;
#region 执行单管组合
if (CuttersCount != 1)
{
//从最短的管材进行配比
foreach (var inventory in inventorys)
{
//查询当前损耗
var material = Context.Queryable<material>().First(x => x.MaterialCode == inventory.materialCode);
loss = material == null ? 0 : (material.Loss == null ? 0 : Convert.ToDecimal(material.Loss));
//损耗合计
var CuttersSum = Cutters.Sum(x => x.CuttingLength) + loss * CuttersCount;
if (inventory.pipeLength >= CuttersSum)
{
//切割方案实体
SchemeOperation scheme = new SchemeOperation();
//添加计算过的切割下料尺寸数据
scheme.CutPlanHead = new cut_plan_head() { PipeLength = Convert.ToDecimal(inventory.pipeLength), OldSN = inventory.oldSN ?? inventory.pipeSN, PipeSN = inventory.pipeSN, MaterialCode = inventory.materialCode, InventoryId = inventory.id, LineCode = inventory.lineCode, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
inventory.pipeLength -= CuttersSum;
Cutters.ForEach(t => { t.PipeSN = inventory.pipeSN; });
if (schemes.Any(x => x.CutPlanHead.InventoryId == inventory.id))
{
schemes.Where(x => x.CutPlanHead.InventoryId == inventory.id).FirstOrDefault().CutPlanDetails.AddRange(AddCutPlanDetail(Cutters, loss));
}
else
{
scheme.CutPlanDetails = AddCutPlanDetail(Cutters, loss);
schemes.Add(scheme);
}
isok = true;
break;
}
}
}
#endregion
//false 组合没有执行成功
if (isok) continue;
//单管找出最短的进行配比
inventorys.ForEach(t =>
{
//切割方案实体
SchemeOperation scheme = new SchemeOperation();
var material = Context.Queryable<material>().First(x => x.MaterialCode == t.materialCode);
loss = material == null ? 0 : (material.Loss == null ? 0 : Convert.ToDecimal(material.Loss));
//切割方案 取原材料数据
scheme.CutPlanHead = new cut_plan_head() { PipeLength = Convert.ToDecimal(t.pipeLength), OldSN = t.oldSN ?? t.pipeSN, PipeSN = t.pipeSN, MaterialCode = t.materialCode, InventoryId = t.id, LineCode = t.lineCode, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
for (int i = 0; i < CuttersCount; i++)
{
//没有下料切割数据那么就不用执行了
if (Cutters.Count == 0)
{
//跳出for循环
break;
}
//当前下料尺寸 拿最短的
var Cutter = Cutters.First();
//当前物料长度够 就进行切割方案添加 当不够那么后面的数据也将不会进入。 需要更换一个物料进行分配
if ((t.pipeLength - loss) >= Cutter.CuttingLength)
{
Cutter.PipeSN = t.pipeSN;
t.pipeLength -= Cutter.CuttingLength + loss;
if (schemes.Exists(x => x.CutPlanHead.InventoryId == t.id))
{
schemes.First(x => x.CutPlanHead.InventoryId == t.id).CutPlanDetails.Add(AddCutPlanDetail(Cutter, loss));
}
else
{
scheme.CutPlanDetails.Add(AddCutPlanDetail(Cutter, loss));
}
//删除 计算后面下料数据
Cutters.Remove(Cutter);
}
else
{
//当前物料长度 不够 就换一个
break;
}
}
if (scheme.CutPlanDetails.Count > 0)
{
schemes.Add(scheme);
}
});
}
#endregion
foreach (var scheme in schemes)
{
scheme.CutPlanHead.LossCount = scheme.CutPlanDetails.Sum(x => x.Loss);
var SumProducts = scheme.CutPlanDetails.Sum(x => x.Loss + x.CuttingLength);
double Percentage = Convert.ToDouble(SumProducts) / Convert.ToDouble(scheme.CutPlanHead.PipeLength);
scheme.Percentage = Percentage.ToString("0.00%");
foreach (var CutPlanDetail in scheme.CutPlanDetails)
{
//进行删除 切割方案当中的下料数据
cutDetail.RemoveAll(x => x.id == CutPlanDetail.CuttingDetailId);
}
#region 余料计算
foreach (var t in inventories.Where(x => x.id == scheme.CutPlanHead.InventoryId))
{
if (t.pipeLength < Convert.ToDecimal(cuttingWasteLength))
{
t.pipeSN = "废料";
}
else
{
if (t.pipeSN.Contains("-YL"))
{
var inedx = t.pipeSN.IndexOf("-YL");
var onepieceName = t.pipeSN.Substring(0, inedx);
var YLNo = t.pipeSN.Substring(t.pipeSN.Length - 2, 2);
if (YLNo.Contains("0"))
{
int Nos = Convert.ToInt32(YLNo) + 1;
t.pipeSN = onepieceName + $"-YL-0{Nos}";
}
else
{
int Nos = Convert.ToInt32(YLNo) + 1;
t.pipeSN = onepieceName + $"-YL-{Nos}";
}
}
else
{
t.oldSN = t.pipeSN;
t.pipeSN += "-YL-01";
}
}
scheme.CutPlanHead.OddmentsLength = Convert.ToDecimal(t.pipeLength);
scheme.CutPlanHead.OddmentsCode = t.pipeSN;
#region 更新当前使用的库存状态
t.useState = (int)InventoryPlanStatus.已经套料;
t.updateTime = DateTime.Now;
t.updateBy = sysUser?.Account;
UpdateInventorys.Add(t);
#endregion
}
#endregion
}
//切割方案
TotalData.SchemeOperations = schemes;
//余材料
TotalData.Inventories = inventories.OrderBy(x => x.pipeLength).ToList();
//未切割工单
TotalData.CutterDetailWorkOrders = cutDetail;
#endregion
return ReturnTableData("计算成功！", 0, new { Middle = TotalData.SchemeOperations, RightUp = TotalData.Inventories, RightDown = TotalData.CutterDetailWorkOrders });
}
/// <summary>
/// 保存套料信息
/// </summary>
public dynamic SaveNestingProgramme()
{
Init();
var result = NestingCalculation();
if (result.code != 0) return result;
if (TotalData.SchemeOperations.Count == 0)
return ReturnTableData("切割方案数据为空", -1);
if (Context.Queryable<cut_plan_detail>().Any(x => x.CuttingDetailId == CuttingDetailId.FirstOrDefault()))
return ReturnTableData("已添加", -1);
#region 修改工单信息
var UpdateCutterHead = new List<cutter_head_work_order>();
foreach (var Record in Records)
{
if (Record.EidtCount == Record.Count) continue;
var cutter = OriginalCutterHeadWorkOrders.Where(x => x.keys == Record.Guid).FirstOrDefault();
if (Record.Count > Record.EidtCount && Record.EidtCount > 0) cutter.State = (int)EnumCutHeadStatus.部分套料;
else if (Record.EidtCount == 0) cutter.State = (int)EnumCutHeadStatus.已套料;
cutter.updateBy = sysUser?.Account;
cutter.updateTime = DateTime.Now;
UpdateCutterHead.Add(cutter);
}
#endregion
#region 记录到之前余料数据当中
var AddCutPlanDetail = new List<cut_plan_detail>();
var AddCutPlanHead = new List<cut_plan_head>();
foreach (var SchemeOperations in TotalData.SchemeOperations)
{
var guid = Guid.NewGuid();
SchemeOperations.CutPlanHead.Keys = guid;
SchemeOperations.CutPlanHead.createBy = sysUser?.Account;
SchemeOperations.CutPlanHead.createTime = DateTime.Now;
AddCutPlanHead.Add(SchemeOperations.CutPlanHead);
SchemeOperations.CutPlanDetails.ForEach(t => { t.HeadKeys = guid; t.createBy = sysUser?.Account; t.createTime = DateTime.Now; });
AddCutPlanDetail.AddRange(SchemeOperations.CutPlanDetails);
}
#endregion
var saveResults = UpdateCuttingPlan(UpdateInventorys, UpdateCutterHead, UpdateCutterDetails, AddCutPlanHead, AddCutPlanDetail);
if (saveResults.code != 0) return ReturnTableData($"保存失败，原因：{saveResults.msg}", -1);
return ReturnTableData("保存成功", 0);
}
/// <summary>
/// 套料保存
/// </summary>
/// <param name="updateInventory">修改库存状态</param>
/// <param name="cutterHeadWorkOrder">修改切割工单主状态</param>
/// <param name="cutterDetailWorkOrder">修改切割工单子状态</param>
/// <param name="addcutPlans">添加方案主</param>
/// <param name="addcutdetail">添加方案子</param>
/// <returns></returns>
public TableData UpdateCuttingPlan(List<inventory> updateInventory, List<cutter_head_work_order> cutterHeadWorkOrder, List<cutter_detail_work_order> cutterDetailWorkOrder, List<cut_plan_head> addcutPlans, List<cut_plan_detail> addcutdetail)
{
Context.Ado.BeginTran();
var result = new TableData { code = 0, data = null, count = 0, msg = "" };
if (Context.Updateable(updateInventory).UpdateColumns(t => new { t.useState, t.updateBy, t.updateTime }).ExecuteCommand() <= 0) result.msg += "更新库存数据失败";
if (Context.Updateable(cutterHeadWorkOrder).UpdateColumns(t => new { t.State, t.updateBy, t.updateTime }).ExecuteCommand() <= 0) result.msg += "更新切割头表数据失败";
if (Context.Updateable(cutterDetailWorkOrder).UpdateColumns(t => new { t.State, t.updateBy, t.updateTime }).ExecuteCommand() <= 0) result.msg += "更新切割明细数据失败";
if (Context.Insertable(addcutPlans).ExecuteCommand() <= 0) result.msg += "新增套料方案头表数据失败";
if (Context.Insertable(addcutdetail).ExecuteCommand() <= 0) result.msg += "新增套料方案明细数据失败";
if (result.msg != "")
{
Context.Ado.RollbackTran();
result.code = -1;
}
Context.Ado.CommitTran();
return result;
}
/// <summary>
/// 切割明细 下料切割工单
/// </summary>
/// <param name="cutter"></param>
/// <param name="Loss"></param>
/// <returns></returns>
public cut_plan_detail AddCutPlanDetail(cutter_detail_work_order cutter, decimal Loss = 0, bool Notcutting = false)
{
#region 切割工单状态修改
cutter.State = (int)EnumCutHeadStatus.已套料;
cutter.updateBy = sysUser?.Account;
cutter.updateTime = DateTime.Now;
UpdateCutterDetails.Add(cutter);
CuttingDetailId.Add(cutter.id);
Records.FirstOrDefault(x => x.Guid == cutter.headKeys).EidtCount--;
#endregion
cut_plan_detail cutPlanDetail = new cut_plan_detail();
cutPlanDetail.PipeSN = cutter.PipeSN;
cutPlanDetail.BarCode = cutter.BarCode;
cutPlanDetail.CuttingLength = cutter.CuttingLength;
cutPlanDetail.Loss = Loss;
cutPlanDetail.CuttingDetailId = cutter.id;
cutPlanDetail.CuttingHeadId = cutter.headKeys;
cutPlanDetail.State = Notcutting ? (int)CutPlanExcuteStatus.无需切割 : (int)CutPlanExcuteStatus.初始;
cutPlanDetail.createBy = sysUser?.Account;
cutPlanDetail.createTime = DateTime.Now;
return cutPlanDetail;
}
/// <summary>
/// 切割明细 切割工单
/// </summary>
/// <param name="cutters"></param>
/// <param name="Loss"></param>
/// <returns></returns>
public List<cut_plan_detail> AddCutPlanDetail(List<cutter_detail_work_order> cutters, decimal Loss = 0)
{
List<cut_plan_detail> list = new List<cut_plan_detail>();
foreach (var cutter in cutters)
{
CuttingDetailId.Add(cutter.id);
Records.FirstOrDefault(x => x.Guid == cutter.headKeys).EidtCount--;
var cutt = new cut_plan_detail() { PipeSN = cutter.PipeSN, BarCode = cutter.BarCode, CuttingLength = Convert.ToInt32(cutter.CuttingLength), Loss = Loss, CuttingDetailId = cutter.id, CuttingHeadId = cutter.headKeys, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
list.Add(cutt);
cutter.updateBy = sysUser?.Account;
cutter.updateTime = DateTime.Now;
cutter.State = (int)EnumCutHeadStatus.已套料;
UpdateCutterDetails.Add(cutter);
}
return list;
}
/// <summary>
/// 导出方法
/// </summary>
/// <returns></returns>
public dynamic Export()
{
return ExceptionsHelp.Instance.ExecuteT(() =>
{
var result = new TableData();
var nestingCalculation = NestingCalculation();
List<dynamic> heads = new List<dynamic>();
List<dynamic> details = new List<dynamic>();
if (nestingCalculation.code > -1)
{
foreach (var item in nestingCalculation.data.Middle)
{
item.CutPlanHead.Percentage = item.Percentage;
heads.Add(item.CutPlanHead);
foreach (var items in item.CutPlanDetails)
{
details.Add(items);
}
}
}
result.data = new
{
LeftUp = GetInventorys().data,
LeftDown = GetCutterInfo().data,
Middle = nestingCalculation.code > -1 ? heads : null,
MiddleDesc = nestingCalculation.code > -1 ? details : null,
RightUp = nestingCalculation.code > -1 ? nestingCalculation.data.RightUp : null,
RightDown = nestingCalculation.code > -1 ? nestingCalculation.data.RightDown : null
};
return result;
}, catchRetrunValue: "actionList");
}
/// <summary>
/// 返回信息
/// </summary>
public TableData ReturnTableData(string msg = "", int? code = 0, dynamic data = null, int count = 0)
{
return new TableData()
{
code = Convert.ToInt32(code == null ? 0 : code),
msg = msg,
data = data,
count = count
};
}
#endregion
#region 执行已呼叫的单管进行套料
/// <summary>
/// 套料计算
/// item1=true 套料停止往下执行 ,如果为true 还要继续往下走 mes 加-$ 【面向过程遗留问题】
/// </summary>
public Tuple<bool, string> CalledNestingCalculation(List<Guid> bodyKeys)
{
#region 查询 工单物料需求表
List<api_material_demand_footer> demandFooters;
if (bodyKeys == null)
{
//执行已呼叫单管操作
var huJiao = (int)MaterialDemandFooterState.已呼叫;
demandFooters = base.Context.Queryable<api_material_demand_footer>()
.Where(t => t.Unit.ToUpper() == "MM" && t.State == huJiao).ToList();
}
else
{
//执行选中的叫料数据套料
var paiChan = (int)MaterialDemandFooterState.已排产;
demandFooters = base.Context.Queryable<api_material_demand_footer>()
.Where(t => t.Unit.ToUpper() == "MM" && t.State == paiChan && bodyKeys.Contains(t.bodyKeys)).ToList();
}
if (demandFooters.Count == 0)
{
Log4NetHelper.Instance.Error("CalledNestingCalculation:工单物料需求查询无数据!");
return new Tuple<bool, string>(true, "工单物料需求查询无数据!");
}
MaterialDemandFooters.AddRange(demandFooters);
#endregion
#region 查找切割工单
//查找工单有问题，既然用了bodyKeys，就应该按照body对应的单管号来赛选工单，如果用IWPNo来筛选范围一下扩大了，超出了bodyKeys的范围
var iWPNos = demandFooters.Select(x => x.IWPNo).ToList();
OriginalCutterHeadWorkOrders = Context.Queryable<cutter_head_work_order>().Where(x => x.State == (int)EnumCutHeadStatus.发布 ||
x.State == (int)EnumCutHeadStatus.部分套料 && iWPNos.Contains(x.IWPNo)).ToList();
if (OriginalCutterHeadWorkOrders.Count == 0)
{
Log4NetHelper.Instance.Error("CalledNestingCalculation：切割工单头信息查询无数据");
return new Tuple<bool, string>(true, "未查询到切割工单头状态【发布】的数据");
}
var cutterHeadKeys = OriginalCutterHeadWorkOrders.Select(x => x.keys).ToList();
OriginalCutterDetailWorkOrders = Context.Queryable<cutter_detail_work_order>().Where(t => t.State == (int)EnumCutBodyStatus.发布 && cutterHeadKeys.Contains(t.headKeys)).ToList();
OriginalCutterDetailWorkOrders = OriginalCutterDetailWorkOrders.Where(t => demandFooters.Exists(x => x.SpoolNo == t.SpoolNo && x.PartCode == t.PartCode &&
x.ProjectCode == t.ProjectCode)).ToList();
if (OriginalCutterDetailWorkOrders.Count == 0)
{
Log4NetHelper.Instance.Error("CalledNestingCalculation:下料尺寸数据无");
return new Tuple<bool, string>(true, "下料尺寸数据(切割工单明细）信息查询无数据");
}
#endregion
var detailMaterialCode = OriginalCutterDetailWorkOrders.Select(x => x.MaterialCode).Distinct().ToList();
var isCallWms = false;
//如果工单中所有的物料，一个都不在库存中，那就提示报错返回
foreach (var item in detailMaterialCode)
{
if (OriginalInventorys.Any(x => x.materialCode == item))
{
isCallWms = true;
break;
}
//if (detailMaterialCode.IndexOf(item) + 1 == detailMaterialCode.Count)
//{
// Log4NetHelper.Instance.Error("没有切割工单所需的物料库存");
// return new Tuple<bool, string>(true, "没有切割工单所需的物料库存");
//}
}
//仓库没有切割工单的物料 需要叫料仓储Wms 程序继续往下走 lsw
if (!isCallWms)
{
Log4NetHelper.Instance.Error("没有切割工单所需的物料库存");
return new Tuple<bool, string>(true, "没有切割工单所需的物料库存-$");
}
var inventories = new List<inventory>();
OriginalInventorys.ForEach(i => inventories.Add(i));
var cutDetail = new List<cutter_detail_work_order>();
OriginalCutterDetailWorkOrders.ForEach(i => cutDetail.Add(i));
var cuttingWasteLength = GetDictionaryDictValue("废料长度", "CuttingWasteLength");
#region 切割计算
decimal loss = 0;
//记录切割方案
var schemes = new List<SchemeOperation>();
var CutterList = new List<List<cutter_detail_work_order>>();
#region 数据筛选 通过切割工单的图纸以及切割工单明细的页码 进行分组操作。 LineNo,ShopDesignDrawingNo
foreach (var order in OriginalCutterHeadWorkOrders.OrderBy(x => x.LineNo).ThenBy(x => x.ShopDesignDrawingNo))
{
//先添加 相同的切割工单
var cutters = cutDetail.Where(t => t.headKeys == order.keys).OrderBy(x => x.CuttingLength).ToList();
CutterList.Add(cutters);
var count = cutters.Count;
Records.Add(new Record() { Guid = order.keys, Count = count, EidtCount = count });
}
#endregion
#region 计算
foreach (var Cutters in CutterList.OrderByDescending(x => x.Sum(t => t.CuttingLength)))
{
bool isok = false;
//跳过 防止报错为null
if (Cutters.Count == 0) continue;
var LineCode = OriginalCutterHeadWorkOrders.FirstOrDefault(x => x.keys == Cutters.FirstOrDefault().headKeys).LineCode;
var materialCodes = Cutters.Select(t => t.MaterialCode).ToList();
var inventorys = inventories.Where(x => materialCodes.Contains(x.materialCode) && x.lineCode == LineCode).OrderBy(x => x.pipeLength).ToList();
if (inventorys.Count == 0) continue;
#region 不需要切割 查找直接匹配管材
var WorkOrderList = new List<cutter_detail_work_order>();
foreach (var Cutter in Cutters)
{
//找出相同的 刚好匹配
var Equalinventory = inventorys.FirstOrDefault(x => x.pipeLength == Cutter.CuttingLength);
if (Equalinventory != null)
{
SchemeOperation scheme = new SchemeOperation();
scheme.CutPlanHead = new cut_plan_head() { PipeLength = Convert.ToDecimal(Equalinventory.pipeLength), OldSN = Equalinventory.oldSN ?? Equalinventory.pipeSN, PipeSN = Equalinventory.pipeSN, MaterialCode = Equalinventory.materialCode, InventoryId = Equalinventory.id, LineCode = Equalinventory.lineCode, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
Equalinventory.pipeLength = 0;
Cutter.PipeSN = Equalinventory.pipeSN;
if (schemes.Any(x => x.CutPlanHead.InventoryId == Equalinventory.id))
{
schemes.FirstOrDefault(x => x.CutPlanHead.InventoryId == Equalinventory.id).CutPlanDetails.Add(AddCutPlanDetail(Cutter, 0, true));
WorkOrderList.Add(Cutter);
}
else
{
scheme.CutPlanDetails.Add(AddCutPlanDetail(Cutter, 0, true));
schemes.Add(scheme);
WorkOrderList.Add(Cutter);
}
}
}
foreach (var WorkOrder in WorkOrderList)
{
Cutters.Remove(WorkOrder);
}
#endregion
//统计次数
var CuttersCount = Cutters.Count;
if (CuttersCount == 0) continue;
#region 执行单管组合
if (CuttersCount != 1)
{
//从最短的管材进行配比
foreach (var inventory in inventorys)
{
//查询当前损耗
var material = Context.Queryable<material>().First(x => x.MaterialCode == inventory.materialCode);
loss = material == null ? 0 : (material.Loss == null ? 0 : Convert.ToDecimal(material.Loss));
//损耗合计
var CuttersSum = Cutters.Sum(x => x.CuttingLength) + loss * CuttersCount;
if (inventory.pipeLength >= CuttersSum)
{
//切割方案实体
SchemeOperation scheme = new SchemeOperation();
//添加计算过的切割下料尺寸数据
scheme.CutPlanHead = new cut_plan_head() { PipeLength = Convert.ToDecimal(inventory.pipeLength), OldSN = inventory.oldSN ?? inventory.pipeSN, PipeSN = inventory.pipeSN, MaterialCode = inventory.materialCode, InventoryId = inventory.id, LineCode = inventory.lineCode, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
inventory.pipeLength -= CuttersSum;
Cutters.ForEach(t => { t.PipeSN = inventory.pipeSN; });
if (schemes.Any(x => x.CutPlanHead.InventoryId == inventory.id))
{
schemes.Where(x => x.CutPlanHead.InventoryId == inventory.id).FirstOrDefault().CutPlanDetails.AddRange(AddCutPlanDetail(Cutters, loss));
}
else
{
scheme.CutPlanDetails = AddCutPlanDetail(Cutters, loss);
schemes.Add(scheme);
}
isok = true;
break;
}
}
}
#endregion
//false 组合没有执行成功
if (isok) continue;
//单管找出最短的进行配比
inventorys.ForEach(t =>
{
//切割方案实体
SchemeOperation scheme = new SchemeOperation();
var material = Context.Queryable<material>().First(x => x.MaterialCode == t.materialCode);
loss = material == null ? 0 : (material.Loss == null ? 0 : Convert.ToDecimal(material.Loss));
//切割方案 取原材料数据
scheme.CutPlanHead = new cut_plan_head() { PipeLength = Convert.ToDecimal(t.pipeLength), OldSN = t.oldSN ?? t.pipeSN, PipeSN = t.pipeSN, MaterialCode = t.materialCode, InventoryId = t.id, LineCode = t.lineCode, State = (int)CutPlanExcuteStatus.初始, createBy = sysUser?.Account, createTime = DateTime.Now };
for (int i = 0; i < CuttersCount; i++)
{
//没有下料切割数据那么就不用执行了
if (Cutters.Count == 0)
{
//跳出for循环
break;
}
//当前下料尺寸 拿最短的
var Cutter = Cutters.First();
//当前物料长度够 就进行切割方案添加 当不够那么后面的数据也将不会进入。 需要更换一个物料进行分配
if ((t.pipeLength - loss) >= Cutter.CuttingLength)
{
Cutter.PipeSN = t.pipeSN;
t.pipeLength -= Cutter.CuttingLength + loss;
if (schemes.Exists(x => x.CutPlanHead.InventoryId == t.id))
{
schemes.First(x => x.CutPlanHead.InventoryId == t.id).CutPlanDetails.Add(AddCutPlanDetail(Cutter, loss));
}
else
{
scheme.CutPlanDetails.Add(AddCutPlanDetail(Cutter, loss));
}
//删除 计算后面下料数据
Cutters.Remove(Cutter);
}
else
{
//当前物料长度 不够 就换一个
break;
}
}
if (scheme.CutPlanDetails.Count > 0)
{
schemes.Add(scheme);
}
});
}
#endregion
foreach (var scheme in schemes)
{
scheme.CutPlanHead.LossCount = scheme.CutPlanDetails.Sum(x => x.Loss);
var SumProducts = scheme.CutPlanDetails.Sum(x => x.Loss + x.CuttingLength);
double Percentage = Convert.ToDouble(SumProducts) / Convert.ToDouble(scheme.CutPlanHead.PipeLength);
scheme.Percentage = Percentage.ToString("0.00%");
foreach (var CutPlanDetail in scheme.CutPlanDetails)
{
//进行删除 切割方案当中的下料数据
cutDetail.RemoveAll(x => x.id == CutPlanDetail.CuttingDetailId);
}
#region 余料计算
foreach (var t in inventories.Where(x => x.id == scheme.CutPlanHead.InventoryId))
{
if (t.pipeLength < Convert.ToDecimal(cuttingWasteLength))
{
t.pipeSN = "废料";
}
else
{
if (t.pipeSN.Contains("-YL"))
{
var inedx = t.pipeSN.IndexOf("-YL");
var onepieceName = t.pipeSN.Substring(0, inedx);
var YLNo = t.pipeSN.Substring(t.pipeSN.Length - 2, 2);
if (YLNo.Contains("0"))
{
int Nos = Convert.ToInt32(YLNo) + 1;
t.pipeSN = onepieceName + $"-YL-0{Nos}";
}
else
{
int Nos = Convert.ToInt32(YLNo) + 1;
t.pipeSN = onepieceName + $"-YL-{Nos}";
}
}
else
{
t.oldSN = t.pipeSN;
t.pipeSN += "-YL-01";
}
}
scheme.CutPlanHead.OddmentsLength = Convert.ToDecimal(t.pipeLength);
scheme.CutPlanHead.OddmentsCode = t.pipeSN;
#region 更新当前使用的库存状态
t.useState = (int)InventoryPlanStatus.已经套料;
t.updateTime = DateTime.Now;
t.updateBy = sysUser?.Account;
UpdateInventorys.Add(t);
#endregion
}
#endregion
}
//切割方案
TotalData.SchemeOperations = schemes;
//余材料
TotalData.Inventories = inventories.OrderBy(x => x.pipeLength).ToList();
//未切割工单
TotalData.CutterDetailWorkOrders = cutDetail;
#endregion
return new Tuple<bool, string>(false, "");
}
/// <summary>
/// 执行已呼叫的切割工单
/// </summary>
public Tuple<bool, string> ExecuteCalledCuttingWorkOrder(List<Guid> bodyKeys)
{
Init();
#region 库存信息查询
OriginalInventorys = Context.Queryable<inventory>().Where(x => x.useState == (int)InventoryPlanStatus.初始 && x.status == InventoryStatus.良品).ToList();
if (OriginalInventorys.Count == 0)
{
Log4NetHelper.Instance.Error("CalledNestingCalculation:库存信息需求查询无数据!");
return new Tuple<bool, string>(false, "库存信息需求查询无数据!");
}
#endregion
var result = CalledNestingCalculation(bodyKeys);
if (result.Item1) return result;
if (TotalData.SchemeOperations.Count == 0)
{
Log4NetHelper.Instance.Error("切割方案数据为空");
return new Tuple<bool, string>(true, "切割方案数据为空");
}
foreach (var item in CuttingDetailId)
{
if (Context.Queryable<cut_plan_detail>().Any(it => it.CuttingDetailId == item))
{
Log4NetHelper.Instance.Error("套料方案数据已经存在切割明细工单套料数据:" + item);
return new Tuple<bool, string>(true, "套料方案数据已经存在切割明细工单套料数据" + item);
}
}
#region 修改工单信息
var UpdateCutterHead = new List<cutter_head_work_order>();
foreach (var Record in Records)
{
if (Record.EidtCount == Record.Count) continue;
var cutter = OriginalCutterHeadWorkOrders.FirstOrDefault(x => x.keys == Record.Guid);
if (Record.Count > Record.EidtCount && Record.EidtCount > 0) cutter.State = (int)EnumCutHeadStatus.部分套料;
else if (Record.EidtCount == 0) cutter.State = (int)EnumCutHeadStatus.已套料;
cutter.updateBy = sysUser?.Account;
cutter.updateTime = DateTime.Now;
UpdateCutterHead.Add(cutter);
}
#endregion
#region 记录到之前余料数据当中
var AddCutPlanDetail = new List<cut_plan_detail>();
var AddCutPlanHead = new List<cut_plan_head>();
foreach (var SchemeOperations in TotalData.SchemeOperations)
{
var guid = Guid.NewGuid();
SchemeOperations.CutPlanHead.Keys = guid;
SchemeOperations.CutPlanHead.createBy = sysUser?.Account;
SchemeOperations.CutPlanHead.createTime = DateTime.Now;
AddCutPlanHead.Add(SchemeOperations.CutPlanHead);
SchemeOperations.CutPlanDetails.ForEach(t => { t.HeadKeys = guid; t.createBy = sysUser?.Account; t.createTime = DateTime.Now; });
AddCutPlanDetail.AddRange(SchemeOperations.CutPlanDetails);
}
#endregion
#region 修改配料单明细状态改为已套料
var demand_Footers = MaterialDemandFooters.Where(x => UpdateCutterDetails.Exists(t => t.SpoolNo == x.SpoolNo && t.PartCode == x.PartCode));
//demand_Footers.ForEach(t => t.State = (int)MaterialDemandFooterState.已套料);
var demandfooters = demand_Footers.Where(t => t.State == (int)MaterialDemandFooterState.已套料).ToList();
#endregion
var resultSave = UpdateCalledCuttingPlan(UpdateInventorys, UpdateCutterHead, UpdateCutterDetails, AddCutPlanHead, AddCutPlanDetail, demandfooters);
return resultSave;
}
/// <summary>
/// 套料保存
/// </summary>
/// <param name="updateInventory">修改库存状态</param>
/// <param name="cutterHeadWorkOrder">修改切割工单主状态</param>
/// <param name="cutterDetailWorkOrder">修改切割工单子状态</param>
/// <param name="addcutPlans">添加方案主</param>
/// <param name="addcutdetail">添加方案子</param>
/// <param name="demand_Footers"></param>
/// <returns></returns>
public Tuple<bool, string> UpdateCalledCuttingPlan(List<inventory> updateInventory, List<cutter_head_work_order> cutterHeadWorkOrder,
List<cutter_detail_work_order> cutterDetailWorkOrder, List<cut_plan_head> addcutPlans,
List<cut_plan_detail> addcutdetail, List<api_material_demand_footer> demand_Footers)
{
//更新库存数据失败
Context.Updateable(updateInventory).UpdateColumns(t => new { t.useState, t.updateBy, t.updateTime }).AddQueue();
//更新切割头表数据失败
Context.Updateable(cutterHeadWorkOrder).UpdateColumns(t => new { t.State, t.updateBy, t.updateTime }).AddQueue();
//更新切割明细数据失败
Context.Updateable(cutterDetailWorkOrder).UpdateColumns(t => new { t.State, t.updateBy, t.updateTime }).AddQueue();
//新增套料方案头表数据失败
Context.Insertable(addcutPlans).AddQueue();
//新增套料方案明细数据失败
Context.Insertable(addcutdetail).AddQueue();
//修改配料单明显状态失败
Context.Updateable(demand_Footers).AddQueue();
Context.SaveQueues();
return new Tuple<bool, string>(false, "套料保存");
}
#endregion
public void Init()
{
OriginalCutterHeadWorkOrders.Clear();
OriginalCutterDetailWorkOrders.Clear();
OriginalInventorys.Clear();
UpdateCutterDetails.Clear();
UpdateInventorys.Clear();
Records.Clear();
CuttingDetailId.Clear();
MaterialDemandFooters.Clear();
}
}
}