MES / MES-BaseMes10.0 · Files

using Hh.Mes.Common.Infrastructure;
using Hh.Mes.Common.log;
using Hh.Mes.Common.Request;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.Response;
using Hh.Mes.Service.Repository;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Hh.Mes.Pojo.System;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.WebEntity.EntityExtension;

namespace Hh.Mes.Service.Base
{
    public class BaseProjectService : RepositorySqlSugar<base_project>
    {
        public dynamic Load(PageReq pageReq, base_project entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var result = new Response();
                var expression = LinqWhere(entity);
                //先组合查询表达式(多表查询查看IOT 设备列表案例)
                var query = Context.Queryable<base_project>().Where(expression);
                //Exel false 分页
                if (!entity.Exel)
                {
                    int total = 0;
                    var list = query.ToOffsetPage(pageReq.page, pageReq.limit, ref total);
                    result.Result = HandleProjectInfo(list);
                    result.Count = total;
                }
                else
                {
                    result.Result = HandleProjectInfo(query.ToList());
                    result.Count = result.Result.Count();
                }
                return result;
            }, catchRetrunValue: "list");
        }

        public dynamic Ins(base_project entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                entity.projectNo = DateTime.Now.ToString("yyyyMMddhhmmss");
                //entity.createBy = sysWebUser.Account;
                entity.createTime = DateTime.Now;
                entity.keys = Guid.NewGuid();
                entity.state = 0;//默认 未开始状态
                response.Status = Add(entity);
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic Upd(base_project entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                //entity.updateBy = sysWebUser.Account;
                //entity.updateTime = DateTime.Now;
                response.Status = Update(entity);
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public dynamic DelByIds(int[] ids)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                //项目没有绑定工单，是初始化状态才能删除
                var list = Context.Queryable<base_project>().Where(i => ids.Contains(i.id)).ToList();
                foreach (var id in ids)
                {
                    var query = list.Where(i => i.id == id).FirstOrDefault();
                    if (query != null)
                    {
                        var isBindOrder = Context.Queryable<base_project_production_order>().Any(i => i.projectKeys == query.keys);
                        if (query.state != (int)EnumProjectState.未开始)
                        {
                            return response.ResponseError("项目非初始化状态，不允许删除！！！");
                        }
                        if (isBindOrder)
                        {
                            return response.ResponseError("项目已经绑定工单，不允许删除！！！");
                        }
                        else
                        {
                            Context.Deleteable<base_project>(query).AddQueue();
                        }
                    }

                }
                response.Status = Context.SaveQueues() > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response;
            });
        }

        public Response ExportData(base_project entity)
        {
            var response = new Response();
            //返回异常数据报错，传空数组给前端
            var sheet1 = Load(null, entity);
            var sheet2 = GetProjectQualityData(entity.keys);
            response.Result = new
            {
                head = sheet1 is string ? "[]" : sheet1.Result,
                body = sheet2 is string ? "[]" : sheet2.Result
            };
            return response;
        }


        public Expression<Func<base_project, bool>> LinqWhere(base_project model)
        {
            try
            {
                var exp = Expressionable.Create<base_project>();
                //数据过滤条件
                //if (!string.IsNullOrWhiteSpace(model.XXX)) exp.And(x => x.XXX.Contains(model.XXX));
                if (!string.IsNullOrWhiteSpace(model.projectName))
                {
                    exp.And(x => x.projectName.Contains(model.projectName));
                }
                if (!string.IsNullOrWhiteSpace(model.projectNo))
                {
                    exp.And(x => x.projectNo.Contains(model.projectNo));
                }
                if (!string.IsNullOrWhiteSpace(model.temp1))
                {
                    exp.And(x => x.temp1.Contains(model.temp1));
                }
                return exp.ToExpression();//拼接表达式
            }
            catch (Exception ex)
            {
                throw new Exception($"{ex.Message}");
            }
        }

        public dynamic BindProjectProcess(Guid keys, Guid processKeys, bool checkeds)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                base_project projectEntity = Context.Queryable<base_project>()
                                        .Where(x => x.keys.Equals(keys)).First();
                if (checkeds)
                {
                    projectEntity.processKeys = processKeys;
                }
                else
                {
                    projectEntity.processKeys = Guid.Empty;
                }
                response.Status = Context.Updateable<base_project>(projectEntity).ExecuteCommand() > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response.ResponseSuccess();
            });
        }
        /// <summary>
        /// 启动/终止项目 0未开始，10生产中，20生产结束，30生产终止
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public dynamic StartOrEndProject(base_project entity)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();
                var project = Context.Queryable<base_project>().Where(x => x.keys.Equals(entity.keys)).First();
                if (entity.state == (int)EnumProjectState.未开始 || entity.state == (int)EnumProjectState.生产终止)
                {
                    //启动项目
                    if (entity.state == (int)EnumProjectState.未开始)
                    {
                        response = ProjectTaskGenerate(entity.keys);
                        if (response.Code != (int)RetCode.SUCCESS)
                        {
                            return response;
                        }
                    }

                    project.state = (int)EnumProjectState.生产中;
                    project.actualStartTime = DateTime.Now.ToString();
                    project.updateTime = DateTime.Now;

                }
                else if (entity.state == (int)EnumProjectState.生产中)
                {
                    //终止项目
                    project.state = (int)EnumProjectState.生产终止;
                    project.updateTime = DateTime.Now;
                }
                response.Status = Context.Updateable<base_project>(project).ExecuteCommand() > 0;
                if (!response.Status) response.Message = SystemVariable.dataActionError;
                return response.ResponseSuccess();
            });
        }

        #region 项目管理-质检任务生成-生产工单生成

        /// <summary>
        /// 项目管理-质检任务生成-生产工单生成
        /// </summary>
        /// <param name="keys">项目keys</param>
        /// <returns></returns>
        public dynamic ProjectTaskGenerate(Guid keys)
        {
            var response = new Response();
            try
            {
                #region  数据验证

                //项目
                var project = Context.Queryable<base_project>().Where(x => x.keys == keys).First();
                if (project == null)
                {
                    return response.ResponseError($"未找到项目数据，请核对！");
                }

                if (project.state != (int)EnumProjectState.未开始)
                {
                    return response.ResponseError($"项目已开始或终止不能进行操作，请核对！");
                }

                //项目工单
                var projectOrder = Context.Queryable<base_project_production_order, base_productionOrder_EP3D>((a, b) => new JoinQueryInfos(
                         JoinType.Left, a.productionOrderKey == b.keys))
                         .Where((a, b) =>
                             b.state == (int)EnumEP3DState.已关联
                             && a.projectKeys == keys
                         ).Select((a, b) => new
                         {
                             b.keys,
                             b.pipelineNo,
                             b.weldingPointNo1,
                             b.weldingMaterial1,
                             b.weldingPointNo2,
                             b.weldingMaterial2,
                             b.pagination,
                             b.pipeSectionNo,
                             b.pipelineGrade,
                             b.pipeLength,
                             b.pipeMaterialCode,
                             b.pipeNumber,
                             b.batchNo
                         }).ToList();
                if (projectOrder.Count <= 0)
                {
                    return response.ResponseError($"项目未关联工单，请核对！");
                }

                //工艺路线
                var processHead = Context.Queryable<base_process_route_head>()
                   .Where(x => x.keys == project.processKeys).First();
                if (processHead == null)
                {
                    return response.ResponseError($"项目未关联工艺路线，请核对！");
                }
                var processDetail = Context.Queryable<base_process_route_detail>()
                    .Where(x => x.headkeys == project.processKeys).OrderBy(x => x.oprSequence, OrderByType.Asc).ToList();
                if (processDetail.Count <= 0)
                {
                    return response.ResponseError($"工艺路线明细为空，请核对！");
                }
                #endregion

                #region 按工单生成数据
                int i = 1;
                //生成工单数据
                foreach (var order in projectOrder)
                {
                    #region  生成工序任务头 bus_workOrder_head
                    var busWorkOrderHead = new bus_workOrder_head
                    {
                        keys = Guid.NewGuid(),
                        topKeys = project.keys,
                        plmeId = order.batchNo + "_" + i.ToString(),
                        workOrderCode = project.projectNo + "_" + i.ToString(),
                        workOrderName = project.projectName + "_生产订单",
                        planCode = project.projectNo + "_" + i.ToString(),
                        processHeadKeys = processHead.keys,//工艺路线keys
                        processCode = processHead.processCode,        //工艺路线编码

                        productHeaderCode = "ep3d",
                        productName = "EP3D工单",

                        factoryCode = "lin4",
                        lineCode = "lin4",
                        orderType = ((int)EnumOrderType.EP3D生产订单).ToString(),
                        edition = processHead.edition,

                        projectCode = project.projectNo,   //项目编码
                        projectName = project.projectName,
                        lineNo = order.pipelineNo.Trim(),               //管线号/图纸号

                        planStartTime = project.scheduledStartTime,
                        planEndTime = project.scheduledEntTime,

                        otherOrderCode = project.projectNo,
                        state = (int)EnumOrderHeadStatus.初始化,
                        isDelete = 1,
                        createTime = DateTime.Now,
                        createBy = SystemVariable.DefaultCreated
                    };

                    // 设置工序任务头的当前工序，为第一个工序任务明细的工序
                    if (processDetail.Count > 0)
                    {
                        busWorkOrderHead.nowOprSequenceCode = processDetail[0].oprSequenceCode;
                    }

                    Context.Insertable(busWorkOrderHead).AddQueue();
                    i++;
                    #endregion

                    foreach (var item in processDetail)
                    {
                        var qualityDetail = new List<base_qualityStencil_detail>();
                        if (item.inspectionFlag == (int)EnumQualityisExecute.是)
                        {
                            qualityDetail = Context.Queryable<base_qualityStencil_detail>()
                               .Where(x => x.headKey == item.qualityKey && x.state == (int)EnumQuality.启用).ToList();

                            if (qualityDetail.Count <= 0)
                            {
                                return response.ResponseError($"工序【{item.oprSequenceCode}】有质检要求，但是关联的质检模板没有明细，请核对！");
                            }
                        }

                        #region  生成工序任务明细 busWorkOrderDetailList
                        var busWorkOrderDetailList = new List<bus_workOrder_detail>();
                        var nowWorkDetail = new bus_workOrder_detail
                        {
                            headKeys = busWorkOrderHead.keys,
                            productHeaderCode = busWorkOrderHead.productHeaderCode,
                            workOrderCode = busWorkOrderHead.workOrderCode,

                            cutMaterCode = order.pipeMaterialCode,
                            cuttingLength = order.pipeLength,

                            lineCode = busWorkOrderHead.lineCode,
                            designNo = order.pagination,
                            designUrl = order.pipelineNo + ".pdf",

                            barCode = order.pipeSectionNo,
                            partCode = order.pipelineNo.Trim(),

                            serialNumber = item.oprSequence,
                            oprSequenceCode = item.oprSequenceCode,
                            oprSequenceName = item.oprSequenceName,
                            workCenterCode = item.workCenterCode,
                            planStartTime = busWorkOrderHead.planStartTime,
                            planEndTime = busWorkOrderHead.planEndTime,

                            isEndProduct = 1,
                            isDelete = 1,
                            state = (int)EnumOrderBodyStatus.初始化,
                            workReportStatus = (int)EnumWorkReportStatus.未报工,
                            createTime = DateTime.Now,
                            createBy = SystemVariable.DefaultCreated
                        };
                        nowWorkDetail.bodyKeys = Guid.NewGuid();
                        nowWorkDetail.serialNumberName = nowWorkDetail.serialNumber + "_1";

                        //如果是组对或焊接需要补充焊口信息
                        if (item.workCenterCode == WorkCenterCode.组对 || item.workCenterCode == WorkCenterCode.焊接 || item.workCenterCode == WorkCenterCode.组焊)
                        {
                            nowWorkDetail.weldNo = order.weldingPointNo1;
                            nowWorkDetail.weldMaterCode = order.weldingMaterial1;
                            busWorkOrderDetailList.Add(nowWorkDetail);

                            if (!string.IsNullOrEmpty(order.weldingPointNo2))
                            {
                                var nowWorkDetai2 = new bus_workOrder_detail
                                {
                                    headKeys = busWorkOrderHead.keys,
                                    productHeaderCode = busWorkOrderHead.productHeaderCode,
                                    workOrderCode = busWorkOrderHead.workOrderCode,

                                    cutMaterCode = order.pipeMaterialCode,
                                    cuttingLength = order.pipeLength,

                                    lineCode = busWorkOrderHead.lineCode,
                                    designNo = order.pagination,
                                    designUrl = order.pipelineNo + ".pdf",

                                    barCode = order.pipeSectionNo,
                                    partCode = order.pipelineNo.Trim(),

                                    serialNumber = item.oprSequence,
                                    oprSequenceCode = item.oprSequenceCode,
                                    oprSequenceName = item.oprSequenceName,
                                    workCenterCode = item.workCenterCode,
                                    planStartTime = busWorkOrderHead.planStartTime,
                                    planEndTime = busWorkOrderHead.planEndTime,

                                    isEndProduct = 1,
                                    isDelete = 1,
                                    state = (int)EnumOrderBodyStatus.初始化,
                                    workReportStatus = (int)EnumWorkReportStatus.未报工,
                                    createTime = DateTime.Now,
                                    createBy = SystemVariable.DefaultCreated
                                };

                                nowWorkDetai2.bodyKeys = Guid.NewGuid();
                                nowWorkDetai2.serialNumberName = nowWorkDetail.serialNumber + "_2";
                                nowWorkDetai2.weldNo = order.weldingPointNo2;
                                nowWorkDetai2.weldMaterCode = order.weldingMaterial2;
                                busWorkOrderDetailList.Add(nowWorkDetai2);
                            }
                        }
                        else
                        {
                            busWorkOrderDetailList.Add(nowWorkDetail);
                        }

                        Context.Insertable(busWorkOrderDetailList).AddQueue();
                        #endregion

                        #region  生成质检任务
                        if (item.inspectionFlag == (int)EnumQualityisExecute.是)
                        {
                            foreach (var detail in qualityDetail)
                            {
                                var bqualityExecute = new base_qualityStencil_Execute
                                {
                                    keys = Guid.NewGuid(),
                                    projectKey = keys,
                                    workOrderDetailKey = nowWorkDetail.bodyKeys,
                                    qualityDetailKey = detail.keys,
                                    isExecute = (int)EnumQualityisExecute.是,//目前直接设置为是，正式项目需要改为否，需要上一工序完成后修改
                                    executeResult = (int)EnumQualityExecute.未执行,
                                    state = (int)EnumQuality.启用,
                                    createTime = DateTime.Now,
                                    updateTime = DateTime.Now
                                };

                                Context.Insertable(bqualityExecute).AddQueue();
                            }
                        }
                        #endregion
                    }
                }
                var inCount = Context.SaveQueues();
                if (inCount <= 0)
                {
                    response.ResponseError($"数据保存数据库失败！");
                }

                #endregion

            }
            catch (Exception ex)
            {
                return response.ResponseError($"{ex.Message}！");
            }

            return response;
        }
        #endregion

        /// <summary>
        /// 查询相关表数据
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public List<base_project> HandleProjectInfo(List<base_project> list)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                if (list != null)
                {
                    var all = Context.Queryable<base_project, base_process_route_head>((p, r) =>
                                    new JoinQueryInfos(JoinType.Left, p.processKeys == r.keys))
                                   .Select((p, r) => new
                                   {
                                       p.keys,
                                       r.processName
                                   })
                                   .ToList();
                    foreach (var p in list)
                    {
                        var query = all.Where(x => x.keys == p.keys).First();
                        p.processName = query.processName;
                    }
                }
                return list;
            });
        } 


        /// <summary>
        /// 获取项目质检数据
        /// </summary>
        /// <param name="keys">项目keys</param>
        /// <returns></returns>
        public dynamic GetProjectQualityData(Guid keys)
        {
            return ExceptionsHelp.Instance.ExecuteT(() =>
            {
                var response = new Response();

                var all = Context.Queryable<base_qualityStencil_Execute, bus_workOrder_detail, base_qualityStencil_detail>((a, b, c) =>
                                   new JoinQueryInfos(JoinType.Left, a.workOrderDetailKey == b.bodyKeys, JoinType.Left, a.qualityDetailKey == c.keys))
                                   .Where((a, b, c) => a.projectKey == keys)
                                  .Select((a, b, c) => new
                                  {
                                      c.describe,//质检要求
                                      a.isExecute,//是否可执行
                                      a.executeUser,//执行人
                                      a.executeResult,//执行结果10合格，20不合格
                                      a.executeTime,//执行时间
                                      a.handleUser,//处理人
                                      a.handleResult,//处理结果 0未处理 ,10通过 ,20下线线下处理 ,30作废 
                                      a.handleTime,//处理时间
                                      b.batchNo,//管线号
                                      b.barCode,//管段码
                                      b.cuttingLength,//管段长度
                                      b.cutMaterCode,//管段物料码
                                      b.oprSequenceCode,//工序code
                                      b.oprSequenceName,//工序name
                                      b.weldNo,//焊口号
                                      b.weldMaterCode,//焊口物料码
                                      b.designUrl,//图纸
                                  })
                                  .ToList();

                var resultList = all.Select(i => new QualityStencilResult
                {
                    describe = i.describe,
                    isExecute = i.isExecute,
                    executeUser = i.executeUser,
                    executeResult = i.executeResult,
                    executeTime = i.executeTime,
                    handleUser = i.handleUser,
                    handleResult = i.handleResult,
                    handleTime = i.handleTime,
                    batchNo = i.batchNo,
                    barCode = i.barCode,
                    cuttingLength = i.cuttingLength,
                    cutMaterCode = i.cutMaterCode,
                    oprSequenceCode = i.oprSequenceCode,
                    oprSequenceName = i.oprSequenceName,
                    weldNo = i.weldNo,
                    weldMaterCode = i.weldMaterCode,
                    designUrl = i.designUrl,
                    isExecuteName = Enum.GetName(typeof(EnumQualityisExecute), i.isExecute), // 添加isExecuteName
                    executeResultName = Enum.GetName(typeof(EnumQualityExecute), i.executeResult), // 添加isExecuteName
                    handleResultName = Enum.GetName(typeof(EnumHandleResult), i.handleResult), // 添加isExecuteName
                }).ToList();
                response.Result = resultList;
                return response;
            });
        }
    }
}