shgx_tz_mom/ZR.Service/mes/pro/ProWorkorderServiceV2.cs

using System;
using System.IO;
using Infrastructure;
using Infrastructure.Attribute;
using Microsoft.AspNetCore.Hosting;
using MiniExcelLibs;
using Model.DBModel;
using SqlSugar;
using ZR.Model.MES.pro;
using ZR.Model.MES.pro.DTO;
using ZR.Model.MES.wms;
using ZR.Service.mes.pro.IService;

namespace ZR.Service.mes.pro
{
    [AppService(ServiceType = typeof(IProWorkorderServiceV2), ServiceLifetime = LifeTime.Transient)]
    public class ProWorkorderServiceV2 : BaseService<ProWorkorder_v2>, IProWorkorderServiceV2
    {
        public (List<ProWorkOrder>, int) GetWorkorderList(
            int pageNum,
            int pageSize,
            int year,
            int week,
            int date,
            int isSchedule
        )
        {
            var predicate = Expressionable
                .Create<ProWorkorder_v2>()
                .AndIF(year > 0, it => it.Year == year)
                .AndIF(week > 0, it => it.Week == week)
                .AndIF(date > 0, it => it.Date == date)
                .ToExpression();

            int totalCount = 0;
            List<ProWorkorder_v2> proWorkorderList = Context
                .Queryable<ProWorkorder_v2>()
                .Where(predicate)
                .OrderBy(it => it.Sort)
                .ToPageList(pageNum, pageSize, ref totalCount);
            List<ProWorkOrder> orders = new();
            foreach (ProWorkorder_v2 item in proWorkorderList)
            {
                ProWorkOrder proWorkOrder =
                    new()
                    {
                        Id = item.Id,
                        Week = item.Week,
                        Year = item.Year,
                        Date = item.Date,
                        BlankNumber = item.BlankNumber,
                        ClientWorkorder = item.ClientWorkorder,
                        FinishedPartNumber = item.FinishedPartNumber,
                        ProductDescription = item.ProductDescription,
                        Specifications = item.Specifications,
                        Colour = item.Colour,
                        CodeNumber = item.CodeNumber,
                        CylinderNumber = item.CylinderNumber,
                        PQualifiedNum = item.PQqualifiedNum,
                        PQualifiedRate = item.PQqualifiedRate,
                        hangNumber = item.hangNumber,
                        PreviousNumber = item.PreviousNumber,
                        VehicleNumber = item.VehicleNumber,
                        CreatedBy = item.CreatedBy,
                        CreatedTime = item.CreatedTime,
                        UpdatedBy = item.UpdatedBy,
                        UpdatedTime = item.UpdatedTime,
                        Sort = item.Sort,
                        Status = item.Status,
                        Remark1 = item.Remark1,
                        Remark2 = item.Remark2,
                        Remark3 = item.Remark3,
                        Remark4 = item.Remark4,
                    };
                proWorkOrder.State = CheckWorkOrder(item);
                orders.Add(proWorkOrder);
            }

            return (orders, totalCount);
        }

        public (List<ProWorkorder_v2>, int) GetWorkorderList_Piliang(
            int pageNum,
            int pageSize,
            int year,
            int week,
            int date,
            int isSchedule
        )
        {
            var predicate = Expressionable
                .Create<ProWorkorder_v2>()
                .AndIF(year > 0, it => it.Year == year)
                .AndIF(week > 0, it => it.Week == week)
                .AndIF(date > 0, it => it.Date == date)
                .ToExpression();

            int totalCount = 0;
            List<ProWorkorder_v2> proWorkorderList = Context
                .Queryable<ProWorkorder_v2>()
                .Where(predicate)
                .Where(it => it.Remark3 == "是")
                .OrderBy(it => it.Sort)
                .ToPageList(pageNum, pageSize, ref totalCount);

            return (proWorkorderList, totalCount);
        }

        /// <summary>
        /// 获取生产计划id
        /// </summary>
        /// <returns></returns>
        private int Getworkplanid_max()
        {
            ProWorkorder_v2 max_workoder = Context
                .Queryable<ProWorkorder_v2>()
                .OrderBy(it => it.Id, OrderByType.Desc)
                .First();
            if (
                max_workoder != null
                && !string.IsNullOrEmpty(max_workoder.Id)
                && max_workoder.Id.Substring(2, 8) == DateTime.Now.ToString("yyyyMMdd")
            )
            {
                int num = Convert.ToInt32(max_workoder.Id.Substring(10)) + 1;
                return num;
            }
            else
            {
                return 0;
            }
        }

