获取过程变量优化

Rodney Chen

2024-07-29 201b456883c4d4799561fd17acec3f8c2111445f

 Tiger.Business/MES/Biz.Route.cs

@@ -10,8 +10,9 @@
using System.Linq;
using Newtonsoft.Json;
using Tiger.IBusiness;
using static Tiger.Business.Biz;
using Microsoft.AspNetCore.Http;
using Tiger.Model.Entitys.WMS.DTOS;
using static Tiger.Model.BIZ_MES_WO;

namespace Tiger.Business
{
@@ -56,14 +57,26 @@
                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.ROT_CODE.Equals(routerId))
                        .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(routerId), x => x.ROT_ID.Equals(routerId))
                        .WhereIF(!string.IsNullOrEmpty(route.ID), x => x.ROT_ID.Equals(route.ID))
                        .ToListAsync();
                    foreach (var node in nodes)
                    {
@@ -84,9 +97,31 @@
                    }
                    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(routerId), x => x.ROT_ID.Equals(routerId))
                        .WhereIF(!string.IsNullOrEmpty(route.ID), x => x.ROT_ID.Equals(route.ID))
                        .ToListAsync();
                    foreach (var edge in edges)
                    {
@@ -152,7 +187,7 @@
                    if (!dbTran.IsSuccess)
                    {
                        result.IsSuccessed = false;
                        result.Message = $"保存边数据异常";
                        result.LocaleMsg = new($"保存边数据异常");
                    }
                }
                catch (Exception ex)
@@ -184,7 +219,7 @@
                    if (!dbTran.IsSuccess)
                    {
                        result.IsSuccessed = false;
                        result.Message = $"保存节点数据异常";
                        result.LocaleMsg = new($"保存节点数据异常");
                    }
                }
                catch (Exception ex)
@@ -195,11 +230,11 @@
            }

            /// <summary>
            /// 保存
            /// 保存行为
            /// </summary>
            /// <param name="router"></param>
            /// <param name="routeAct"></param>
            /// <returns></returns>
            public async Task<ApiAction> SaveRoute(MES_ROUTE router)
            public async Task<ApiAction> SaveActs(List<MES_ROUTE_NODE_ACT> routeAct)
            {
                var result = new ApiAction();
                try
@@ -207,7 +242,46 @@
                    var db = Db;
                    var dbTran = db.UseTran(() =>
                    {
                        var y = db.Storageable(router)
                        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;
                    }
                    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();
@@ -236,11 +310,6 @@
                var result = new ApiAction();
                try
                {
                    var actionNode = await SaveNodes(routeData.nodes);
                    if (!actionNode.IsSuccessed) { return actionNode; }
                    var actionEdge = await SaveEdges(routeData.edges);
                    if (!actionEdge.IsSuccessed) { return actionEdge; }

                    var db = Db;
                    var dbTran = db.UseTran(() =>
                    {
@@ -252,11 +321,26 @@
                            y.AsInsertable.ExecuteCommand();
                            y.AsUpdateable.IgnoreColumns(x => x.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 (!dbTran.IsSuccess)
                    {
                        result.IsSuccessed = false;
                        result.Message = $"保存工艺路线图形数据异常";
                        result.LocaleMsg = new($"保存工艺路线图形数据异常");
                    }
                }
                catch (Exception ex)
@@ -265,6 +349,208 @@
                }
                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;
            }
        }
    }
}