using iWareSql;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using iWareSql.DBModel;
|
using XiGang.Core.Model;
|
using iWareSql.DataAccess;
|
using iWareCommon.Common.Globle;
|
using System.Threading;
|
using iWareCommon.Utils;
|
using iWareModel;
|
using iWareCC.Common.Helper;
|
|
namespace iWareCC
|
{
|
/// <summary>
|
/// 出库计划任务分解线程
|
/// </summary>
|
public class OutPlanTaskDecompose
|
{
|
/// <summary>
|
/// 处理【下发中】的出库计划任务
|
/// </summary>
|
public static void HandlerIssuingTask()
|
{
|
var errMsg = "";
|
bool result;
|
while (true)
|
{
|
Thread.Sleep(2000);//休眠2秒
|
try
|
{
|
if (SystemValue.isAllowRuning_HandlerIssuingTask && SystemValue.isStartedModel)
|
{
|
//查询状态=下发中的出库计划
|
var queryState1 = (int)OutPlanStateEnum.下发中;
|
var queryState2 = (int)OutPlanStateEnum.部分下发;
|
List<Plan_OutTask> planList = null;
|
var isAllowDecomposePlanTask = false;
|
using (DbModel context = new DbModel())
|
{
|
planList = context.Plan_OutTask.Where(x => x.PlanState == queryState1 || x.PlanState == queryState2).ToList();
|
if (planList != null && planList.Count > 0)
|
{
|
//屏蔽，这样每次只处理3个，会导致赵通他们板链线ecu刷数据 【EditBy shaocx,2022-08-12】
|
/*
|
//首先验证下是否允许下发
|
isAllowDecomposePlanTask = IsAllowDecomposePlanTask(context, ref errMsg);
|
if (isAllowDecomposePlanTask == false)
|
{
|
SystemWarningMsg._lbl_Alert_HandlerIssuingTask = errMsg;
|
continue;//继续下一个循环
|
}
|
//*/
|
}
|
}
|
if (planList != null && planList.Count > 0)
|
{
|
foreach (var item in planList)
|
{
|
errMsg = "";//重置
|
using (DbModel mycontext = new DbModel())
|
{
|
//建议：一次只执行一个出库计划,只要有一个计划成功创建了任务，该循环就跳出，目的是解决出库计划时若下发5个任务中，若其中4号任务不齐套，在5号及以后出库时4号任务刚好齐套，则将4号任务作为最高优先级插队进行出库 【EditBy shaocx,2022-08-10】
|
result = SingleOutPlanTaskHandler(mycontext, item, ref errMsg);
|
|
Log4NetHelper.WriteInfoLog(LogType.OutPlanTask, "处理【下发中】的出库计划任务=>" + errMsg);
|
SystemWarningMsg._lbl_Alert_HandlerIssuingTask = errMsg + "[处理任务" + item.PlanNo + "]";
|
if (result == true)
|
{
|
break;//跳出循环，直接执行循环的下一个过程 【EditBy shaocx,2022-08-10】
|
}
|
}
|
}
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
SystemWarningMsg._lbl_Alert_HandlerIssuingTask = "出现异常:" + ex.Message;
|
Log4NetHelper.WriteErrorLog(LogType.CCWCFService, "HandlerIssuingTask出现异常：" + ex.Message, ex);
|
}
|
}
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="context"></param>
|
/// <param name="outTask"></param>
|
/// <param name="errMsg"></param>
|
/// <returns>true:表示已经找到库存，并创建好了任务，false：表示没有找到库存</returns>
|
private static bool SingleOutPlanTaskHandler(DbModel context, Plan_OutTask outTask, ref string errMsg)
|
{
|
bool fun_Result = false;
|
//注意：这里必须重新获取下对象，因为前面的方法中DbModel是不一样的,不是一个上下文，修改不了数据 【EditBy shaocx,2022-07-28】
|
Plan_OutTask new_outTask = context.Plan_OutTask.Where(x => x.Id == outTask.Id).First();
|
errMsg = "";
|
var queryState1 = (int)OutTaskDetailStateEnum.等待中;
|
var queryState2 = (int)OutTaskDetailStateEnum.缺料;
|
var detaiList = context.Plan_OutTaskDetail.Where(x =>
|
(x.OutTaskDetailState == queryState1 || x.OutTaskDetailState == queryState2)
|
&& x.M_PlanId == new_outTask.Id)
|
.OrderBy(x => x.CreateTime)//按照创建时间升序 【EditBy shaocx,2022-08-10】
|
.ThenBy(x => x.PlanSequence)//其次按照顺序升序，主要是给 按照按订货号出库的出库顺序来的 【EditBy shaocx,2024-01-31】
|
.ToList();
|
if (detaiList != null && detaiList.Count > 0)
|
{
|
//建议：一次只执行一次出库任务
|
foreach (var item in detaiList)
|
{
|
var result = SingleOutPlanDetailTaskHandlerForVirtual(context, new_outTask, item, ref errMsg);
|
//var result = false;//暂时先屏蔽读取虚拟库存的数据
|
if (result == false)
|
{//表示没有找到虚拟库存，就再去查 真实库存
|
result = SingleOutPlanDetailTaskHandler(context, new_outTask, item, ref errMsg);
|
if (result == false)
|
{//表示没有找到实际库存
|
|
}
|
else
|
{//表示找到了实际库存，并成功创建了任务
|
fun_Result = true;
|
break;//成功后就跳出循环
|
}
|
}
|
else
|
{//表示找到了虚拟出库，并成功创建了任务
|
fun_Result = true;
|
break;//成功后就跳出循环
|
}
|
}
|
}
|
else
|
{
|
//不予处理
|
}
|
return fun_Result;
|
}
|
|
/// <summary>
|
/// 单个处理出库计划明细-真实库存中处理
|
/// </summary>
|
/// <param name="context"></param>
|
/// <param name="outTask"></param>
|
/// <param name="outDetailTask"></param>
|
/// <param name="errMsg"></param>
|
/// <returns>true:表示已经找到库存，并创建好了任务，false：表示没有找到库存</returns>
|
private static bool SingleOutPlanDetailTaskHandler(DbModel context, Plan_OutTask outTask, Plan_OutTaskDetail outDetailTask, ref string errMsg)
|
{
|
errMsg = "";
|
var remark = "消费下发中的任务";
|
//1、搜索库存是否存在
|
var queliaoReason = "";
|
var findStore = StoreHandler.FindStoreForOutPlan(context, outDetailTask, ref errMsg, ref queliaoReason);
|
if (findStore == null)
|
{//表示查找库存失败
|
//更新Plan_OutTaskDetail表的OperationRemark值
|
var changeOutTaskDetailState = OutTaskDetailStateEnum.缺料;
|
outDetailTask.OutTaskDetailState = (int)changeOutTaskDetailState;
|
outDetailTask.OutTaskDetailStateName = changeOutTaskDetailState.ToString();//更新 状态为缺料 [EditBy shaocx,2022-08-24]
|
outDetailTask.OperationRemark = SysGloble.QUELIAO_STR;
|
|
//赋值缺料原因 【Editby shaocx,2022-10-24】
|
outDetailTask.Remark = MyExtendHelper.GetQueliaoReason(outDetailTask.Remark, queliaoReason);
|
|
outDetailTask.ModifyTime = DateTime.Now;
|
outDetailTask.ModifyBy = SysGloble.WCSSystem;
|
//重要：！提前生成顺序号 [EditBy shaocx,2022-08-24]
|
string taskSequenceGuid = "";
|
outDetailTask.MainTaskSequence = MainTaskHandler.GenerateTaskSequence(context, ref taskSequenceGuid);
|
outDetailTask.TaskSequenceGuid = taskSequenceGuid;
|
|
context.SaveChanges();
|
|
Log4NetHelper.WriteInfoLog(LogType.OutPlanTask, errMsg);
|
return false;
|
}
|
else
|
{//查找到库存
|
|
#region 事务处理
|
string taskSequenceGuid = "";
|
int myTaskSequence = GetLastOutTaskDetailTaskSequenceForQueLiao(context, outDetailTask, ref taskSequenceGuid);
|
using (var trans = context.Database.BeginTransaction())
|
{
|
try
|
{
|
var sourcePlace = StationHandler.GetPlaceByPlaceId(findStore.StationId, context);
|
//2、锁定库存
|
StationHandler.SetPlaceLockStatus(true, SysGloble.WCSSystem, ref sourcePlace, remark);
|
StationHandler.SetPlaceTaskDoingStatus(true, SysGloble.WCSSystem, ref sourcePlace, remark);
|
|
//3、创建出库任务
|
FunRetEntity addOutStoreTaskResult = MainTaskHandler.AddOutStoreTask(outDetailTask, findStore, context, MainTaskTypeEnum.自动出库, new SysUser()
|
{
|
ID = 0,
|
Name = SysGloble.WCSSystem
|
}, sourcePlace, myTaskSequence, taskSequenceGuid);
|
if (addOutStoreTaskResult.result == false)
|
{
|
errMsg = addOutStoreTaskResult.resMsg;
|
throw new Exception(errMsg);
|
}
|
|
//4、更新出库明细表
|
var mainTask = addOutStoreTaskResult.resData as Task_Main;
|
if (mainTask == null)
|
{
|
errMsg = "新建的主任务对象为NULL";
|
throw new Exception(errMsg);
|
}
|
|
outDetailTask.TaskSequenceGuid = mainTask.TaskSequenceGuid;//重要！保存TaskSequenceGuid值 【EditBy shaocx,2022-08-25】
|
|
outDetailTask.OperationRemark = "设备任务已创建";//注意：这里的OperationRemark一定要更新，因为缺料的时候我更新了，缺料的查询也用到了 【EditBy shaocx,2022-04-29】
|
outDetailTask.MainTaskId = mainTask.Id;
|
outDetailTask.MainTaskNo = mainTask.TaskNo;
|
outDetailTask.SerialNumber = findStore.SerialNumber;//保存序列号
|
outDetailTask.OrderNo = findStore.OrderNo;
|
outDetailTask.MaterialId = findStore.MaterialId;//保存物料信息
|
var changeOutTaskDetailState = OutTaskDetailStateEnum.设备任务待执行;
|
PlanOutTaskHandler.UpdateStateForOutTaskDetail(outDetailTask, changeOutTaskDetailState, remark);
|
//5、更新出库主表
|
SetPlanStateForPlan_OutTask(context, outTask, changeOutTaskDetailState, remark);
|
|
//清理之前残留的缺料的信息 【Editby shaocx,2022-10-24】
|
outDetailTask.Remark = MyExtendHelper.CleareQueliaoReason(outDetailTask.Remark);
|
|
////更改任务主表为任务已分解
|
////更新主表的任务状态
|
//var _changeTaskState = MainTaskStatusEnum.出库任务已分解;
|
//mainTask.TaskState = (int)_changeTaskState;
|
//mainTask.TaskStateName = _changeTaskState.ToString();
|
|
//保存数据库
|
context.SaveChanges();
|
|
trans.Commit();
|
return true;//找到了库存，并处理成功了
|
}
|
catch (Exception ex)
|
{
|
trans.Rollback();
|
SystemWarningMsg._lbl_Alert_HandlerIssuingTask = "SingleOutPlanDetailTaskHandler出现异常:" + ex.Message;
|
Log4NetHelper.WriteErrorLog(LogType.CCWCFService, "SingleOutPlanDetailTaskHandler 出现异常：" + ex.Message, ex);
|
throw ex;
|
}
|
}
|
#endregion
|
}
|
}
|
|
|
/// <summary>
|
/// 单个处理出库计划明细-虚拟库存中处理 [Editby shaocx,2022-07-28]
|
/// </summary>
|
/// <param name="context"></param>
|
/// <param name="outTask"></param>
|
/// <param name="outDetailTask"></param>
|
/// <param name="errMsg"></param>
|
/// <returns>true:表示找到虚拟库存，并处理成功了，false表示没有找到虚拟库存</returns>
|
private static bool SingleOutPlanDetailTaskHandlerForVirtual(DbModel context, Plan_OutTask outTask, Plan_OutTaskDetail outDetailTask, ref string errMsg)
|
{
|
errMsg = "";
|
var remark = "消费下发中的任务";
|
//1、搜索库存是否存在
|
var findVirtualStore = StoreHandler.FindStoreForOutPlanByVirtual(context, outDetailTask, ref errMsg);
|
if (findVirtualStore == null)
|
{//表示查找库存失败
|
return false;//表示在虚拟库存中没有找到库存
|
}
|
else
|
{//查找到库存
|
|
#region 事务处理
|
using (var trans = context.Database.BeginTransaction())
|
{
|
try
|
{
|
//1、库存移除
|
context.Wms_VirtualStore.Remove(findVirtualStore);
|
//findVirtualStore.IsDeleted = true;
|
//findVirtualStore.ModifyBy = "";
|
//findVirtualStore.OperationRemark = remark + "[锁定库存]";
|
//findVirtualStore.ModifyTime = DateTime.Now;
|
|
//2、创建虚拟出库任务，注意：任务状态必须是已完成，因为是虚拟出库
|
FunRetEntity addOutStoreTaskResult = MainTaskHandler.AddOutStoreTaskForVirtual(outDetailTask, findVirtualStore, context, MainTaskTypeEnum.自动出库, new SysUser()
|
{
|
ID = 0,
|
Name = SysGloble.WCSSystem
|
});
|
if (addOutStoreTaskResult.result == false)
|
{
|
errMsg = addOutStoreTaskResult.resMsg;
|
throw new Exception(errMsg);
|
}
|
|
//4、更新出库明细表
|
var mainTask = addOutStoreTaskResult.resData as Task_Main;
|
if (mainTask == null)
|
{
|
errMsg = "新建的主任务对象为NULL";
|
throw new Exception(errMsg);
|
}
|
|
outDetailTask.OperationRemark = "设备任务已创建,并完成";//注意：这里的OperationRemark一定要更新，因为缺料的时候我更新了，缺料的查询也用到了 【EditBy shaocx,2022-04-29】
|
outDetailTask.MainTaskId = mainTask.Id;
|
outDetailTask.MainTaskNo = mainTask.TaskNo;
|
outDetailTask.SerialNumber = findVirtualStore.SerialNumber;//保存序列号
|
outDetailTask.OrderNo = findVirtualStore.OrderNo;
|
outDetailTask.MaterialId = findVirtualStore.MaterialId;//保存物料信息
|
var changeOutTaskDetailState = OutTaskDetailStateEnum.完成;//注意：要变成 已完成
|
PlanOutTaskHandler.UpdateStateForOutTaskDetail(outDetailTask, changeOutTaskDetailState, remark);
|
//5、更新出库主表
|
SetPlanStateForPlan_OutTask(context, outTask, changeOutTaskDetailState, remark);
|
|
|
//保存数据库
|
context.SaveChanges();
|
|
trans.Commit();
|
|
return true;
|
}
|
catch (Exception ex)
|
{
|
trans.Rollback();
|
SystemWarningMsg._lbl_Alert_HandlerIssuingTask = "SingleOutPlanDetailTaskHandler出现异常:" + ex.Message;
|
Log4NetHelper.WriteErrorLog(LogType.CCWCFService, "SingleOutPlanDetailTaskHandler 出现异常：" + ex.Message, ex);
|
throw ex;
|
}
|
}
|
|
#endregion
|
}
|
}
|
|
private static void SetPlanStateForPlan_OutTask(DbModel context, Plan_OutTask outTask, OutTaskDetailStateEnum currnetChange, string remark)
|
{
|
//计算数量
|
var queryState1 = (int)OutTaskDetailStateEnum.完成;
|
var queryState2 = (int)OutTaskDetailStateEnum.执行中;
|
var allPlanList = context.Plan_OutTaskDetail.Where(x => x.M_PlanId == outTask.Id).ToList();
|
outTask.Qty = allPlanList.Count;//重新赋值总数量
|
|
var issued_planList = allPlanList.Where(x => x.OutTaskDetailState == queryState1 || x.OutTaskDetailState == queryState2).ToList();
|
int issued_planListCount = issued_planList.Count();
|
|
if (currnetChange == OutTaskDetailStateEnum.完成 || currnetChange == OutTaskDetailStateEnum.执行中)
|
{
|
//计入本次要修改的条数
|
//是否这里不需要+1,待测试 【重要！！！！！】
|
//issued_planListCount += 1;
|
}
|
OutPlanStateEnum changeOutTaskDetailState;
|
if (outTask.Qty <= issued_planListCount)
|
{//更新主表状态为 全部下发
|
|
changeOutTaskDetailState = OutPlanStateEnum.全部下发;
|
PlanOutTaskHandler.UpdateStateForOutTask(outTask, changeOutTaskDetailState, remark);
|
//修改齐套性为已齐套 [EditBy shaocx,2022-05-16]
|
outTask.IsPickFinished = true;
|
//更新计划进度
|
outTask.PlanRate = 100;
|
outTask.Qty_Finish = outTask.Qty;
|
outTask.Qty_NoFinish = 0;
|
}
|
else if (issued_planListCount > 0)
|
{
|
changeOutTaskDetailState = OutPlanStateEnum.部分下发;
|
PlanOutTaskHandler.UpdateStateForOutTask(outTask, changeOutTaskDetailState, remark);
|
//更新计划进度
|
//outTask.PlanRate = (issued_planListCount / allPlanList.Count()) * 100;
|
outTask.PlanRate = CSharpHelper.ExecPercentRetInt(issued_planListCount, outTask.Qty);
|
|
outTask.Qty_Finish = issued_planListCount;
|
outTask.Qty_NoFinish = outTask.Qty - issued_planListCount;
|
}
|
}
|
|
|
/// <summary>
|
/// 是否允许继续分解任务计划 [EditBy shaocx,2022-08-11]
|
/// </summary>
|
/// <param name="context"></param>
|
/// <returns></returns>
|
private static bool IsAllowDecomposePlanTask(DbModel context, ref string errMsg)
|
{
|
var queryState1 = (int)MainTaskStatusEnum.待出库;
|
var queryState2 = (int)MainTaskStatusEnum.出库任务已分解;
|
var queryState3 = (int)MainTaskStatusEnum.出库中;
|
|
var queryMaterialType = (int)MaterialTypeEnum.一般物料;
|
|
var queryInOutFlag = (int)MainInOutFlagEnum.出库;
|
|
|
var mainList = context.Task_Main.Where(x => (x.TaskState == queryState1 || x.TaskState == queryState2 || x.TaskState == queryState3) && x.MaterialType == queryMaterialType
|
&& x.InOutFlag == queryInOutFlag).ToList();
|
|
if (mainList != null && mainList.Count >= 3)
|
{//为什么是3，考虑到 1012+2个出库口都有发动机的情况
|
errMsg = "目前已有" + mainList.Count + "条出库任务未结束，不允许继续分解任务计划";
|
return false;
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 缺料的数据，插队处理
|
/// </summary>
|
/// <param name="context"></param>
|
/// <param name="planDetail"></param>
|
/// <returns></returns>
|
private static int GetLastOutTaskDetailTaskSequenceForQueLiao(DbModel context, Plan_OutTaskDetail planDetail, ref string taskSequenceGuid)
|
{
|
if (planDetail.OutTaskDetailState == (int)OutTaskDetailStateEnum.缺料)
|
{//如果是缺料的话，就需要 插队处理 【EditBy shaocx,2022-08-24】
|
//首先要判断当前同一个TaskSequenceGuid是否都做完了，如果都做完了，那么他就要排到第一位优先执行，如果还没做完，就按照原先的顺序来。
|
taskSequenceGuid = planDetail.TaskSequenceGuid;
|
bool isNeedChaDui = PlanOutTaskHandler.IsNeedChaDuiCommonTaskSequenceGuid(context, taskSequenceGuid);
|
if (isNeedChaDui)
|
{
|
return 1;//插队处理
|
}
|
return Convert.ToInt32(planDetail.MainTaskSequence);//按照原先的节奏顺序走
|
}
|
return 0;//正常排序
|
}
|
}
|
}
|
