public SetNodeChecked(Prod_Roads nodes)
{
InitializeComponent();
ProdRoad = nodes;
IsPass = false;
EventInit();
}
public List<Prod_Roads> IncrementalAjustPlanRoadsWithNoSubmit(Prod_Roads curPRoad, List<Prod_Roads> prList)
{
//后续节点开始调整的时间即为当前节点调整后的结束时间
//DateTime tmpDate = ScheduleDate(curPRoad.PRoad_Begin, curPRoad.PRoad_EquTimeCost, curPRoad.PRoad_TimeCost);
//curPRoad.PRoad_End = tmpDate;
DateTime tmpDate = curPRoad.PRoad_Begin;
foreach (Prod_Roads pr in prList)
{
if (pr.PRoad_Order >= curPRoad.PRoad_Order)
{
pr.PRoad_Begin = tmpDate;
tmpDate = ScheduleDate(tmpDate, pr.PRoad_EquTimeCost, pr.PRoad_TimeCost);
pr.PRoad_End = tmpDate;
}
}
return prList;
}
public void IncrementalAjustPlanRoads(Prod_Roads curPRoad)
{
//获取当前节点之后的节点列表
List<Prod_Roads> prList = GetProdRoadsForAjust(curPRoad);
//后续节点开始调整的时间即为当前节点调整后的结束时间
DateTime tmpDate = ScheduleDate(curPRoad.PRoad_Begin, curPRoad.PRoad_EquTimeCost, curPRoad.PRoad_TimeCost);
curPRoad.PRoad_End = tmpDate;
Instance.Update(curPRoad);
foreach (Prod_Roads pr in prList)
{
pr.PRoad_Begin = tmpDate;
tmpDate = ScheduleDate(tmpDate, pr.PRoad_EquTimeCost, pr.PRoad_TimeCost);
pr.PRoad_End = tmpDate;
Instance.Update(pr);
}
}
/// <summary>
/// 工序节点导入
/// </summary>
/// <param name="pp"></param>
/// <param name="rnList"></param>
/// <returns></returns>
public int ImportPlanRoads(Prod_PlanProd pp, List<Road_Nodes> rnList)
{
//第一个节点从当天8点开始计算
DateTime planBegin = pp.PlanProd_Begin.AddHours(8);
DateTime planEnd = pp.PlanProd_End;
DateTime tmpDate = pp.PlanProd_Begin;
for (int i = 0; i < rnList.Count; i++)
{
Road_Nodes rn = rnList[i];
Prod_Roads pr = new Prod_Roads();
if (i == 0)
{
pr.PRoad_IsCurrent = 1;
pr.PRoad_ActRTime = DateTime.Now;
}
//工艺节点工时
decimal timeCost = rn.RNodes_TimeCost;
pr.PRoad_PlanCode = pp.PlanProd_PlanCode;
pr.PRoad_ProdCode = pp.PlanProd_Code;
//零件图号
pr.PRoad_CompCode = pp.PlanProd_PartNo;
pr.PRoad_NodeCode = rn.RNodes_Code;
pr.PRoad_NodeName = rn.RNodes_Name;
pr.PRoad_NodeDepCode = rn.RNodes_Dept_Code;
pr.PRoad_NodeDepName = rn.RNodes_Dept_Name;
pr.PRoad_Order = rn.RNodes_Order;
pr.PRoad_TimeCost = rn.RNodes_TimeCost;
pr.PRoad_Date = DateTime.Now;
//设备负荷时长
pr.PRoad_EquCode = rn.RNodes_EquCode;
pr.PRoad_EquName = rn.RNodes_EquName;
pr.PRoad_EquTimeCost = (int)rn.RNodes_EquTime;
int equTimeCost = pr.PRoad_EquTimeCost;
//时间安排（自动调整 开始时间）
pr.PRoad_Begin = tmpDate;
//前置条件 上一工序完成后的时间是否可以直接递推（另起一天）
//工序工时超过设备负荷时间-->时间递推条件以设备能完成的时间为主
if (timeCost > equTimeCost)
{
if (equTimeCost == 0)
{
equTimeCost = 1;
}
double days = (Convert.ToDouble(timeCost) % Convert.ToDouble(equTimeCost));
double hours = (Convert.ToDouble(timeCost) / Convert.ToDouble(equTimeCost));
tmpDate = tmpDate.AddDays(days + hours);
}//工序工时所需设备满足负荷时间-->时间递推条件以工时为主
else if (timeCost > 8)
{
tmpDate = tmpDate.AddHours(Convert.ToDouble(timeCost));
}
pr.PRoad_End = tmpDate;
Instance.Add(pr);
}
return 1;
}
/// <summary>
/// 设置工艺节点检测状态
/// </summary>
/// <param name="pr">当前工艺节点</param>
/// <returns></returns>
public bool SetProdNodeChecked(bool isPass, Prod_Roads pr, List<Road_TestRef> testlist)
{
bool flag = true;
if (isPass)
{
//设置生产状态
pr.PRoad_IsQuality = true;
prInstance.Update(pr);
//foreach (Road_TestRef t in testlist)
//{
// //添加检测记录
// Prod_TestRef test = new Prod_TestRef();
// //产品编码
// test.PTestRef_ProdCode =pr.PRoad_ProdCode;
// test.PTestRef_Code = trInstance.GenerateTestRefCode();
// test.PTestRef_NodeCode = pr.PRoad_NodeCode;
// test.PTestRef_NodeName = pr.PRoad_NodeName;
// test.PTestRef_RefValue = t.TestRef_Value;
// test.PTestRef_TestName = t.TestRef_Name;
// test.PTestRef_TestNode = t.TestRef_Code;
// test.PTestRef_High = t.TestRef_High;
// test.PTestRef_Low = t.TestRef_Low;
// test.PTestRef_IsLast = t.TestRef_IsLast;
// test.PTestRef_Order = t.TestRef_Order;
// var d=trInstance.AddTestRef(test);
//}
//判断是否最后一个质检
List<Prod_Roads> list = prInstance.GetPlanRoadList(pr.PRoad_PlanCode);
var checkedList = list.Where(o => o.PRoad_IsQuality);
//如果已全部质检,则更新计划状态(库存表)
if (checkedList.Count() == list.Count)
{
//判断是否存在终检
var model = invInstance.GetInvByProdCode(pr);
model.IInfor_Stat = OperationTypeEnum.InvStatEnum.Entering.ToString();
invInstance.Update(model);
var model1 = ppInstance.GetModelByKey(pr.PRoad_PlanCode);
model1.PlanProd_FDate = DateTime.Now;
ppInstance.UpdatePlan(model1);
var temp = ppInstance.GetModelByProdCode(pr.PRoad_ProdCode);
IsFinTask(temp.PlanProd_TaskCode);
////获取所有计划列表
//var planList = ppInstance.GetFinPlanProdList(temp.PlanProd_TaskCode);
//var task = ptInstance.GetTaskByCode(temp.PlanProd_TaskCode);
//if (planList.Count == task.TaskDetail_Num)
//{
// task.Task_Stat = OperationTypeEnum.ProdTaskStatEnum.Finish.ToString();
// ptInstance.UpdateProdTaskStat(task);
//}
}
}
else
{
pr.PRoad_IsQuality = false;
prInstance.Update(pr);
//库存更新
var model = invInstance.GetInvByProdCode(pr);
model.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Unqualified.ToString();
invInstance.Update(model);
//foreach (Road_TestRef t in testlist)
//{
// //添加检测记录
// Prod_TestRef test = new Prod_TestRef();
// test.PTestRef_Code = trInstance.GenerateTestRefCode();
// test.PTestRef_NodeCode = pr.PRoad_NodeCode;
// test.PTestRef_NodeName = pr.PRoad_NodeName;
// test.PTestRef_ProdCode = pr.PRoad_ProdCode;
// test.PTestRef_RefValue = t.TestRef_Value;
// test.PTestRef_TestName = t.TestRef_Name;
// test.PTestRef_TestNode = t.TestRef_Code;
// test.PTestRef_High = t.TestRef_High;
// test.PTestRef_Low = t.TestRef_Low;
// test.PTestRef_IsLast = t.TestRef_IsLast;
// test.PTestRef_Order = t.TestRef_Order;
// var d=trInstance.AddTestRef(test);
//}
var plan = ppInstance.GetModelByKey(pr.PRoad_PlanCode);
//进入不合格品流程
Failure_Information fi = new Failure_Information();
fi.FInfo_Code = fiInstance.GenerateFailureInfor();
fi.FInfo_PartNo = plan.PlanProd_PartNo;
fi.FInfo_PartName = plan.PlanProd_Code;
fi.FInfo_CmdCode = plan.PlanProd_CmdCode;
fi.FInfo_PartName = plan.PlanProd_PartName;
fi.FInfo_Num = 1;
fi.FInfo_ProdNo = plan.PlanProd_Code;
fi.FInfo_FindNode = pr.PRoad_NodeCode;
fi.FInfo_FindNodeName = pr.PRoad_NodeName;
fi.FInfo_RespEntity = pr.PRoad_NodeDepName;
fi.FInfo_Date = DateTime.Now;
fi.FInfo_Stat = OperationTypeEnum.ProdStatEnum.Defective.ToString();
fi.FInfo_Owner = SessionConfig.UserCode;
//状态设置
fi.AuditStat = OperationTypeEnum.AudtiOperaTypeEnum.Auditing.ToString();
Verify_TemplateConfig config = auInstance.GetVerifyTemplateFirstNode(OperationTypeEnum.AuditTemplateEnum.FailureAudit_F001.ToString());
if (config != null)
{
fi.AuditCurAudit = config.VT_VerifyNode_Code;
}
fiInstance.AddFailure(fi);
}
return flag;
}
/// <summary>
/// 根据零件编号获取对应库存信息（零件编号在库存表中唯一）
/// </summary>
/// <param name="prodCode"></param>
/// <returns></returns>
public Inv_Information GetInvByProdCode(Prod_Roads pr)
{
string strCondition = string.Format(" AND IInfor_PlanCode='{0}'", pr.PRoad_PlanCode);
List<Inv_Information> list = Instance.GetListByWhere(strCondition);
Inv_Information model = new Inv_Information();
if (list != null && list.Count > 0)
{
model = list[0];
}
else
{
model = null;
}
return model;
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Update(Prod_Roads model)
{
bool result = false;
int _rseult = Instance.Update(model);
if (_rseult > 0)
{
result = true;
}
return result;
}
/// <summary>
/// 设置当前产品所处节点状态
/// </summary>
/// <param name="pr"></param>
/// <returns></returns>
public void SetInvNodeStat(Prod_Roads pr)
{
Inv_Information inv = invInstance.GetInvByProdCode(pr);
//更新库存表 状态
inv.IInfor_Stat = pr.PRoad_NodeCode;
var re1 = invInstance.Update(inv);
}
/// <summary>
/// 逻辑删除数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Delete(Prod_Roads pr)
{
bool result = false;
pr.Stat = 1;
if (Instance.Update(pr) > 0)
{
result = true;
}
//List<Prod_Roads> list = Instance.GetListByWhere(" AND RDetail_Code='" + Code + "'");
//if (list.Count > 0)
//{
// Prod_Roads model = list[0];
// model.Stat = 1;
// int _rseult = Instance.Update(model);
// if (_rseult > 0)
// {
// result = true;
// }
//}
return result;
}
//public Prod_Roads GetNextNode(Prod_Roads pr)
//{
// List<Prod_Roads> list = GetPlanRoadList(pr.PRoad_PlanCode);
// var temp = list.Where(o => o.PRoad_Order > pr.PRoad_Order).OrderBy(o=>o.PRoad_Order).FirstOrDefault();
// return temp;
//}
/// <summary>
/// 更新或添加工序节点
/// </summary>
/// <param name="prodPlan"></param>
/// <param name="nodeDict"></param>
/// <param name="timeCostDict"></param>
/// <returns></returns>
public int AddOrUpdatePlanRoads(Prod_PlanProd prodPlan, Dictionary<string, int> nodeDict, Dictionary<string, string> timeCostDict)
{
int flag = 1;
try
{
Instance.idb.BeginTransaction();
//获取该零件图号原来对应的工艺路线
List<Prod_Roads> roadNodesList = this.GetPlanRoadList(prodPlan.PlanProd_PlanCode);
foreach (Prod_Roads r in roadNodesList)
{
//Bse_Dict roadNode=dcInstance.GetDictByKey(DictKeyEnum.RoadNode,
//如果存在则更新
if (nodeDict.ContainsKey(r.PRoad_NodeCode))
{
r.PRoad_Order = nodeDict[r.PRoad_NodeCode];
//额定工时
r.PRoad_TimeCost = Convert.ToDecimal(timeCostDict[r.PRoad_NodeCode]);
//编制时间
r.PRoad_Date = DateTime.Now;
this.Update(r);
//更新完后移除该该工艺节点
nodeDict.Remove(r.PRoad_NodeCode);
}//不存在则删除
else
{
this.Delete(r);
}
}
foreach (KeyValuePair<string, int> kv in nodeDict)
{
Prod_Roads pr = new Prod_Roads();
pr.PRoad_NodeCode = kv.Key;
//设置工艺路线
Bse_Dict roadNode = dcInstance.GetDictByKey(DictKeyEnum.RoadNode.ToString(), kv.Key);
pr.PRoad_NodeName = roadNode.Dict_Name;
pr.PRoad_ClassCode = roadNode.Dict_UDef1;
pr.PRoad_ClassName = roadNode.Dict_UDef2;
//额定工时
pr.PRoad_TimeCost = Convert.ToDecimal(timeCostDict[kv.Key]);
//零件图号
pr.PRoad_CompCode = prodPlan.PlanProd_PartNo;
pr.PRoad_Order = kv.Value;
//生产计划编码
pr.PRoad_PlanCode = prodPlan.PlanProd_PlanCode;
//产品编码
pr.PRoad_ProdCode = prodPlan.PlanProd_Code;
//默认生技处
pr.PRoad_NodeDepCode = GlobalConfiguration.ProdDept;
pr.PRoad_NodeDepName = GlobalConfiguration.ProdDeptName;
//时间安排（自动调整 开始时间）
pr.PRoad_Begin = prodPlan.PlanProd_Begin;
pr.PRoad_End = prodPlan.PlanProd_End;
//编制时间
pr.PRoad_Date = DateTime.Now;
Instance.Add(pr);
}
Instance.idb.CommitTransaction();
}
catch (Exception e)
{
flag = 0;
Instance.idb.RollbackTransaction();
}
return flag;
}
/// <summary>
/// 批量工序调整
/// </summary>
/// <param name="roadNodesList"></param>
/// <param name="nodeDict"></param>
/// <param name="timeCostDict"></param>
/// <returns></returns>
public List<Prod_Roads> AddOrUpdatePlanRoadsWithNoSubmit(List<Prod_Roads> roadNodesList, Dictionary<string, int> nodeDict, Dictionary<string, string> timeCostDict)
{
List<Prod_Roads> result = new List<Prod_Roads>();
List<Prod_Roads> list = new List<Prod_Roads>();
try
{
//foreach (Prod_Roads r in roadNodesList)
//{
// //如果存在则更新信息并添加到集合,不存在则不处理（相当于删除）
// if (nodeDict.ContainsKey(r.PRoad_NodeCode))
// {
// r.PRoad_Order = nodeDict[r.PRoad_NodeCode];
// //额定工时
// r.PRoad_TimeCost = Convert.ToDecimal(timeCostDict[r.PRoad_NodeCode]);
// //编制时间
// r.PRoad_Date = DateTime.Now;
// result.Add(r);
// //更新完后移除该该工艺节点
// nodeDict.Remove(r.PRoad_NodeCode);
// }
//}
foreach (KeyValuePair<string, int> kv in nodeDict)
{
Prod_Roads pr = new Prod_Roads();
pr.PRoad_NodeCode = kv.Key;
//设置工艺路线
Bse_Dict roadNode = dcInstance.GetDictByKey(DictKeyEnum.RoadNode.ToString(), kv.Key);
pr.PRoad_NodeName = roadNode.Dict_Name;
pr.PRoad_ClassCode = roadNode.Dict_UDef1;
pr.PRoad_ClassName = roadNode.Dict_UDef2;
//额定工时
pr.PRoad_TimeCost = Convert.ToDecimal(timeCostDict[kv.Key]);
pr.PRoad_Order = kv.Value;
////生产计划编码
//pr.PRoad_PlanCode = prodPlan.PlanProd_PlanCode;
////产品编码
//pr.PRoad_ProdCode = prodPlan.PlanProd_Code;
//默认生技处
pr.PRoad_NodeDepCode = GlobalConfiguration.ProdDept;
pr.PRoad_NodeDepName = GlobalConfiguration.ProdDeptName;
//时间安排（自动调整 开始时间）
pr.PRoad_Begin = DateTime.Now;
pr.PRoad_End = DateTime.Now;
//编制时间
pr.PRoad_Date = DateTime.Now;
list.Add(pr);
}
}
catch (Exception e)
{
//如果出现异常则置空结果
//roadNodesList = new List<Prod_Roads>();
}
return roadNodesList.Union(list).OrderBy(o => o.PRoad_Order).ToList();
}
public bool AddOrUpdatePlanRoads(Prod_PlanProd planProd, List<Prod_Roads> list, Dictionary<string, int> nodeDict, Dictionary<string, string> timeCostDict)
{
bool flag = true;
try
{
foreach (var n in list)
{
var re1 = Update(n);
}
foreach (KeyValuePair<string, int> kv in nodeDict)
{
Prod_Roads pr = new Prod_Roads();
pr.PRoad_NodeCode = kv.Key;
//设置工艺路线
Bse_Dict roadNode = dcInstance.GetDictByKey(DictKeyEnum.RoadNode.ToString(), kv.Key);
pr.PRoad_NodeName = roadNode.Dict_Name;
pr.PRoad_ClassCode = roadNode.Dict_UDef1;
pr.PRoad_ClassName = roadNode.Dict_UDef2;
//额定工时
pr.PRoad_TimeCost = Convert.ToDecimal(timeCostDict[kv.Key]);
//零件图号
pr.PRoad_CompCode = planProd.PlanProd_PartNo;
pr.PRoad_Order = kv.Value;
//生产计划编码
pr.PRoad_PlanCode = planProd.PlanProd_PlanCode;
//产品编码
pr.PRoad_ProdCode = planProd.PlanProd_Code;
//默认生技处
pr.PRoad_NodeDepCode = GlobalConfiguration.ProdDept;
pr.PRoad_NodeDepName = GlobalConfiguration.ProdDeptName;
//时间安排（自动调整 开始时间）
pr.PRoad_Begin = planProd.PlanProd_Begin;
pr.PRoad_End = planProd.PlanProd_End;
//编制时间
pr.PRoad_Date = DateTime.Now;
Instance.Add(pr);
}
}
catch (Exception e)
{
flag = false;
}
return flag;
}
/// <summary>
/// 设置不合格单据状态
/// </summary>
/// <param name="finfo"></param>
public Prod_Roads CheckProdStat(Failure_Information finfo)
{
//bool flag = false;
Prod_Roads pr = new Prod_Roads();
string stat = finfo.FInfo_Stat;
//如果检验合格，则更新库存状态和工序节点
if (stat == QX.Common.C_Class.OperationTypeEnum.ProdStatEnum.Normal.ToString() || stat == "MoreUse")
{
finfo.AuditStat = OperationTypeEnum.AudtiOperaTypeEnum.LastAudit.ToString();
//更新单据状态
var re1 = UpdateFailure(finfo);
//库存
var model = invInstance.GetInvByProdCode(finfo.FInfo_CmdCode, finfo.FInfo_ProdNo);
model.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Normal.ToString();
var re2 = invInstance.Update(model);
//更新工序节点
pr = prInstance.GetModel(string.Format(" AND PRoad_PlanCode='{0}' AND PRoad_NodeCode='{1}'", model.IInfor_PlanCode, finfo.FInfo_FindNode));
if (pr != null)
{
pr.PRoad_IsQuality = true;
var re3 = prInstance.Update(pr);
}
}
//如果已终审并为能处理合格，则产品进入次品处理
if (finfo.AuditStat == OperationTypeEnum.AudtiOperaTypeEnum.LastAudit.ToString() && stat == QX.Common.C_Class.OperationTypeEnum.ProdStatEnum.Defective.ToString())
{
//库存
var model = invInstance.GetInvByProdCode(finfo.FInfo_CmdCode, finfo.FInfo_ProdNo);
model.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Defective.ToString();
var re2 = invInstance.Update(model);
}
return pr;
}
public void SetProdNodeChecked(Prod_Roads pr)
{
//Prod_Roads pr = new Prod_Roads();
//设置生产状态
//pr.PRoad_IsQuality = true;
//prInstance.Update(pr);
//判断是否最后一个质检
List<Prod_Roads> list = prInstance.GetPlanRoadList(pr.PRoad_PlanCode);
var checkedList = list.Where(o => o.PRoad_IsQuality);
//如果已全部质检,则更新计划状态(库存表)
if (checkedList.Count() == list.Count)
{
//判断是否存在终检
var model = invInstance.GetInvByPlanCode(pr.PRoad_PlanCode);
model.IInfor_Stat = OperationTypeEnum.InvStatEnum.Entering.ToString();
//实际完工时间
model.IInfor_InTime = DateTime.Now;
invInstance.Update(model);
var temp = ppInstance.GetModelByKey(pr.PRoad_PlanCode);
temp.PlanProd_FStat = OperationTypeEnum.ProdPlanStatEnum.Finish.ToString();
ppInstance.UpdatePlan(temp);
IsFinTask(temp.PlanProd_TaskCode);
}
}
public Failure_Information SetProdNodeChecked(bool isPass, Prod_Roads pr)
{
//bool flag = true;
//进入不合格品流程
Failure_Information fi = null;
if (isPass)
{
//设置生产状态
pr.PRoad_IsQuality = true;
prInstance.Update(pr);
//判断是否最后一个质检
List<Prod_Roads> list = prInstance.GetPlanRoadList(pr.PRoad_PlanCode);
var checkedList = list.Where(o => o.PRoad_IsQuality);
//如果已全部质检,则更新计划状态(库存表)
if (checkedList.Count() == list.Count)
{
//判断是否存在终检
var model = invInstance.GetInvByProdCode(pr);
model.IInfor_Stat = OperationTypeEnum.InvStatEnum.Entering.ToString();
//实际完工时间
model.IInfor_InTime = DateTime.Now;
invInstance.Update(model);
var temp = ppInstance.GetModelByKey(pr.PRoad_PlanCode);
temp.PlanProd_FStat = OperationTypeEnum.ProdPlanStatEnum.Finish.ToString();
temp.PlanProd_FDate = DateTime.Now;
ppInstance.UpdatePlan(temp);
IsFinTask(temp.PlanProd_TaskCode);
}
}
else
{
pr.PRoad_IsQuality = false;
prInstance.Update(pr);
//库存更新
var model = invInstance.GetInvByProdCode(pr);
model.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Unqualified.ToString();
invInstance.Update(model);
//计划更新
var plan = ppInstance.GetModelByKey(pr.PRoad_PlanCode);
fi = new Failure_Information();
fi.FInfo_Code = fiInstance.GenerateFailureInfor();
fi.FInfo_PartNo = plan.PlanProd_PartNo;
fi.FInfo_PartName = plan.PlanProd_Code;
fi.FInfo_CmdCode = plan.PlanProd_CmdCode;
fi.FInfo_PartName = plan.PlanProd_PartName;
fi.FInfo_Num = 1;
fi.FInfo_ProdNo = plan.PlanProd_Code;
fi.FInfo_FindNode = pr.PRoad_NodeCode;
fi.FInfo_FindNodeName = pr.PRoad_NodeName;
fi.FInfo_RespEntity = pr.PRoad_NodeDepName;
fi.FInfo_Date = DateTime.Now;
fi.FInfo_Stat = OperationTypeEnum.ProdStatEnum.Defective.ToString();
fi.FInfo_Owner = SessionConfig.UserCode;
//状态设置
fi.AuditStat = OperationTypeEnum.AudtiOperaTypeEnum.Auditing.ToString();
Verify_TemplateConfig config = auInstance.GetVerifyTemplateFirstNode(OperationTypeEnum.AuditTemplateEnum.FailureAudit_F001.ToString());
if (config != null)
{
fi.AuditCurAudit = config.VT_VerifyNode_Code;
}
int id = fiInstance.AddFailureWithReturn(fi);
fi.FInfo_ID = id;
}
return fi;
}
/// <summary>
/// 插入数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Insert(Prod_Roads model)
{
bool result = false;
try
{
int _result = Instance.Add(model);
if (_result > 0)
{
result = true;
}
}
catch (Exception ex)
{
throw ex;
}
return result;
}
/// <summary>
/// 设置当前所处工序
/// </summary>
/// <param name="oldNode"></param>
/// <param name="newNode"></param>
public void SetCurrentNode(Prod_Roads oldNode, Prod_Roads newNode)
{
newNode.PRoad_IsCurrent = 1;
var f1 = Instance.Update(newNode);
if (oldNode != null)
{
oldNode.PRoad_IsCurrent = 0;
oldNode.PRoad_IsDone = true;
oldNode.PRoad_ActCTime = DateTime.Now;
oldNode.PRoad_FDate = DateTime.Now;
var f2 = Instance.Update(oldNode);
}
SetInvNodeStat(newNode);
}
/// <summary>
/// 获取实体数据
/// </summary>
/// <param name="strCondition"></param>
/// <returns></returns>
public Prod_Roads GetModel(string strCondition)
{
List<Prod_Roads> list = Instance.GetListByWhere(strCondition);
Prod_Roads model = new Prod_Roads();
if (list != null && list.Count > 0)
{
model = list[0];
}
else
{
model = null;
}
return model;
}
public bool SetProdNodeFinish(Prod_Roads pr)
{
bool flag = true;
////设置生产状态
//pr.PRoad_IsDone = true;
//pr.PRoad_ActCTime = DateTime.Now;
//pr.PRoad_FDate = DateTime.Now;
//Update(pr);
//获取库存表对应零件信息
Inv_Information inv = invInstance.GetInvByProdCode(pr);
Prod_Roads nextNode = GetNextNode(pr);
//如果为空则表示当前节点是最后一个工艺节点
if (nextNode != null)
{
//更新库存表 状态
inv.IInfor_Stat = nextNode.PRoad_NodeCode;
var re1 = invInstance.Update(inv);
}
else
{
//更新库存表 状态
inv.IInfor_Stat = OperationTypeEnum.InvStatEnum.Entering.ToString();
invInstance.Update(inv);
}
return flag;
}
/// <summary>
/// 获取当前节点下一结点
/// </summary>
/// <param name="pr"></param>
/// <returns></returns>
public Prod_Roads GetNextNode(Prod_Roads pr)
{
string where = string.Format(" AND PRoad_PlanCode='{0}' AND PRoad_Order>{1} order by PRoad_Order", pr.PRoad_PlanCode, pr.PRoad_Order);
List<Prod_Roads> prList = GetProadRoadsByWhere(where);
if (prList != null && prList.Count > 0)
{
//列表中第一个节点就是当前节点下一结点
return prList[0];
}
else
{
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="pr"></param>
/// <param name="type">0 表示正常 1表示需要外协处理</param>
/// <returns></returns>
public bool UpdateDept(Prod_Roads pr, int type)
{
bool flag = true;
try
{
//Instance.idb.BeginTransaction();
//infoInstance.instance.idb.BeginTransaction(Instance.idb.GetTransaction());
//pInstance.instance.idb.BeginTransaction(Instance.idb.GetTransaction());
switch (type)
{
case 0:
Instance.Update(pr);
break;
case 1:
//更新部门信息
var re1 = Instance.Update(pr);
break;
}
//Instance.idb.CommitTransaction();
}
catch (Exception e)
{
//Instance.idb.RollbackTransaction();
}
return flag;
}
/// <summary>
/// 获取当前工艺节点之后的节点列表
/// </summary>
/// <param name="pr"></param>
/// <returns></returns>
public List<Prod_Roads> GetProdRoadsForAjust(Prod_Roads pr)
{
string where = string.Format(" AND PRoad_PlanCode='{0}' AND PRoad_Order>{1} Order by PRoad_Order", pr.PRoad_PlanCode, pr.PRoad_Order);
return Instance.GetListByWhere(where);
}
public List<Prod_Roads> GetTemplateProdRoadsByComptCode(string compCode, DateTime startDate)
{
List<Road_Nodes> rnList = rnInstance.GetRoadNodesByComponents(compCode);
List<Prod_Roads> prList = new List<Prod_Roads>();
DateTime tmpDate = startDate;
foreach (var rn in rnList)
{
Prod_Roads pr = new Prod_Roads();
//工艺节点工时
decimal timeCost = rn.RNodes_TimeCost;
pr.PRoad_NodeCode = rn.RNodes_Code;
pr.PRoad_NodeName = rn.RNodes_Name;
pr.PRoad_NodeDepCode = rn.RNodes_Dept_Code;
pr.PRoad_NodeDepName = rn.RNodes_Dept_Name;
pr.PRoad_Order = rn.RNodes_Order;
pr.PRoad_TimeCost = rn.RNodes_TimeCost;
pr.PRoad_Date = DateTime.Now;
//设备负荷时长
pr.PRoad_EquCode = rn.RNodes_EquCode;
pr.PRoad_EquName = rn.RNodes_EquName;
pr.PRoad_EquTimeCost = (int)rn.RNodes_EquTime;
int equTimeCost =(int) pr.PRoad_EquTimeCost;
//时间安排（自动调整 开始时间）
pr.PRoad_Begin = tmpDate;
//前置条件 上一工序完成后的时间是否可以直接递推（另起一天）
//工序工时超过设备负荷时间-->时间递推条件以设备能完成的时间为主
if (timeCost > equTimeCost)
{
double days = (Convert.ToDouble(timeCost) % Convert.ToDouble(equTimeCost));
double hours = (Convert.ToDouble(timeCost) / Convert.ToDouble(equTimeCost));
tmpDate = tmpDate.AddDays(days + hours);
}//工序工时所需设备满足负荷时间-->时间递推条件以工时为主
else if (timeCost > 8)
{
tmpDate = tmpDate.AddHours(Convert.ToDouble(timeCost));
}
pr.PRoad_End = tmpDate;
prList.Add(pr);
}
return prList;
}
/// <summary>
/// 单个节点进入外协
/// </summary>
/// <param name="pr"></param>
/// <returns></returns>
public bool EnterFHelper(Prod_Roads pr)
{
//外协处理流程
FHelper_Info info1 = infoInstance.GetModel(string.Format(" AND FHelperInfo_ProdCode='{0}' AND isnull(FHelperInfo_Stat,'')<>'Done' ", pr.PRoad_ProdCode));
if (info1 != null)
{
return false;
}
//外协处理流程
FHelper_Info info = new FHelper_Info();
info.FHelperInfo_Code = infoInstance.GenerateCode();
//零件图号
info.FHelperInfo_PartCode = pr.PRoad_CompCode;
//info.FHelperInfo_RoadNodeName = pr.PRoad_NodeName;
//产品编码/零件编码
info.FHelperInfo_ProdCode = pr.PRoad_ProdCode;
info.FHelperInfo_RoadNodes = pr.PRoad_NodeCode;
info.FHelperInfo_Date = DateTime.Now;
info.FHelperInfo_Owner = SessionConfig.UserCode;
info.FHelperInfo_Num = 1;
//如果有记录则不走价格否则价格审核流程(添加一条价格信息)
//FHelper_Price price = pInstance.GetFHelperPrice(pr.PRoad_CompCode, pr.PRoad_NodeCode);
//if (price == null)
//{
FHelper_Price price = new FHelper_Price();
//info.FHelperInfo_Price = Convert.ToInt32(price.FP_Price);
//info.FHelperInfo_FSup = price.FP_ManuCode;
price.FP_CompCode = info.FHelperInfo_PartCode;
price.FP_PNodeCode = pr.PRoad_NodeCode;
price.FP_NodeName = pr.PRoad_NodeName;
MethodInvoker mi = delegate
{
Bll_Road_Components rcInst = new Bll_Road_Components();
var dd = rcInst.GetRoadComponentByCode(pr.PRoad_CompCode);
price.FP_CompName = dd.Comp_Name;
BLL.Bll_FHelper_Price fpInst = new Bll_FHelper_Price();
price.FP_Code = fpInst.GenerateFPCode();
fpInst.AddPrice(price);
};
var asysn = mi.BeginInvoke(null, null);
try
{
mi.EndInvoke(asysn);
}
catch (Exception ee)
{
}
//}
info.FHelperInfo_Stat = OperationTypeEnum.FHelper_Stat.ConfirmSup.ToString();
info.FHelperInfo_iType = "FHelper";
var re = infoInstance.Insert(info);
return re;
}
