/// <summary>
/// 新增库存信息（虚拟库存）
/// </summary>
/// <param name="planProd">计划生产的零件</param>
/// <returns></returns>
public string AddInventoryInfor(Prod_PlanProd planProd, List<Road_Nodes> nodeslist)
{
Inv_Information inv = new Inv_Information();
inv.IInfor_ProdCode = planProd.PlanProd_Code;
inv.IInfor_PartNo = planProd.PlanProd_PartNo;
inv.IInfor_PartName = planProd.PlanProd_PartName;
inv.IInfor_PlanBegin = planProd.PlanProd_Begin;
inv.IInfor_PlanEnd = planProd.PlanProd_End;
//计划编码
inv.IInfor_PlanCode = planProd.PlanProd_PlanCode;
//指令编码
inv.IInfor_CmdCode = planProd.PlanProd_CmdCode;
inv.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Normal.ToString();
//任务编码
inv.IInfor_TaskCode = planProd.PlanProd_TaskCode;
inv.IInfor_Num = 1;
inv.CreateTime = DateTime.Now;
if (nodeslist != null && nodeslist.Count > 0)
{
//var temp = nodeslist.OrderBy(o => o.RNodes_Order);
inv.IInfor_Stat = nodeslist[0].RNodes_Code;
}
//实际完成时间 库存状态 编制人等信息之后实时更新
//仅添加一条虚拟库存记录，不做出入库操作
Instance.Add(inv);
return inv.IInfor_ProdCode;
}
public bool UpdatePlan(Prod_PlanProd plan)
{
if (Instance.Update(plan) > 0)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 作废零件
/// </summary>
/// <param name="plan"></param>
/// <returns></returns>
public bool TrashProd(Prod_PlanProd plan)
{
var inv = invInstance.GetInvByPlanCode(plan.PlanProd_PlanCode);
inv.IInfor_ProdStat = OperationTypeEnum.ProdStatEnum.Defective.ToString();
inv.IInfor_CustBak = SessionConfig.EmpName + "手动作废 " + DateTime.Now.ToString();
plan.PlanProd_Bak = SessionConfig.EmpName + "手动作废 " + DateTime.Now.ToString();
Instance.Update(plan);
return invInstance.Update(inv);
}
/// <summary>
/// 获取合同细目关联的零件
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<Prod_PlanProd> GetTracePlanList(string key)
{
string where = string.Format("AND SDR_DetailCode ='{0}'", key);
List<SD_CRProdCode> list = crInstance.GetListByWhere(where);
List<Prod_PlanProd> list1 = new List<Prod_PlanProd>();
foreach (var p in list)
{
Prod_PlanProd p1 = new Prod_PlanProd();
p1.PlanProd_Code = p.SDR_ProdCode;
p1.PlanProd_PlanCode = p.SDR_PlanCode;
p1.PlanProd_CmdCode = p.SDR_CmdCode;
p1.PlanProd_PartNo = p.SDR_PartNo;
p1.PlanProd_PartName = p.SDR_PartName;
list1.Add(p1);
}
return list1;
}
public List<Prod_PlanProd> DeployPlanWithNoSubmit(Prod_Task prodTask, int DeployNum)
{
List<Prod_PlanProd> planList = new List<Prod_PlanProd>();
for (int i = 0; i < DeployNum; i++)
{
//生产计划
Prod_PlanProd prodPlan = new Prod_PlanProd();
//prodPlan.PlanProd_Code = invInstance.CreateInvCode();
//prodPlan.PlanProd_PlanCode = CreateProdPlanCode();
//任务编码
prodPlan.PlanProd_TaskCode = prodTask.Task_Code;
//生产命令编码
prodPlan.PlanProd_CmdCode = prodTask.TaskDetail_CmdCode;
//零件图号
prodPlan.PlanProd_PartNo = prodTask.TaskDetail_PartNo;
//零件名称
prodPlan.PlanProd_PartName = prodTask.TaskDetail_PartName;
//数量
prodPlan.PlanProd_Num = 1;
prodPlan.PlanProd_Begin = prodTask.TaskDetail_PlanBegin;
prodPlan.PlanProd_End = prodTask.TaskDetail_PlanEnd;
//编制人 完工数量 长票编号 确认人 等未赋值
prodPlan.PlanProd_FStat = OperationTypeEnum.ProdPlanStatEnum.Planing.ToString();
planList.Add(prodPlan);
}
return planList;
}
/// <summary>
/// 下发计划 需修改
/// </summary>
/// <param name="prodTask">待计划任务</param>
/// <returns></returns>
public int DeployPlan(Prod_Task prodTask)
{
//设置任务状态--Planing
//生成计划列表
//写入库存
//导入对应工序
int flag = 1;
try
{
//下达任务数量
int compCount = prodTask.Task_DNum;
List<Road_Nodes> nodeList = rnInstance.GetRoadNodesByComponents(prodTask.TaskDetail_PartNo);
Instance.idb.BeginTransaction();
ptInstance.Instance.idb.BeginTransaction(Instance.idb.GetTransaction());
prInstance.Instance.idb.BeginTransaction(Instance.idb.GetTransaction());
invInstance.Instance.idb.BeginTransaction(Instance.idb.GetTransaction());
prodTask.Task_Stat = OperationTypeEnum.ProdTaskStatEnum.Planing.ToString();
ptInstance.Update(prodTask);
for (int i = 0; i < compCount; i++)
{
//生产计划
Prod_PlanProd prodPlan = new Prod_PlanProd();
//产品编码
prodPlan.PlanProd_Code = invInstance.CreateInvCode();
prodPlan.PlanProd_PlanCode = CreateProdPlanCode();
prodPlan.PlanProd_TaskCode = prodTask.Task_Code;
prodPlan.PlanProd_CmdCode = prodTask.TaskDetail_CmdCode;
prodPlan.PlanProd_PartNo = prodTask.TaskDetail_PartNo;
prodPlan.PlanProd_PartName = prodTask.TaskDetail_PartName;
prodPlan.PlanProd_Num = 1;
prodPlan.PlanProd_Begin = prodTask.TaskDetail_PlanBegin;
prodPlan.PlanProd_End = prodTask.TaskDetail_PlanEnd;
//编制人 完工数量 长票编号 确认人 等未赋值
prodPlan.PlanProd_FStat = OperationTypeEnum.ProdPlanStatEnum.Planing.ToString();
//添加生产计划
Instance.Add(prodPlan);
//添加库存信息
invInstance.AddInventoryInfor(prodPlan, nodeList);
//工艺路线导入
prInstance.ImportPlanRoads(prodPlan, nodeList);
}
Instance.idb.CommitTransaction();
}
catch (Exception e)
{
Instance.idb.RollbackTransaction();
}
return flag;
}
public Prod_PlanProd CreateProdPlanWithNoPersist(Prod_Task prodTask)
{
//生产计划
Prod_PlanProd prodPlan = new Prod_PlanProd();
//prodPlan.PlanProd_Code = invInstance.CreateInvCode();
//prodPlan.PlanProd_PlanCode = CreateProdPlanCode();
//任务编码
prodPlan.PlanProd_TaskCode = prodTask.Task_Code;
//生产命令编码
prodPlan.PlanProd_CmdCode = prodTask.TaskDetail_CmdCode;
//零件图号
prodPlan.PlanProd_PartNo = prodTask.TaskDetail_PartNo;
//零件名称
prodPlan.PlanProd_PartName = prodTask.TaskDetail_PartName;
//数量
prodPlan.PlanProd_Num = 1;
prodPlan.PlanProd_Begin = prodTask.TaskDetail_PlanBegin;
prodPlan.PlanProd_End = prodTask.TaskDetail_PlanEnd;
//编制人 完工数量 长票编号 确认人 等未赋值
return prodPlan;
}
/// <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;
}
//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="pp"></param>
/// <returns></returns>
public int AjustPlanRoadsTimeCost(Prod_PlanProd pp)
{
var flag = 1;
try
{
List<Prod_Roads> prList = this.GetPlanRoadList(pp.PlanProd_PlanCode);
DateTime planBegin = pp.PlanProd_Begin;
DateTime planEnd = pp.PlanProd_End;
DateTime tmpDate = pp.PlanProd_Begin;
foreach (var pr in prList)
{
int equTimeCost = pr.PRoad_EquTimeCost;
//工艺节点工时
decimal timeCost = pr.PRoad_TimeCost;
//如果设备额定工时为0，则表示不作时间限制
if (equTimeCost == 0)
{
equTimeCost = int.MaxValue;
}
//时间安排（自动调整 开始时间）
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)
{
//问题 递推一天的条件？ AddDay？
tmpDate = tmpDate.AddHours(Convert.ToDouble(timeCost));
}
else
{
tmpDate = tmpDate.AddHours(Convert.ToDouble(timeCost));
}
pr.PRoad_End = tmpDate;
Instance.Update(pr);
}
}
catch (Exception e)
{
flag = 0;
}
return flag;
}
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="plan"></param>
/// <param name="inf"></param>
/// <param name="nodestr"></param>
/// <param name="nodelist"></param>
/// <returns></returns>
public bool BatchEnterFHelper(Prod_PlanProd plan, FHelper_Info inf, string nodestr, string nodelist)
{
////外协处理流程
//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_FSup = inf.FHelperInfo_FSup;
info.FHelperInfo_Code = infoInstance.GenerateCode();
//零件图号
info.FHelperInfo_PartCode = plan.PlanProd_PartNo;
//info.FHelperInfo_RoadNodeName = pr.PRoad_NodeName;
//产品编码/零件编码
info.FHelperInfo_ProdCode = plan.PlanProd_Code;
info.FHelperInfo_RoadNodes = nodestr;
info.FHelperInfo_Date = DateTime.Now;
info.FHelperInfo_Owner = SessionConfig.UserCode;
info.FHelperInfo_Num = 1;
info.FHelperInfo_IsBatch = nodelist;
//如果有记录则不走价格否则价格审核流程(添加一条价格信息)
//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 = nodestr;
price.FP_NodeName = nodestr;
MethodInvoker mi = delegate
{
price.FP_CompName = plan.PlanProd_PartName;
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;
}