        public string ImportExceldata(List<ProWorkorder_v2> workorderList)
        {
            int max_id = Getworkplanid_max();

            // 更新生产计划
            if (workorderList != null && workorderList.Count > 0)
            {
                workorderList.ForEach(item =>
                {
                    item.Id = "WO" + DateTime.Now.ToString("yyyyMMdd") + max_id.ToString("000");
                    item.Remark4 = "Excel导入";
                    // 添加属性 ------》 排序规则是 年周日+序列号（000）
                    item.Sort = Convert.ToInt32(
                        item.Year.ToString("0000").Substring(2)
                            + item.Week.ToString("00")
                            + item.Date.ToString("00")
                            + workorderList.IndexOf(item).ToString("000")
                    );

                    if (item.Remark2 == "批量")
                    {
                        item.Remark3 = "是";
                    }
                    item.Status = 0;

                    max_id++;
                });

                foreach (ProWorkorder_v2 item in workorderList)
                {
                    // 修正计划
                    ProWorklplan_v2 planItem = Context
                        .Queryable<ProWorklplan_v2>()
                        .Where(it => it.Id == item.FinishedPartNumber)
                        .First();
                    if (planItem != null)
                    {
                        Context
                            .Updateable<ProWorklplan_v2>()
                            .Where(it => it.Id == planItem.Id)
                            .SetColumns(it =>
                                it.NoSchedule == planItem.RequireNum - item.hangNumber
                            )
                            .ExecuteCommandAsync();
                    }
                }

                UseTran(() =>
                {
                    // 删除之前的工单
                    Context
                        .Deleteable<ProWorkorder_v2>()
                        .Where(it => it.Year == workorderList[0].Year)
                        .Where(it => it.Week == workorderList[0].Week)
                        .Where(it => it.Date == workorderList[0].Date)
                        .ExecuteCommand();

                    //插入
                    Context.Insertable(workorderList).ExecuteCommand();
                });

                return "success";
            }

            //var x = Context.Storageable(workorderList)
            //                 .SplitUpdate(it => it.Any())//存在更新
            //                 .SplitInsert(it => true)//否则插入（更新优先级大于插入）
            //                 .WhereColumns(it => new { it.Year, it.Week, it.Date, it.FinishedPartNumber })//如果不是主键可以这样实现（多字段it=>new{it.x1,it.x2}）
            //                 .ToStorage();

            //x.AsInsertable.ExecuteCommand();//插入可插入部分;
            //x.AsUpdateable.IgnoreColumns(it => it.Id).ExecuteCommand();//存在更新

            //string msg = string.Format(" 插入{0} 更新{1} 错误数据{2} 不计算数据{3} 删除数据{4} 总共{5}",
            //                   x.InsertList.Count,
            //                   x.UpdateList.Count,
            //                   x.ErrorList.Count,
            //                   x.IgnoreList.Count,
            //                   x.DeleteList.Count,
            //                   x.TotalList.Count);


            return ""; //插入可插入部分
        }

        /// <summary>
        /// 下载
        /// </summary>
        /// <param name="year"></param>
        /// <param name="week"></param>
        /// <param name="date"></param>
        /// <returns></returns>
        public (string, string) ExportExceldata(int year, int week, int date)
        {
            //1.0 读取表数据
            var list = Queryable()
                .Where(it => it.Year == year && it.Week == week && it.Date == date)
                .OrderBy(it => it.Sort)
                .ToList();

            //2.0 保存为excel
            IWebHostEnvironment webHostEnvironment = (IWebHostEnvironment)
                App.ServiceProvider.GetService(typeof(IWebHostEnvironment));
            string sFileName = $"{year}年{week}周{date}日计划-{DateTime.Now:MM-dd-HHmmss}.xlsx";
            string fullPath = Path.Combine(webHostEnvironment.WebRootPath, "export", sFileName);
            Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
            var Sheet1 = new
            {
                year = year,
                week = week,
                date = date,
                title = $"{year}年车镜实业涂装事业{week}周{date}生产滚动表",

                workorder = list
            };
            string templatePath = Path.Combine(
                webHostEnvironment.WebRootPath,
                "ImportTemplate",
                "日生产计划模板1.xlsx"
            );
            MiniExcel.SaveAsByTemplate(fullPath, templatePath, Sheet1);
            // MiniExcel.SaveAs(fullPath, list);
            //3.0 返回路径和文件名
            return (sFileName, fullPath);
        }

