kunshan-bzfm-mes-backend/DOAN.Service/MES/Product/ProWorkorderUtilityService.cs

using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Service.MES.product.IService;
using Infrastructure;
using Infrastructure.Attribute;

namespace DOAN.Service.MES.product
{
    /// <summary>
    /// 工单工具服务
    /// </summary>
    [AppService(
        ServiceType = typeof(IProWorkorderUtilityService),
        ServiceLifetime = LifeTime.Transient
    )]
    public class ProWorkorderUtilityService : BaseService<ProWorkorder>, IProWorkorderUtilityService
    {
        /// <summary>
        /// 生成工单号
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public int Generate_workorder(ProWorkorderQueryDto2 parm)
        {
            DateTime update_time = parm.WorkorderDate.ToLocalTime().Date;

            List<ProWorkorder> proWorkorderList = Context
                .Queryable<ProWorkorder>()
                .Where(it => it.WorkorderDate == update_time)
                .Where(it => it.Status == 1)
                .OrderBy(it => it.Sort)
                .ToList();
            string maxs = Context
                .Queryable<ProWorkorder>()
                .Where(it => it.WorkorderDate == update_time)
                .Where(it => it.Status == 3)
                .Max(it => it.Workorder);

            if (proWorkorderList != null && proWorkorderList.Count() > 0)
            {
                string baseSort = update_time.ToString("yyyyMMdd");
                int index = 1;
                if (!string.IsNullOrEmpty(maxs))
                {
                    index = Convert.ToInt32(maxs.Substring(maxs.Length - 3)) + 1;
                }

                foreach (ProWorkorder item in proWorkorderList)
                {
                    item.Workorder = baseSort + index.ToString("000");
                    item.Sort = index * 10;
                    index++;
                }
            }

            return Context.Updateable(proWorkorderList).ExecuteCommand();
        }

        /// <summary>
        /// 移动工单
        /// </summary>
        /// <param name="id"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public int MoveWorkorder(string id, int type)
        {
            int result = 0;

            try
            {
                // 获取要移动的工单
                ProWorkorder toMove = Context
                    .Queryable<ProWorkorder>()
                    .Where(it => it.Id == id)
                    .First();

                // 检查工单是否存在
                if (toMove == null)
                {
                    return result;
                }

                // 检查Sort值是否存在
                if (!toMove.Sort.HasValue)
                {
                    return result;
                }

                ProWorkorder exchange = null;

                // 上移动：找到Sort值小于当前工单的最大Sort值的工单
                if (type == 1)
                {
                    exchange = Context
                        .Queryable<ProWorkorder>()
                        .Where(it => it.WorkorderDate == toMove.WorkorderDate)
                        .Where(it => it.PlanNum > 0) 
                        .Where(it => it.Sort.HasValue && it.Sort < toMove.Sort)
                        .OrderByDescending(it => it.Sort)
                        .First();
                }
                // 下移：找到Sort值大于当前工单的最小Sort值的工单
                else if (type == 2)
                {
                    exchange = Context
                        .Queryable<ProWorkorder>()
                        .Where(it => it.WorkorderDate == toMove.WorkorderDate)
                        .Where(it => it.PlanNum > 0) 
                        .Where(it => it.Sort.HasValue && it.Sort > toMove.Sort)
                        .OrderBy(it => it.Sort)
                        .First();
                }

                // 检查交换工单是否存在
                if (exchange != null && exchange.Sort.HasValue)
                {
                    // 使用事务确保两个工单的Sort值同时更新
                    UseTran2(() =>
                    {
                        // 交换Sort值
                        int temp = toMove.Sort.Value;
                        toMove.Sort = exchange.Sort;
                        exchange.Sort = temp;

                        // 更新工单
                        result += Context.Updateable(toMove).ExecuteCommand();
                        result += Context.Updateable(exchange).ExecuteCommand();
                    });
                }
            }
            catch (Exception ex)
            {
                // 记录错误日志
                Console.WriteLine($"移动工单时出错: {ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 查询BOM及其所需数量
        /// </summary>
        /// <param name="workorder_num"></param>
        /// <returns></returns>
        public List<WorkOrderBom> SearchBOMNum(string workorder_num)
        {
            // 这里需要实现BOM查询逻辑
            // 暂时返回空列表
            return new List<WorkOrderBom>();
        }

        /// <summary>
        /// 工单变更日志
        /// </summary>
        /// <param name="workorder"></param>
        /// <param name="log"></param>
        /// <param name="Operator"></param>
        /// <returns></returns>
        public List<ProWorkorderUpdateLog> WorkOrderLog(string workorder)
        {
            var result = Context
                .Queryable<ProWorkorderUpdateLog>()
                .Where(it => it.Workorder == workorder)
                .OrderByDescending(it => it.ChangeTime)
                .ToList();
            return result;
        }

        /// <summary>
        /// 导出PDF
        /// </summary>
        /// <param name="workorderArray"></param>
        /// <returns></returns>
        public Task<(string, Stream)> ExportPDFByQuestPDFDemo(string[] workorderArray)
        {
            // 这里需要实现PDF导出逻辑
            // 暂时返回空结果
            return Task.FromResult(("", (Stream)new MemoryStream()));
        }

        /// <summary>
        /// 打印工单
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public Task<CustomException> PrintTicketsByTemplate(ProWorkorderExportDto param)
        {
            // 这里需要实现工单打印逻辑
            // 暂时返回成功
            return Task.FromResult((CustomException)null);
        }
    }
}