using Tiger.Model;
|
using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq.Expressions;
|
using System.Text;
|
using System.Threading.Tasks;
|
using Rhea.Common;
|
using System.Net;
|
using System.Linq;
|
using Newtonsoft.Json;
|
using Tiger.IBusiness;
|
using Microsoft.AspNetCore.Http;
|
using Tiger.Model.Entitys.WMS.DTOS;
|
using static Tiger.Model.BIZ_MES_WO;
|
using Tiger.Model.Entitys.MES.Position;
|
|
namespace Tiger.Business
|
{
|
public partial class Biz
|
{
|
/// <summary>
|
/// 工艺路线
|
/// </summary>
|
public partial class Route : IRoute
|
{
|
/// <summary>
|
/// 获取工艺路线
|
/// </summary>
|
/// <param name="routerCode"></param>
|
/// <returns></returns>
|
public async Task<ApiAction<List<MES_ROUTE>>> GetRoute(string routerCode)
|
{
|
var res = new ApiAction<List<MES_ROUTE>>();
|
List<MES_ROUTE> list = new List<MES_ROUTE>();
|
try
|
{
|
list = await Db.Queryable<MES_ROUTE>()
|
.WhereIF(!string.IsNullOrEmpty(routerCode), x => x.ROT_CODE.Equals(routerCode))
|
.OrderBy(x => x.CREATE_TIME).ToListAsync();
|
}
|
catch (Exception ex)
|
{
|
res.CatchExceptionWithLog(ex, "查询异常");
|
}
|
res.Data = list;
|
return res;
|
}
|
|
/// <summary>
|
/// 获取工艺路线图形数据
|
/// </summary>
|
/// <param name="routerId"></param>
|
/// <returns></returns>
|
public async Task<ApiAction<RouteData>> GetRouteData(string routerId)
|
{
|
var res = new ApiAction<RouteData>();
|
RouteData rotData = new RouteData();
|
try
|
{
|
if (string.IsNullOrEmpty(routerId))
|
{
|
res.IsSuccessed = false;
|
res.LocaleMsg = new($"传入的工艺路线ID为空，不能查找工艺路线！");
|
return res;
|
}
|
//工艺路线
|
var route = await Db.Queryable<MES_ROUTE>()
|
.WhereIF(!string.IsNullOrEmpty(routerId), x => x.ID.Equals(routerId) || x.ROT_CODE == routerId)
|
.OrderBy(x => x.CREATE_TIME).FirstAsync();
|
rotData.route = route;
|
if (route == null)
|
{
|
res.IsSuccessed = false;
|
res.LocaleMsg = new($"不能查找到工艺路线！");
|
return res;
|
}
|
//节点
|
var nodes = await Db.Queryable<MES_ROUTE_NODE>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.ROT_ID.Equals(route.ID))
|
.ToListAsync();
|
foreach (var node in nodes)
|
{
|
node.node = new()
|
{
|
id = node.ID,
|
type = node.GPH_TYPE,
|
x = node.GPH_X,
|
y = node.GPH_Y,
|
properties = node.GPH_PROP,
|
text = new()
|
{
|
x = node.GPH_X,
|
y = node.GPH_Y,
|
value = node.GPH_TEXT
|
}
|
};
|
}
|
rotData.nodes = nodes;
|
|
var acts = await Db.Queryable<MES_ROUTE_NODE_ACT>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.ROT_ID.Equals(route.ID))
|
.ToListAsync();
|
foreach (var act in acts)
|
{
|
act.node = new()
|
{
|
id = act.ID,
|
type = act.GPH_TYPE,
|
x = act.GPH_X,
|
y = act.GPH_Y,
|
properties = act.GPH_PROP,
|
text = new()
|
{
|
x = act.GPH_X,
|
y = act.GPH_Y,
|
value = act.GPH_TEXT
|
}
|
};
|
}
|
rotData.acts = acts;
|
|
//边
|
var edges = await Db.Queryable<MES_ROUTE_EDGE>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.ROT_ID.Equals(route.ID))
|
.ToListAsync();
|
foreach (var edge in edges)
|
{
|
edge.edge = new()
|
{
|
id = edge.ID,
|
type = edge.GPH_TYPE,
|
sourceNodeId = edge.SRC_NODE,
|
targetNodeId = edge.TGT_NODE,
|
properties = edge.GPH_PROP,
|
startPoint = new()
|
{
|
x = edge.GPH_SRC_X,
|
y = edge.GPH_SRC_Y,
|
},
|
endPoint = new()
|
{
|
x = edge.GPH_TGT_X,
|
y = edge.GPH_TGT_Y,
|
},
|
pointsList = new()
|
{
|
new(){
|
x = edge.GPH_SRC_X,
|
y = edge.GPH_SRC_Y,
|
},
|
new(){
|
x = edge.GPH_TGT_X,
|
y = edge.GPH_TGT_Y,
|
}
|
}
|
};
|
}
|
rotData.edges = edges;
|
}
|
catch (Exception ex)
|
{
|
res.CatchExceptionWithLog(ex, "查询异常");
|
}
|
res.Data = rotData;
|
return res;
|
}
|
|
/// <summary>
|
/// 保存边数据
|
/// </summary>
|
/// <param name="routeEdge"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveEdges(List<MES_ROUTE_EDGE> routeEdge)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(routeEdge)
|
.WhereColumns(t => new { t.ID, t.GHOST_ROW })
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存边数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存边数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存节点数据
|
/// </summary>
|
/// <param name="routeNode"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveNodes(List<MES_ROUTE_NODE> routeNode)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(routeNode)
|
.WhereColumns(t => new { t.ID, t.GHOST_ROW })
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存节点数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存节点数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存行为
|
/// </summary>
|
/// <param name="routeAct"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveActs(List<MES_ROUTE_NODE_ACT> routeAct)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(routeAct)
|
.WhereColumns(t => new { t.ID, t.GHOST_ROW })
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存行为数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存行为数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存
|
/// </summary>
|
/// <param name="route"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveRoute(MES_ROUTE route)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var _route = Db.Queryable<MES_ROUTE>().Where(x => x.ROT_CODE == route.ROT_CODE).First();
|
//if (_route != null && Db.Queryable<MES_ROUTE_NODE>().Where(x => x.ROT_ID == _route.ID).Any())
|
//{
|
// result.IsSuccessed = false;
|
// result.LocaleMsg = new($"工艺路线已经有设计记录，不能保存！");
|
// return result;
|
//}
|
if (_route != null && Db.Queryable<MES_PROD_OPER>().Where(x => x.ROT_ID == _route.ID).Any())
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"工艺路线已经有绑定记录，不能保存！");
|
return result;
|
}
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(route)
|
//.WhereColumns(t => new { t.ROT_CODE, t.GHOST_ROW })
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.Message = $"保存工艺路线异常";
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存工艺路线异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存工艺路线图形数据
|
/// </summary>
|
/// <param name="routeData"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveRouteData(RouteData routeData)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var nodeIds = routeData.nodes.Select(x => x.ID).ToList();
|
var actIds = routeData.acts.Select(x => x.ID).ToList();
|
//如果工序节点ID没在产品工序里就新增
|
List<MES_PROD_OPER> operList = new List<MES_PROD_OPER>();
|
foreach (var node in routeData.nodes)
|
{
|
if (!Db.Queryable<MES_PROD_OPER>().Any(q => q.NODE_ID == node.ID && q.ROT_ID == routeData.route.ID))
|
{
|
operList.Add(new()
|
{
|
PROD_CODE = routeData.route.PROD_CODE,
|
CUST_CODE = routeData.route.CUST_CODE,
|
NODE_ID = node.ID,
|
NODE_NAME = node.NODE_NAME,
|
ROT_ID = node.ROT_ID,
|
OPER_CODE = node.OPER_CODE,
|
IS_ACTIVE = "Y",
|
CAN_SKIP = "N",
|
IS_CALC_FPY = "N",
|
ALLOW_DFT_IN = "N",
|
IS_INPUT = "N",
|
IS_OUTPUT = "N",
|
AUTH_ORG = node.AUTH_ORG,
|
AUTH_PROD = node.AUTH_PROD,
|
AUTH_WH = node.AUTH_WH,
|
});
|
}
|
}
|
//如果行为节点ID没在产品行为里就新增
|
List<MES_PROD_ACTION> actList = new List<MES_PROD_ACTION>();
|
foreach (var act in routeData.acts)
|
{
|
if (!Db.Queryable<MES_PROD_ACTION>().Any(q => q.ACT_ID == act.ID && q.ROT_ID == routeData.route.ID))
|
{
|
actList.Add(new()
|
{
|
PROD_CODE = routeData.route.PROD_CODE,
|
CUST_CODE = routeData.route.CUST_CODE,
|
NODE_ID = act.NODE_ID,
|
ACT_ID = act.ID,
|
ACT_TYPE = act.ACT_TYPE,
|
ROT_ID = act.ROT_ID,
|
ACT_CODE = act.ACT_CODE,
|
RULE_CODE = "",
|
ITEM_CODE = "",
|
TEST_CODE = "",
|
SAPL_CODE = "",
|
LABEL_CODE = "",
|
PKG_CODE = "",
|
IS_ACTIVE = "Y",
|
SETUP_FINISH = "N",
|
AUTH_ORG = act.AUTH_ORG,
|
AUTH_PROD = act.AUTH_PROD,
|
AUTH_WH = act.AUTH_WH,
|
});
|
}
|
}
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
if (routeData.route != null)
|
{
|
var y = db.Storageable(routeData.route)
|
.WhereColumns(t => new { t.ROT_CODE, t.GHOST_ROW })
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.IgnoreColumns(x => x.ID).ExecuteCommand();
|
}
|
if (!routeData.route.PROD_CODE.IsNullOrEmpty())
|
{
|
db.Deleteable<MES_PROD_OPER>().Where(x => x.PROD_CODE == routeData.route.PROD_CODE && !SqlFunc.ContainsArray(nodeIds, x.NODE_ID)).ExecuteCommand();
|
db.Deleteable<MES_PROD_ACTION>().Where(x => x.PROD_CODE == routeData.route.PROD_CODE && !SqlFunc.ContainsArray(actIds, x.ACT_ID)).ExecuteCommand();
|
}
|
db.Deleteable<MES_ROUTE_NODE>(false).Where(x => x.ROT_ID == routeData.route.ID).ExecuteCommand();
|
db.Deleteable<MES_ROUTE_EDGE>(false).Where(x => x.ROT_ID == routeData.route.ID).ExecuteCommand();
|
db.Deleteable<MES_ROUTE_NODE_ACT>(false).Where(x => x.ROT_ID == routeData.route.ID).ExecuteCommand();
|
if (routeData.nodes != null)
|
{
|
db.Insertable(routeData.nodes).ExecuteCommand();
|
}
|
if (routeData.edges != null)
|
{
|
db.Insertable(routeData.edges).ExecuteCommand();
|
}
|
if (routeData.acts != null)
|
{
|
db.Insertable(routeData.acts).ExecuteCommand();
|
}
|
if (!routeData.route.PROD_CODE.IsNullOrEmpty())
|
{
|
if (operList.Count > 0)
|
{
|
db.Insertable(operList).ExecuteCommand();
|
}
|
if (actList.Count > 0)
|
{
|
db.Insertable(actList).ExecuteCommand();
|
}
|
}
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存工艺路线图形数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存工艺路线图形数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 删除工艺路线
|
/// </summary>
|
/// <param name="routeId"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> DeleteRoute(string routeId)
|
{
|
var result = new ApiAction();
|
try
|
{
|
//查询是否已经有工单在用或者有绑定产品
|
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
db.Deleteable<MES_ROUTE_NODE>(false).Where(x => x.ROT_ID == routeId).ExecuteCommand();
|
db.Deleteable<MES_ROUTE_EDGE>(false).Where(x => x.ROT_ID == routeId).ExecuteCommand();
|
db.Deleteable<MES_ROUTE_NODE_ACT>(false).Where(x => x.ROT_ID == routeId).ExecuteCommand();
|
db.Deleteable<MES_ROUTE>().Where(x => x.ID == routeId).ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"删除工艺路线异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "删除工艺路线异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存节点岗位资源
|
/// </summary>
|
/// <param name="nodePost"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveRouteNodePost(List<MES_ROUTE_NODE_POST> nodePost)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(nodePost)
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存节点岗位资源数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存节点岗位资源数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 删除产品绑定的工艺路线
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
/// <exception cref="NotImplementedException"></exception>
|
public async Task<ApiAction> DeleteProdRoute(DelProdRotInput input)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var expable = Expressionable.Create<MES_PROD_ACTION>();
|
var expableOper = Expressionable.Create<MES_PROD_OPER>();
|
if (!string.IsNullOrEmpty(input.rotId))
|
{
|
expable.And(x => x.ROT_ID == input.rotId);
|
expableOper.And(x => x.ROT_ID == input.rotId);
|
}
|
else if (!string.IsNullOrEmpty(input.rotCode))
|
{
|
var item = await Db.Queryable<MES_ROUTE>().Where(x => x.ROT_CODE == input.rotCode).FirstAsync();
|
if (item != null)
|
{
|
expable.And(x => x.ROT_ID == item.ID);
|
expableOper.And(x => x.ROT_ID == item.ID);
|
}
|
}
|
if (!string.IsNullOrEmpty(input.prodCode))
|
{
|
expable.And(x => x.PROD_CODE == input.prodCode);
|
expableOper.And(x => x.PROD_CODE == input.prodCode);
|
}
|
var exp = expable.ToExpression();
|
var expOper = expableOper.ToExpression();
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
db.Deleteable<MES_PROD_ACTION>().Where(exp).ExecuteCommand();
|
db.Deleteable<MES_PROD_OPER>().Where(expOper).ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"删除工艺路线异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "删除工艺路线异常");
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 删除工单绑定的工艺路线
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
/// <exception cref="NotImplementedException"></exception>
|
public async Task<ApiAction> DeleteWoRoute(DelWoRotInput input)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var bizMesWo = await Db.Queryable<BIZ_MES_WO>().Where(x => x.ORDER_NO == input.wo).FirstAsync();
|
if (bizMesWo != null && bizMesWo.STATUS > (int)STATUSs.Imported && bizMesWo.STATUS < (int)STATUSs.Closed)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"工单状态为[{EnumHelper.GetDesc(EnumHelper.GetEnum<STATUSs>(bizMesWo.STATUS))}]，不能删除工艺路线");
|
return result;
|
}
|
var expableNode = Expressionable.Create<MES_WO_NODE>();
|
var expableEdge = Expressionable.Create<MES_WO_EDGE>();
|
var expableAct = Expressionable.Create<MES_WO_NODE_ACT>();
|
var expable = Expressionable.Create<MES_WO_ACTION>();
|
var expableOper = Expressionable.Create<MES_WO_OPER>();
|
var _rotId = input.rotId;
|
if (!string.IsNullOrEmpty(input.rotId))
|
{
|
expable.And(x => x.ROT_ID == input.rotId);
|
expableOper.And(x => x.ROT_ID == input.rotId);
|
expableNode.And(x => x.ROT_ID == input.rotId);
|
expableEdge.And(x => x.ROT_ID == input.rotId);
|
expableAct.And(x => x.ROT_ID == input.rotId);
|
}
|
else if (!string.IsNullOrEmpty(input.rotCode))
|
{
|
var item = await Db.Queryable<MES_ROUTE>().Where(x => x.ROT_CODE == input.rotCode).FirstAsync();
|
if (item != null)
|
{
|
_rotId = item.ID;
|
expable.And(x => x.ROT_ID == item.ID);
|
expableOper.And(x => x.ROT_ID == item.ID);
|
expableNode.And(x => x.ROT_ID == item.ID);
|
expableEdge.And(x => x.ROT_ID == item.ID);
|
expableAct.And(x => x.ROT_ID == item.ID);
|
}
|
}
|
//如果除了删除的当前工艺路线不存在其他绑定的工艺路线，则更新状态
|
if (bizMesWo != null && !Db.Queryable<MES_WO_NODE>().Where(x => x.WORK_ORDER == input.wo && x.ROT_ID != _rotId).Any())
|
{
|
bizMesWo.ROUTE_STATUS = (int)ROUTE_STATUSs.WaitSet;
|
bizMesWo.STATUS = (int)STATUSs.Init;
|
bizMesWo.ROUTE_CODE = "";
|
}
|
if (!string.IsNullOrEmpty(input.wo))
|
{
|
expable.And(x => x.WORK_ORDER == input.wo);
|
expableOper.And(x => x.WORK_ORDER == input.wo);
|
expableNode.And(x => x.WORK_ORDER == input.wo);
|
expableEdge.And(x => x.WORK_ORDER == input.wo);
|
expableAct.And(x => x.WORK_ORDER == input.wo);
|
}
|
var exp = expable.ToExpression();
|
var expOper = expableOper.ToExpression();
|
var expNode = expableNode.ToExpression();
|
var expEdge = expableEdge.ToExpression();
|
var expAct = expableAct.ToExpression();
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
db.Deleteable<MES_WO_ACTION>().Where(exp).ExecuteCommand();
|
db.Deleteable<MES_WO_OPER>().Where(expOper).ExecuteCommand();
|
db.Deleteable<MES_WO_NODE>().Where(expNode).ExecuteCommand();
|
db.Deleteable<MES_WO_EDGE>().Where(expEdge).ExecuteCommand();
|
db.Deleteable<MES_WO_NODE_ACT>().Where(expAct).ExecuteCommand();
|
db.Updateable(bizMesWo).ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"删除工艺路线异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "删除工艺路线异常");
|
}
|
return result;
|
}
|
|
#region 工单工艺路线相关
|
|
|
/// <summary>
|
/// 获取工单工艺路线图形数据
|
/// </summary>
|
/// <param name="workorder"></param>
|
/// <returns></returns>
|
public async Task<ApiAction<WoRouteData>> GetWoRouteData(string workorder)
|
{
|
var res = new ApiAction<WoRouteData>();
|
WoRouteData rotData = new WoRouteData();
|
try
|
{
|
if (string.IsNullOrEmpty(workorder))
|
{
|
res.IsSuccessed = false;
|
res.LocaleMsg = new($"传入的工艺路线ID为空，不能查找工艺路线！");
|
return res;
|
}
|
//工艺路线
|
var route = await Db.Queryable<BIZ_MES_WO, MES_ROUTE>((q, s) => new JoinQueryInfos(JoinType.Inner, q.ROUTE_CODE == s.ROT_CODE))
|
.Where((q, s) => q.ID.Equals(workorder) || q.ORDER_NO == workorder).Select((q, s) => new MES_ROUTE
|
{
|
ID = s.ID,
|
ROT_CODE = s.ROT_CODE,
|
ROT_NAME = s.ROT_NAME,
|
ROT_TYPE = s.ROT_TYPE,
|
ROT_VER = s.ROT_VER,
|
IS_ACTIVE = s.IS_ACTIVE,
|
REMARK = s.REMARK,
|
WORK_ORDER = q.ORDER_NO,
|
PROD_CODE = q.ITEM_CODE,
|
CUST_CODE = q.CUST_CODE,
|
}).FirstAsync();
|
rotData.route = route;
|
if (route == null)
|
{
|
res.IsSuccessed = false;
|
res.LocaleMsg = new($"不能查找到工单工艺路线！");
|
return res;
|
}
|
//节点
|
var nodes = await Db.Queryable<MES_WO_NODE>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.WORK_ORDER.Equals(route.WORK_ORDER))
|
.ToListAsync();
|
foreach (var node in nodes)
|
{
|
node.node = new()
|
{
|
id = node.ID,
|
type = node.GPH_TYPE,
|
x = node.GPH_X,
|
y = node.GPH_Y,
|
properties = node.GPH_PROP,
|
text = new()
|
{
|
x = node.GPH_X,
|
y = node.GPH_Y,
|
value = node.GPH_TEXT
|
}
|
};
|
}
|
rotData.nodes = nodes;
|
|
var acts = await Db.Queryable<MES_WO_NODE_ACT>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.WORK_ORDER.Equals(route.WORK_ORDER))
|
.ToListAsync();
|
foreach (var act in acts)
|
{
|
act.node = new()
|
{
|
id = act.ID,
|
type = act.GPH_TYPE,
|
x = act.GPH_X,
|
y = act.GPH_Y,
|
properties = act.GPH_PROP,
|
text = new()
|
{
|
x = act.GPH_X,
|
y = act.GPH_Y,
|
value = act.GPH_TEXT
|
}
|
};
|
}
|
rotData.acts = acts;
|
|
//边
|
var edges = await Db.Queryable<MES_WO_EDGE>()
|
.WhereIF(!string.IsNullOrEmpty(route.ID), x => x.WORK_ORDER.Equals(route.WORK_ORDER))
|
.ToListAsync();
|
foreach (var edge in edges)
|
{
|
edge.edge = new()
|
{
|
id = edge.ID,
|
type = edge.GPH_TYPE,
|
sourceNodeId = edge.SRC_NODE,
|
targetNodeId = edge.TGT_NODE,
|
properties = edge.GPH_PROP,
|
startPoint = new()
|
{
|
x = edge.GPH_SRC_X,
|
y = edge.GPH_SRC_Y,
|
},
|
endPoint = new()
|
{
|
x = edge.GPH_TGT_X,
|
y = edge.GPH_TGT_Y,
|
},
|
pointsList = new()
|
{
|
new(){
|
x = edge.GPH_SRC_X,
|
y = edge.GPH_SRC_Y,
|
},
|
new(){
|
x = edge.GPH_TGT_X,
|
y = edge.GPH_TGT_Y,
|
}
|
}
|
};
|
}
|
rotData.edges = edges;
|
}
|
catch (Exception ex)
|
{
|
res.CatchExceptionWithLog(ex, "查询异常");
|
}
|
res.Data = rotData;
|
return res;
|
}
|
|
/// <summary>
|
/// 保存工单工艺路线图形数据
|
/// </summary>
|
/// <param name="routeData"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveWoRouteData(WoRouteData routeData)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var nodeIds = routeData.nodes.Select(x => x.ID).ToList();
|
var actIds = routeData.acts.Select(x => x.ID).ToList();
|
//如果工序节点ID没在工单工序里就新增
|
List<MES_WO_OPER> operList = new List<MES_WO_OPER>();
|
foreach (var node in routeData.nodes)
|
{
|
if (!Db.Queryable<MES_WO_OPER>().Any(q => q.NODE_ID == node.ID))
|
{
|
operList.Add(new()
|
{
|
WORK_ORDER = node.WORK_ORDER,
|
PROD_CODE = node.PROD_CODE,
|
CUST_CODE = node.CUST_CODE,
|
NODE_ID = node.ID,
|
NODE_NAME = node.NODE_NAME,
|
ROT_ID = node.ROT_ID,
|
OPER_CODE = node.OPER_CODE,
|
IS_ACTIVE = "Y",
|
CAN_SKIP = "N",
|
IS_CALC_FPY = "N",
|
ALLOW_DFT_IN = "N",
|
IS_INPUT = "N",
|
IS_OUTPUT = "N",
|
AUTH_ORG = node.AUTH_ORG,
|
AUTH_PROD = node.AUTH_PROD,
|
AUTH_WH = node.AUTH_WH,
|
});
|
}
|
}
|
//如果行为节点ID没在工单行为里就新增
|
List<MES_WO_ACTION> actList = new List<MES_WO_ACTION>();
|
foreach (var act in routeData.acts)
|
{
|
if (!Db.Queryable<MES_WO_ACTION>().Any(q => q.ACT_ID == act.ID))
|
{
|
actList.Add(new()
|
{
|
WORK_ORDER = act.WORK_ORDER,
|
PROD_CODE = act.PROD_CODE,
|
CUST_CODE = act.CUST_CODE,
|
NODE_ID = act.NODE_ID,
|
ACT_ID = act.ID,
|
ACT_TYPE = act.ACT_TYPE,
|
ROT_ID = act.ROT_ID,
|
ACT_CODE = act.ACT_CODE,
|
RULE_CODE = "",
|
ITEM_CODE = "",
|
TEST_CODE = "",
|
SAPL_CODE = "",
|
LABEL_CODE = "",
|
PKG_CODE = "",
|
IS_ACTIVE = "Y",
|
SETUP_FINISH = "N",
|
AUTH_ORG = act.AUTH_ORG,
|
AUTH_PROD = act.AUTH_PROD,
|
AUTH_WH = act.AUTH_WH,
|
});
|
}
|
}
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
//if (routeData.route != null)
|
//{
|
// var y = db.Storageable(routeData.route)
|
// .WhereColumns(t => new { t.ROT_CODE, t.GHOST_ROW })
|
// .ToStorage();
|
// y.AsInsertable.ExecuteCommand();
|
// y.AsUpdateable.IgnoreColumns(x => x.ID).ExecuteCommand();
|
//}
|
db.Deleteable<MES_WO_OPER>().Where(x => x.WORK_ORDER == routeData.route.WORK_ORDER && !SqlFunc.ContainsArray(nodeIds, x.NODE_ID)).ExecuteCommand();
|
db.Deleteable<MES_WO_ACTION>().Where(x => x.WORK_ORDER == routeData.route.WORK_ORDER && !SqlFunc.ContainsArray(actIds, x.ACT_ID)).ExecuteCommand();
|
db.Deleteable<MES_WO_NODE>(false).Where(x => x.WORK_ORDER == routeData.route.WORK_ORDER).ExecuteCommand();
|
db.Deleteable<MES_WO_EDGE>(false).Where(x => x.WORK_ORDER == routeData.route.WORK_ORDER).ExecuteCommand();
|
db.Deleteable<MES_WO_NODE_ACT>(false).Where(x => x.WORK_ORDER == routeData.route.WORK_ORDER).ExecuteCommand();
|
if (routeData.nodes != null)
|
{
|
db.Insertable(routeData.nodes).ExecuteCommand();
|
}
|
if (routeData.edges != null)
|
{
|
db.Insertable(routeData.edges).ExecuteCommand();
|
}
|
if (routeData.acts != null)
|
{
|
db.Insertable(routeData.acts).ExecuteCommand();
|
}
|
if (operList.Count>0)
|
{
|
db.Insertable(operList).ExecuteCommand();
|
}
|
if (actList.Count > 0)
|
{
|
db.Insertable(actList).ExecuteCommand();
|
}
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存工单工艺路线图形数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存工单工艺路线图形数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
|
/// <summary>
|
/// 保存工单工艺节点岗位资源
|
/// </summary>
|
/// <param name="nodePost"></param>
|
/// <returns></returns>
|
public async Task<ApiAction> SaveWoRouteNodePost(List<MES_WO_NODE_POST> nodePost)
|
{
|
var result = new ApiAction();
|
try
|
{
|
var db = Db;
|
var dbTran = db.UseTran(() =>
|
{
|
var y = db.Storageable(nodePost)
|
.ToStorage();
|
y.AsInsertable.ExecuteCommand();
|
y.AsUpdateable.ExecuteCommand();
|
});
|
if (!dbTran.IsSuccess)
|
{
|
result.IsSuccessed = false;
|
result.LocaleMsg = new($"保存工单工艺节点岗位资源数据异常");
|
}
|
}
|
catch (Exception ex)
|
{
|
result.CatchExceptionWithLog(ex, "保存工单工艺节点岗位资源数据异常");
|
}
|
return await Task.FromResult(result);
|
}
|
#endregion
|
} //endClass Route
|
} //endClass Biz
|
}
|
