zhuangpei-mesbackend/DOAN.Service/MES/process/ProcessmodelWorkStepService.cs

using Aliyun.OSS;
using DOAN.Model;
using DOAN.Model.Business;
using DOAN.Model.Dto;
using DOAN.Model.MES.dev;
using DOAN.Model.MES.dev.Dto;
using DOAN.Model.MES.process;
using DOAN.Repository;
using DOAN.Service.Business.IBusinessService;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using JinianNet.JNTemplate;
using NPOI.SS.Formula.Functions;
using NPOI.XSSF.Streaming.Values;
using SqlSugar;
using System;
using System.Linq;
using UAParser;

namespace DOAN.Service.Business
{
    /// <summary>
    /// Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IProcessmodelWorkStepService), ServiceLifetime = LifeTime.Transient)]
    public class ProcessmodelWorkStepService : BaseService<ProcessmodelWorkStep>, IProcessmodelWorkStepService
    {
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProcessmodeWorkStepDto> GetList(ProcessmodelWorkStepQueryDto parm)
        {
            var predicate = Expressionable.Create<ProcessmodelWorkStep>()
                                          .AndIF(!string.IsNullOrEmpty(parm.ProcessCode), p => p.ProcessCode.Contains(parm.ProcessCode))
                                          .AndIF(!string.IsNullOrEmpty(parm.StepCode), p => p.StepCode.Contains(parm.StepCode))
                                          .AndIF(!string.IsNullOrEmpty(parm.StepName), p => p.StepName.Contains(parm.StepName));

            var response = Queryable()
                .Where(predicate.ToExpression())
                .GroupBy(p => p.StepCode)
                .ToPage<ProcessmodelWorkStep, ProcessmodeWorkStepDto>(parm);

            return response;
        }


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

            return response;
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ProcessmodelWorkStep AddProcessmodelWorkStep(ProcessmodelWorkStep model)
        {
            return Context.Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProcessmodelWorkStep(ProcessmodelWorkStep model)
        {
            return Update(model, true);
        }

        /// <summary>
        /// 获取设备列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<UniqueValueQueryDto> GetUniqueValueList(UniqueDto parm)
        {
            // 1. 初始化分页结果
            var pagedResult = new PagedInfo<UniqueValueQueryDto>
            {
                PageIndex = parm.PageNum < 1 ? 1 : parm.PageNum, // 页码最小为1
                PageSize = parm.PageSize < 1 || parm.PageSize > 100 ? 10 : parm.PageSize // 每页条数限制1-100
            };

            // 2. 校验 StepCode 是否存在（不存在返回空分页）
            bool stepCodeExists = Context.Queryable<ProcessmodelWorkStep>()
                .Where(p => p.StepCode == parm.StepCode)
                .Any();

            if (!stepCodeExists)
            {
                pagedResult.TotalNum = 0;
                pagedResult.Result = new List<UniqueValueQueryDto>();
                return pagedResult;
            }

            // 3. 构建查询
            var baseQuery = Context.Queryable<ProcessmodelWorkStep>()
                .Where(p => p.StepCode == parm.StepCode)
                .Distinct() 
                .LeftJoin<DeviceAccount>((ws, da) => ws.UniqueValue == da.DeviceCode)
                .Where((ws, da) => da != null)
                .WhereIF(!string.IsNullOrEmpty(parm.DeviceCode), (ws, da) => da.DeviceCode.Contains(parm.DeviceCode))
                .WhereIF(!string.IsNullOrEmpty(parm.DeviceName), (ws, da) => da.DeviceName.Contains(parm.DeviceName))
                .Select((ws, da) => new UniqueValueQueryDto
                {
                    Id = ws.Id,
                    DeviceCode = ws.UniqueValue,
                    DeviceName = da.DeviceName,
                    Workshop = da.Workshop,
                    Workline = da.Workline,
                    Status = da.Status,
                    DeviceSpecification = da.DeviceSpecification,
                    ResponsiblePerson = da.ResponsiblePerson
                });

            // 4. 查询总记录数
            pagedResult.TotalNum = baseQuery.Count();

            // 5. 分页查询数据
            int skipCount = (pagedResult.PageIndex - 1) * pagedResult.PageSize;
            pagedResult.Result = baseQuery
                .Skip(skipCount) 
                .Take(pagedResult.PageSize)
                .ToList();

            return pagedResult;
        }

        public List<WorkshopDto> GetAccountList()
        {
            // 1. SqlSugar 链式查询
            var flatData = Context.Queryable<DeviceAccount>()
                .Where(d => !string.IsNullOrEmpty(d.Workshop) && !string.IsNullOrEmpty(d.Workline))
                .Select(d => new
                {
                    d.Workshop,
                    d.Workline,
                    d.DeviceCode,
                    d.DeviceName
                })
                .ToList();

            // 2. 手动构建 DTO 结构
            var result = new List<WorkshopDto>();

            // 先获取所有不重复的车间
            var allWorkshops = flatData.Select(d => d.Workshop).Distinct().ToList();

            foreach (var workshop in allWorkshops)
            {
                // 构建当前车间 DTO
                var workshopDto = new WorkshopDto { Workshop = workshop };

                // 获取当前车间下的所有数据
                var workshopData = flatData.Where(d => d.Workshop == workshop).ToList();

                // 获取当前车间下不重复的产线
                var allWorklines = workshopData.Select(d => d.Workline).Distinct().ToList();

                foreach (var workline in allWorklines)
                {
                    // 构建当前产线 DTO
                    var worklineDto = new WorklineDto { Workline = workline };

                    // 获取当前产线下的所有设备
                    var devices = workshopData
                        .Where(d => d.Workline == workline)
                        .Select(d => new DeviceDto
                        {
                            DeviceCode = d.DeviceCode,
                            DeviceName = d.DeviceName
                        })
                        .ToList();

                    worklineDto.Devices = devices;
                    workshopDto.Worklines.Add(worklineDto);
                }

                result.Add(workshopDto);
            }

            return result;
        }

        /// <summary>
        /// 新增设备
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        /// <exception cref="Exception"></exception>
        public int AddUniqueValue(UniqueQueryDto parm)
        {

            // 查询工步基础信息
            var workStep = Context.Queryable<ProcessmodelWorkStep>()
                .Where(x => x.StepCode == parm.StepCode && x.ProcessCode == parm.ProcessCode)
                .First();

            if (workStep == null)
            {
                throw new Exception("未找到对应的工步信息");
            }

            // 插入新的工步记录
            var newWorkStep = new ProcessmodelWorkStep
            {
                StepCode = workStep.StepCode,
                StepName = workStep.StepName,
                ProcessCode = workStep.ProcessCode,
                Description = workStep.Description,
                IsActive = workStep.IsActive,
                UniqueValue = parm.DeviceCode,
                CreateTime = DateTime.Now
            };

            return Context.Insertable(newWorkStep).ExecuteCommand();
        }

        /// <summary>
        /// 获取工序表
        /// </summary>
        public List<ProcessListDto> GetModelProcessList()
        {
            var response = Context.Queryable<ProcessmodelProcess>()
                                  .Select(p => new ProcessListDto
                                  {
                                      ProcessCode = p.ProcessCode,
                                      ProcessName = p.ProcessName,
                                  })
                                  .ToList();
            return response;
        }
    }
}