FYCore/LanSheng/LanShengService/DeviceService.cs

using CommonModel;
using Dapr.Client;
using LanShengInterface;
using LanShengModel;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using NewLife.Reflection;
using Newtonsoft.Json.Linq;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using ZhongLianModel;

namespace LanShengService
{
    public class DeviceService : IDeviceService
    {
        public DeviceService(IServiceProvider services)
        {
            Services = services;

            Logger = services.GetRequiredService<ILogger<DeviceService>>();

            Db = services.GetRequiredService<ISqlSugarClient>();

            Db.CodeFirst.InitTables(typeof(DeviceData));

            Db.CodeFirst.SplitTables().InitTables(typeof(TcpDataLog<DeviceData>));

            Db.CodeFirst.SplitTables().InitTables(typeof(DeviceError));

            Logger.LogDebug("加载数据结构");

            CacheService = services.GetRequiredService<CacheInterface.ICacheService>();

            Logger.LogDebug("加载缓存服务");

            InitDeviceError();

            Logger.LogDebug("加载设备故障表");

            Logger.LogDebug("创建设备服务");

            ClearDataLogDo();
        }

        private readonly IServiceProvider Services;

        private readonly ILogger Logger;

        private readonly ISqlSugarClient Db;

        private readonly CacheInterface.ICacheService CacheService;

        private readonly int TicketInsertDataDo = 1000;

        private readonly int TicketInsertDataLogDo = 5000;

        private readonly int TicketClearDataLogDo = 1000 * 60 * 60 * 24;

        private readonly int ValidClearDataLogDo = 1000 * 60 * 60 * 24 * 3;

        public async Task InsertData(DeviceData deviceData)
        {
            Logger.LogDebug($"设备数据插入队列{JsonSerializer.Serialize(deviceData)}");

            if (deviceData.MsgType!.StartsWith("1"))
            {
                await SetError(deviceData);

                await SetRunCount(deviceData);
            }

            await CacheService.Set($"DeviceData:{deviceData.Id}.{Guid.NewGuid().ToString()}", deviceData, 5);
        }

