MES / DataAcquisition · Files

using HHECS.BllModel;
using HHECS.DAQHandle.Dto;

using HHECS.DAQShared.Common.Enums;

using HHECS.DAQShared.Common.Utils;

using HHECS.DAQShared.Dto;

using HHECS.DAQShared.Models;

using HHECS.EquipmentModel;
using System.Text.Json;

namespace HHECS.DAQHandle.EquipmentHandle
{
    internal abstract class AnalysisBase : IAnalysis
    {

        protected readonly IFreeSql freeSql;

        /// <summary>
        /// 当前设备类型
        /// </summary>

        protected readonly EquipmentTypeExtend CurrentEquipmentType;

        /// <summary>
        /// 程序配置信息
        /// </summary>
        protected readonly AppConfig AppConfig;

        /// <summary>
        /// 当前类型设备数据
        /// </summary>
        protected readonly List<EquipmentExtend> Equipments;

        /// <summary>
        /// 设备总报警属性编码
        /// </summary>
        protected readonly string EquipmentTotalAlarmCode;

        protected AnalysisBase(AnalysisParameter parameter)
        {
            Equipments = parameter.Equipments;
            CurrentEquipmentType = parameter.EquipmentType;
            AppConfig = parameter.AppConfig;
            EquipmentTotalAlarmCode = parameter.EquipmentTotalAlarmCode;

            freeSql = GlobalVar.FreeSql;

        }