        /// <summary>
        /// 删除周计划全部
        /// </summary>
        /// <param name="week"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int DeleteAllWorkorder(int year, int week, int date)
        {
            return Context
                .Deleteable<ProWorkorder_v2>()
                .Where(it => it.Year == year && it.Week == week && it.Date == date)
                .ExecuteCommand();
        }

        /// <summary>
        /// 获取生产计划id
        /// </summary>
        /// <returns></returns>
        private int Getworkorderid_max()
        {
            ProWorkorder_v2 max_workorder = Context
                .Queryable<ProWorkorder_v2>()
                .OrderBy(it => it.Id, OrderByType.Desc)
                .First();
            if (
                max_workorder != null
                && !string.IsNullOrEmpty(max_workorder.Id)
                && max_workorder.Id.Substring(2, 8) == DateTime.Now.ToString("yyyyMMdd")
            )
            {
                int num = Convert.ToInt32(max_workorder.Id.Substring(10)) + 1;
                return num;
            }
            else
            {
                return 0;
            }
        }

        public int AddWorkOrder(ProWorkorder_v2 workorder)
        {
            workorder.Id =
                "WO" + DateTime.Now.ToString("yyyyMMdd") + Getworkorderid_max().ToString("000");
            workorder.Remark4 = "手动插入";
            workorder.Status = 0;
            if (workorder.Remark2 == "批量")
            {
                workorder.Remark3 = "是";
            }
            // 更改以下工单的顺序
            if (workorder.Sort > 0)
            {
                int max = Convert.ToInt32(workorder.Sort.ToString().Substring(0, 6) + "999");
                Context
                    .Updateable<ProWorkorder_v2>()
                    .Where(it => it.Sort >= workorder.Sort && it.Sort <= max)
                    .SetColumns(it => it.Sort == it.Sort + 1)
                    .ExecuteCommand();
            }

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

        public int DeleteWorkOrder(string id)
        {
            return Context.Deleteable<ProWorkorder_v2>().In(id).ExecuteCommand();
        }

        public int UpdateWorkOrder(ProWorkorder_v2 workorder)
        {
            workorder.Status = 0;
            if (workorder.Remark2 == "批量")
            {
                workorder.Remark3 = "是";
            }
            else
            {
                workorder.Remark3 = "";
            }

            return Context
                .Updateable(workorder)
                .IgnoreColumns(it => new
                {
                    it.CreatedBy,
                    it.CreatedTime,
                    it.Remark4,
                    it.Sort
                })
                .ExecuteCommand();
        }

        /// <summary>
        /// 更改工单顺序
        /// </summary>
        /// <param name="id">工单id</param>
        /// <param name="sort">新位置占据的排序值</param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int UpdateworkorderSort(string id, int sort)
        {
            if (sort > 0)
            {
                int finalreuslt = 0;

                int max = Convert.ToInt32(sort.ToString().Substring(0, 6) + "999");

                int result = Context
                    .Updateable<ProWorkorder_v2>()
                    .Where(it => it.Sort >= sort && it.Sort <= max)
                    .SetColumns(it => it.Sort == it.Sort + 1)
                    .ExecuteCommand();

                if (result > 0)
                {
                    finalreuslt = Context
                        .Updateable<ProWorkorder_v2>()
                        .Where(it => it.Id == id)
                        .SetColumns(it => it.Sort == sort)
                        .ExecuteCommand();
                }
                return finalreuslt;
            }

            return 0;
        }

        /// <summary>
        /// 工单开始
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int StartWorkOrder(string id)
        {
            return Context
                .Updateable<ProWorkorder_v2>()
                .Where(it => it.Id == id)
                .SetColumns(it => it.Status == 1)
                .ExecuteCommand();
        }

        /// <summary>
        /// 工单上线取消
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int CancelWorkOrder(string id)
        {
            return Context
                .Updateable<ProWorkorder_v2>()
                .Where(it => it.Id == id)
                .SetColumns(it => it.Status == 0)
                .ExecuteCommand();
        }

        /// <summary>
        /// 生成工单号
        /// </summary>
        /// <param name="year"></param>
        /// <param name="week"></param>
        /// <param name="date"></param>
        /// <returns></returns>

        public int GenerateWorkorder(int year, int week, int date)
        {
            if (year > 0 && week > 0 && date > 0)
            {
                DateTime week_first = GetWeekStartTime(year, week);

                string date_now = week_first.AddDays(date - 1).ToString("yyMMdd");
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"生成工单号前缀{date_now}");
                List<ProWorkorder_v2> workorderList = Context
                    .Queryable<ProWorkorder_v2>()
                    .Where(it => it.Year == year && it.Week == week && it.Date == date)
                    .Where(it => it.Remark3 == "是")
                    .ToList();

                foreach (ProWorkorder_v2 item in workorderList)
                {
                    int index = workorderList.IndexOf(item) + 1;
                    item.ClientWorkorder = date_now + index.ToString("000");
                }

                return Context.Updateable(workorderList).ExecuteCommand();
            }
            return 0;
        }

