ECS / ECS_EquipmentMangaSystem_BingChengTaiGuang · Files

using HHECS.Application.ApiModel;
using HHECS.BllModel;
using HHECS.Dal.Repository;
using HHECS.Infrastructure.Json;
using HHECS.Infrastructure.LogHelper;
using HHECS.Model.ViewEntity;
using HHECS.WebAPI.Service;
using HHECS.WebAPI.Service.Interface;
using HHECS.WebAPI.ViewModel;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Mvc;
using MySqlX.XDevAPI.Common;
using Newtonsoft.Json;
using NPOI.OpenXmlFormats.Spreadsheet;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data;
using System.Drawing;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;

namespace HHECS.WebAPI.Controllers
{
    /// <summary>
    /// 看板Api
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    [EnableCors("cors")]
    public class DashboardController : BaseController
    {
        private readonly IDashboardService _dashboardService;

        public DashboardController(DashboardService dashboardService)
        {
            _dashboardService = dashboardService;
        }

        /// <summary>
        /// 获取设备保养看板数据【看板接口，循环展示所有设备数据】
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public BllResult<EquipmentMaintainViewModel> MaintainResult()
        {
            lock ("MaintainResult")
            {
                try
                {
                    var result = _dashboardService.GetEquipmentMaintain();
                    return BllResultFactory.Success(result);
                }
                catch (Exception ex)
                {
                    Log4NetHelper.Instance.Error($"获取设备保养看板数据出现异常、{ex.Message}");
                    Console.WriteLine($"获取设备保养看板数据出现异常、{ex.Message}");
                    return BllResultFactory.Error<EquipmentMaintainViewModel>(ex.Message);
                }
            }
        }

        /// <summary>
        /// 获取设备报警信息【看板接口】
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public BllResult<EquipmentAlarmViewModel> AlarmResult()
        {
            lock ("AlarmResult")
            {
                try
                {
                    var result = _dashboardService.GetEquipmentAlarmResult();
                    return BllResultFactory.Success(result);
                }
                catch (Exception ex)
                {
                    Log4NetHelper.Instance.Error($"获取设备报警信息出现异常、{ex.Message}");
                    Console.WriteLine($"获取设备报警信息出现异常、{ex.Message}");
                    return BllResultFactory.Error<EquipmentAlarmViewModel>(ex.Message);
                }
            }

        }

        /// <summary>
        /// 获取设备利用率【看板接口】
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public BllResult<EquipmentUtilizationViewModel> UtilizationResult()
        {
            lock ("UtilizationResult")
            {
                try
                {
                    var result = _dashboardService.GetEquipmentUtilization();
                    return BllResultFactory.Success(result);
                }
                catch (Exception ex)
                {
                    Log4NetHelper.Instance.Error($"获取设备利用率出现异常、{ex.Message}");
                    Console.WriteLine($"获取设备利用率出现异常、{ex.Message}");
                    return BllResultFactory.Error<EquipmentUtilizationViewModel>(ex.Message);
                }

            }
        }

        /// <summary>
        /// 设备运行信息看板接口
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public BllResult<EquipmentRunStatusViewModel> RunStatusResult()
        {
            lock ("RunStatusResult")
            {
                try
                {
                    var result = _dashboardService.GetEquipmentRunStatus();
                    return BllResultFactory.Success(result);
                }
                catch (Exception ex)
                {
                    Log4NetHelper.Instance.Error($"设备运行信息看板接口出现异常、{ex.Message}");
                    Console.WriteLine($"设备运行信息看板接口出现异常、{ex.Message}");
                    return BllResultFactory.Error<EquipmentRunStatusViewModel>(ex.Message);
                }
            }

        }

