MES / DataAcquisition · Files

using DataAcquisition.Common.Enums;
using DataAcquisition.DataAccess;
using DataAcquisition.Models;
using DataAcquisition.Services;
using DataAcquisition.ViewModels.Board;

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Caching.Memory;

namespace DataAcquisition.ApiControllers

{
    /// <summary>
    /// 看板接口
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class BoardController : ControllerBase
    {
        private readonly IDbContextFactory<DataContext> _dbContextFactory;
        private readonly DataCacheService _dataCacheService;

        private readonly IMemoryCache _memoryCache;
        private readonly TimeSpan _absoluteExpirationRelativeToNow;

        public BoardController(IDbContextFactory<DataContext> dbContextFactory, DataCacheService dataCacheService, IMemoryCache memoryCache)

        {
            _dbContextFactory = dbContextFactory;
            _dataCacheService = dataCacheService;

            _memoryCache = memoryCache;

            _absoluteExpirationRelativeToNow = TimeSpan.FromSeconds(2);

        }

        /// <summary>

        /// 焊接看板1

        /// </summary>

        /// <param name="robotNo">机器人编号</param>

        /// <remarks>1号厂房</remarks>

        /// <returns></returns>
        [HttpGet]

        [Route("WeldBoard/{robotNo:int}")]

        public BoardResult<dynamic> GetWeldBoardData(int robotNo = 1)

        {

            var result = new BoardResult<dynamic>();

            try
            {

                var key = $"{nameof(GetWeldBoardData)}_{robotNo}";
                var cacheData = _memoryCache.Get<BoardResult<dynamic>>(key);
                if (cacheData != null)
                {
                    return cacheData;
                }

                //本月开始时间
                var monthStartTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).Date;
                using var context = _dbContextFactory.CreateDbContext();

                var robotEquipment = robotNo switch

                {

                    1 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.KukaC4_1.ToString())!,
                    2 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.KukaC4_2.ToString())!,
                    3 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.KukaC2_1.ToString())!,
                    4 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.KukaC2_2.ToString())!,

                    5 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.Efort_1.ToString())!,
                    6 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.Fanuc_1.ToString())!,

                    _ => throw new NotImplementedException($"未找到编号为“{robotNo}”的设备数据!"),

                };

                var plc = robotNo switch

                {

                    1 or 2 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.SiemensPLC_1.ToString())!,
                    3 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.SiemensPLC_2.ToString())!,
                    4 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.SiemensPLC_3.ToString())!,

                    5 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.CoTrust_PLC1.ToString())!,
                    6 => _dataCacheService.Equipments.Find(x => x.Code == EquipmentConst.SiemensPLC_4.ToString())!,

                    _ => throw new NotImplementedException($"未找到编号为“{robotNo}”的PLC设备数据!"),

                };

                _ = double.TryParse(robotEquipment[RobotProps.Pos_X.ToString()].Value, out var pos_X);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_Y.ToString()].Value, out var pos_Y);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_Z.ToString()].Value, out var pos_Z);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_A.ToString()].Value, out var pos_A);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_B.ToString()].Value, out var pos_B);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_C.ToString()].Value, out var pos_C);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_E1.ToString()].Value, out var pos_E1);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_E2.ToString()].Value, out var pos_E2);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_E3.ToString()].Value, out var pos_E3);
                _ = double.TryParse(robotEquipment[RobotProps.Pos_E4.ToString()].Value, out var pos_E4);

                _ = bool.TryParse(robotEquipment[RobotProps.Weld_CleanGun.ToString()].Value, out var weld_CleanGun);
                _ = bool.TryParse(robotEquipment[RobotProps.WeldFlag.ToString()].Value, out var weldFlag);
                _ = bool.TryParse(robotEquipment[RobotProps.Weld_Gas.ToString()].Value, out var weld_Gas);
                _ = bool.TryParse(robotEquipment[RobotProps.WeldCompleteFlag.ToString()].Value, out var weldCompleteFlag);
                _ = bool.TryParse(robotEquipment[RobotProps.BootFlag.ToString()].Value, out var bootFalgValue);
                _ = bool.TryParse(robotEquipment[RobotProps.Alarm.ToString()].Value, out var alarmValue);
                _ = bool.TryParse(robotEquipment[RobotProps.WorkFlag.ToString()].Value, out var workFlagValue);

                _ = bool.TryParse(robotEquipment[RobotProps.Work_Time.ToString()].Value, out var workTime);

                _ = float.TryParse(robotEquipment[RobotProps.Weld_V.ToString()].Value, out var weld_V);
                _ = float.TryParse(robotEquipment[RobotProps.Weld_I.ToString()].Value, out var weld_I);
                _ = float.TryParse(robotEquipment[RobotProps.Weld_Speed.ToString()].Value, out var weld_Speed);
                _ = int.TryParse(robotEquipment[RobotProps.Work_Mode.ToString()].Value, out var work_Mode);
                _ = int.TryParse(robotEquipment[RobotProps.Program_No.ToString()].Value, out var program_no);
                _ = int.TryParse(robotEquipment[RobotProps.Type.ToString()].Value, out var type);

                var equipmentState = "在线";

                if (!bootFalgValue)
                {
                    equipmentState = "离线";
                }

                //仅自动模式显示
                else if (alarmValue && work_Mode >= 3)

                {
                    equipmentState = "报警";
                }

                else if (workFlagValue)
                {
                    equipmentState = "工作";
                }

                //加工状态
                var productStateName = "空闲";

                var timeSum = 0d;

                if (workTime)

                {

                    productStateName = weldFlag ? "焊接" : "加工";

                    timeSum = Math.Round(TimeSpan.FromTicks(context.WorkpieceProductions.Where(x => x.EquipmentCode == robotEquipment.Code && x.ProgramNo == type).OrderByDescending(x => x.CreateTime).Select(x => x.UpdateTime.Ticks - x.CreateTime.Ticks).FirstOrDefault()).TotalMinutes, 2);

                }

                //功率

                _ = double.TryParse(plc[RobotPlcProps.P_KW.ToString()].Value, out var kw);

                var lastProductionId = context.WorkpieceProductions.Where(x => x.EquipmentCode == robotEquipment.Code).OrderByDescending(x => x
                .CreateTime).Select(x => x.Id).FirstOrDefault();

                var days = 7;//显示最近N天的数据
                var xAxisData = Enumerable.Range(0, days).Select(x => DateTime.Today.AddDays(-x)).OrderBy(x => x).ToList();

                var bootFalgTicks = context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString()).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks);

                var vm = new Board1VM
                {
                    NowDayCountLeft = new NowDayCountLeft
                    {

                        WorkTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WorkFlag.ToString() && x.CreateTime >= DateTime.Today).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                        ArcingTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WeldFlag.ToString() && x.CreateTime >= DateTime.Today).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                        FinishCount = context.WorkpieceProductions.Where(x => x.EquipmentCode == robotEquipment.Code && x.CreateTime >= DateTime.Today && x.IsEnd).Count(),

                        PowerTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString() && x.CreateTime >= DateTime.Today).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2)

                    },
                    EqCenter = new EquipmentStatusVM
                    {

                        EqCode = robotEquipment.Code,
                        EqName = robotEquipment.Name,

                        EqState = equipmentState,

                        Eqmode = work_Mode switch
                        {
                            1 => "T1模式",
                            2 => "T2模式",
                            3 => "自动模式",
                            4 => "外部自动模式",

                            _ => "无数据"

                        },

                        MonthDaoDian = context.WorkpieceProductions.Where(x => x.EquipmentCode == robotEquipment.Code && x.CreateTime >= monthStartTime && x.IsEnd).Count(),

                        MonthWeld = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.Weld_Speed.ToString() && x.CreateTime >= monthStartTime).Select(x => x.Value).AsEnumerable().Sum(Convert.ToSingle), 2),

                        MonthVoltage = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == plc.Code && x.EquipmentPropertyCode == RobotPlcProps.Electricity.ToString() && x.CreateTime >= monthStartTime).Select(x => x.Value).AsEnumerable().Sum(Convert.ToSingle), 2),

                        NowDayVoltage = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == plc.Code && x.EquipmentPropertyCode == RobotPlcProps.Electricity.ToString() && x.CreateTime >= DateTime.Today).Select(x => x.Value).AsEnumerable().Sum(Convert.ToSingle), 2),

                        MonthWeldVoltage = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == $"{RobotProps.WeldFlag}_{RobotPlcProps.Electricity}" && x.CreateTime >= monthStartTime).Select(x => x

                        .Value).AsEnumerable().Sum(Convert.ToSingle), 2),

                        TodayWeldVoltage = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == $"{RobotProps.WeldFlag}_{RobotPlcProps.Electricity}" && x.CreateTime >= DateTime.Today).Select(x => x

                        .Value).AsEnumerable().Sum(Convert.ToSingle), 2),

                        MonthGas = $"{context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.Gas_Flow.ToString() && x.CreateTime >= monthStartTime).Select(x => x.Value).AsEnumerable().Sum(Convert.ToSingle):N2}/L",

                        P_KW = kw,

                    },
                    MonthCountRight = new MonthCountRight
                    {

                        WorkTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WorkFlag.ToString() && x.CreateTime >= monthStartTime).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                        ArcingTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WeldFlag.ToString() && x.CreateTime >= monthStartTime).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                        PowerTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString() && x.CreateTime >= monthStartTime).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                        AlarmTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.Alarm.ToString() && x.CreateTime >= monthStartTime).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),

                    },

                    EqInfoLeft = new EquipmentInfoLeftVM
                    {
                        ClearSpearState = weld_CleanGun,
                        ArcingState = weldFlag,
                        AspiratedState = weld_Gas,

                        NowProject = type == 0 ? "无" : $"程序{type}",

                        ProjectRow = program_no,

                        X = Math.Round(pos_X, 1),
                        Y = Math.Round(pos_Y, 1),
                        Z = Math.Round(pos_Z, 1),
                        A = Math.Round(pos_A, 1),
                        B = Math.Round(pos_B, 1),
                        C = Math.Round(pos_C, 1),
                        E1 = Math.Round(pos_E1, 1),
                        E2 = Math.Round(pos_E2, 1),
                        E3 = Math.Round(pos_E3, 1),
                        E4 = Math.Round(pos_E4, 1),

                        SsSpeed = Math.Round(weld_Speed, 1),
                        Current = Math.Round(weld_I, 1),

                        Voltage = GetVoltageVal(weld_I, weld_V, robotEquipment),

                    },
                    EqInfoRight = new EquipmentInfoRight
                    {
                        EfficiencyList = new Efficiency
                        {

                            Arcing = xAxisData.Select(x => Convert.ToInt32(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(r => r.EquipmentCode == robotEquipment.Code && r.EquipmentPropertyCode == RobotProps.WeldFlag.ToString() && r.CreateTime.Date == x).Sum(r => r.UpdateTime.Ticks - r.CreateTime.Ticks)).TotalMinutes)).ToList(),

                            PowerOn = xAxisData.Select(x => Convert.ToInt32(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(r => r.EquipmentCode == robotEquipment.Code && r.EquipmentPropertyCode == RobotProps.BootFlag.ToString() && r.CreateTime.Date == x).Sum(r => r.UpdateTime.Ticks - r.CreateTime.Ticks)).TotalMinutes)).ToList(),

                            Work = xAxisData.Select(x => Convert.ToInt32(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(r => r.EquipmentCode == robotEquipment.Code && r.EquipmentPropertyCode == RobotProps.Work_Time.ToString() && r.CreateTime.Date == x).Sum(r => r.UpdateTime.Ticks - r.CreateTime.Ticks)).TotalMinutes)).ToList(),

                            XAxisData = xAxisData.Select(x => x.ToString("M")).ToList(),
                        },

                        WeldFlagData = xAxisData.Select(x => new BoardChart
                        {
                            Name = x.ToString("M"),
                            Value = GetWeldFlagRate(context, robotEquipment, x)
                        }).ToList(),

                        ProductInfo = type.ToString(),

                        ProductState = productStateName,

                        TimeSum = timeSum,

                        YieldList = new YieldListVM
                        {
                            XAxisData = xAxisData.Select(x => x.ToString("M")).ToList(),

                            Yield = xAxisData.Select(x => context.WorkpieceProductions.Where(w => w.EquipmentCode == robotEquipment.Code && w.CreateTime.Date == x.Date && w.IsEnd).Count()).ToList(),

                        }
                    },

                    CurrentList = context.WeldProcessRecords.Where(x => x.ProductionId == lastProductionId && x.Code == RobotProps.Weld_I.ToString()).OrderBy(x => x.CreateTime).Select(x => x.Value).AsEnumerable().Select(x =>
                    {
                        _ = double.TryParse(x, out var val);
                        return Math.Round(val, 1);
                    }).ToList(),

                    EqEfficiencyCenter = new EquipmentEfficiency

                    {

                        AlarmRate = GetAlarmRate(context, robotEquipment),
                        AutoRate = GetAutoRate(context, robotEquipment),

                        OnLineRate = GetOnLineRate(context, robotEquipment),

                        UtilizeRate = UtilizeRate(context, robotEquipment),

                    },

                    VoltagetList = context.WeldProcessRecords.Where(x => x.ProductionId == lastProductionId && x.Code == RobotProps.Weld_V.ToString()).OrderBy(x => x.CreateTime).Select(x => x.Value).AsEnumerable().Select(x =>
                    {
                        _ = double.TryParse(x, out var val);
                        return Math.Round(val, 1);
                    }).ToList(),

                };

                //获取电压值
                double GetVoltageVal(float weld_I, float weld_V, Equipment robot)
                {
                    //Kuka C2设备数值有误差，电流值为0时，电压应显示0
                    var codes = new List<EquipmentConst>
                    {

                        EquipmentConst.KukaC2_1,
                        EquipmentConst.KukaC2_2,

                    }.Select(x => x.ToString()).ToList();
                    if (codes.Contains(robot.Code) && weld_I <= 0)
                    {
                        return 0;
                    }
                    return Math.Round(weld_V, 1);
                }

                //故障率

                int GetAlarmRate(DataContext context, Equipment robotEquipment)

                {
                    if (bootFalgTicks == 0) return 0;

                    return Convert.ToInt32(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.Alarm.ToString()).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks) * 100 / bootFalgTicks);

                }

                int UtilizeRate(DataContext context, Equipment robotEquipment)

                {
                    if (bootFalgTicks == 0) return 0;

                    return Convert.ToInt32(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WorkFlag.ToString()).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks) * 100 / bootFalgTicks);

                }

                int GetAutoRate(DataContext context, Equipment robotEquipment)

                {
                    if (bootFalgTicks == 0) return 0;

                    return Convert.ToInt32(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.WeldFlag.ToString()).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks) * 100 / bootFalgTicks);

                }

                //在线率
                int GetOnLineRate(DataContext context, Equipment robotEquipment)
                {

                    var bootFlagStartDay = context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString()).OrderBy(x => x.CreateTime).Select(x => x.CreateTime).FirstOrDefault();

                    if (bootFlagStartDay == default) return 0;
                    else if (bootFlagStartDay <= DateTime.Today.AddMonths(-1))
                    {
                        bootFlagStartDay = DateTime.Today.AddMonths(-1);
                    }

                    return Convert.ToInt32(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robotEquipment.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString()).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks) * 100 / (DateTime.Now - bootFlagStartDay).Ticks);

                }

                result.Data = new
                {
                    Head = new
                    {
                        vm.NowDayCountLeft,
                        vm.EqCenter,
                        vm.MonthCountRight,
                    },
                    Center = new
                    {
                        vm.EqInfoLeft,
                        vm.EqInfoRight,
                    },
                    Footer = new
                    {
                        vm.CurrentList,
                        vm.EqEfficiencyCenter,
                        vm.VoltagetList,
                    }
                };

                _memoryCache.Set(key, result, _absoluteExpirationRelativeToNow);

            }
            catch (Exception ex)
            {
                result.Code = 500;
                result.Message = ex.Message;
            }

            return result;
        }

        /// <summary>
        /// 焊接看板2
        /// </summary>
        /// <remarks>2号厂房</remarks>
        /// <returns></returns>
        [HttpGet]
        [Route("WeldBoard")]
        public BoardResult<Board2VM> GetWeldBoardData()
        {
            try
            {

                var key = $"{nameof(GetWeldBoardData)}";
                var cacheData = _memoryCache.Get<BoardResult<Board2VM>>(key);
                if (cacheData != null)

                {

                    return cacheData;
                }

                using var context = _dbContextFactory.CreateDbContext();

                //本月开始时间
                var monthStartTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).Date;
                var days = 7;//显示最近N天的数据
                var xAxisData = Enumerable.Range(0, days).Select(x => DateTime.Today.AddDays(-x)).OrderBy(x => x).ToList();
                var vm = new Board2VM
                {

                    Robot1 = GetRobotInfo(EquipmentConst.KukaC4_1),
                    Robot2 = GetRobotInfo(EquipmentConst.KukaC4_2),
                    Robot3 = GetRobotInfo(EquipmentConst.KukaC2_1),
                    Robot4 = GetRobotInfo(EquipmentConst.KukaC2_2),

                    Robot5 = GetRobotInfo(EquipmentConst.Efort_1),
                    Robot6 = GetRobotInfo(EquipmentConst.Fanuc_1),
                };

                var result = new BoardResult<Board2VM>

                {
                    Code = 200,
                    Data = vm,
                    Message = "成功"
                };

                _memoryCache.Set(key, result, _absoluteExpirationRelativeToNow);
                return result;

                RobotDto GetRobotInfo(EquipmentConst equipmentCode)
                {
                    var robot = context.Equipments.Where(x => x.Code == equipmentCode.ToString()).FirstOrDefault();
                    if (robot == null)
                    {
                        return new RobotDto();
                    }
                    var result = new RobotDto
                    {
                        RobotCode = robot.Code,
                        RobotName = robot.Name,

                        CompleteCount = context.WorkpieceProductions.Where(x => x.EquipmentCode == robot.Code && x.CreateTime >= monthStartTime).Count(),

                        WorkTime = Math.Round(TimeSpan.FromTicks(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robot.Code && x.EquipmentPropertyCode == RobotProps.WorkFlag.ToString() && x.CreateTime >= monthStartTime).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks)).TotalHours, 2),
                        MonthWeld = Math.Round(context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robot.Code && x.EquipmentPropertyCode == RobotProps.Weld_Speed.ToString() && x.CreateTime >= monthStartTime).Select(x => x.Value).AsEnumerable().Sum(Convert.ToSingle)),
                        Charts = xAxisData.Select(x => new BoardChart
                        {
                            Name = x.ToString("M"),
                            Value = GetWeldFlagRate(context, robot, x)
                        }).ToList()
                    };
                    return result;
                }
            }
            catch (Exception ex)
            {
                return new BoardResult<Board2VM>
                {
                    Code = 500,
                    Message = ex.Message
                };
            }
        }

        /// <summary>
        /// 焊接总看板
        /// </summary>
        /// <remarks>1号厂房</remarks>
        /// <returns></returns>
        [HttpGet]
        [Route("MainWeldBoard")]
        public BoardResult<Board3VM> GetMainWeldBoard()
        {
            var result = new BoardResult<Board3VM>();
            try
            {

                var key = $"{nameof(GetMainWeldBoard)}";
                var cacheData = _memoryCache.Get<BoardResult<Board3VM>>(key);
                if (cacheData != null)
                {
                    return cacheData;
                }

                var monthStartTime = DateTime.Today.AddDays(1 - DateTime.Today.Day).Date;
                using var context = _dbContextFactory.CreateDbContext();
                var robotCodes = new List<EquipmentConst>
                {

                    EquipmentConst.KukaC4_1,
                    EquipmentConst.KukaC4_2,
                    EquipmentConst.KukaC2_1,
                    EquipmentConst.KukaC2_2,

                    EquipmentConst.Efort_1,
                    EquipmentConst.Fanuc_1,
                }.Select(x => x.ToString()).ToList();
                var days = 7;//显示最近N天的数据
                var xAxisData = Enumerable.Range(0, days).Select(x => DateTime.Today.AddDays(-x)).OrderBy(x => x).ToList();
                var robots = _dataCacheService.Equipments.Where(x => robotCodes.Contains(x.Code)).OrderBy(x => x.Code).ToList();

                var totalTicks = (DateTime.Now - DateTime.Today).Ticks;

                var vm = new Board3VM
                {
                    RobotStateMonitor = robots.Select(x =>
                    {
                        _ = bool.TryParse(x[RobotProps.BootFlag.ToString()].Value, out var bootFalgValue);
                        _ = bool.TryParse(x[RobotProps.Alarm.ToString()].Value, out var alarmValue);
                        _ = bool.TryParse(x[RobotProps.WorkFlag.ToString()].Value, out var workFlagValue);
                        _ = int.TryParse(x[RobotProps.Work_Mode.ToString()].Value, out var work_Mode);

                        var state = 2;//待机
                        if (!bootFalgValue)
                        {
                            state = 0;//离线
                        }
                        else if (workFlagValue)
                        {
                            state = 1;//工作
                        }
                        //仅自动模式显示
                        else if (alarmValue && work_Mode >= 3)
                        {
                            state = 3;//报警
                        }

                        var data = new RobotState
                        {
                            Code = x.Code,
                            Name = x.Name,
                            State = state,
                            StateName = state switch
                            {
                                1 => "运行",
                                2 => "待机",
                                3 => "报警",
                                _ => "离线",
                            }
                        };
                        return data;
                    }).ToList(),
                    RobotConditions = robots.Select(x =>
                    {
                        _ = int.TryParse(x[RobotProps.Work_Mode.ToString()].Value, out var mode);
                        _ = bool.TryParse(x[RobotProps.Weld_CleanGun.ToString()].Value, out var weld_CleanGun);
                        _ = float.TryParse(x[RobotProps.Weld_I.ToString()].Value, out var weld_I);
                        _ = float.TryParse(x[RobotProps.Weld_V.ToString()].Value, out var weld_V);
                        _ = float.TryParse(x[RobotProps.Weld_Speed.ToString()].Value, out var weld_Speed);
                        var data = new RobotCondition
                        {
                            EquipmentCode = x.Code,
                            Weld_CleanGun = weld_CleanGun,
                            Weld_I = Math.Round(weld_I, 1),
                            Weld_V = Math.Round(weld_V, 1),
                            Weld_Speed = Math.Round(weld_Speed, 1),
                            WorkMode = mode switch
                            {
                                1 => "T1模式",
                                2 => "T2模式",
                                3 => "自动模式",
                                4 => "外部自动模式",
                                _ => "无数据",
                            }
                        };
                        return data;
                    }).ToList(),

                    RobotStateStatistics = robots.Select(robot =>

                    {

                        var bootFlagTicks = context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robot.Code && x.EquipmentPropertyCode == RobotProps.BootFlag.ToString() && x.CreateTime >= DateTime.Today).Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks);

                        var run = 0d;
                        var free = 0d;
                        var alarm = 0d;

                        var offLine = 0d;
                        if (totalTicks == 0 || bootFlagTicks == 0)

                        {

                            offLine = 100;

                        }
                        else
                        {

                            var workFlagRecords = context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robot.Code && x.EquipmentPropertyCode == RobotProps.WorkFlag.ToString() && x.CreateTime >= DateTime.Today).Select(x => new
                            {
                                x.CreateTime,
                                x.UpdateTime,
                            }).ToList();

                            var alarmFlagRecords = context.EquipmentPropertyRecords.Where(x => x.EquipmentCode == robot.Code && x.EquipmentPropertyCode == RobotProps.Alarm.ToString() && x.CreateTime >= DateTime.Today).Select(x => new
                            {
                                x.CreateTime,
                                x.UpdateTime,
                            }).ToList();

                            var workFlagTicks = workFlagRecords.Sum(workRecord =>
                            {
                                var alarmRecord = alarmFlagRecords.Where(x => x.CreateTime >= workRecord.CreateTime && x.CreateTime <= workRecord.UpdateTime).FirstOrDefault();
                                if (alarmRecord == null)
                                {
                                    return (workRecord.UpdateTime - workRecord.CreateTime).Ticks;
                                }

                                if (alarmRecord.UpdateTime > workRecord.UpdateTime)
                                {
                                    return (alarmRecord.CreateTime - workRecord.CreateTime).Ticks;
                                }
                                return (workRecord.UpdateTime - workRecord.CreateTime).Ticks - (alarmRecord.UpdateTime - alarmRecord.CreateTime).Ticks;
                            });

                            var alarmFlagTicks = alarmFlagRecords.Sum(x => x.UpdateTime.Ticks - x.CreateTime.Ticks);