        public virtual BllResult Execute(IEnumerable<EquipmentDataRecord> records)
        {
            try
            {
                foreach (var item in records.GroupBy(x => x.EquipmentCode))
                {
                    var equipmentSN = item.Key;
                    var orderItems = item.OrderBy(x => x.Timestamp).ToList();
                    var lastRecord = orderItems.Last();
                    var equipment = Equipments.Where(x => x.Code == equipmentSN).FirstOrDefault();
                    if (equipment != null)
                    {

                        _ = UpdateTagValue(equipment, lastRecord);
                        //更新报警
                        var alarmHandleResult = UpdateEquipmentAlarm(equipment, orderItems);
                        if (!alarmHandleResult.Success)
                        {
                            return alarmHandleResult;
                        }
                        //更新状态
                        var statusHandleResult = UpdateEquipmentStatus(equipment, orderItems);
                        if (!statusHandleResult.Success)
                        {
                            return statusHandleResult;
                        }

                        //记录手动状态
                        _ = UpdateEquipmentManualRecord(equipment, orderItems);

                    }
                }
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"数据解析出现异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 更新设备属性值
        /// </summary>
        /// <param name="equipment">设备</param>
        /// <param name="record">最后一条记录</param>

        /// <returns><see cref="BllResult"/></returns>

        protected virtual BllResult UpdateTagValue(EquipmentExtend equipment, EquipmentDataRecord record)
        {
            try
            {

                var acceptTime = TimestampConvertToLocalDateTime(record.Timestamp);

                var equipmetProps = equipment.EquipmentProps.Where(x => x.Updated < acceptTime || x.Updated == null).ToList();

                if (equipmetProps.Count == 0)
                {
                    return BllResultFactory.Error($"设备[{equipment.Code}]属性集合为空！");
                }

                var tagResult = JsonConvertToTagList(record.Tags);
                if (!tagResult.Success)
                {
                    return tagResult;
                }
                var tagData = tagResult.Data;

                using var equipmentPropRepository = freeSql.GetRepository<EquipmentPropExtend>();

                //待更新数据缓存
                var temps = new List<EquipmentPropExtend>();

                foreach (var prop in equipmetProps)
                {

                    var tagCodes = new List<string>
                    {
                        prop.EquipmentTypePropTemplateCode,
                        prop.Address
                    };

                    var tag = tagData.Where(x => tagCodes.Contains(x.Tag, StringComparer.OrdinalIgnoreCase)).FirstOrDefault();

                    if (tag == null)
                    {
                        continue;
                    }

                    equipmentPropRepository.Attach(prop);

                    prop.Value = tag.Value;
                    prop.Updated = acceptTime;

                    temps.Add(prop);

                }

                equipmentPropRepository.Update(temps);

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"更新[{equipment.Code}]设备属性值失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 更新设备报警记录
        /// </summary>
        /// <param name="equipment">设备</param>
        /// <param name="records">记录数据</param>

        /// <remarks>
        /// <para>一台设备一次仅记录一条主报警信息，报警明细附加在明细字段</para>
        /// <para>时间跨天的数据需要进行分割，方便后期清理数据</para>
        /// </remarks>
        /// <returns><see cref="BllResult"/></returns>

        protected virtual BllResult UpdateEquipmentAlarm(EquipmentExtend equipment, IEnumerable<EquipmentDataRecord> records)
        {
            try
            {

                using var equipmentAlarmRecordRepository = freeSql.GetRepository<EquipmentAlarmRecord>();

                using var equipmentAlarmRecordDetailRepository = freeSql.GetRepository<EquipmentAlarmRecordDetail>();

                if (string.IsNullOrWhiteSpace(EquipmentTotalAlarmCode))
                {
                    return BllResultFactory.Error($"设备[{equipment.Code}]总报警编码[{nameof(EquipmentTotalAlarmCode)}]字段不能为空！");
                }

                var alarmRecordCacheTempsResult = AssemblyAlarmData(equipment, records);
                if (!alarmRecordCacheTempsResult.Success)
                {
                    return BllResultFactory.Error(alarmRecordCacheTempsResult.Msg);
                }

                //无报警数据

                if (alarmRecordCacheTempsResult.Data.Count == 0)
                {

                    //结束当前设备的超时主报警
                    var needEndAlaremRecords = equipmentAlarmRecordRepository.Where(x => x.EquipmentCode == equipment.Code && !x.IsEnd).OrderBy(x => x.CreateTime).Limit(100)
                        .ToList(x => new EquipmentAlarmRecord
                        {
                            Id = x.Id,
                        });
                    foreach (var item in needEndAlaremRecords)
                    {
                        equipmentAlarmRecordRepository.Attach(item);
                        item.IsEnd = true;
                    }
                    equipmentAlarmRecordRepository.Update(needEndAlaremRecords);

                    //结束当前设备的超时报警明细
                    var mainAlarmIds = needEndAlaremRecords.Select(x => x.Id).ToList();
                    var needEndAlaremDetailRecords = equipmentAlarmRecordDetailRepository.Where(x => mainAlarmIds.Contains(x.EquipmentAlarmRecordId) && x.EquipmentCode == equipment.Code && !x.IsEnd).OrderBy(x => x.CreateTime).ToList(x => new EquipmentAlarmRecordDetail
                    {
                        Id = x.Id,
                    });
                    foreach (var item in needEndAlaremDetailRecords)
                    {
                        equipmentAlarmRecordDetailRepository.Attach(item);
                        item.IsEnd = true;
                    }
                    equipmentAlarmRecordDetailRepository.Update(needEndAlaremDetailRecords);

                    //无报警则跳过
                    return BllResultFactory.Success();

                }

                var alarmRecordCacheTemps = alarmRecordCacheTempsResult.Data;

                var oldAlarmRecord = equipmentAlarmRecordRepository.Where(x => x.EquipmentCode == equipment.Code && x.EquipmentPropCode == EquipmentTotalAlarmCode && !x.IsEnd).OrderByDescending(x => x.CreateTime).First();

                var lastCacheTemp = alarmRecordCacheTemps.OrderByDescending(x => x.CreateTime).First();

                var addTemps = new List<EquipmentAlarmRecord>();

                //数据库无报警记录
                if (oldAlarmRecord == null)
                {
                    foreach (var item in alarmRecordCacheTemps)
                    {
                        //不是最后一条记录的数据需要结束
                        if (!item.Equals(lastCacheTemp))
                        {
                            item.IsEnd = true;
                        }

                        addTemps.Add(item);

                    }

                    equipmentAlarmRecordRepository.Insert(addTemps);

                    var allAlarmDetail = addTemps.SelectMany(x => x.EquipmentAlarmRecordDetails).ToList();
                    equipmentAlarmRecordDetailRepository.Insert(allAlarmDetail);
                    return BllResultFactory.Success();

                }

                //数据库有报警记录，则需要校验

                foreach (var item in alarmRecordCacheTemps)

                {

                    //对于之前的数据，这里暂时不做处理
                    if (oldAlarmRecord.UpdateTime >= item.UpdateTime)

                    {

                        continue;
                    }

                    //日期为同一天，在设定时间以内，则更新
                    if (oldAlarmRecord.UpdateTime.Date == item.CreateTime.Date && (item.CreateTime - oldAlarmRecord.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut)
                    {
                        equipmentAlarmRecordRepository.Attach(oldAlarmRecord);
                        //不是最后一条记录，说明已经成为历史报警，需要结束标记

                        if (!item.Equals(lastCacheTemp))
                        {
                            oldAlarmRecord.IsEnd = true;
                        }

                        //无具体报警信息，则更新报警文本，这里的文本需要与数据组装方法“AssemblyAlarmData”里面的文本内容一致
                        if (oldAlarmRecord.AlarmMessage.Contains("无具体报警信息") && oldAlarmRecord.AlarmMessage != item.AlarmMessage)
                        {
                            oldAlarmRecord.AlarmMessage = item.AlarmMessage;
                        }

                        oldAlarmRecord.ErrorDuration = (int)(item.UpdateTime - oldAlarmRecord.CreateTime).TotalSeconds;
                        oldAlarmRecord.UpdateTime = item.UpdateTime;
                        oldAlarmRecord.HandleTime = DateTime.Now;
                        equipmentAlarmRecordRepository.Update(oldAlarmRecord);

                        //更新报警明细
                        var allAlarmDetail = equipmentAlarmRecordDetailRepository.Where(x => !x.IsEnd &&
                        x.EquipmentAlarmRecordId == oldAlarmRecord.Id).ToList();

                        var addAlarmDetailTemps = new List<EquipmentAlarmRecordDetail>();

                        //报警明细
                        var equipmentAlarmRecordDetails = item.EquipmentAlarmRecordDetails.Select(x => new EquipmentAlarmRecordDetail

                        {

                            EquipmentAlarmRecordId = oldAlarmRecord.Id,
                            EquipmentCode = x.EquipmentCode,
                            EquipmentName = x.EquipmentName,
                            EquipmentPropCode = x.EquipmentPropCode,
                            EquipmentPropName = x.EquipmentPropName,
                            EquipmentTypeCode = x.EquipmentTypeCode,
                            ErrorDuration = x.ErrorDuration,
                            AlarmMessage = x.AlarmMessage,
                            ProjectCode = x.ProjectCode,
                            FactoryCode = x.FactoryCode,
                            IsEnd = oldAlarmRecord.IsEnd,
                            CreateTime = x.CreateTime,
                            UpdateTime = x.UpdateTime,
                        }).ToList();

                        foreach (var alarmDetailGroup in equipmentAlarmRecordDetails.GroupBy(x => x.EquipmentPropCode))
                        {
                            //缓存里面的第一条记录
                            var firstCacheTemp = alarmDetailGroup.OrderBy(x => x.CreateTime).First();
                            //数据库里面的最后一条记录

                            var lastDBTemp = allAlarmDetail.Where(x => x.EquipmentPropCode == alarmDetailGroup.Key).OrderByDescending(x => x.CreateTime).FirstOrDefault();

                            //存在记录，且在设定时间之内，则需要更新
                            if (lastDBTemp != null && (firstCacheTemp.CreateTime - lastDBTemp.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut)
                            {
                                equipmentAlarmRecordDetailRepository.Attach(lastDBTemp);
                                lastDBTemp.ErrorDuration = (int)(firstCacheTemp.UpdateTime - lastDBTemp.CreateTime).TotalSeconds;
                                lastDBTemp.UpdateTime = firstCacheTemp.UpdateTime;

                                //状态有编号，则更新
                                if (lastDBTemp.IsEnd != oldAlarmRecord.IsEnd)
                                {
                                    lastDBTemp.IsEnd = oldAlarmRecord.IsEnd;
                                }
                                equipmentAlarmRecordDetailRepository.Update(lastDBTemp);

                                addAlarmDetailTemps.AddRange(alarmDetailGroup.Where(x => !x.Equals(firstCacheTemp)).ToList());
                                continue;
                            }
                            addAlarmDetailTemps.AddRange(alarmDetailGroup.ToList());

                        }

                        equipmentAlarmRecordDetailRepository.Insert(addAlarmDetailTemps);
                        continue;

                    }

                    //其他情况需要新增记录
                    //不是最后一条记录
                    if (!item.Equals(lastCacheTemp))
                    {
                        item.IsEnd = true;
                    }
                    addTemps.Add(item);

                }

                equipmentAlarmRecordRepository.Insert(addTemps);
                equipmentAlarmRecordDetailRepository.Insert(addTemps.SelectMany(x => x.EquipmentAlarmRecordDetails).ToList());

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {

                return BllResultFactory.Error($"更新设备{equipment.Code}报警信息失败：{ex.Message}");

            }
        }

        /// <summary>
        /// 更新设备状态记录
        /// </summary>
        /// <param name="equipment">设备</param>
        /// <param name="records">记录集合</param>

        /// <remarks>

        /// <para>实时记录表仅记录实时状态，历史表记录实时状态和历史状态</para>

        /// <para>时间跨天的数据需要进行分割，方便后期清理数据</para>
        /// </remarks>
        /// <returns><see cref="BllResult"/></returns>

        protected virtual BllResult UpdateEquipmentStatus(EquipmentExtend equipment, IEnumerable<EquipmentDataRecord> records)
        {
            try
            {

                using var equipmentStatusRecordRepository = freeSql.GetRepository<EquipmentStatusRecord>();
                using var equipmentStatusRecordHistoryRepository = freeSql.GetRepository<EquipmentStatusRecordHistory>();

                //结束当前设备的超时状态
                var needEndAlaremRecords = equipmentStatusRecordHistoryRepository.Where(x => x.EquipmentCode == equipment.Code && !x.IsEnd && x.UpdateTime < DateTime.Now.AddSeconds(-AppConfig.DataTimeOut)).OrderBy(x => x.CreateTime).Limit(100)
                    .ToList(x => new EquipmentStatusRecordHistory
                    {
                        Id = x.Id,
                    });
                foreach (var item in needEndAlaremRecords)
                {
                    equipmentStatusRecordHistoryRepository.Attach(item);
                    item.IsEnd = true;
                }
                equipmentStatusRecordHistoryRepository.Update(needEndAlaremRecords);

                //组装数据

                var statusRecordCacheTempsResult = AssemblyStatusData(equipment, records);
                if (!statusRecordCacheTempsResult.Success)
                {
                    return BllResultFactory.Error(statusRecordCacheTempsResult.Msg);
                }

                if (statusRecordCacheTempsResult.Data.Count == 0)
                {

                    //无数据则跳过
                    return BllResultFactory.Success();

                }

                var statusRecordCacheTemps = statusRecordCacheTempsResult.Data;

                //实时状态表中的实时状态记录
                var equipmentStatusRecord = equipmentStatusRecordRepository.Where(x => x.EquipmentCode == equipment.Code).OrderByDescending(x => x.CreateTime).First();

                //历史状态表中的实时状态记录
                var equipmentStatusRecordHistory = equipmentStatusRecordHistoryRepository.Where(x => x.EquipmentCode == equipment.Code).OrderByDescending(x => x.CreateTime).First();

                //组装数据中的最后一条
                var lastCacheStatusRecord = statusRecordCacheTemps.OrderByDescending(x => x.CreateTime).First();

                #region 更新实时状态表数据

                //实时记录表数据为空，则新增
                if (equipmentStatusRecord == null)

                {

                    var temp = new EquipmentStatusRecord
                    {
                        EquipmentCode = equipment.Code,
                        EquipmentName = equipment.Name,
                        EquipmentTypeCode = equipment.EquipmentType.Code,
                        Status = lastCacheStatusRecord.Status,
                        IsEnd = false,
                        ProjectCode = equipment.ProjectCode,
                        FactoryCode = equipment.FactoryCode,
                        CreateTime = lastCacheStatusRecord.CreateTime,
                        UpdateTime = lastCacheStatusRecord.UpdateTime,
                        HandleTime = DateTime.Now,
                        StatusDuration = lastCacheStatusRecord.StatusDuration,
                    };
                    equipmentStatusRecordRepository.Insert(temp);
                }
                //记录不为空，则更新
                else
                {
                    //新数据在记录数据时间之后
                    if (lastCacheStatusRecord.CreateTime >= equipmentStatusRecord.UpdateTime)

                    {

                        //状态一致，日期为同一天，且在超时时间范围内，且组装数据只有一条记录,更新结束时间

                        if (equipmentStatusRecord.Status == lastCacheStatusRecord.Status

                            && lastCacheStatusRecord.CreateTime.Date == equipmentStatusRecord.UpdateTime.Date

                            && (lastCacheStatusRecord.CreateTime - equipmentStatusRecord.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut
                            && statusRecordCacheTemps.Count == 1)
                        {
                            equipmentStatusRecordRepository.Attach(equipmentStatusRecord);

                            if (equipmentStatusRecord.ProjectCode != equipment.ProjectCode)
                            {
                                equipmentStatusRecord.ProjectCode = equipment.ProjectCode;
                            }
                            if (equipmentStatusRecord.FactoryCode != equipment.FactoryCode)
                            {
                                equipmentStatusRecord.FactoryCode = equipment.FactoryCode;
                            }

                            equipmentStatusRecord.HandleTime = DateTime.Now;
                            equipmentStatusRecord.UpdateTime = lastCacheStatusRecord.UpdateTime;

                            equipmentStatusRecord.StatusDuration = (int)(lastCacheStatusRecord.UpdateTime - equipmentStatusRecord.CreateTime).TotalSeconds;

                            equipmentStatusRecordRepository.Update(equipmentStatusRecord);
                        }
                        //其他情况，更新历史起始和结束时间
                        else

                        {

                            equipmentStatusRecordRepository.Attach(equipmentStatusRecord);

                            if (equipmentStatusRecord.ProjectCode != equipment.ProjectCode)
                            {
                                equipmentStatusRecord.ProjectCode = equipment.ProjectCode;
                            }
                            if (equipmentStatusRecord.FactoryCode != equipment.FactoryCode)
                            {
                                equipmentStatusRecord.FactoryCode = equipment.FactoryCode;
                            }

                            equipmentStatusRecord.HandleTime = DateTime.Now;
                            equipmentStatusRecord.Status = lastCacheStatusRecord.Status;
                            equipmentStatusRecord.CreateTime = lastCacheStatusRecord.CreateTime;
                            equipmentStatusRecord.UpdateTime = lastCacheStatusRecord.UpdateTime;
                            equipmentStatusRecord.StatusDuration = lastCacheStatusRecord.StatusDuration;
                            equipmentStatusRecordRepository.Update(equipmentStatusRecord);
                        }
                    }

                    //异常情况：倘若当前设备在实时状态表存在多条数据，应将其他数据删除
                    var temps = equipmentStatusRecordRepository.Where(x => x.EquipmentCode == equipmentStatusRecord.EquipmentCode && x.Id != equipmentStatusRecord.Id)

                        .ToList(x => new EquipmentStatusRecord
                        {
                            Id = x.Id,
                        });

                    if (temps.Count > 0)
                    {
                        equipmentStatusRecordRepository.Delete(temps);

                    }
                }

                #endregion

                #region 更新历史状态表

                //历史表无记录
                if (equipmentStatusRecordHistory == null)

                {
                    foreach (var item in statusRecordCacheTemps)
                    {
                        if (!item.Equals(lastCacheStatusRecord))
                        {

                            //不是最后一条记录的数据加上结束标记
                            item.IsEnd = true;

                        }
                    }

                    equipmentStatusRecordHistoryRepository.Insert(statusRecordCacheTemps);

                }

                //历史记录表有数据
                else

                {

                    //现有记录时间之后的数据
                    statusRecordCacheTemps = statusRecordCacheTemps.Where(x => x.CreateTime >= equipmentStatusRecordHistory.UpdateTime).ToList();

                    if (statusRecordCacheTemps.Count == 0)
                    {
                        return BllResultFactory.Success();
                    }

                    var firstCacheStatusRecord = statusRecordCacheTemps.OrderBy(x => x.CreateTime).First();

                    //需新增的数据
                    var addTemps = new List<EquipmentStatusRecordHistory>();
                    foreach (var item in statusRecordCacheTemps.OrderBy(x => x.CreateTime))

                    {

                        //是第一条记录，与历史记录表的数据进行比较
                        if (item.Equals(firstCacheStatusRecord))

                        {

                            //状态一致，日期为同一天，且在设定超时时间范围内，则更新记录
                            if (equipmentStatusRecordHistory.Status == item.Status
                                && item.CreateTime.Date == equipmentStatusRecordHistory.UpdateTime.Date
                                && (item.CreateTime - equipmentStatusRecordHistory.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut)

                            {

                                equipmentStatusRecordHistoryRepository.Attach(equipmentStatusRecordHistory);
                                if (equipmentStatusRecordHistory.ProjectCode != equipment.ProjectCode)

                                {

                                    equipmentStatusRecordHistory.ProjectCode = equipment.ProjectCode;

                                }

                                if (equipmentStatusRecordHistory.FactoryCode != equipment.FactoryCode)

                                {

                                    equipmentStatusRecordHistory.FactoryCode = equipment.FactoryCode;

                                }

                                equipmentStatusRecordHistory.IsEnd = !item.Equals(lastCacheStatusRecord);
                                equipmentStatusRecordHistory.HandleTime = DateTime.Now;
                                equipmentStatusRecordHistory.UpdateTime = item.UpdateTime;
                                equipmentStatusRecordHistory.StatusDuration = (int)(item.UpdateTime - equipmentStatusRecordHistory.CreateTime).TotalSeconds;
                                equipmentStatusRecordHistoryRepository.Update(equipmentStatusRecordHistory);

                                continue;
                            }

                            //超过设定时间，需要结束历史记录

                            equipmentStatusRecordHistoryRepository.Attach(equipmentStatusRecordHistory);
                            if (equipmentStatusRecord.ProjectCode != equipment.ProjectCode)

                            {

                                equipmentStatusRecord.ProjectCode = equipment.ProjectCode;
                            }
                            if (equipmentStatusRecord.FactoryCode != equipment.FactoryCode)
                            {
                                equipmentStatusRecord.FactoryCode = equipment.FactoryCode;

                            }

                            equipmentStatusRecordHistory.IsEnd = true;
                            equipmentStatusRecordHistory.HandleTime = DateTime.Now;
                            equipmentStatusRecordHistoryRepository.Update(equipmentStatusRecordHistory);

                        }

                        //不是最后一条记录，需加上结束标记
                        if (!item.Equals(lastCacheStatusRecord))

                        {

                            item.IsEnd = true;

                        }

                        addTemps.Add(item);

                    }

                    if (addTemps.Count > 0)

                    {

                        equipmentStatusRecordHistoryRepository.Insert(addTemps);

                    }
                }

                #endregion

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"更新[{equipment.Code}]设备状态记录失败：{ex.Message}");
            }
        }

        /// <summary>

        /// 更新设备手动模式记录
        /// </summary>
        /// <param name="equipment"></param>
        /// <param name="records"></param>
        /// <returns></returns>
        protected virtual BllResult UpdateEquipmentManualRecord(EquipmentExtend equipment, IEnumerable<EquipmentDataRecord> records)
        {
            try
            {
                var statusRecordCacheTempsResult = AssemblyManualStatusData(equipment, records);
                if (!statusRecordCacheTempsResult.Success)
                {
                    return BllResultFactory.Error(statusRecordCacheTempsResult.Msg);
                }

                var statusRecordCacheTemps = statusRecordCacheTempsResult.Data;
                if (statusRecordCacheTemps.Count == 0)
                {
                    //无数据则跳过
                    return BllResultFactory.Success();
                }

                var equipmentManualStatusRecordRepository = freeSql.GetRepository<EquipmentManualStatusRecord>();
                var lastRecord = equipmentManualStatusRecordRepository.Where(x => x.EquipmentCode == equipment.Code).OrderByDescending(x => x.CreateTime).First();

                //无记录，全部新增
                if (lastRecord == null)
                {
                    equipmentManualStatusRecordRepository.Insert(statusRecordCacheTemps);
                    return BllResultFactory.Success();
                }

                //存在记录，只记录历史状态时间之后的数据
                var cacheTemps = statusRecordCacheTemps.Where(x => x.CreateTime >= lastRecord.UpdateTime).OrderBy(x => x.CreateTime).ToList();
                var addTemps = new List<EquipmentManualStatusRecord>();
                foreach (var cacheTemp in cacheTemps)
                {
                    if (cacheTemp.CreateTime.Date == lastRecord.UpdateTime.Date
                        && (cacheTemp.CreateTime - lastRecord.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut)
                    {
                        equipmentManualStatusRecordRepository.Attach(lastRecord);
                        lastRecord.UpdateTime = cacheTemp.UpdateTime;
                        equipmentManualStatusRecordRepository.Update(lastRecord);
                        continue;
                    }
                    addTemps.Add(cacheTemp);
                }
                if (addTemps.Count > 0)
                {
                    equipmentManualStatusRecordRepository.Insert(addTemps);
                }

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        /// <summary>

        /// 组装报警数据
        /// </summary>
        /// <param name="equipment">设备</param>
        /// <param name="records">记录</param>
        /// <returns></returns>
        protected BllResult<List<EquipmentAlarmRecord>> AssemblyAlarmData(EquipmentExtend equipment, IEnumerable<EquipmentDataRecord> records)
        {
            try
            {
                //获取设备总报警编号，仅在设备报总故障时才记录报警
                var totalAlarmProp = equipment.EquipmentProps.Where(x => x.EquipmentTypePropTemplateCode == EquipmentTotalAlarmCode).FirstOrDefault();
                if (totalAlarmProp == null)
                {
                    return BllResultFactory.Error<List<EquipmentAlarmRecord>>($"设备[{equipment.Code}]总报警编码[{EquipmentTotalAlarmCode}]未配置！");
                }

                //当前设备监控地址属性模板

                var monitorPropTemps = equipment.EquipmentProps.Where(x => x.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCMonitorAddress
                && !string.IsNullOrEmpty(x.EquipmentTypePropTemplate.MonitorCompareValue))
                    .DistinctBy(x => x.EquipmentTypePropTemplate.Code)
                    .OrderBy(x => x.Id).ToList();

                //数据组装
                var temps = new List<EquipmentAlarmRecord>();
                foreach (var item in records.OrderBy(x => x.Timestamp))
                {
                    var currentRecordStatusResult = GetEquipmentStatus(equipment, item);
                    if (!currentRecordStatusResult.Success)
                    {
                        continue;
                    }

                    if (currentRecordStatusResult.Data != EquipmentStatus.Failure)
                    {

                        //状态有变化，则结束最后一条报警记录
                        var lastTemp = temps.Where(x => !x.IsEnd).OrderByDescending(x => x.CreateTime).FirstOrDefault();
                        if (lastTemp != null)
                        {
                            lastTemp.IsEnd = true;
                            lastTemp.EquipmentAlarmRecordDetails.ForEach(x => x.IsEnd = true);
                        }

                        continue;
                    }

                    var time = TimestampConvertToLocalDateTime(item.Timestamp);

                    var tagResult = JsonConvertToTagList(item.Tags);
                    //数据不合法，则直接弃用这条记录
                    if (!tagResult.Success)
                    {
                        continue;
                    }
                    var tagItems = tagResult.Data;

                    var (mainAlarm, detailAlarms) = GenerateAlarmMessage(equipment, totalAlarmProp, monitorPropTemps, tagItems);

                    var cacheTemp = temps.Where(x => x.EquipmentPropCode == totalAlarmProp.EquipmentTypePropTemplateCode && !x.IsEnd)

                        .OrderByDescending(x => x.CreateTime).FirstOrDefault();

                    //间隔在设定时间内，认为是同一个主报警
                    if (cacheTemp != null && cacheTemp.UpdateTime.Date == time.Date &&
                       (time - cacheTemp.UpdateTime).TotalSeconds <= AppConfig.DataTimeOut)

                    {

                        cacheTemp.UpdateTime = time;

                        cacheTemp.ErrorDuration = (int)(time - cacheTemp.CreateTime).TotalSeconds;

                        //结束其他报警明细
                        var alarmCodes = detailAlarms.Select(x => x.Key).ToList();
                        foreach (var oldAlarm in cacheTemp.EquipmentAlarmRecordDetails)

                        {

                            if (oldAlarm.IsEnd)
                            {
                                continue;
                            }

                            if (!alarmCodes.Contains(oldAlarm.EquipmentPropCode))
                            {
                                //本次无报警的记录，需要结束
                                oldAlarm.IsEnd = true;
                            }
                        }

                        //更新报警明细
                        foreach (var newAlarm in detailAlarms)

                        {

                            var lastItem = cacheTemp.EquipmentAlarmRecordDetails.Where(x => x.EquipmentPropCode == newAlarm.Key && !x.IsEnd).FirstOrDefault();
                            if (lastItem == null)
                            {
                                var newItem = new EquipmentAlarmRecordDetail
                                {

                                    EquipmentAlarmRecordId = cacheTemp.Id,

                                    EquipmentCode = equipment.Code,
                                    EquipmentName = equipment.Name,
                                    EquipmentPropCode = newAlarm.Key,
                                    EquipmentPropName = monitorPropTemps.Where(p => p.EquipmentTypePropTemplateCode == newAlarm.Key).Select(p => p.Remark).FirstOrDefault(),
                                    EquipmentTypeCode = CurrentEquipmentType.Code,
                                    ProjectCode = equipment.ProjectCode,
                                    FactoryCode = equipment.FactoryCode,
                                    AlarmMessage = newAlarm.Value,
                                    IsEnd = false,
                                    ErrorDuration = 1,
                                    CreateTime = time,
                                    UpdateTime = time,
                                };
                                cacheTemp.EquipmentAlarmRecordDetails.Add(newItem);
                                continue;
                            }

                            //记录不为空，更新时间
                            lastItem.UpdateTime = time;
                            lastItem.ErrorDuration = (int)(time - lastItem.CreateTime).TotalSeconds;

                        }

                        continue;

                    }

                    //获取设备故障坐标
                    GetEquipmentAlarmPoints(equipment, tagItems, out string axis, out string points);
                    var alarmMessage = string.Join(";", detailAlarms.Select(x => x.Value));
                    if (string.IsNullOrWhiteSpace(alarmMessage))

                    {

                        alarmMessage = $"{mainAlarm}，无具体报警信息";

                    }

                    var mainAlarmRecord = new EquipmentAlarmRecord

                    {

                        Id = Guid.NewGuid(),

                        EquipmentCode = equipment.Code,

                        EquipmentName = equipment.Name,

                        EquipmentPropCode = totalAlarmProp.EquipmentTypePropTemplateCode,
                        EquipmentPropName = totalAlarmProp.EquipmentTypePropTemplate.Name,
                        EquipmentTypeCode = CurrentEquipmentType.Code,
                        ErrorDuration = 1,
                        IsEnd = false,

                        AlarmMessage = alarmMessage,

                        FactoryCode = equipment.FactoryCode,
                        ProjectCode = equipment.ProjectCode,

                        HandleTime = DateTime.Now,

                        CreateTime = time,
                        UpdateTime = time,

                        Axis = axis,
                        Points = points

                    };

                    mainAlarmRecord.EquipmentAlarmRecordDetails = detailAlarms.Select(x => new EquipmentAlarmRecordDetail
                    {
                        EquipmentAlarmRecordId = mainAlarmRecord.Id,
                        EquipmentCode = equipment.Code,
                        EquipmentName = equipment.Name,
                        EquipmentPropCode = x.Key,
                        EquipmentPropName = monitorPropTemps.Where(p => p.EquipmentTypePropTemplateCode == x.Key).Select(p => p.Remark).FirstOrDefault(),
                        EquipmentTypeCode = CurrentEquipmentType.Code,
                        ProjectCode = equipment.ProjectCode,
                        FactoryCode = equipment.FactoryCode,
                        AlarmMessage = x.Value,
                        IsEnd = false,
                        ErrorDuration = 1,
                        CreateTime = time,
                        UpdateTime = time,
                    }).ToList();

                    //其他情况，新增
                    temps.Add(mainAlarmRecord);