        /// <summary>
        /// 累计故障明细 /api/Dashboard/EquipmentBreakdownInfoByDayResult?begin=2023-04-27 00:00:00&end=2023-05-02 23:59:59
        /// </summary>
        /// <param name="begin">格式需满足yyyy-MM-dd</param>
        /// <param name="end"></param>
        /// <returns></returns>
        [HttpGet]
        public string EquipmentBreakdownInfoByDayResult(string begin, string end, string eqType)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetEquipmentBreakdownInfoByDay(begin, end, eqType);
                response.count = result.Rows.Count;
                response.data = result;
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 月故障明细 /api/Dashboard/EquipmentBreakdownInfoByMonthResult?begin=2023-04&end=2023-05
        /// </summary>
        /// <param name="begin">必须是yyyy-MM格式</param>
        /// <param name="end">必须是yyyy-MM格式</param>
        /// <returns></returns>
        [HttpGet]
        public string EquipmentBreakdownInfoByMonthResult(string begin, string end, string eqType)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetEquipmentBreakdownOfMonthInfoByMonth(begin, end, eqType);
                response.count = result.Rows.Count;
                response.data = result;
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 故障統計分析
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string FaultStatistics(string begin, string end, string eqType)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.FaultStatistics(begin, end, eqType);
                response.count = result.Item2;
                response.data = result.Item1;
                return response.ResponseSuccess(); ;
            });
        }

        /// <summary>
        /// 故障統計分析
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string FaultStatisticsRepeat(string begin, string end, string eqType)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.FaultStatisticsRepeat(begin, end, eqType);
                response.count = result.Item2;
                response.data = result.Item1;
                return response.ResponseSuccess(); ;
            });
        }

        /// <summary>
        /// 倉庫月平均時間
        /// 年度故障分析（两个数据表数据是：月份、故障次数、正常运作时间(or 故障维修时间)，
        /// 时间单位都是分钟，如果需要小时为单位，需要处理[x÷60]，sql里被除数小于60得出都是0了，故未处理；
        /// 仅查出有数据的月份。）
        /// </summary>
        /// <param name="year">提供参数年份：格式必须是yyyy</param>
        /// <returns></returns>
        [HttpGet]
        public string WarehouseAvgByYearResult(string year)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                response.data = _dashboardService.GetWarehouseAvgByYear(year);
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 仓库月平均时间 agv月故障时间 MTTR MTBF
        /// </summary>
        /// <param name="year"></param>
        /// <returns></returns>
        [HttpGet]
        public string WarehouseAvgByYearResultForAGV(string year)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                response.data = _dashboardService.GetWarehouseAvgByYearForAGV(year);
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 故障总结(提供年故障仓库每月MTTR(故障平均维修时间)、MTBF(平均故障间隔时间)分析数据)
        /// </summary>
        /// <param name="year"></param>
        /// <returns></returns>
        [HttpGet]
        public string WarehouseFauilreSummaryByYearResult(string year)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                response.data = _dashboardService.GetWarehouseFauilreSummaryByYear(year);
                return response.ResponseSuccess();
            });
        }


        /// <summary>
        /// 设备曲线 运行电流、振动
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string GetEqRunInfo(string begin, string end, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetEqRunInfo(eqCode, begin, end);
                response.count = result.Rows.Count;
                response.data = result;
                return response.ResponseSuccess(); ;
            });
        }

        /// <summary>
        /// 获取设备类型 默认是堆垛机
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string GetEquipmentByCode()
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetEquipmentByCode();
                response.count = result.Rows.Count;
                response.data = result;
                return response.ResponseSuccess(); ;
            });
        }


        /// <summary>
        /// 故障報告 yyyy-mm
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string GetFaultReport(string yyyyMonth, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var ds = _dashboardService.GetFaultReport(yyyyMonth, eqCode);
                var quxianEcharts = CombineLM1ToBM2(ds.Item1.Tables[5]);
                if (quxianEcharts.Rows.Count > 0)
                {
                    quxianEcharts = quxianEcharts.Rows.Cast<DataRow>().OrderBy(r => r["sumtime"]).CopyToDataTable();
                    quxianEcharts.DefaultView.Sort = " sumtime desc ";
                    quxianEcharts = quxianEcharts.DefaultView.ToTable();
                }

                List<AreaClass> areaList = new List<AreaClass>();
                if (!string.IsNullOrEmpty(eqCode)) areaList = JsonConvert.DeserializeObject<List<AreaClass>>(eqCode);
                //var monthData = CombineLM1ToBM2(ds.Item1.Tables[0]);

                //DataTable newMonthData = monthData.Clone();
                //areaList.ForEach(x => newMonthData.Rows.Add(x.label));
                //foreach (DataRow row in newMonthData.Rows)
                //{
                //    var data = monthData.AsEnumerable().FirstOrDefault(x => x["name"].ToString().Equals(row["name"].ToString()));
                //    if (data != null)
                //    {
                //        row["warehouseCode"] = data["warehouseCode"];
                //        row["sumTime"] = data["sumTime"].ToString();
                //    }
                //    else
                //    {
                //        row["warehouseCode"] = "";
                //        row["sumTime"] = "0";
                //    }
                //}


                //当天是否在本周内
                var nowDay = DateTime.Now;
                var selectDay = Convert.ToDateTime(yyyyMonth);
                var startWeekDay = nowDay.AddDays(-(int)nowDay.DayOfWeek + 1).ToString("yyyy-MM-dd 00:00:00");//当前周的周一日期
                var weekOne = selectDay.AddDays(0 - (Convert.ToInt16(selectDay.DayOfWeek) == 0 ? 7 : Convert.ToInt16(selectDay.DayOfWeek)) + 1).ToString("yyyy-MM-dd 00:00:00");//当前所选周的周一日期
                var isInterval = false;
                if (startWeekDay == weekOne) isInterval = true;

                response.data = new
                {
                    listMonth = ds.Item1.Tables[0],
                    listWeek = ds.Item1.Tables[1],//CombineLM1ToBM2(ds.Item1.Tables[1]),//本周设备故障分析柱状图
                    listmorningAndEvening = ds.Item1.Tables[2],

                    eqRun = ds.Item1.Tables[3],
                    listAlarmSum40 = ds.Item1.Tables[4],
                    quxianEcharts = quxianEcharts,
                    quxianEchartsSumTimeRun = CombineLM1ToBM2(ds.Item1.Tables[6]),

                    diffDay = ds.Item2,
                    monthStr = ds.Item3,
                    weekStr = ds.Item4,

                    weekDefault = ds.Item1.Tables[7],

                    properlyTarget = ds.Item1.Tables[8],

                    factoryTarget = ds.Item1.Tables[9],

                    isInterval = isInterval
                };
                response.count = ds.Item1.Tables[0].Rows.Count;
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 故障分析（重复次数） yyyy-mm
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string GetFaultCount(string yyyyMonth, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var ds = _dashboardService.GetFaultCount(yyyyMonth, eqCode);//故障原因及次数
                response.data = new
                {
                    listWeek = ds[0].Item1,
                    listMonth = ds[1].Item1,
                };
                response.count = ds[0].Item2;//周故障总条数
                return response.ResponseSuccess(); ;
            });
        }

        /// <summary>
        /// 故障分析（重复次数）时间段
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetFaultCountDate(string startTime, string endTime, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var ds = _dashboardService.GetFaultCount(startTime, endTime, eqCode);//故障原因及次数
                response.data = new
                {
                    listWeek = ds.Item1,
                };
                response.count = ds.Item2;//周故障总条数
                return response.ResponseSuccess(); ;
            });
        }

        /// <summary>
        /// 妥善率趋势图
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <param name="yearOrdaySelectVal"></param>
        /// <param name="timeFlag"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetProperRate(string startTime, string endTime, string eqCode, string yearOrdaySelectVal, string timeFlag)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetProperRate(startTime, endTime, eqCode, yearOrdaySelectVal, timeFlag);
                response.data = Combine(result);
                response.count = result.Rows.Count;
                return response;
            });
        }

        /// <summary>
        /// 故障时间超40分钟报表
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetFaultOverTime(string startTime, string endTime, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetFaultOverTime(startTime, endTime, eqCode);
                response.data = result.Tables[0];
                response.count = result.Tables[0].Rows.Count;
                return response.ResponseSuccess();
            });
        }


        /// <summary>
        /// AGV异常记录跟踪表
        /// </summary>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <param name="eqCode">设备</param>
        /// <param name="alarm">故障</param>
        /// <returns></returns>
		[HttpGet]
        public string GetAGVAbnormalRecord(string startTime, string endTime, string eqCode, string alarm)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                #region 判断所选天是否在本周内
                var nowDay = DateTime.Now;
                var selectDay = Convert.ToDateTime(startTime);
                var startWeekDay = nowDay.AddDays(-(int)nowDay.DayOfWeek + 1).ToString("yyyy-MM-dd 00:00:00");//当前周的周一日期
                var weekOne = selectDay.AddDays(0 - (Convert.ToInt16(selectDay.DayOfWeek) == 0 ? 7 : Convert.ToInt16(selectDay.DayOfWeek)) + 1).ToString("yyyy-MM-dd 00:00:00");//当前所选周的周一日期
                var isInterval = false;
                if (startWeekDay == weekOne) isInterval = true;
                #endregion

                var result = _dashboardService.GetAGVAbnormalRecord(startTime, endTime, eqCode, alarm);

                #region 处理没数据的返回0
                result = HandleReturnData(result, eqCode, startTime);
                #endregion

                DataView dv = new DataView(result);
                if (eqCode.Contains("AGV"))
                {
                    dv.Sort = "EquipmentCode ASC";
                }
                else
                {
                    dv.Sort = "name,EquipmentCode ASC";
                }
                result = dv.ToTable();

                response.data = new
                {
                    result,
                    isInterval
                };
                response.count = result.Rows.Count;
                return response;
            });
        }

        //获取AGV异常信息作为下拉框数据源
        public string GetAgvAlarmMessageList()
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                using EquipmentAlarmRecordRepository equipmentAlarmRecordRepository = new EquipmentAlarmRecordRepository();
                var result = equipmentAlarmRecordRepository.Where(x => x.EquipmentName.Contains("AGV")).ToList().Select(t => t.Alarm).Distinct().ToList();
                response.data = result;
                response.count = result.Count;
                return response;
            });
        }

        /// <summary>
        /// 获取自动仓超限记录
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <param name="alarm"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetSRMOverAlarmRecord(string startTime, string endTime, string eqCode, string alarm)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetSRMOverAlarmRecord(startTime, endTime, eqCode, alarm);
                #region 处理没数据的返回0
                result = HandleReturnData(result, eqCode, startTime);
                #endregion
                response.data = result;
                response.count = result.Rows.Count;
                return response;
            });
        }

        //获取自动仓（堆垛机设备）超限报警信息下拉框数据源
        public string GetSRMOverAlarmMsgList()
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                using EquipmentAlarmRecordRepository equipmentAlarmRecordRepository = new EquipmentAlarmRecordRepository();
                var result = equipmentAlarmRecordRepository.Where(t => t.EquipmentPropCode.StartsWith("F85") && Convert.ToInt32(t.EquipmentPropCode.Substring(3, t.EquipmentPropCode.Length - 3)) >= 13 && Convert.ToInt32(t.EquipmentPropCode.Substring(3, t.EquipmentPropCode.Length - 3)) <= 21)
                                                           .ToList()
                                                           .Select(t => new { Alarm = t.Alarm.TrimEnd(), t.EquipmentPropCode })
                                                           .OrderBy(t => t.EquipmentPropCode)
                                                           .Distinct()
                                                           .ToList();
                response.data = result;
                response.count = result.Count;
                return response;
            });
        }

        /// <summary>
        /// 获取AGV设备点位发生故障频率
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <param name="alarm"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetAGVCodePointAlarmRecord(string startTime, string endTime, string eqCode, string alarm)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetAGVCodePointAlarmRecord(startTime, endTime, eqCode, alarm);
                #region 处理数据为0的
                List<AreaClass> areaList = JsonConvert.DeserializeObject<List<AreaClass>>(eqCode);//前端传的所有设备
                using EquipmentAlarmRecordRepository equipmentAlarmRecordRepository = new EquipmentAlarmRecordRepository();
                if (result.Tables[0].Rows.Count > 0)
                {
                    //1：处理所查区间 部分设备没数据；
                    //分组去重获取已存在数据的仓库中设备
                    var isHaveEqCode = result.Tables[0].AsEnumerable().GroupBy(r => new { warehouse = r["warehousecode"], label = r["name"], value = r["EquipmentCode"] }).Distinct().Select(g => g.Key).ToList();
                    //遍历每个仓库，查询不存在的设备
                    foreach (var area in areaList)
                    {
                        var codes = area.value.Split(",").ToArray();
                        var resCodes = isHaveEqCode.Where(i => i.label.ToString() == area.label).Select(i => i.value);

                        var unmatchCodeList = codes.Except(resCodes);//查询返回结果不存在的设备
                        if (unmatchCodeList.Any())
                        {
                            foreach (var i in unmatchCodeList)
                            {
                                var warehousecode = equipmentAlarmRecordRepository.Where(j => j.EquipmentCode == i.ToString()).First(j => j.WarehouseCode);
                                DataRow newRow = result.Tables[0].NewRow();
                                newRow["name"] = area.label;
                                newRow["warehousecode"] = warehousecode;
                                newRow["EquipmentCode"] = i;
                                newRow["count"] = 0;
                                newRow["CodePoint"] = 0;
                                result.Tables[0].Rows.Add(newRow);
                            }
                        }
                    }
                }
                else
                {
                    //2：处理所查区间 所有设备没数据；
                    foreach (var area in areaList)
                    {
                        var codes = area.value.Split(",").ToArray();
                        foreach (var i in codes)
                        {
                            var warehousecode = equipmentAlarmRecordRepository.Where(j => j.EquipmentCode == i.ToString()).First(j => j.WarehouseCode);
                            DataRow dr = result.Tables[0].NewRow();
                            dr["name"] = area.label;
                            dr["warehousecode"] = warehousecode;
                            dr["EquipmentCode"] = i;
                            dr["count"] = 0;
                            dr["CodePoint"] = 0;
                            result.Tables[0].Rows.Add(dr);
                        }
                    }
                }
                #endregion
                response.data = result;
                response.count = result.Tables[0].Rows.Count;
                return response;
            });
        }

        public DataTable Combine(DataTable dt)
        {
            DataTable resDt = dt.Clone();
            if (dt != null && dt.Rows.Count > 0)
            {
                var groupDt = from row in dt.AsEnumerable()
                              group row by new { name = row["name"], date = row["date"] } into g
                              select new
                              {
                                  name = g.Key.name,
                                  warehousecode = string.Join(",", g.Select(i => i.Field<string>("warehousecode"))),
                                  date = g.Key.date,
                                  sumTime = g.Sum(t => t.Field<int>("sumTime")),
                              };
                groupDt.ToList().ForEach(i => { resDt.Rows.Add(i.name, i.warehousecode, i.date, i.sumTime); });
                if (resDt.Rows.Count > 0)
                {
                    foreach (DataRow row in resDt.Rows)
                    {
                        if (row["warehousecode"].ToString().Contains("LM1"))
                        {
                            row["warehousecode"] = "BM2";
                        }
                    }
                }
            }
            return resDt;

        }

        public DataTable CombineLM1ToBM2(DataTable dt)
        {
            if (dt != null && dt.Rows.Count > 0)
            {
                var lm1SumTime = 0;
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    if (dt.Rows[i]["warehouseCode"].ToString() == "LM1")
                    {
                        lm1SumTime = Convert.ToInt32(dt.Rows[i]["sumTime"]);
                        dt.Rows[i].Delete();
                    }
                }
                dt.AcceptChanges();
                foreach (DataRow dr in dt.Rows)
                {
                    if (dt.Columns.Contains("name"))
                    {
                        if (dr["warehouseCode"].ToString() == "BM2" && dr["name"].ToString() == "混合倉立庫")
                        {
                            dr["sumTime"] = Convert.ToInt32(dr["sumTime"]) + lm1SumTime;
                        }
                    }
                    else
                    {
                        if (dr["warehouseCode"].ToString() == "BM2")
                        {
                            dr["sumTime"] = Convert.ToInt32(dr["sumTime"]) + lm1SumTime;
                        }
                    }

                    //&& 

                }
            }
            return dt;
        }

        public DataTable HandleReturnData(DataTable result, string eqCode, string startTime)
        {
            List<AreaClass> areaList = JsonConvert.DeserializeObject<List<AreaClass>>(eqCode);//前端传的所有设备
            using EquipmentAlarmRecordRepository equipmentAlarmRecordRepository = new EquipmentAlarmRecordRepository();
            if (result.Rows.Count > 0)
            {
                //1：处理所查区间 部分设备没数据；
                //分组去重获取已存在数据的仓库中设备
                var isHaveEqCode = result.AsEnumerable().GroupBy(r => new { warehouse = r["warehousecode"], label = r["name"], value = r["EquipmentCode"] }).Distinct().Select(g => g.Key).ToList();
                //遍历每个仓库，查询不存在的设备
                foreach (var area in areaList)
                {
                    var codes = area.value.Split(",").ToArray();
                    var resCodes = isHaveEqCode.Where(i => i.label.ToString() == area.label).Select(i => i.value);

                    var unmatchCodeList = codes.Except(resCodes);//查询返回结果不存在的设备
                    if (unmatchCodeList.Any())
                    {
                        foreach (var i in unmatchCodeList)
                        {
                            var warehousecode = equipmentAlarmRecordRepository.Where(j => j.EquipmentCode == i.ToString()).First(j => j.WarehouseCode);
                            DataRow newRow = result.NewRow();
                            newRow["name"] = area.label;
                            newRow["warehousecode"] = warehousecode;
                            newRow["date"] = startTime.TrimEnd();
                            newRow["EquipmentCode"] = i;
                            newRow["count"] = 0;
                            result.Rows.Add(newRow);
                        }
                    }
                }
            }
            else
            {
                //2：处理所查区间 所有设备没数据；
                foreach (var area in areaList)
                {
                    var codes = area.value.Split(",").ToArray();
                    foreach (var i in codes)
                    {
                        var warehousecode = equipmentAlarmRecordRepository.Where(j => j.EquipmentCode == i.ToString()).First(j => j.WarehouseCode);
                        DataRow dr = result.NewRow();
                        dr["name"] = area.label;
                        dr["warehousecode"] = warehousecode;
                        dr["date"] = startTime.TrimEnd();
                        dr["EquipmentCode"] = i;
                        dr["count"] = 0;
                        result.Rows.Add(dr);
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 故障报告-本周故障分析-具体每天故障分析
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="eqCode">库别</param>
        /// <returns></returns>
        [HttpGet]
        public string GetEquipmentWeekDayFaultInfo(string startTime, string endTime, string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var result = _dashboardService.GetEquipmentWeekDayFaultInfo(startTime, endTime, eqCode);
                response.data = new
                {
                    top = result.Tables[0],
                    table = result.Tables[1],
                };
                response.count = result.Tables[1].Rows.Count;
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 获取任意时间段各区域故障总时间
        /// </summary>
        /// <param name="startTime">2024-09-11</param>
        /// <param name="endTime"></param>
        /// <param name="eqCode"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetEquipmentFaultReport(string startTime,string endTime,string eqCode)
        {
            return Serialize(() =>
            {
                var response = new ResponseNew();
                var dt = _dashboardService.GetEquipmentFaultReport(startTime,endTime, eqCode);
             
                response.data = dt;//本周设备故障分析柱状图
                response.count = dt.Rows.Count;
                return response.ResponseSuccess();
            });
        }

        /// <summary>
        /// 获取 指令删除查询
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="code">指令删除人</param>
        /// <returns></returns>
        [HttpGet]
        public string GetDeleteTaskInfoRecord(string startDate,string endDate,string code)
        {
            return Serialize(() =>
            {
                var response=new ResponseNew();
                var dt = _dashboardService.GetDeleteTaskInfo(startDate, endDate, code);
                response.data = dt;
                response.count = dt.Rows.Count;
                return response.ResponseSuccess();
            });
        }
    }
}