BaseAnalysis.cs 6.76 KB
using HHECS.DAQHandle.Common.Enums;
using HHECS.DAQHandle.Common.Utils;
using HHECS.DAQHandle.DataAccess;
using HHECS.DAQHandle.Models;
using HHECS.EquipmentModel;
using System.Configuration;
using System.Text.Json;

namespace HHECS.DAQHandle.EquipmentHandle
{
    internal abstract class BaseAnalysis : IAnalysis
    {
        protected DataContext Context = DbContextFactory.CreateDbContext();
        protected int AlarmTimeOut = int.Parse(ConfigurationManager.AppSettings["AlarmTimeOut"]);

        protected int EquipmentTypeId;
        protected List<EquipmentTypePropTemplateExtend> EquipmentTypePropTemps;


        public virtual void Execute(IEnumerable<EquipmentDataRecord> records)
        {
            if (!records.Any()) return;
            if (EquipmentTypeId == default)
            {
                EquipmentTypeId = GetEquipmentTypeId(records.Min());//Context.EquipmentType.Where(x => x.EquipmentType.Code == "Stacker");
            }
            if (EquipmentTypePropTemps == default)
            {
                EquipmentTypePropTemps = Context.EquipmentTypePropTemplate.Where(x => x.EquipmentTypeId == EquipmentTypeId).ToList();
            }
        }

        /// <summary>
        /// 更新设备属性值
        /// </summary>
        /// <param name="record">取最后一条记录</param>
        protected virtual bool UpdateTagValue(EquipmentDataRecord record)
        {
            try
            {


                DateTime acceptTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Local).AddSeconds(record.Timestamp);
                //获取所有修改时间小于当前数据时间的属性
                var equipment = Context.Equipment.Where(x => x.Code == record.EquipmentCode).First();
                var allProps = Context.EquipmentProp.Where(x => x.EquipmentId == equipment.Id).ToList();
                var props = allProps.Where(x => x.Updated < acceptTime).ToList();
                if (props.Count != allProps.Count)
                {
                    SystemLog.PrintError($"记录{record.Id}已经过期");
                    return false;
                }
                foreach (var prop in props)
                {
                    if (record.Props.TryGetValue(prop.EquipmentTypePropTemplateCode, out string value))
                    {
                        prop.Value = value;
                        prop.Updated = acceptTime;
                    }
                    //else
                    //{
                    //    SystemLog.PrintInfo($"设备[{record.EquipmentCode}]的属性{prop.EquipmentTypePropTemplateCode}不存在");

                    //}
                }
                Context.EquipmentProp.UpdateRange(props);
                Context.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                SystemLog.PrintError($"{ex}");
                return false;

            }
        }

        /// <summary>
        /// 更新设备状态记录
        /// </summary>
        /// <param name="records"></param>
        protected virtual void UpdateEquipmentStatus<T>(string equipmentSN, IList<T> statusCodes, IList<EquipmentDataRecord> records) where T : Enum
        {
            var endRecords = Context.EquipmentStatusRecords.Where(x => !x.IsEnd && (DateTime.Now - (DateTime)x.UpdateTime).TotalSeconds > AlarmTimeOut).ToList();
            var addRecords = new List<EquipmentStatusRecord>();
            endRecords.ForEach(x =>
            {
                if (x.Status != EquipmentStatusRecordStatus.Free.ToString())
                {
                    x.UpdateTime = DateTime.Now;
                    x.IsEnd = true;
                    addRecords.Add(x);
                }
            });
            Context.Update(endRecords);
            Context.AddRange(addRecords);
            Context.SaveChanges();
        }

        /// <summary>
        /// 更新设备报警记录
        /// </summary>
        /// <param name="records"></param>
        protected virtual void UpdateEquipmentAlarm<T>(string equipmentSN, IList<T> alarmCodes, IList<EquipmentDataRecord> records) where T : Enum
        {

            var endRecords = Context.EquipmentAlarmRecords.Where(x => !x.IsEnd && (DateTime.Now - (DateTime)x.UpdateTime).TotalSeconds > AlarmTimeOut).ToList();
            endRecords.ForEach(x => { x.UpdateTime = DateTime.Now; x.IsEnd = true; });
            Context.Update(endRecords);
        }


        protected int GetEquipmentTypeId(EquipmentDataRecord record)
        {
            var equipment = Context.Equipment.Where(x => x.Code == record.EquipmentCode).First();
            return equipment.EquipmentTypeId;
        }


        /// <summary>
        /// 记录设备状态
        /// </summary>
        /// <param name="srm"></param>
        /// <param name="records"></param>
        /// <param name="equipmentStatusRecordStatus"></param>
        public void RecordEquipmentStatus(EquipmentDataRecord srm, List<EquipmentStatusRecord> records, EquipmentStatusRecordStatus equipmentStatusRecordStatus)
        {

            var record = records.Find(t => t.Status == equipmentStatusRecordStatus.ToString());
            var equipment = Context.Equipment.Where(x => x.Code == srm.EquipmentCode).First();
            try
            {
                if (record == null)
                {
                    Context.UnitOfWork.GetOrBeginTransaction();

                    //新建
                    EquipmentStatusRecord equipmentStatusRecord = new EquipmentStatusRecord();
                    equipmentStatusRecord.EquipmentCode = srm.EquipmentCode;
                    equipmentStatusRecord.EquipmentName = equipment.Name;
                    equipmentStatusRecord.Status = equipmentStatusRecordStatus.ToString();
                    equipmentStatusRecord.UpdateTime = DateTime.Now;
                    equipmentStatusRecord.CreateTime = DateTime.Now;
                    //更新上一个状态
                    var lastRecord = records.First();
                    lastRecord.UpdateTime = DateTime.Now;
                    lastRecord.IsEnd = true;
                    Context.Update(lastRecord);
                    Context.Add(equipmentStatusRecord);

                    Context.SaveChanges();
                    Context.UnitOfWork.Commit();

                }
                else
                {

                    //更新
                    record.UpdateTime = DateTime.Now;
                    Context.Update(record);
                }
            }
            catch (Exception ex)
            {
                Context.UnitOfWork.Rollback();
                //修改数据记录
                srm.HandleStage = (byte)(srm.HandleStage ^ srm.SET_STATUS_ERROR);
                SystemLog.PrintError($"记录{srm.Id}更新设备状态失败{ex}");
            }
            srm.IsHandle = true;

        }

    }
}