        public async Task TimerInsertDataDo()
        {
            Logger.LogDebug($"启动设备数据定时任务");

            await Task.Factory.StartNew(async () =>
            {
                while (true)
                {
                    try
                    {
                        await InsertDataDo();
                    }
                    catch (Exception ex)
                    {
                        Logger.LogError(ex.ToString());
                    }
                    finally
                    {
                        Thread.Sleep(TicketInsertDataDo);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

        public async Task InsertDataDo()
        {
            var Devices = await CacheService.Query<DeviceData>("DeviceData:");
            await CacheService.BatchDelete(Devices.Keys.ToArray());
            Logger.LogDebug($"执行设备数据队列插入{JsonSerializer.Serialize(Devices)}");
            if (Devices.Count > 0)
            {
                var DeviceValues = Devices.Values.GroupBy(x => x == null ? null : x.Id).Select(x => x.First());

                var Values1001 = DeviceValues.Where(x => x != null && (x.MsgType == "1001" || x.MsgType == "9104")).ToList();

                if (Values1001.Count > 0)
                {
                    var temp = Db.Storageable(Values1001).ToStorage();

                    await temp.AsInsertable.ExecuteCommandAsync();

                    await temp.AsUpdateable
                        .UpdateColumns(DeviceData.GetNotNullColumns(Values1001))
                        .ExecuteCommandAsync();
                }

                var Values1103 = DeviceValues.Where(x => x != null && x.MsgType == "1103").ToList();

                if (Values1103.Count > 0)
                {
                    var temp = Db.Storageable(Values1103).ToStorage();

                    await temp.AsInsertable.ExecuteCommandAsync();

                    await temp.AsUpdateable
                        .UpdateColumns(DeviceData.GetNotNullColumns(Values1103))
                        .ExecuteCommandAsync();
                }

                var Values2001 = DeviceValues.Where(x => x != null && (x.MsgType == "2001" || x.MsgType == "8104")).ToList();

                if (Values2001.Count > 0)
                {
                    var temp = Db.Storageable(Values2001).ToStorage();

                    await temp.AsInsertable.ExecuteCommandAsync();

                    await temp.AsUpdateable
                        .UpdateColumns(DeviceData.GetNotNullColumns(Values2001))
                        .ExecuteCommandAsync();
                }

                var Values2103 = DeviceValues.Where(x => x != null && x.MsgType == "2103").ToList();

                if (Values2103.Count > 0)
                {
                    var temp = Db.Storageable(Values2103).ToStorage();

                    await temp.AsInsertable.ExecuteCommandAsync();

                    await temp.AsUpdateable
                        .UpdateColumns(DeviceData.GetNotNullColumns(Values2103))
                        .ExecuteCommandAsync();
                }
            }
        }

        public async Task InsertDataLog(TcpDataLog<DeviceData> dataLog)
        {
            Logger.LogDebug($"日志插入队列{JsonSerializer.Serialize(dataLog)}");

            await CacheService.Set($"TcpDataLog:{dataLog.DTU_ID}.{Guid.NewGuid().ToString()}", dataLog, 30);
        }

        public async Task TimerInsertDataLogDo()
        {
            Logger.LogDebug($"启动设备日志定时任务");
            await Task.Factory.StartNew(async () =>
            {
                while (true)
                {
                    try
                    {
                        await InsertDataLogDo();
                    }
                    catch (Exception ex)
                    {
                        Logger.LogError(ex.ToString());
                    }
                    finally
                    {
                        Thread.Sleep(TicketInsertDataLogDo);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

        public async Task TimerClearDataLogDo()
        {
            Logger.LogDebug($"启动设备日志定时清理任务");
            await Task.Factory.StartNew(async () =>
            {
                while (true)
                {
                    try
                    {
                        await ClearDataLogDo();
                    }
                    catch (Exception ex)
                    {
                        Logger.LogError(ex.ToString());
                    }
                    finally
                    {
                        Thread.Sleep(TicketClearDataLogDo);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

        public async Task InsertDataLogDo()
        {
            var Logs = await CacheService.Query<TcpDataLog<DeviceData>>("TcpDataLog:");
            await CacheService.BatchDelete(Logs.Keys.ToArray());
            Logger.LogDebug($"执行日志队列插入{JsonSerializer.Serialize(Logs)}");
            if (Logs.Count > 0)
            {
                await Db.Insertable(Logs.Values.ToList()).SplitTable().ExecuteCommandAsync();
            }
        }

        public async Task ClearDataLogDo()
        {
            while (true)
            {
                var _Deletes = Db.SplitHelper<TcpDataLog>().GetTables().Where(x => x.Date < DateTime.Now.AddDays(-5));
                foreach (var _Table in _Deletes)
                {
                    Db.DbMaintenance.DropTable(_Table.TableName);
                }
                await Task.Delay(1000 * 60 * 6 * 10);
            }
        }

        public async Task Offline(string id = "")
        {
            Logger.LogDebug($"设备离线{id}");
            if (string.IsNullOrEmpty(id))
            {
                await Db.Updateable<DeviceData>().SetColumns(x => x.Status == "offline").SetColumns(x => x.ErrCode == "").SetColumns(x => x.ErrMsg == "").SetColumns(x => x.OfflineDate == DateTime.Now).Where(x => 1 == 1).ExecuteCommandAsync();
            }
            else
            {
                await Db.Updateable<DeviceData>().SetColumns(x => x.Status == "offline").SetColumns(x => x.ErrCode == "").SetColumns(x => x.ErrMsg == "").SetColumns(x => x.OfflineDate == DateTime.Now).Where(x => x.Id == id).ExecuteCommandAsync();
            }
        }

        public async Task ResetRunCount(string id = "")
        {
            Logger.LogDebug($"重置运行次数{id}");
            if (!string.IsNullOrEmpty(id))
            {
                await Db.Updateable<DeviceData>().SetColumns(x => x.RunCount == 0).Where(x => x.Id == id).ExecuteCommandAsync();

                await CacheService.Set<int>($"{id}_RunCount", 0);
            }
        }

        public async Task<DeviceData> GetDeviceData(string id)
        {
            var Result = await GetDeviceData(new string[] { id });
            if (Result.Count > 0)
            {
                return Result[0];
            }
            else
            {
                throw new BadRequestException("设备编号不存在");
            }
        }

        public async Task<List<DeviceData>> GetDeviceData(string[] ids)
        {
            var Result = await Db.Queryable<DeviceData>().In("Id", ids)
            .IgnoreColumns(x => new
            {
                x.Data25_B4,
                x.Data25_B0,
                x.Data26_B4,
                x.Data26_B0
            })
            .ToListAsync();

            Result.ForEach(async x =>
            {
                x.Data6 = x.Data6 / 10;
                decimal Latitude = 0;
                Decimal.TryParse(x.Latitude, out Latitude);
                x.Latitude = (Latitude / 1000000).ToString();
                decimal Longitude = 0;
                Decimal.TryParse(x.Longitude, out Longitude);
                x.Longitude = (Longitude / 1000000).ToString();

                if (!string.IsNullOrEmpty(x.WZGPS))
                {
                    x.WZ = await Db.Queryable<DeviceData>().FirstAsync(y => y.Id == x.WZGPS);
                }
            });

            return Result;
        }

        private Task SetError(DeviceData deviceData)
        {
            deviceData.ErrCode = "";
            deviceData.ErrMsg = "";

            #region 一体机驱动故障
            if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            {
                SetData4Error(deviceData);
            }
            #endregion

            #region 一体机逻辑故障
            if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            {
                SetData5Error(deviceData);
            }
            #endregion

            #region 门机故障
            if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            {
                SetData17Error(deviceData);
            }
            #endregion

            #region 语音码故障
            if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            {
                SeteData22Error(deviceData);
            }
            #endregion

            #region 自定义故障
            //int TempTime = 12;

            //进料门限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data3_B7_Date = CacheService.Get<DateTime>($"Data3_B7_Date:{deviceData.Id}").Result;
            //    if (Data3_B7_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data3_B7_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data3_B7:{deviceData.Id}", deviceData.Data3_B7).Wait();
            //    }
            //    else
            //    {
            //        var Data3_B7 = CacheService.Get<int?>($"Data3_B7:{deviceData.Id}").Result;
            //        if (Data3_B7 == deviceData.Data3_B7)
            //        {
            //            TimeSpan span = DateTime.Now - Data3_B7_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS001";
            //                deviceData.ErrMsg = "进料门限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data3_B7_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data3_B7:{deviceData.Id}", deviceData.Data3_B7).Wait();
            //        }
            //    }
            //}

            //出料门限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data3_B6_Date = CacheService.Get<DateTime>($"Data3_B6_Date:{deviceData.Id}").Result;
            //    if (Data3_B6_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data3_B6_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data3_B6:{deviceData.Id}", deviceData.Data3_B6).Wait();
            //    }
            //    else
            //    {
            //        var Data3_B6 = CacheService.Get<int?>($"Data3_B6:{deviceData.Id}").Result;
            //        if (Data3_B6 == deviceData.Data3_B6)
            //        {
            //            TimeSpan span = DateTime.Now - Data3_B6_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS002";
            //                deviceData.ErrMsg = "出料门限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data3_B6_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data3_B6:{deviceData.Id}", deviceData.Data3_B6).Wait();
            //        }
            //    }
            //}

            //进料门上限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data15_B3_Date = CacheService.Get<DateTime>($"Data15_B3_Date:{deviceData.Id}").Result;
            //    if (Data15_B3_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data15_B3_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data15_B3:{deviceData.Id}", deviceData.Data15_B3).Wait();
            //    }
            //    else
            //    {
            //        var Data15_B3 = CacheService.Get<int?>($"Data15_B3:{deviceData.Id}").Result;
            //        if (Data15_B3 == deviceData.Data15_B3)
            //        {
            //            TimeSpan span = DateTime.Now - Data15_B3_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS003";
            //                deviceData.ErrMsg = "进料门上限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data15_B3_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data15_B3:{deviceData.Id}", deviceData.Data3_B6).Wait();
            //        }
            //    }
            //}

            //进料门下限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data15_B2_Date = CacheService.Get<DateTime>($"Data15_B2_Date:{deviceData.Id}").Result;
            //    if (Data15_B2_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data15_B2_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data15_B2:{deviceData.Id}", deviceData.Data15_B2).Wait();
            //    }
            //    else
            //    {
            //        var Data15_B2 = CacheService.Get<int?>($"Data15_B2:{deviceData.Id}").Result;
            //        if (Data15_B2 == deviceData.Data15_B2)
            //        {
            //            TimeSpan span = DateTime.Now - Data15_B2_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS004";
            //                deviceData.ErrMsg = "进料门下限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data15_B2_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data15_B2:{deviceData.Id}", deviceData.Data15_B2).Wait();
            //        }
            //    }
            //}

            //出料门上限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data15_B1_Date = CacheService.Get<DateTime>($"Data15_B1_Date:{deviceData.Id}").Result;
            //    if (Data15_B1_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data15_B1_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data15_B1:{deviceData.Id}", deviceData.Data15_B1).Wait();
            //    }
            //    else
            //    {
            //        var Data15_B1 = CacheService.Get<int?>($"Data15_B1:{deviceData.Id}").Result;
            //        if (Data15_B1 == deviceData.Data15_B1)
            //        {
            //            TimeSpan span = DateTime.Now - Data15_B1_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS005";
            //                deviceData.ErrMsg = "出料门上限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data15_B1_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data15_B1:{deviceData.Id}", deviceData.Data15_B1).Wait();
            //        }
            //    }
            //}

            //出料门下限位保护
            //if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            //{
            //    var Data15_B0_Date = CacheService.Get<DateTime>($"Data15_B0_Date:{deviceData.Id}").Result;
            //    if (Data15_B0_Date == default)
            //    {
            //        CacheService.Set<DateTime>($"Data15_B0_Date:{deviceData.Id}", DateTime.Now).Wait();
            //        CacheService.Set<int?>($"Data15_B0:{deviceData.Id}", deviceData.Data15_B0).Wait();
            //    }
            //    else
            //    {
            //        var Data15_B0 = CacheService.Get<int?>($"Data15_B0:{deviceData.Id}").Result;
            //        if (Data15_B0 == deviceData.Data15_B0)
            //        {
            //            TimeSpan span = DateTime.Now - Data15_B0_Date;
            //            if (span.TotalHours > TempTime)
            //            {
            //                deviceData.ErrCode = "LS007";
            //                deviceData.ErrMsg = "出料门下限位长时间未动作";
            //            }
            //        }
            //        else
            //        {
            //            CacheService.Set<DateTime>($"Data15_B0_Date:{deviceData.Id}", DateTime.Now).Wait();
            //            CacheService.Set<int?>($"Data15_B0:{deviceData.Id}", deviceData.Data15_B0).Wait();
            //        }
            //    }
            //}

            //人数摄像头保护
            if (string.IsNullOrEmpty(deviceData.ErrCode) && string.IsNullOrEmpty(deviceData.ErrMsg))
            {
                if (deviceData.Data16_B4 == 0)
                {
                    deviceData.ErrCode = "LS008";
                    deviceData.ErrMsg = "人数摄像头通讯异常";
                }
            }
            #endregion

            #region 故障记录
            DeviceError tempErr = CacheService.Get<DeviceError>($"DeviceError:{deviceData.Id}").Result;
            if (!string.IsNullOrEmpty(deviceData.ErrCode))
            {
                if (tempErr == null || (tempErr != null && tempErr.ErrCode != deviceData.ErrCode))
                {
                    if (tempErr != null)
                    {
                        tempErr.EndDate = DateTime.Now;
                        Db.Updateable<DeviceError>(tempErr).UpdateColumns(x => x.EndDate).SplitTable().ExecuteCommand();
                    }
                    tempErr = new DeviceError()
                    {
                        Id = Guid.NewGuid().ToString(),
                        ErrCode = deviceData.ErrCode,
                        ErrMsg = deviceData.ErrMsg,
                        DeviceId = deviceData.Id,
                        CreateDate = DateTime.Now
                    };
                    Db.Insertable<DeviceError>(tempErr).SplitTable().ExecuteCommand();

                    CacheService.Set<DeviceError>($"DeviceError:{deviceData.Id}", tempErr);
                }
            }
            else
            {
                if (tempErr != null)
                {
                    tempErr.EndDate = DateTime.Now;
                    Db.Updateable<DeviceError>(tempErr).UpdateColumns(x => x.EndDate).SplitTable().ExecuteCommand();
                    CacheService.Delete($"DeviceError:{deviceData.Id}");
                }
            }
            #endregion
            return Task.CompletedTask;
        }

        private void InitDeviceError()
        {
            Db.Updateable<DeviceData>().SetColumns(x => x.ErrCode == "").SetColumns(x => x.ErrMsg == "").Where(x => 1 == 1).ExecuteCommand();
            Db.Updateable<DeviceError>().SetColumns(x => x.EndDate == DateTime.Now).Where(x => x.EndDate == null).SplitTable(tas => tas.Take(2)).ExecuteCommand();
        }

        public async Task<PageData<DeviceError>> GetDeviceErrorPage(PageYearSearch<DeviceError> search)
        {
            RefAsync<int> _Total = 0;
            var Data = await Db.Queryable<DeviceError>()
            .WhereIF(!string.IsNullOrEmpty(search.Search), x => x.Id!.Contains(search.Search!) || x.DeviceId!.Contains(search.Search!) || x.ErrCode!.Contains(search.Search!) || x.ErrMsg!.Contains(search.Search!))
            .WhereIF(search.Mode != null && !string.IsNullOrEmpty(search.Mode.Id), x => x.Id == search.Mode!.Id)
            .WhereIF(search.Mode != null && !string.IsNullOrEmpty(search.Mode.DeviceId), x => x.DeviceId == search.Mode!.DeviceId)
            .WhereIF(search.Mode != null && !string.IsNullOrEmpty(search.Mode.ErrCode), x => x.ErrCode == search.Mode!.ErrCode)
            .WhereIF(search.Mode != null && !string.IsNullOrEmpty(search.Mode.ErrMsg), x => x.ErrMsg!.Contains(search.Mode!.ErrMsg!))
            .SplitTable((DateTime)search.StartDate!, (DateTime)search.EndDate!)
            .OrderByDescending(x => x.CreateDate)
            .ToPageListAsync(search.Index, search.Size, _Total);
            return new PageData<DeviceError> { Total = _Total.Value, Data = Data };
        }

        private void SeteData22Error(DeviceData deviceData)
        {
            #region 创安处理逻辑
            if (deviceData.Id!.IndexOf("CASSH") >= 0)
            {
                //修复默认值传1的问题
                if (deviceData.Data22 == 1)
                {
                    deviceData.Data22 = 0;
                }

                if (deviceData.Data3_B5 == 0)
                {
                    deviceData.Data22 = 1;
                }
                if (deviceData.Data15_B0 == 0 && deviceData.Data3_B6 == 0)
                {
                    deviceData.Data22 = 2;
                }
                if (deviceData.Data15_B2 == 0 && deviceData.Data3_B7 == 0)
                {
                    deviceData.Data22 = 3;
                }
                if (deviceData.Data3_B4 == 0)
                {
                    deviceData.Data22 = 4;
                }
                //if (deviceData.Data3_B3 == 0)
                //{
                //    deviceData.Data22 = 5;
                //}
                if (deviceData.Data2_B3 == 0)
                {
                    deviceData.Data22 = 6;
                }
                if (deviceData.Data2_B2 == 0)
                {
                    deviceData.Data22 = 7;
                }
                if (deviceData.Data2_B1 == 0)
                {
                    deviceData.Data22 = 8;
                }
                if (deviceData.Data27_B7 == 1)
                {
                    deviceData.Data22 = 9;
                }
                if (deviceData.Data27_B6 == 1)
                {
                    deviceData.Data22 = 10;
                }
                if (deviceData.Data2_B5 == 0)
                {
                    deviceData.Data22 = 11;
                }
                if (deviceData.Data2_B4 == 0)
                {
                    deviceData.Data22 = 12;
                }
                if (deviceData.Data2_B6 == 0)
                {
                    deviceData.Data22 = 13;
                }
                if (deviceData.Data16_B1 == 0)
                {
                    var ticks = CacheService.Get<long>($"{deviceData.Id}_Data16_B1").Result;
                    if (ticks != 0)
                    {
                        var time = new TimeSpan(DateTime.Now.Ticks).Subtract(new TimeSpan(ticks));
                        if (time.TotalSeconds > 10 && time.TotalMinutes <= 5)
                        {
                            deviceData.Data22 = 101;
                        }
                        else if (time.TotalMinutes > 5)
                        {
                            deviceData.Data22 = 102;
                        }
                    }
                    else
                    {
                        CacheService.Set<long>($"{deviceData.Id}_Data16_B1", DateTime.Now.Ticks);
                    }
                }
                else
                {
                    CacheService.Delete($"{deviceData.Id}_Data16_B1");
                }
                if (deviceData.Data16_B0 == 0)
                {
                    var ticks = CacheService.Get<long>($"{deviceData.Id}_Data16_B0").Result;
                    if (ticks != 0)
                    {
                        var time = new TimeSpan(DateTime.Now.Ticks).Subtract(new TimeSpan(ticks));
                        if (time.TotalSeconds > 10 && time.TotalMinutes <= 5)
                        {
                            deviceData.Data22 = 103;
                        }
                        else if (time.TotalMinutes > 5)
                        {
                            deviceData.Data22 = 104;
                        }
                    }
                    else
                    {
                        CacheService.Set<long>($"{deviceData.Id}_Data16_B0", DateTime.Now.Ticks);
                    }
                }
                else
                {
                    CacheService.Delete($"{deviceData.Id}_Data16_B0");
                }
                if (deviceData.Data15_B3 == 0 && deviceData.Data15_B2 == 0)
                {
                    deviceData.Data22 = 37;
                }
                if (deviceData.Data15_B1 == 0 && deviceData.Data15_B0 == 0)
                {
                    deviceData.Data22 = 38;
                }
            }
            if (deviceData.Data23 == 0)
            {
                deviceData.Data22 = 100;
            }
            #endregion
            if (deviceData.Data22 != null && deviceData.Data22 > 0)
            {
                switch (deviceData.Data22)
                {
                    case 1:
                        deviceData.ErrCode = "YY001";
                        deviceData.ErrMsg = "天窗门未关好";
                        break;
                    case 2:
                        deviceData.ErrCode = "YY002";
                        deviceData.ErrMsg = "双开门未关好";
                        break;
                    case 3:
                        deviceData.ErrCode = "YY003";
                        deviceData.ErrMsg = "单开门未关好";
                        break;
                    case 4:
                        deviceData.ErrCode = "YY004";
                        deviceData.ErrMsg = "上限位已断开";
                        break;
                    case 5:
                        deviceData.ErrCode = "YY005";
                        deviceData.ErrMsg = "下限位已断开";
                        break;
                    case 6:
                        deviceData.ErrCode = "YY006";
                        deviceData.ErrMsg = "请注意防坠器限位已断开";
                        break;
                    case 7:
                        deviceData.ErrCode = "YY007";
                        deviceData.ErrMsg = "请注意防冲顶限位已断开";
                        break;
                    case 8:
                        deviceData.ErrCode = "YY008";
                        deviceData.ErrMsg = "请注意备用限位已断开";
                        break;
                    case 9:
                        deviceData.ErrCode = "YY009";
                        deviceData.ErrMsg = "电梯控制远程限速";
                        break;
                    case 10:
                        deviceData.ErrCode = "YY010";
                        deviceData.ErrMsg = "电梯控制远程锁机";
                        break;
                    case 11:
                        deviceData.ErrCode = "YY011";
                        deviceData.ErrMsg = "急停按钮已被按下";
                        break;
                    case 12:
                        deviceData.ErrCode = "YY012";
                        deviceData.ErrMsg = "笼顶急停按钮已被按下";
                        break;
                    case 13:
                        deviceData.ErrCode = "YY013";
                        deviceData.ErrMsg = "电锁或者IC卡未插好";
                        break;
                    case 14:
                        deviceData.ErrCode = "YY014";
                        deviceData.ErrMsg = "请注意编码器脉冲值异常";
                        break;
                    case 15:
                        deviceData.ErrCode = "YY015";
                        deviceData.ErrMsg = "请注意电梯发生逆变单元保护故障";
                        break;
                    case 16:
                        deviceData.ErrCode = "YY016";
                        deviceData.ErrMsg = "请注意电梯发生过流故障";
                        break;
                    case 17:
                        deviceData.ErrCode = "YY017";
                        deviceData.ErrMsg = "请注意电梯发生过压故障";
                        break;
                    case 18:
                        deviceData.ErrCode = "YY018";
                        deviceData.ErrMsg = "请注意电梯发生欠压故障";
                        break;
                    case 19:
                        deviceData.ErrCode = "YY019";
                        deviceData.ErrMsg = "请注意电梯发生驱动器过载故障";
                        break;
                    case 20:
                        deviceData.ErrCode = "YY020";
                        deviceData.ErrMsg = "请注意电梯发生模块过热故障";
                        break;
                    case 21:
                        deviceData.ErrCode = "YY021";
                        deviceData.ErrMsg = "请注意电梯发生对地短路故障";
                        break;
                    case 22:
                        deviceData.ErrCode = "YY022";
                        deviceData.ErrMsg = "请注意电梯发生输入缺相故障";
                        break;
                    case 23:
                        deviceData.ErrCode = "YY023";
                        deviceData.ErrMsg = "请注意电梯发生输出缺相故障";
                        break;
                    case 24:
                        deviceData.ErrCode = "YY024";
                        deviceData.ErrMsg = "请注意电梯自检异常";
                        break;
                    case 25:
                        deviceData.ErrCode = "YY025";
                        deviceData.ErrMsg = "请注意电梯已超载";
                        break;
                    case 26:
                        deviceData.ErrCode = "YY026";
                        deviceData.ErrMsg = "请注意编码器故障";
                        break;
                    case 27:
                        deviceData.ErrCode = "YY027";
                        deviceData.ErrMsg = "请注意刹车电流过大";
                        break;
                    case 28:
                        deviceData.ErrCode = "YY028";
                        deviceData.ErrMsg = "请注意刹车信号故障";
                        break;
                    case 29:
                        deviceData.ErrCode = "YY029";
                        deviceData.ErrMsg = "请注意刹车电流较小";
                        break;
                    case 30:
                        deviceData.ErrCode = "YY030";
                        deviceData.ErrMsg = "请注意刹车片磨损严重";
                        break;
                    case 31:
                        deviceData.ErrCode = "YY031";
                        deviceData.ErrMsg = "请注意电梯超速";
                        break;
                    case 32:
                        deviceData.ErrCode = "YY032";
                        deviceData.ErrMsg = "进料门有异物卡住";
                        break;
                    case 33:
                        deviceData.ErrCode = "YY033";
                        deviceData.ErrMsg = "出料门有异物卡住";
                        break;
                    case 34:
                        deviceData.ErrCode = "YY034";
                        deviceData.ErrMsg = "门机发生故障";
                        break;
                    case 35:
                        deviceData.ErrCode = "YY035";
                        deviceData.ErrMsg = "人数超载请自觉退出";
                        break;
                    case 36:
                        deviceData.ErrCode = "WR036";
                        deviceData.ErrMsg = "请勿遮挡光幕";
                        break;
                    case 37:
                        deviceData.ErrCode = "YY037";
                        deviceData.ErrMsg = "进料门上下限位异常";
                        break;
                    case 38:
                        deviceData.ErrCode = "YY038";
                        deviceData.ErrMsg = "出料门上下限位异常";
                        break;
                    case 39:
                        deviceData.ErrCode = "YY039";
                        deviceData.ErrMsg = "请勿遮挡光幕";
                        break;
                    case 40:
                        deviceData.ErrCode = "YY040";
                        deviceData.ErrMsg = "上行通道限位断开";
                        break;
                    case 41:
                        deviceData.ErrCode = "YY041";
                        deviceData.ErrMsg = "下行通道限位断开";
                        break;
                    case 100:
                        deviceData.ErrCode = "YY100";
                        deviceData.ErrMsg = "请打开自动平层开关";
                        break;
                    case 101:
                        deviceData.ErrCode = "WR101";
                        deviceData.ErrMsg = "请勿遮挡进料门光幕";
                        break;
                    case 102:
                        deviceData.ErrCode = "YY102";
                        deviceData.ErrMsg = "请勿遮挡进料门光幕";
                        break;
                    case 103:
                        deviceData.ErrCode = "WR103";
                        deviceData.ErrMsg = "请勿遮挡出料门光幕";
                        break;
                    case 104:
                        deviceData.ErrCode = "YY104";
                        deviceData.ErrMsg = "请勿遮挡出料门光幕";
                        break;
                    default:
                        break;
                }
            }
        }

        private void SetData17Error(DeviceData deviceData)
        {
            switch (deviceData.Data17)
            {
                case 2:
                    deviceData.ErrCode = "MJ0002";
                    deviceData.ErrMsg = "门机故障-加速过电流";
                    break;
                case 3:
                    deviceData.ErrCode = "MJ0003";
                    deviceData.ErrMsg = "门机故障-减速过电流";
                    break;
                case 4:
                    deviceData.ErrCode = "MJ0004";
                    deviceData.ErrMsg = "门机故障-恒速过电流";
                    break;
                case 5:
                    deviceData.ErrCode = "MJ0005";
                    deviceData.ErrMsg = "门机故障-加速过电压";
                    break;
                case 6:
                    deviceData.ErrCode = "MJ0006";
                    deviceData.ErrMsg = "门机故障-减速过电压";
                    break;
                case 7:
                    deviceData.ErrCode = "MJ0007";
                    deviceData.ErrMsg = "门机故障-恒速过电压";
                    break;
                case 8:
                    deviceData.ErrCode = "MJ0008";
                    deviceData.ErrMsg = "门机故障-控制电源异常";
                    break;
                case 9:
                    deviceData.ErrCode = "MJ0009";
                    deviceData.ErrMsg = "门机故障-欠电压";
                    break;
                case 10:
                    deviceData.ErrCode = "MJ0010";
                    deviceData.ErrMsg = "门机故障-变频器过载";
                    break;
                case 11:
                    deviceData.ErrCode = "MJ0011";
                    deviceData.ErrMsg = "门机故障-电机过载";
                    break;
                case 12:
                    deviceData.ErrCode = "MJ0012";
                    deviceData.ErrMsg = "门机故障-输入缺相";
                    break;
                case 13:
                    deviceData.ErrCode = "MJ0013";
                    deviceData.ErrMsg = "门机故障-输出缺相";
                    break;
                case 14:
                    deviceData.ErrCode = "MJ0014";
                    deviceData.ErrMsg = "门机故障-模块过热";
                    break;
                case 15:
                    deviceData.ErrCode = "MJ0015";
                    deviceData.ErrMsg = "门机故障-外部故障";
                    break;
                case 16:
                    deviceData.ErrCode = "MJ0016";
                    deviceData.ErrMsg = "门机故障-通讯异常";
                    break;
                case 17:
                    deviceData.ErrCode = "MJ0017";
                    deviceData.ErrMsg = "门机故障-接触器异常";
                    break;
                case 18:
                    deviceData.ErrCode = "MJ0018";
                    deviceData.ErrMsg = "门机故障-电流检测异常";
                    break;
                case 19:
                    deviceData.ErrCode = "MJ0019";
                    deviceData.ErrMsg = "门机故障-电机调谐异常";
                    break;
                case 20:
                    deviceData.ErrCode = "MJ0020";
                    deviceData.ErrMsg = "门机故障-编码器/PG卡异常";
                    break;
                case 21:
                    deviceData.ErrCode = "MJ0021";
                    deviceData.ErrMsg = "门机故障-EPPROM读写异常";
                    break;
                case 22:
                    deviceData.ErrCode = "MJ0022";
                    deviceData.ErrMsg = "门机故障-变频器硬件故障";
                    break;
                case 23:
                    deviceData.ErrCode = "MJ0023";
                    deviceData.ErrMsg = "门机故障-电机对地短路";
                    break;
                case 26:
                    deviceData.ErrCode = "MJ0026";
                    deviceData.ErrMsg = "门机故障-累计运行时间到达";
                    break;
                case 29:
                    deviceData.ErrCode = "MJ0029";
                    deviceData.ErrMsg = "门机故障-累计上电时间到达";
                    break;
                case 30:
                    deviceData.ErrCode = "MJ0030";
                    deviceData.ErrMsg = "门机故障-掉载";
                    break;
                case 31:
                    deviceData.ErrCode = "MJ0031";
                    deviceData.ErrMsg = "门机故障-运行时PID反馈丢失";
                    break;
                case 40:
                    deviceData.ErrCode = "MJ0040";
                    deviceData.ErrMsg = "门机故障-CBC限流保护";
                    break;
                case 42:
                    deviceData.ErrCode = "MJ0040";
                    deviceData.ErrMsg = "门机故障-速度偏差过大";
                    break;
                case 43:
                    deviceData.ErrCode = "MJ0043";
                    deviceData.ErrMsg = "门机故障-过速度";
                    break;
                case 45:
                    deviceData.ErrCode = "MJ0045";
                    deviceData.ErrMsg = "门机故障-电机过热";
                    break;
                default:
                    break;
            }
        }

        private void SetData5Error(DeviceData deviceData)
        {
            switch (deviceData.Data5)
            {
                case 1:
                    deviceData.ErrCode = "Pb01";
                    deviceData.ErrMsg = "超载";
                    break;
                case 2:
                    deviceData.ErrCode = "Pb02";
                    deviceData.ErrMsg = "超载报警";
                    break;
                case 3:
                    deviceData.ErrCode = "Pb03";
                    deviceData.ErrMsg = "EEPROM 存储故障";
                    break;
                case 4:
                    deviceData.ErrCode = "Pb04";
                    deviceData.ErrMsg = "编码器故障";
                    break;
                case 5:
                    deviceData.ErrCode = "Pb05";
                    deviceData.ErrMsg = "刹车电流过大";
                    break;
                case 6:
                    deviceData.ErrCode = "Pb06";
                    deviceData.ErrMsg = "刹车信号故障";
                    break;
                case 7:
                    deviceData.ErrCode = "Pb07";
                    deviceData.ErrMsg = "运行时抱闸未及时打开";
                    break;
                case 8:
                    deviceData.ErrCode = "Pb08";
                    deviceData.ErrMsg = "停机时抱闸未及时断开";
                    break;
                case 9:
                    deviceData.ErrCode = "Pb09";
                    deviceData.ErrMsg = "刹车片磨损较大";
                    break;
                case 10:
                    deviceData.ErrCode = "Pb10";
                    deviceData.ErrMsg = "变频器通讯故障";
                    break;
                case 11:
                    deviceData.ErrCode = "Pb11";
                    deviceData.ErrMsg = "运行超速故障";
                    break;
                case 13:
                    deviceData.ErrCode = "Pb13";
                    deviceData.ErrMsg = "输入缺相";
                    break;
                case 41:
                    deviceData.ErrCode = "Pb41";
                    deviceData.ErrMsg = "工频输出接触器未吸合";
                    break;
                case 42:
                    deviceData.ErrCode = "Pb42";
                    deviceData.ErrMsg = "工频输出接触器异常吸合";
                    break;
                case 43:
                    deviceData.ErrCode = "Pb43";
                    deviceData.ErrMsg = "工频输入电源相序错误";
                    break;
                case 44:
                    deviceData.ErrCode = "Pb44";
                    deviceData.ErrMsg = "工频上升接触器黏连";
                    break;
                case 45:
                    deviceData.ErrCode = "Pb45";
                    deviceData.ErrMsg = "工频下降接触器黏连";
                    break;
                default:
                    break;
            }
        }

        private void SetData4Error(DeviceData deviceData)
        {
            switch (deviceData.Data4)
            {
                case 1:
                    deviceData.ErrCode = "ERR01";
                    deviceData.ErrMsg = "逆变单元保护";
                    break;
                case 2:
                    deviceData.ErrCode = "ERR02";
                    deviceData.ErrMsg = "硬件过流";
                    break;
                case 3:
                    deviceData.ErrCode = "ERR03";
                    deviceData.ErrMsg = "硬件过压";
                    break;
                case 4:
                    deviceData.ErrCode = "ERR04";
                    deviceData.ErrMsg = "加速过电流";
                    break;
                case 5:
                    deviceData.ErrCode = "ERR05";
                    deviceData.ErrMsg = "减速过电流";
                    break;
                case 6:
                    deviceData.ErrCode = "ERR06";
                    deviceData.ErrMsg = "恒速过电流";
                    break;
                case 7:
                    deviceData.ErrCode = "ERR07";
                    deviceData.ErrMsg = "停止过电流";
                    break;
                case 8:
                    deviceData.ErrCode = "ERR08";
                    deviceData.ErrMsg = "加速过电压";
                    break;
                case 9:
                    deviceData.ErrCode = "ERR09";
                    deviceData.ErrMsg = "减速过电压";
                    break;
                case 10:
                    deviceData.ErrCode = "ERR10";
                    deviceData.ErrMsg = "恒速过电压";
                    break;
                case 11:
                    deviceData.ErrCode = "ERR11";
                    deviceData.ErrMsg = "停止过电压";
                    break;
                case 12:
                    deviceData.ErrCode = "ERR12";
                    deviceData.ErrMsg = "欠压故障";
                    break;
                case 13:
                    deviceData.ErrCode = "ERR13";
                    deviceData.ErrMsg = "驱动器过载";
                    break;
                case 14:
                    deviceData.ErrCode = "ERR14";
                    deviceData.ErrMsg = "电机过载";
                    break;
                case 15:
                    deviceData.ErrCode = "ERR15";
                    deviceData.ErrMsg = "模块过热";
                    break;
                case 16:
                    deviceData.ErrCode = "ERR16";
                    deviceData.ErrMsg = "AD转换故障";
                    break;
                case 17:
                    deviceData.ErrCode = "ERR17";
                    deviceData.ErrMsg = "IU电流检测故障";
                    break;
                case 18:
                    deviceData.ErrCode = "ERR18";
                    deviceData.ErrMsg = "IV电流检测故障";
                    break;
                case 19:
                    deviceData.ErrCode = "ERR19";
                    deviceData.ErrMsg = "IW电流检测故障";
                    break;
                case 20:
                    deviceData.ErrCode = "ERR20";
                    deviceData.ErrMsg = "对地短路故障";
                    break;
                case 21:
                    deviceData.ErrCode = "ERR21";
                    deviceData.ErrMsg = "电机参数调谐故障";
                    break;
                case 23:
                    deviceData.ErrCode = "ERR23";
                    deviceData.ErrMsg = "输入缺相";
                    break;
                case 24:
                    deviceData.ErrCode = "ERR24";
                    deviceData.ErrMsg = "输出缺相";
                    break;
                case 25:
                    deviceData.ErrCode = "ERR25";
                    deviceData.ErrMsg = "存储器故障";
                    break;
                case 26:
                    deviceData.ErrCode = "ERR26";
                    deviceData.ErrMsg = "密码输入错误超过3次";
                    break;
                case 27:
                    deviceData.ErrCode = "ERR27";
                    deviceData.ErrMsg = "通信故障";
                    break;
                case 28:
                    deviceData.ErrCode = "ERR28";
                    deviceData.ErrMsg = "外部故障";
                    break;
                default:
                    break;
            }
        }

        private Task SetRunCount(DeviceData deviceData)
        {
            deviceData.RunCount = CacheService.Get<int>($"{deviceData.Id}_RunCount").Result;
            if (deviceData.RunCount == 0)
            {
                var temp = Db.Queryable<DeviceData>().Single(x => x.Id == deviceData.Id);
                deviceData.RunCount = temp == null ? 0 : temp.RunCount;
                if (deviceData.RunCount != null)
                {
                    CacheService.Set<int>($"{deviceData.Id}_RunCount", (int)deviceData.RunCount!);
                }
            }

            if (deviceData.MsgType == "1103" && deviceData.Data11 == 1)
            {

                var OldData11 = CacheService.Get<int>($"{deviceData.Id}_Data11").Result;

                if (OldData11 > 1)
                {
                    Db.Updateable<DeviceData>().SetColumns(x => x.RunCount == x.RunCount + 1).Where(x => x.Id == deviceData.Id).ExecuteCommand();
                    deviceData.RunCount = Db.Queryable<DeviceData>().Single(x => x.Id == deviceData.Id).RunCount;
                    if (deviceData.RunCount != null)
                    {
                        CacheService.Set<int>($"{deviceData.Id}_RunCount", (int)deviceData.RunCount!);
                    }
                }
            }
            if (deviceData.Data11 != null)
            {
                CacheService.Set<int>($"{deviceData.Id}_Data11", (int)deviceData.Data11!);
            }
            return Task.CompletedTask;
        }

        #region 故障统计
        /// <summary>
        /// 获取设备故障报表
        /// </summary>
        /// <param name="report">报表筛选</param>
        /// <returns></returns>
        public async Task<DeviceErrorReport> GetDeviceErrorReport(DeviceErrorReport report)
        {
            #region 有效校验
            var TempDate = DateTime.Now;
            if (report.StartDate == null)
            {
                report.StartDate = TempDate.AddDays(-TempDate.Day);
            }
            if (report.EndDate == null)
            {
                report.EndDate = TempDate;
            }
            var TempUnits = new string[] { "year", "month", "day" };
            if (!string.IsNullOrEmpty(report.Unit) && !TempUnits.Any(x => x == report.Unit.ToLower()))
            {
                throw new BadRequestException("单元无效");
            }
            #endregion
            if ((report.CompanyIds != null && report.CompanyIds.Count() > 0) || (report.ProjectIds != null && report.ProjectIds.Count() > 0) || (report.DeviceIds != null && report.DeviceIds.Count() > 0))
            {
                var TempCompanyIds = report.CompanyIds;
                var TempProjectIds = report.ProjectIds;
                var TempDeviceIds = report.DeviceIds;

                var TempGpss = Db.Queryable<DeviceDO>()
                    .LeftJoin<ProjectDO>((x, y) => x.ProjectId == y.Id)
                    .WhereIF(TempCompanyIds != null && TempCompanyIds.Count() > 0, (x, y) => TempCompanyIds!.Contains(y.CompanyId))
                    .WhereIF(TempProjectIds != null && TempProjectIds.Count() > 0, (x, y) => TempProjectIds!.Contains(x.ProjectId))
                    .WhereIF(TempDeviceIds != null && TempDeviceIds.Count() > 0, (x, y) => TempDeviceIds!.Contains(x.Id))
                    .Where((x, y) => x.Deleted == 0)
                    .Select((x, y) => x.Gps!.ToString())
                    .ToList();

                var TempGpsIds = new List<string>();
                TempGpss.ForEach(v =>
                {
                    try
                    {
                        var tempGps = JsonSerializer.Deserialize<IEnumerable<DeviceGpsDO>>(v!);
                        TempGpsIds.AddRange(tempGps!.Select(x => x.Id!));
                    }
                    catch
                    {

                    }
                });
                report.GpsIds = report.GpsIds == null ? TempGpsIds! : report.GpsIds.Concat(TempGpsIds!);
            }
            var TempErrors = await GetDayError(report);
            var TempErrorGroup = TempErrors.Select(x => x.ErrCode).Distinct();
            var TempItems = new List<DeviceErrorReportItem>();
            if (string.IsNullOrEmpty(report.Unit))
            {
                foreach (var group in TempErrorGroup)
                {
                    TempItems.Add(new DeviceErrorReportItem
                    {
                        Code = group!,
                        Msg = TempErrors.First(x => x.ErrCode == group).ErrMsg!,
                        Count = TempErrors.Where(x => x.ErrCode == group).Select(x => x.Count).Sum().ToInt()
                    });
                }
            }
            else if (report.Unit.ToLower() == "year")
            {
                var TempErrorDate = TempErrors.Select(x => x.Id!.Substring(0, 4)).Distinct();
                foreach (var group in TempErrorGroup)
                {
                    var item = new DeviceErrorReportItem
                    {
                        Code = group!,
                        Msg = TempErrors.First(x => x.ErrCode == group).ErrMsg!,
                        Count = TempErrors.Where(x => x.ErrCode == group).Select(x => x.Count).Sum().ToInt()
                    };

                    foreach (var date in TempErrorDate)
                    {
                        item.Counts.Add(date, TempErrors.Where(x => x.ErrCode == group && x.Id!.IndexOf(date) == 0).Select(x => x.Count).Sum().ToInt());
                    }
                    TempItems.Add(item);
                }
            }
            else if (report.Unit.ToLower() == "month")
            {
                var TempErrorDate = TempErrors.Select(x => x.Id!.Substring(0, 7)).Distinct();
                foreach (var group in TempErrorGroup)
                {
                    var item = new DeviceErrorReportItem
                    {
                        Code = group!,
                        Msg = TempErrors.First(x => x.ErrCode == group).ErrMsg!,
                        Count = TempErrors.Where(x => x.ErrCode == group).Select(x => x.Count).Sum().ToInt()
                    };

                    foreach (var date in TempErrorDate)
                    {
                        item.Counts.Add(date, TempErrors.Where(x => x.ErrCode == group && x.Id!.IndexOf(date) == 0).Select(x => x.Count).Sum().ToInt());
                    }
                    TempItems.Add(item);
                }
            }
            else if (report.Unit.ToLower() == "day")
            {
                var TempErrorDate = TempErrors.Select(x => x.Id).Distinct();
                foreach (var group in TempErrorGroup)
                {
                    var item = new DeviceErrorReportItem
                    {
                        Code = group!,
                        Msg = TempErrors.First(x => x.ErrCode == group).ErrMsg!,
                        Count = TempErrors.Where(x => x.ErrCode == group).Select(x => x.Count).Sum().ToInt()
                    };

                    foreach (var date in TempErrorDate)
                    {
                        item.Counts.Add(date, TempErrors.Where(x => x.ErrCode == group && x.Id!.IndexOf(date) == 0).Select(x => x.Count).Sum().ToInt());
                    }
                    TempItems.Add(item);
                }
            }
            report.Items = TempItems;
            report.GpsIds = null;
            return report;
        }

        private Task<List<DeviceError>> GetDayError(DeviceErrorReport report)
        {
            var TempStart = (DateTime)report.StartDate!;
            var TempEnd = (DateTime)report.EndDate!;
            var TempSpan = TempEnd - TempStart;
            var TempDayCount = (int)TempSpan.TotalDays;
            var TempDaySpan = 5;

            var TempTasks = new Task<List<DeviceError>>[TempDayCount % TempDaySpan > 0 ? TempDayCount / TempDaySpan + 1 : TempDayCount / TempDaySpan];
            for (var i = 0; i < TempTasks.Length; i++)
            {
                SqlSugarClient client = new SqlSugarClient(Db.CurrentConnectionConfig);
                TempTasks[i] = client.Queryable<DeviceError>()
                .WhereIF(report.ErrCodes != null && report.ErrCodes.Count() > 0, x => report.ErrCodes!.Contains(x.ErrCode))
                .WhereIF(report.GpsIds != null && report.GpsIds.Count() > 0, x => report.GpsIds!.Contains(x.DeviceId!))
                .Select(x => new DeviceError
                {
                    ErrCode = x.ErrCode,
                    ErrMsg = x.ErrMsg,
                    Id = ((DateTime)x.CreateDate!).ToString("yyyy-MM-dd"),
                    Count = SqlFunc.AggregateCount(x.ErrCode)
                })
                .GroupBy(x => new { x.ErrCode, x.ErrMsg, Date = ((DateTime)x.CreateDate!).ToString("yyyy-MM-dd") })
                .SplitTable(TempStart.AddDays(i * TempDaySpan), TempStart.AddDays((i + 1) * TempDaySpan))
                .OrderBy(x => x.Id)
                .ToListAsync();
            }
            Task.WaitAll(TempTasks);
            List<DeviceError> result = new List<DeviceError>();
            foreach (var task in TempTasks)
            {
                result.AddRange(task.Result);
            }
            return Task.FromResult(result);
        }

        public async Task<IEnumerable<DeviceError>> GetErrorList(string search)
        {
            var _Query = Db.Queryable<DeviceError>()
                .WhereIF(!string.IsNullOrWhiteSpace(search), x => x.ErrCode!.Contains(search) || x.ErrMsg!.Contains(search))
                .Distinct()
                .Select(x => new DeviceError
                {
                    ErrCode = x.ErrCode,
                    ErrMsg = x.ErrMsg
                })
                .SplitTable(DateTime.Now.AddYears(-1), DateTime.Now)
                .Distinct()
                .Select(x => new DeviceError
                {
                    ErrCode = x.ErrCode,
                    ErrMsg = x.ErrMsg
                });
            var _Sql = _Query.ToSqlString();
            return await _Query.ToListAsync();
        }
        #endregion
    }
}