guiyang-fluorescent-line-lmes-backend/RIZO.Service/Mes/WorkOrderInfo/WorkOrderService.cs

using Infrastructure.Attribute;
using Infrastructure.Extensions;
using RIZO.Model.Mes.Dto.GatherData;
using RIZO.Model.Mes.Dto.WorkOrderInfo;
using RIZO.Model.Mes.MasterData;
using RIZO.Model.Mes.Material;
using RIZO.Model.Mes.WorkOrderInfo;
using RIZO.Repository;
using RIZO.Service.Mes.IMesService.MasterData;
using RIZO.Service.Mes.IMesService.Material;
using RIZO.Service.Mes.IMesService.WorkOrderInfo;
using RIZO.Service.Mes.MasterData;
using RIZO.Service.Mes.Material;
using RIZO.Service.Mes.Process;

namespace RIZO.Service.Mes.WorkOrderInfo
{
    /// <summary>
    /// 工单主表Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IWorkOrderService), ServiceLifetime = LifeTime.Transient)]
    public class WorkOrderService : BaseService<WorkOrder>, IWorkOrderService
    {
        private MaterialInfoService materialInfoService = new MaterialInfoService();
        private PlcFirstCodeService plcFirstCodeService = new PlcFirstCodeService();
        private WorkOrderItemService workOrderItemService = new WorkOrderItemService();
        
        /// <summary>
        /// 查询工单主表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<WorkOrderDto> GetList(WorkOrderQueryDto parm)
        {
            var predicate = QueryExp(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<WorkOrder, WorkOrderDto>(parm);

            return response;
        }


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

            return response;
        }

        /// <summary>
        /// 添加工单主表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WorkOrder AddWorkOrder(WorkOrder model)
        {
            return Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改工单主表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateWorkOrder(WorkOrder model)
        {
            return Update(model, true);
        }

        /// <summary>
        /// 查询导出表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<WorkOrder> QueryExp(WorkOrderQueryDto parm)
        {
            var predicate = Expressionable.Create<WorkOrder>();
            if (!string.IsNullOrWhiteSpace(parm.LineCode))
            {
                predicate.And(it => it.LineCode.Contains(parm.LineCode));
            }
            if (!string.IsNullOrWhiteSpace(parm.LineName))
            {
                predicate.And(it => it.LineName.Contains(parm.LineName));
            }
            if (!string.IsNullOrWhiteSpace(parm.WorkOrderCode))
            {
                predicate.And(it => it.WorkOrderCode.Contains(parm.WorkOrderCode));
            }
            if (!string.IsNullOrWhiteSpace(parm.OrderDate))
            {
                predicate.And(it => it.OrderDate.Contains(parm.OrderDate));
            }
            return predicate;
        }

        public WorkOrderItem CreateDataBySacnCode(ScanCodeParm parm)
        {
            try
            {
                WorkOrderItem workOrderItems = new WorkOrderItem();
                string strLineCode = parm.LineCode;
                string strProcessCode = parm.ProcessCode;
                string strIdCode = parm.IDCode;
                string strMaterialCode = strIdCode;
                string strLineName = parm.LineName;
                string strProcessName = parm.ProcessName;
                //根据IDCode解析的数据去检索物料档案
                MaterialInfo material = (MaterialInfo)materialInfoService.Queryable().Where(it => it.MaterialCode == strMaterialCode);
                if (material != null)
                {
                    string strDay = DateTime.Now.ToString("yyyyMMdd");
                    string strWorkOrderCode = createWorkOrder(strDay, strLineCode, strLineName);
                    string strPlcCode = createWorkOrderItem(strWorkOrderCode, strMaterialCode, strLineCode, strLineName, strProcessCode, strProcessName, strIdCode, material);
                }
                return workOrderItems;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        //根据工单主表号去创建工单从表数据
        private string createWorkOrderItem(string strWorkOrderCode, string strMaterialCode, string strLineCode, string strLineName, string strProcessCode, string strProcessName, string strIdCode, MaterialInfo material)
        {
            string plcCode = "";
            string materialCode = material.MaterialCode;
            string strFeature = material.Feature;
            List<PlcFirstCode> plcFirstCodes = plcFirstCodeService.Queryable()
                .Where(it => it.LineCode == strLineCode && (it.Feature == "ALL" || it.Feature == strFeature)).ToList();
            string strPlcFirstCode = "";
            if (plcFirstCodes != null && plcFirstCodes.Any())
            {
                strPlcFirstCode = plcFirstCodes[0].FirstCode;
            }
            int Sequcence = 1;
            WorkOrderItem workOrderItem = workOrderItemService.Queryable()
                .Where(it => it.WorkOrderCode == strWorkOrderCode).OrderByDescending(it => it.Sequcence).First();
            if (workOrderItem != null)
            {
                Sequcence = workOrderItem.Sequcence;
                Sequcence += 1;
            }
            string formattedSequence = Sequcence.ToString("D4");
            string strWorkOrderItemCode = strWorkOrderCode + formattedSequence;
            plcCode = strPlcFirstCode + materialCode + strWorkOrderItemCode;
            WorkOrderItem workOrderItem1 = new WorkOrderItem();
            workOrderItem1.WorkOrderCode = strWorkOrderCode;
            workOrderItem1.WorkOrderItemCode = strWorkOrderItemCode;
            workOrderItem.PlcCode = plcCode;
            workOrderItem1.ProcessCode = strProcessCode;
            workOrderItem1.ProcessName = strProcessName;
            workOrderItem1.MaterialCode = materialCode;
            workOrderItem1.MaterialName = material.MaterialName;
            workOrderItem1.Sequcence = Sequcence;
            int iFlag = workOrderItemService.Insert(workOrderItem1);
            return plcCode;
        }

        //去寻找特定日期，特定产线的工单，若存在返回工单号，若不存在创建再返回工单号
        private string createWorkOrder(string strDay, string strLineCode, string strLineName)
        {
            try
            {
                string workOrderCode = "";
                WorkOrder WorkOrder = (WorkOrder)Queryable()
                    .Where(it => it.OrderDate == strDay && it.LineCode == strLineCode);
                if (WorkOrder != null)
                {
                    workOrderCode = WorkOrder.WorkOrderCode;
                }
                else
                {
                    WorkOrder orderInfoNew = new WorkOrder();
                    orderInfoNew.OrderDate = strDay;
                    orderInfoNew.WorkOrderCode = strLineCode + strDay;
                    orderInfoNew.LineCode = strLineCode;
                    orderInfoNew.LineName = strLineName;
                    orderInfoNew.OrderDate = strDay;
                    orderInfoNew.OrderStatus = 1;
                    workOrderCode = orderInfoNew.WorkOrderCode;
                    int iFlag = Update(orderInfoNew);
                }
                return workOrderCode;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
    }
}