kunshan-bzfm-mes-backend/DOAN.Service/MES/Base/BaseWorkRouteService.cs

using System;
using System.Linq;
using System.Reflection;
using DOAN.Model;
using DOAN.Model.MES.base_;
using DOAN.Model.MES.base_.Dto;
using DOAN.Repository;
using DOAN.Service.MES.base_.IService;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using JinianNet.JNTemplate.Dynamic;
using SqlSugar;

namespace DOAN.Service.MES.base_
{
    /// <summary>
    /// 工艺路线Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IBaseWorkRouteService), ServiceLifetime = LifeTime.Transient)]
    public class BaseWorkRouteService : BaseService<BaseWorkRoute>, IBaseWorkRouteService
    {
        /// <summary>
        /// 查询工艺路线列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<BaseWorkRouteDto_bind_process> GetList(BaseWorkRouteQueryDto parm)
        {
            List<BaseWorkProcessesDto3> baseWorks = Context.Queryable<BaseRelWorkRouteProcesses>()
                  .LeftJoin<BaseWorkProcesses>((r, p) => r.FkWorkProcesses == p.Id)
                  .Where((r, p) => r.FkWorkRoute != null)
                  .Select((r, p) => new BaseWorkProcessesDto3()
                  {
                      fk_id = r.FkWorkRoute
                  }, true)
                  .ToList();
            var predicate = Expressionable
                .Create<BaseWorkRoute>()
                .AndIF(!string.IsNullOrEmpty(parm.Name), it => it.Name.Contains(parm.Name))
                .AndIF(!string.IsNullOrEmpty(parm.Code), it => it.Code.Contains(parm.Code))
                .AndIF(!string.IsNullOrEmpty(parm.ProductionCode), it => it.Code.Contains(parm.ProductionCode))
                .AndIF(parm.Status > -1, it => it.Status == parm.Status);
            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<BaseWorkRoute, BaseWorkRouteDto_bind_process>(parm);
            
            if (response != null && response.Result.Count > 0)
            {
                foreach (var item in response.Result)
                {
                    item.BaseWorkProcessesList = baseWorks.Where(it => it.fk_id == item.Id).ToList();
                }

            }

            return response;
        }




        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public BaseWorkRoute GetInfo(int Id)
        {
            var response = Queryable().Where(x => x.Id == Id).First();

            return response;
        }

        /// <summary>
        /// 添加工艺路线
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public BaseWorkRoute AddBaseWorkRoute(BaseWorkRoute model)
        {
            return Context.Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改工艺路线
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateBaseWorkRoute(BaseWorkRoute model)
        {
            //var response = Update(w => w.Id == model.Id, it => new BaseWorkRoute()
            //{
            //    Name = model.Name,
            //    Status = model.Status,
            //    Remark = model.Remark,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //    Code = model.Code,
            //    LogicFlowData = model.LogicFlowData,
            //});
            //return response;
            return Update(model, true);
        }

        /// <summary>
        /// 工艺路线解析后绑定工序
        /// </summary>
        /// <param name="baseParseNodeDto"></param>
        /// <returns></returns>
        public int ParseRouteBindProccess(BaseParseNodeDto baseParseNodeDto)
        {
            int result = 0;
            //TODO  1  解析string->object
            BaseParseNode baseParse = JsonConvert.DeserializeObject<BaseParseNode>(baseParseNodeDto.LogicFlowData);

            //TODO  2  获取绑定的节点
            //int[] workProcess = null;
            //if (baseParse != null && (baseParse.nodes.Count() > 0))
            //{
            //    // 绑定的工序id
            //    workProcess = new int[baseParse.nodes.Count()];
            //    int index = 0;
            //    foreach (var node in baseParse.nodes)
            //    {
            //        workProcess[index] = node.properties.processesId;
            //        index++;
            //    }

            //}

            //TODO 3   排序
            // 找到首节点  首节点没有终点target
            List<BaseRelWorkRouteProcesses> need_insert_node = new List<BaseRelWorkRouteProcesses>();
            string first_node_id = "";// 首节点id
            foreach (var node in baseParse.nodes)
            {
                int count = 0;
                foreach (var edge in baseParse.edges)
                {
                    if (node.id == first_node_id)
                    {
                        count++;
                    }
                }
                if (count == 0)
                {
                    first_node_id = node.id;
                    break;

                }

            }
            BaseRelWorkRouteProcesses firstnode = new BaseRelWorkRouteProcesses();
            firstnode.FkWorkProcesses = baseParse.nodes.Where(it => it.id == first_node_id).Select(it => it.properties.processesId).FirstOrDefault();
            firstnode.Sort = 0;
            firstnode.FkWorkRoute = baseParseNodeDto.FkRouteCode;
            firstnode.CreatedTime = DateTime.Now;
            need_insert_node.Add(firstnode);
            //----------------------------------------
           
            string levels = first_node_id;
            int index3 = 0;
            while (true)
            {
                index3++;
                string next_id = baseParse.edges.Where(it => it.sourceNodeId == levels).Select(it => it.targetNodeId).FirstOrDefault();
                if (!string.IsNullOrEmpty(next_id))
                {
                    levels = next_id;
                    BaseRelWorkRouteProcesses nextnode = new BaseRelWorkRouteProcesses();
                    nextnode.FkWorkProcesses = baseParse.nodes.Where(it => it.id == levels).Select(it => it.properties.processesId).FirstOrDefault(); ;
                    nextnode.Sort = index3;
                    nextnode.FkWorkRoute = baseParseNodeDto.FkRouteCode;
                    nextnode.CreatedTime = DateTime.Now;
                    need_insert_node.Add(nextnode);
                }
                else
                {
                    break;
                }
            }


            //TODO 4  解绑 然后更新
            UseTran2(() =>
            {
                Context.Deleteable<BaseRelWorkRouteProcesses>()
                  .Where(it => it.FkWorkRoute == baseParseNodeDto.FkRouteCode)
                  .ExecuteCommand();
                result = Context.Insertable(need_insert_node).ExecuteCommand();
            });
            return result;
        }


    }
}