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

using Infrastructure.Attribute;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using ZR.Common;
using ZR.Service.mes.pro.IService;
using ZR.Service.MES.md.IService;
using static System.Net.WebRequestMethods;
using JinianNet.JNTemplate;
using static Aliyun.OSS.Model.LiveChannelStat;
using ZR.Model.MES.pro.DTO;
using ZR.Model.MES.qu;
using ZR.Model.MES.pro;
using Model.DBModel;
using Infrastructure;
using Microsoft.AspNetCore.Hosting;
using MiniExcelLibs;
using System.IO;
using SqlSugar.Extensions;
using ZR.Model.mes.pro;
using SqlSugar;

namespace ZR.Service.mes.pro
{
    [AppService(ServiceType = typeof(IProWorkorderServiceV2), ServiceLifetime = LifeTime.Transient)]
    public class ProWorkorderServiceV2 : BaseService<ProWorkorder_v2>, IProWorkorderServiceV2
    {

        public (List<ProWorkorder_v2>, 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);

            return (proWorkorderList, 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 = "是";
            }

            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;
        }
    }
}