        /// <summary>
        /// 它接受年份和一年中的周数和星期几作为输入，并返回对应的日期。
        /// </summary>
        /// <param name="year"></param>
        /// <param name="week"></param>
        /// <param name="date"></param>
        /// <returns></returns>
        static DateTime GetDateFromWeek(int year, int weekNumber, DayOfWeek dayOfWeek)
        {
            DateTime jan1 = new DateTime(year, 1, 1);
            int daysOffset = (int)dayOfWeek - (int)jan1.DayOfWeek;

            DateTime firstDayOfWeek = jan1.AddDays(7 * (weekNumber - 1) - daysOffset + 2);
            return firstDayOfWeek;
        }

        /// <summary>
        /// 当前周的第一天(星期一)
        /// </summary>
        /// <param name="yearWeek">周数，格式：yyyywww</param>
        /// <returns></returns>
        private DateTime GetWeekStartTime(int year, int weekNum)
        {
            //本年1月1日
            DateTime firstOfYear = new DateTime(year, 1, 1);
            //周数

            //本年1月1日与本周星期一相差的天数
            int dayDiff =
                (
                    firstOfYear.DayOfWeek == DayOfWeek.Sunday
                        ? 7
                        : Convert.ToInt32(firstOfYear.DayOfWeek)
                ) - 1;
            //第一周的星期一
            DateTime firstDayOfFirstWeek = firstOfYear.AddDays(-dayDiff);
            //当前周的星期一
            DateTime firstDayOfThisWeek = firstDayOfFirstWeek.AddDays((weekNum - 1) * 7);
            return firstDayOfThisWeek;
        }

        public int UpdateworkorderSort2(string oldId, int oldSort, string newId, int newSort)
        {
            int finalreuslt = 0;
            int result1 = Context
                .Updateable<ProWorkorder_v2>()
                .Where(it => it.Id == oldId)
                .SetColumns(it => it.Sort == newSort)
                .ExecuteCommand();
            int result2 = Context
                .Updateable<ProWorkorder_v2>()
                .Where(it => it.Id == newId)
                .SetColumns(it => it.Sort == oldSort)
                .ExecuteCommand();
            if (result1 > 0 && result2 > 0)
            {
                finalreuslt = 1;
            }
            return finalreuslt;
        }

        public int UpdateWorkOrderStatus(string id, int status)
        {
            return Context
                .Updateable<ProWorkorder_v2>()
                .Where(it => it.Id == id)
                .SetColumns(it => it.Status == status)
                .ExecuteCommand();
        }

        /// <summary>
        /// 判断
        /// </summary>
        /// <param name="proWorkplan"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public int CheckWorkOrder(ProWorkorder_v2 proWorkorder)
        {
            try
            {
                if (string.IsNullOrEmpty(proWorkorder.FinishedPartNumber))
                {
                    return 0;
                }
                WmMaterial material = Context
                    .Queryable<WmMaterial>()
                    .Where(it => it.Partnumber == proWorkorder.FinishedPartNumber)
                    // .Where(it => it.Status == 1)
                    .First();
                // 物料号不存在
                if (material == null)
                {
                    return 1;
                }
                // 毛坯号异常
                if (
                    !string.IsNullOrEmpty(material.BlankNum)
                    && material.BlankNum != proWorkorder.BlankNumber
                )
                {
                    return 2;
                }
                // 颜色异常
                if (
                    !string.IsNullOrEmpty(material.Color)
                    && !material.Color.Contains(proWorkorder.Colour)
                )
                {
                    return 3;
                }
                // 规格异常
                if (
                    !string.IsNullOrEmpty(material.Specification)
                    && !material.Specification.Contains(proWorkorder.Specifications)
                )
                {
                    return 4;
                }
                // 描述异常不包含
                if (
                    !string.IsNullOrEmpty(material.Description)
                    && !material.Description.Contains(proWorkorder.ProductDescription)
                )
                {
                    return 5;
                }
                // 全部正常
                return 0;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
    }
}