MES / IOT · Files

using Hh.Mes.POJO.ApiEntity.BiDecision;
using Hh.Mes.POJO.Entity;
using Hh.Mes.POJO.EnumEntitys;
using Hh.Mes.POJO.Response;
using Hh.Mes.Service.Repository;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Hh.Mes.Service
{
    public partial class BiDecisionService : RepositorySqlSugar<sys_user>
    {
        /// <summary>
        /// 妥善率统计
        /// </summary>
        /// <param name="projectClientInfoKeys"></param>
        /// <param name="begin"></param>
        /// 
        /// <param name="end"></param>
        /// <param name="projectCode"></param>
        /// <param name="equipmentCode"></param>
        /// <returns></returns>
        public Response<EquipmentReadinessRate> GetEquipmentReadinessRate(Guid projectClientInfoKeys, DateTime begin, string projectCode = null, string equipmentCode = null)
        {
            var response = new Response<EquipmentReadinessRate>();
            try
            {
                if (string.IsNullOrWhiteSpace(projectCode))
                {
                    projectCode = Context.Queryable<base_project>().OrderBy(x => x.id).Select(x => x.projectCode).First();
                }

                var expression = Expressionable.Create<base_project_client_info, base_project>()
                    .AndIF(projectClientInfoKeys != Guid.Empty, (x, y) => x.keys == projectClientInfoKeys)
                    .AndIF(!string.IsNullOrEmpty(projectCode), (x, y) => y.projectCode == projectCode)
                    .ToExpression();

                var baseProjects = Context.Queryable<base_project_client_info, base_project>((x, y) => new object[]
                {
                    JoinType.Inner, x.keys == y.projectClientInfoKeys,
                }).Where(expression).Select((x, y) => y).ToList();

                var baseProjectKeys = baseProjects.ConvertAll(x => x.keys);
                var expression2 = Expressionable.Create<base_equipment>()
                    .And(x => baseProjectKeys.Contains(x.projectKeys))
                    .AndIF(!string.IsNullOrEmpty(equipmentCode), x => x.equipmentCode == equipmentCode)
                    .ToExpression();
                var baseEquipments = Context.Queryable<base_equipment>().Where(expression2).OrderBy(x => x.equipmentName).ToList();

                var allEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Select((t1, t2, t3) => new
                {
                    ClientName = t1.clientName,
                    EquipmentCode = t3.otherCode,
                }).Distinct().ToList();

                var kunShanEquipmentCodes = allEquipmentCodes.Where(x => x.ClientName.Contains("昆山"))
                .Select(x => x.EquipmentCode)
                .Distinct()
                .ToList();

                var xuZhouEquipmentCodes = allEquipmentCodes.Where(x => x.ClientName.Contains("徐州"))
                .Select(x => x.EquipmentCode)
                .Distinct()
                .ToList();

                var changShaEquipmentCodes = allEquipmentCodes.Where(x => x.ClientName.Contains("长沙"))
                .Select(x => x.EquipmentCode)
                .Distinct()
                .ToList();

                CalculateDateRanges(begin, out DateTime weekStartTime, out DateTime weekEndTime, out DateTime monthStartTime, out DateTime monthEndTime, out DateTime quarterStartTime, out DateTime quarterEndTime);

                //设备妥善率统计
                var month = new EquipmentReadinessRateArea();

                var monthGroups = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => x.createTime >= monthStartTime && x.updateTime <= monthEndTime)
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.status
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        Status = x.status,
                        SumTime = SqlFunc.AggregateSum(x.statusDuration)
                    }).ToList();

                var kunShanMonthFailureSecond = monthGroups.Where(x => kunShanEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var kunShanMonthOnSecond = monthGroups.Where(x => kunShanEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                var xuZhouMonthFailureSecond = monthGroups.Where(x => xuZhouEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var xuZhouMonthOnSecond = monthGroups.Where(x => xuZhouEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                var changShaMonthFailureSecond = monthGroups.Where(x => changShaEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var changShaMonthOnSecond = monthGroups.Where(x => changShaEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                // 计算月妥善率
                month.KunShan = kunShanMonthOnSecond == 0 ? 1 : Math.Round(1 - (kunShanMonthFailureSecond / kunShanMonthOnSecond), 2);
                month.XuZhou = xuZhouMonthOnSecond == 0 ? 1 : Math.Round(1 - (xuZhouMonthFailureSecond / xuZhouMonthOnSecond), 2);
                month.ChangSha = changShaMonthOnSecond == 0 ? 1 : Math.Round(1 - (changShaMonthFailureSecond / changShaMonthOnSecond), 2);
                month.Total = Math.Round((month.KunShan + month.XuZhou + month.ChangSha) / 3, 2);

                var quarter = new EquipmentReadinessRateArea();
                var quarterGroups = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => x.createTime >= quarterStartTime && x.updateTime <= quarterEndTime)
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.status
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        Status = x.status,
                        SumTime = SqlFunc.AggregateSum(x.statusDuration)
                    }).ToList();

                var kunShanQuarterFailureSecond = quarterGroups.Where(x => kunShanEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var kunhanQuarterOnSecond = quarterGroups.Where(x => kunShanEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                var xuZhouQuarterFailureSecond = quarterGroups.Where(x => xuZhouEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var xuZhouQuarterOnSecond = quarterGroups.Where(x => xuZhouEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                var changShaQuarterFailureSecond = quarterGroups.Where(x => changShaEquipmentCodes.Contains(x.EquipmentCode) && x.Status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.SumTime);

                var changShaQuarterOnSecond = quarterGroups.Where(x => changShaEquipmentCodes.Contains(x.EquipmentCode))
                    .Sum(x => x.SumTime);

                // 计算季度妥善率
                quarter.KunShan = kunhanQuarterOnSecond == 0 ? 1 : Math.Round(1 - (kunShanQuarterFailureSecond / kunhanQuarterOnSecond), 2);
                quarter.XuZhou = xuZhouQuarterOnSecond == 0 ? 1 : Math.Round(1 - (xuZhouQuarterFailureSecond / xuZhouQuarterOnSecond), 2);
                quarter.ChangSha = changShaQuarterOnSecond == 0 ? 1 : Math.Round(1 - (changShaQuarterFailureSecond / changShaQuarterOnSecond), 2);
                quarter.Total = Math.Round((quarter.KunShan + quarter.XuZhou + quarter.ChangSha) / 3, 2);

                var details = new List<EquipmentReadinessRateDetail>();
                var days = (weekEndTime - weekStartTime).Days;

                var equipmentCodes = baseEquipments.ConvertAll(x => x.otherCode);
                //长沙项目编码
                if (projectCode == "HH-CXYF-20240301")
                {
                    //长沙项目编码，忽略CNC与焊接机器人
                    var equipmentTypeCodes = new List<string>
                    {
                        "CNC",
                        "WeldRobot"
                    };
                    equipmentCodes = baseEquipments.Where(x => !equipmentTypeCodes.Contains(x.equipmentTypeCode)).Select(x => x.otherCode).ToList();
                }

                var secondGroup = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => x.createTime >= weekStartTime && x.updateTime <= weekEndTime
                && x.status == EquipmentStatus.Failure.ToString() && equipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.createTime.Date
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        SumTime = SqlFunc.AggregateSum(x.statusDuration),
                        x.createTime.Date
                    }).ToList();

                for (int i = 0; i <= days; i++)
                {
                    var currentDate = weekStartTime.AddDays(i).Date;
                    foreach (var equipment in baseEquipments)
                    {
                        //故障时间
                        var second = secondGroup.Where(x => x.EquipmentCode == equipment.otherCode && x.Date == currentDate)
                            .Select(x => x.SumTime)
                            .FirstOrDefault();
                        var detail = new EquipmentReadinessRateDetail
                        {
                            EquipmentCode = equipment.equipmentCode,
                            EquipmentName = equipment.equipmentName,
                            ProjectName = baseProjects.Where(x => x.keys == equipment.projectKeys).Select(x => x.projectName).FirstOrDefault(),
                            Sequence = i, // 序号可以根据需要设置
                            Date = currentDate.ToString("yyyy-MM-dd"), // 当前日期
                            SumTime = Math.Round(second / 60, 2)
                        };
                        // 这里可以添加逻辑来计算SumTime等其他字段
                        details.Add(detail);
                    }
                }

                response.Result = new EquipmentReadinessRate
                {
                    Month = month,
                    Quarter = quarter,
                    Details = details
                };
                return response;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
                return response;
            }
        }

        /// <summary>
        /// 报警时长统计-报警时长视角
        /// </summary>
        /// <param name="projectClientInfoKeys"></param>
        /// <param name="begin"></param>
        /// <param name="projectCode"></param>
        /// <param name="equipmentCode"></param>
        /// <param name="type">0：本月，其他：本季度</param>
        /// <returns></returns>
        public Response<EquipmentAlarmDuration> GetEquipmentAlarmDuration(Guid projectClientInfoKeys, DateTime begin, string projectCode, string equipmentCode = null, int type = 0)
        {
            var response = new Response<EquipmentAlarmDuration>();
            try
            {
                var expression = Expressionable.Create<base_project_client_info>()
                    .AndIF(projectClientInfoKeys != Guid.Empty, x => x.keys == projectClientInfoKeys)
                    .ToExpression();

                var baseProjectClientInfos = Context.Queryable<base_project_client_info>().Where(expression).ToList();

                var baseProjectClientInfoKeys = baseProjectClientInfos.ConvertAll(x => x.keys);
                var baseProjects = Context.Queryable<base_project>().Where(x => baseProjectClientInfoKeys.Contains(x.projectClientInfoKeys)).ToList();

                var baseProjectKeys = baseProjects.ConvertAll(x => x.keys);
                var expression2 = Expressionable.Create<base_equipment>()
                    .And(x => baseProjectKeys.Contains(x.projectKeys))
                    .AndIF(!string.IsNullOrEmpty(equipmentCode), x => x.equipmentCode == equipmentCode)
                    .ToExpression();
                var baseEquipments = Context.Queryable<base_equipment>().Where(expression2).ToList();

                var kunShanEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("昆山")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                var xuZhouEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("徐州")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                var changShaEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("长沙")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                CalculateDateRanges(begin, out DateTime weekStartTime, out DateTime weekEndTime, out DateTime monthStartTime, out DateTime monthEndTime, out DateTime quarterStartTime, out DateTime quarterEndTime);

                //计算周故障时长
                var week = new EquipmentReadinessRateArea();

                //DateTime.Now.Hour
                var kunShanWeekFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => kunShanEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= weekStartTime && x.updateTime <= weekEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);
                var xuZhouWeekFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => xuZhouEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= weekStartTime && x.updateTime <= weekEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);
                var changShaWeekFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => changShaEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= weekStartTime && x.updateTime <= weekEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);

                week.KunShan = Math.Round(TimeSpan.FromSeconds(kunShanWeekFailureSecond).TotalHours, 2);
                week.XuZhou = Math.Round(TimeSpan.FromSeconds(xuZhouWeekFailureSecond).TotalHours, 2);
                week.ChangSha = Math.Round(TimeSpan.FromSeconds(changShaWeekFailureSecond).TotalHours, 2);
                week.Total = Math.Round((week.KunShan + week.XuZhou + week.ChangSha), 2);

                //计算月故障时长
                var month = new EquipmentReadinessRateArea();

                var kunShanMonthFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => kunShanEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= monthStartTime && x.updateTime <= monthEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);
                var xuZhouMonthFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => xuZhouEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= monthStartTime && x.updateTime <= monthEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);
                var changShaMonthFailureSecond = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => changShaEquipmentCodes.Contains(x.equipmentCode)
                && x.createTime >= monthStartTime && x.updateTime <= monthEndTime && x.status == EquipmentStatus.Failure.ToString())
                    .Sum(x => x.statusDuration);

                month.KunShan = Math.Round(TimeSpan.FromSeconds(kunShanMonthFailureSecond).TotalHours, 2);
                month.XuZhou = Math.Round(TimeSpan.FromSeconds(xuZhouMonthFailureSecond).TotalHours, 2);
                month.ChangSha = Math.Round(TimeSpan.FromSeconds(changShaMonthFailureSecond).TotalHours, 2);
                month.Total = Math.Round((month.KunShan + month.XuZhou + month.ChangSha), 2);

                //报警时长视角详情:(公司维度)
                var beginTime = monthStartTime;
                var endTime = monthEndTime;
                var equipmentCodes = baseEquipments.ConvertAll(x => x.otherCode);
                if (type != 0)
                {
                    beginTime = quarterStartTime;
                    endTime = quarterEndTime;
                }

                var secondGroup = Context.Queryable<daq_equipment_status_record_history>()
                    .Where(x => x.createTime >= beginTime && x.updateTime <= endTime && equipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.createTime.Date,
                        x.status
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        x.createTime.Date,
                        SumTime = SqlFunc.AggregateSum(x.statusDuration),
                        x.status
                    }).ToList();

                var equipmentAlarmDurationItems = new List<EquipmentAlarmDurationItem>();
                foreach (var baseProjectClientInfo in baseProjectClientInfos)
                {
                    var currentProjects = baseProjects.Where(x => x.projectClientInfoKeys == baseProjectClientInfo.keys).ToList();
                    var temp = new EquipmentAlarmDurationItem
                    {
                        ProjectName = baseProjectClientInfo.clientName[..2]
                    };
                    equipmentAlarmDurationItems.Add(temp);
                    foreach (var item in currentProjects)
                    {
                        var currentEquipmentCodes = baseEquipments.Where(x => x.projectKeys == item.keys)
                            .Select(x => x.otherCode).ToList();

                        var equipmentAlarmDurationItem = new EquipmentAlarmDurationItem
                        {
                            ProjectName = item.projectName
                        };

                        equipmentAlarmDurationItem.AlarmTime1 = Math.Round(secondGroup.Where(x => currentEquipmentCodes.Contains(x.EquipmentCode)
                        && x.Date >= weekStartTime && x.Date <= weekEndTime && x.status == EquipmentStatus.Failure.ToString())
                            .Sum(x => x.SumTime) / 60, 2); // 转换为分

                        var onTime1 = Math.Round(secondGroup.Where(x => currentEquipmentCodes.Contains(x.EquipmentCode)
                         && x.Date >= weekStartTime && x.Date <= weekEndTime).Sum(x => x.SumTime) / 60, 2); // 转换为分

                        equipmentAlarmDurationItem.OnTime1 = onTime1; // 周的在线时长
                        equipmentAlarmDurationItem.ReadinessRate1 = onTime1 == 0 ? 1 : Math.Round(1 - equipmentAlarmDurationItem.AlarmTime1 / equipmentAlarmDurationItem.OnTime1, 2);

                        equipmentAlarmDurationItem.AlarmTime2 = Math.Round(secondGroup.Where(x => currentEquipmentCodes.Contains(x.EquipmentCode)
                        && x.status == EquipmentStatus.Failure.ToString()).Sum(x => x.SumTime) / 60, 2); // 转换为分

                        var onTime2 = Math.Round(secondGroup.Where(x => currentEquipmentCodes.Contains(x.EquipmentCode)).Sum(x => x.SumTime) / 60, 2); // 转换为分

                        equipmentAlarmDurationItem.OnTime2 = onTime2;

                        equipmentAlarmDurationItem.ReadinessRate2 = onTime2 == 0 ? 1 : Math.Round(1 - equipmentAlarmDurationItem.AlarmTime2 / equipmentAlarmDurationItem.OnTime2, 2);
                        equipmentAlarmDurationItem.IsLast = item == currentProjects.Last(); // 是否是最后一个项目
                        equipmentAlarmDurationItems.Add(equipmentAlarmDurationItem);
                    }
                }

                response.Result = new EquipmentAlarmDuration
                {
                    Week = week,
                    Month = month,
                    Items = equipmentAlarmDurationItems
                };
                return response;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
                return response;
            }
        }

        /// <summary>
        /// 报警时长统计-报警时长视角详情
        /// </summary>
        /// <param name="projectClientInfoKeys"></param>
        /// <param name="begin"></param>
        /// <param name="projectCode"></param>
        /// <param name="equipmentCode"></param>
        /// <returns></returns>
        public Response<EquipmentAlarmDurationDetail> GetEquipmentAlarmDurationDetail(Guid projectClientInfoKeys, DateTime begin, string projectCode, string equipmentCode)
        {
            var response = new Response<EquipmentAlarmDurationDetail>();
            try
            {
                if (string.IsNullOrWhiteSpace(projectCode))
                {
                    projectCode = Context.Queryable<base_project>().OrderBy(x => x.id).Select(x => x.projectCode).First();
                }

                var expression = Expressionable.Create<base_project_client_info, base_project>()
                    .AndIF(projectClientInfoKeys != Guid.Empty, (x, y) => x.keys == projectClientInfoKeys)
                    .AndIF(!string.IsNullOrEmpty(projectCode), (x, y) => y.projectCode == projectCode)
                    .ToExpression();

                var baseProjects = Context.Queryable<base_project_client_info, base_project>((x, y) => new object[]
                {
                    JoinType.Inner, x.keys == y.projectClientInfoKeys,
                }).Where(expression).Select((x, y) => y).ToList();

                var baseProjectKeys = baseProjects.ConvertAll(x => x.keys);
                var expression2 = Expressionable.Create<base_equipment>()
                    .And(x => baseProjectKeys.Contains(x.projectKeys))
                    .AndIF(!string.IsNullOrEmpty(equipmentCode), x => x.equipmentCode == equipmentCode)
                    .ToExpression();
                var baseEquipments = Context.Queryable<base_equipment>().Where(expression2).ToList();

                CalculateDateRanges(begin, out DateTime weekStartTime, out DateTime weekEndTime, out DateTime monthStartTime, out DateTime monthEndTime, out DateTime quarterStartTime, out DateTime quarterEndTime);

                var equipmentCodes = baseEquipments.ConvertAll(x => x.otherCode);
                var secondGroup = Context.Queryable<daq_equipment_status_record_history>().Where(x => x.createTime >= weekStartTime && x.updateTime <= weekEndTime
                  && equipmentCodes.Contains(x.equipmentCode) && x.status == EquipmentStatus.Failure.ToString())
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.createTime.Date,
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        x.createTime.Date,
                        SumTime = SqlFunc.AggregateSum(x.statusDuration),
                    }).ToList();

                var dateRange = Enumerable.Range(0, (weekEndTime - weekStartTime).Days + 1).Select(offset => weekStartTime.AddDays(offset)).ToList();
                var chart = new EquipmentAlarmDurationDetailChart();

                var sumAlarmTime = secondGroup.Sum(x => x.SumTime);
                foreach (var item in dateRange)
                {
                    var currentAlarmTime = secondGroup.Where(x => x.Date == item.Date).Sum(x => x.SumTime);
                    chart.AlarmTime.Add(Math.Round(currentAlarmTime / 60, 2));
                    chart.Proportion.Add(Math.Round(sumAlarmTime == 0 ? 0 : currentAlarmTime / sumAlarmTime, 2));
                    chart.DateArray.Add(item.ToString("MM-dd"));
                }

                var detailList = new List<Dictionary<string, object>>();
                foreach (var item in baseEquipments)
                {
                    var obj = new Dictionary<string, object>();
                    obj.TryAdd("EquipmentCode", item.equipmentCode);
                    obj.TryAdd("EquipmentName", item.equipmentName);
                    var total = 0;
                    var trend = new List<double>();
                    var dateColIndex = 1;
                    var colDateList = new List<string>();
                    foreach (var date in dateRange)
                    {
                        var currentAlarmSecond = secondGroup.Where(x => x.EquipmentCode == item.otherCode && x.Date == date.Date).Sum(x => x.SumTime);
                        var currentAlarmMin = Math.Round(currentAlarmSecond / 60, 2);
                        //obj.TryAdd($"D{date:MM-dd}", currentAlarmMin);
                        colDateList.Add(date.ToString("MM-dd"));
                        obj.TryAdd($"DateCol" + dateColIndex++, currentAlarmMin);
                        trend.Add(currentAlarmMin);
                    }
                    obj.TryAdd("Total", total);
                    //趋势
                    obj.TryAdd("Trend", trend);
                    obj.TryAdd("colDateList", colDateList);

                    //波动浮动
                    var mean = trend.Average();
                    if (mean == 0)
                    {
                        obj.TryAdd("cvPercentage", 0);
                    }
                    else
                    {
                        var sumOfSquares = trend.Sum(x => Math.Pow(x - mean, 2));
                        var variance = sumOfSquares / (trend.Count - 1);
                        var standardDeviation = Math.Sqrt(variance);
                        var cvPercentage = standardDeviation / mean;
                        obj.TryAdd("cvPercentage", Math.Round(cvPercentage, 2));
                    }
                    detailList.Add(obj);
                }

                response.Result = new EquipmentAlarmDurationDetail
                {
                    Chart = chart,
                    Detail = detailList
                };

                return response;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
                return response;
            }
        }

        /// <summary>
        /// 报警频率统计-报警次数视角
        /// </summary>
        /// <param name="projectClientInfoKeys"></param>
        /// <param name="begin"></param>
        /// <param name="projectCode"></param>
        /// <param name="equipmentCode"></param>
        /// <returns></returns>
        public Response<EquipmentAlarmFrequency> GetEquipmentAlarmFrequency(Guid projectClientInfoKeys, DateTime begin, string projectCode, string equipmentCode)
        {
            var response = new Response<EquipmentAlarmFrequency>();
            try
            {
                var expression = Expressionable.Create<base_project_client_info, base_project>()
                                               .AndIF(projectClientInfoKeys != Guid.Empty, (x, y) => x.keys == projectClientInfoKeys)
                                                //.AndIF(!string.IsNullOrEmpty(projectCode), (x, y) => y.projectCode == projectCode)
                                                .ToExpression();

                var baseProjects = Context.Queryable<base_project_client_info, base_project>((x, y) => new object[]
                {
                    JoinType.Inner, x.keys == y.projectClientInfoKeys,
                }).Where(expression).Select((x, y) => y).ToList();

                var baseProjectKeys = baseProjects.ConvertAll(x => x.keys);
                var expression2 = Expressionable.Create<base_equipment>()
                    .And(x => baseProjectKeys.Contains(x.projectKeys))
                    .AndIF(!string.IsNullOrEmpty(equipmentCode), x => x.equipmentCode == equipmentCode)
                    .ToExpression();
                var baseEquipments = Context.Queryable<base_equipment>().Where(expression2).ToList();

                CalculateDateRanges(begin, out DateTime weekStartTime, out DateTime weekEndTime, out DateTime monthStartTime, out DateTime monthEndTime, out DateTime quarterStartTime, out DateTime quarterEndTime);

                var kunShanEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("昆山")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                var xuZhouEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("徐州")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                var changShaEquipmentCodes = Context.Queryable<base_project_client_info, base_project, base_equipment>((t1, t2, t3) => new object[]
                {
                    JoinType.Inner, t1.keys == t2.projectClientInfoKeys,
                    JoinType.Inner, t2.keys == t3.projectKeys,
                }).Where((t1, t2, t3) => t1.clientName.Contains("长沙")).Select((t1, t2, t3) => t3.otherCode).Distinct().ToList();

                //月报警次数
                var month = new EquipmentReadinessRateArea();

                month.KunShan = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => kunShanEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= monthStartTime && x.updateTime <= monthEndTime)
                    .Count();

                month.XuZhou = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => xuZhouEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= monthStartTime && x.updateTime <= monthEndTime)
                    .Count();

                month.ChangSha = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => changShaEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= monthStartTime && x.updateTime <= monthEndTime)
                    .Count();

                month.Total = month.KunShan + month.XuZhou + month.ChangSha;

                //季报警次数
                var quarter = new EquipmentReadinessRateArea();

                quarter.KunShan = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => kunShanEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= quarterStartTime && x.updateTime <= quarterEndTime)
                    .Count();

                quarter.XuZhou = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => xuZhouEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= quarterStartTime && x.updateTime <= quarterEndTime)
                    .Count();

                quarter.ChangSha = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => changShaEquipmentCodes.Contains(x.equipmentCode) && x.createTime >= quarterStartTime && x.updateTime <= quarterEndTime)
                    .Count();

                quarter.Total = quarter.KunShan + quarter.XuZhou + quarter.ChangSha;

                //昆山
                var kunShanGroup = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => x.createTime >= monthStartTime && x.updateTime <= monthEndTime && kunShanEquipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.equipmentName,
                    })
                    .Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        EquipmentName = x.equipmentName,
                        AlarmCount = SqlFunc.AggregateCount(x.id),
                        Duration = SqlFunc.AggregateSum(x.errorduration)
                    }).OrderByDescending(x => x.AlarmCount).Take(15).ToList();

                var kunShanAlarmCountSum = kunShanGroup.Sum(x => x.AlarmCount);
                var kunShan = kunShanGroup.Select(x => new EquipmentAlarmFrequencyArea
                {
                    EquipmentCode = x.EquipmentCode,
                    EquipmentName = x.EquipmentName,
                    AlarmCount = x.AlarmCount,
                    Duration = Math.Round(x.Duration / 60, 2), // 转换为分钟
                    Proportion = Math.Round(x.AlarmCount * 1.0 / kunShanAlarmCountSum, 2) // 占比
                }).ToList();

                //徐州
                var xuZhouGroup = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => x.createTime >= monthStartTime && x.updateTime <= monthEndTime && xuZhouEquipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.equipmentName,
                    })
                    .Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        EquipmentName = x.equipmentName,
                        AlarmCount = SqlFunc.AggregateCount(x.id),
                        Duration = SqlFunc.AggregateSum(x.errorduration)
                    }).OrderByDescending(x => x.AlarmCount).Take(15).ToList();

                var xuZhouAlarmCountSum = xuZhouGroup.Sum(x => x.AlarmCount);
                var xuZhou = xuZhouGroup.Select(x => new EquipmentAlarmFrequencyArea
                {
                    EquipmentCode = x.EquipmentCode,
                    EquipmentName = x.EquipmentName,
                    AlarmCount = x.AlarmCount,
                    Duration = Math.Round(x.Duration / 60, 2), // 转换为分钟
                    Proportion = Math.Round(x.AlarmCount * 1.0 / xuZhouAlarmCountSum, 2) // 占比
                }).ToList();

                //长沙
                var changShaGroup = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => x.createTime >= monthStartTime && x.updateTime <= monthEndTime && changShaEquipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.equipmentName,
                    })
                    .Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        EquipmentName = x.equipmentName,
                        AlarmCount = SqlFunc.AggregateCount(x.id),
                        Duration = SqlFunc.AggregateSum(x.errorduration)
                    }).OrderByDescending(x => x.AlarmCount).Take(15).ToList();

                var changShaAlarmCountSum = changShaGroup.Sum(x => x.AlarmCount);
                var changSha = changShaGroup.Select(x => new EquipmentAlarmFrequencyArea
                {
                    EquipmentCode = x.EquipmentCode,
                    EquipmentName = x.EquipmentName,
                    AlarmCount = x.AlarmCount,
                    Duration = Math.Round(x.Duration / 60, 2), // 转换为分钟
                    Proportion = Math.Round(x.AlarmCount * 1.0 / changShaAlarmCountSum, 2) // 占比
                }).ToList();

                response.Result = new EquipmentAlarmFrequency
                {
                    Month = month,
                    Quarter = quarter,
                    KunShan = kunShan,
                    XuZhou = xuZhou,
                    ChangSha = changSha
                };
                return response;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
                return response;
            }
        }

        /// <summary>
        /// 报警频率统计-报警次数视角详情
        /// </summary>
        /// <param name="projectClientInfoKeys"></param>
        /// <param name="begin"></param>
        /// <param name="end"></param>
        /// <param name="projectCode"></param>
        /// <param name="equipmentCode"></param>
        /// <returns></returns>
        public Response<List<Dictionary<string, object>>> GetEquipmentAlarmFrequencyDetail(Guid projectClientInfoKeys, DateTime begin, string projectCode, string equipmentCode)
        {
            var response = new Response<List<Dictionary<string, object>>>();
            try
            {
                //赋予默认值
                if (string.IsNullOrWhiteSpace(projectCode))
                {
                    projectCode = Context.Queryable<base_project>().OrderBy(x => x.id).Select(x => x.projectCode).First();
                }

                var expression = Expressionable.Create<base_project_client_info, base_project>()
                    .AndIF(projectClientInfoKeys != Guid.Empty, (x, y) => x.keys == projectClientInfoKeys)
                    .AndIF(!string.IsNullOrEmpty(projectCode), (x, y) => y.projectCode == projectCode)
                    .ToExpression();

                var baseProjects = Context.Queryable<base_project_client_info, base_project>((x, y) => new object[]
                {
                    JoinType.Inner, x.keys == y.projectClientInfoKeys,
                }).Where(expression).Select((x, y) => y).ToList();

                var baseProjectKeys = baseProjects.ConvertAll(x => x.keys);
                var expression2 = Expressionable.Create<base_equipment>()
                    .And(x => baseProjectKeys.Contains(x.projectKeys))
                    .AndIF(!string.IsNullOrEmpty(equipmentCode), x => x.equipmentCode == equipmentCode)
                    .ToExpression();
                var baseEquipments = Context.Queryable<base_equipment>().Where(expression2).ToList();

                var equipmentCodes = baseEquipments.ConvertAll(x => x.otherCode).OrderBy(x => x).ToList();
                CalculateDateRanges(begin, out DateTime weekStartTime, out DateTime weekEndTime, out DateTime monthStartTime, out DateTime monthEndTime, out DateTime quarterStartTime, out DateTime quarterEndTime);

                var top15EquipmentCodes = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => x.createTime >= weekStartTime && x.updateTime <= monthEndTime && equipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => x.equipmentCode)
                    .Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        AlarmCount = SqlFunc.AggregateCount(x.id)
                    }).OrderByDescending(x => x.AlarmCount)
                    .Take(15)
                    .ToList().ConvertAll(x => x.EquipmentCode);

                var group = Context.Queryable<daq_equipment_alarm_record>()
                    .Where(x => x.createTime >= weekStartTime && x.updateTime <= monthEndTime && top15EquipmentCodes.Contains(x.equipmentCode))
                    .GroupBy(x => new
                    {
                        x.equipmentCode,
                        x.equipmentName,
                        x.createTime.Date
                    }).Select(x => new
                    {
                        EquipmentCode = x.equipmentCode,
                        EquipmentName = x.equipmentName,
                        x.createTime.Date,
                        AlarmCount = SqlFunc.AggregateCount(x.id),
                    }).OrderByDescending(x => x.AlarmCount).ToList();

                var dateRange = Enumerable.Range(0, (weekEndTime - weekStartTime).Days + 1).Select(offset => weekStartTime.AddDays(offset)).ToList();
                var detailList = new List<Dictionary<string, object>>();
                foreach (var item in equipmentCodes)
                {
                    var obj = new Dictionary<string, object>();
                    obj.TryAdd("EquipmentCode", item);
                    var equipmentName = baseEquipments.Where(x => x.equipmentCode == item).Select(x => x.equipmentName).FirstOrDefault();
                    obj.TryAdd("EquipmentName", equipmentName);
                    var total = 0;
                    var trend = new List<int>();
                    var colDateList = new List<string>();
                    var dateColIndex = 1;
                    foreach (var date in dateRange)
                    {
                        var currentAlarmCount = group.Where(x => x.EquipmentCode == item && x.Date == date.Date).Sum(x => x.AlarmCount);
                        colDateList.Add(date.ToString("MM-dd"));
                        //obj.TryAdd($"D{date:MM-dd}", currentAlarmCount);
                        obj.TryAdd($"DateCol" + dateColIndex++, currentAlarmCount);
                        total += currentAlarmCount;
                        trend.Add(currentAlarmCount);
                    }
                    //总数
                    obj.TryAdd("Total", total);
                    //趋势
                    obj.TryAdd("Trend", trend);
                    obj.TryAdd("colDateList", colDateList);

                    //波动浮动
                    var mean = trend.Average();
                    if (mean == 0)
                    {
                        obj.TryAdd("cvPercentage", 0);
                    }
                    else
                    {
                        var sumOfSquares = trend.Sum(x => Math.Pow(x - mean, 2));
                        var variance = sumOfSquares / (trend.Count - 1);
                        var standardDeviation = Math.Sqrt(variance);
                        var cvPercentage = standardDeviation / mean;
                        obj.TryAdd("cvPercentage", Math.Round(cvPercentage, 2));
                    }
                    detailList.Add(obj);
                }
                response.Result = detailList;
                return response;
            }
            catch (Exception ex)
            {
                response.ResponseErr(ex.Message);
                return response;
            }
        }
    }
}