using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.RedisCache
{
    /// <summary>
    /// 监测记录缓存辅助类
    /// </summary>
    public class MonitorRecordCacheHelper
    {
        //监测记录
        private const string _flag = "monitor-record";
        //最后一条记录
        private const string _lastRecord = "last-record";
        //最后一条正常记录
        private const string _lastNormalRecord = "last-normal-record";
        //最后一条不正常记录
        private const string _lastAbnormalRecord = "last-abnormal-record";
        //Redis客户端辅助类对象
        private readonly RedisClientHelper _redisClient = new RedisClientHelper();

        //获取 RedisKey前缀
        private static string GetRedisKeyPrefix(long CorpID, long MonitorPointID)
        {
            return $"{RedisKeyHelper.CreateKey(_flag)}:{CorpID}-{MonitorPointID}-";
        }

        //创建RedisKey
        private static string CreateRedisKey(long CorpID, long MonitorPointID, long SignalID)
        {
            return $"{RedisKeyHelper.CreateKey(_flag)}:{CorpID}-{MonitorPointID}-{SignalID}";
        }

        #region 记录(只允许获取)

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public Model.MonitorBasicRecord GetLastRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastRecord(long CorpID,long MonitorPointID,IEnumerable<long> SignalIds)
        {
            return GetLastRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID,SignalIds);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorBasicRecord>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public Model.MonitorBasicRecord GetLastNormalRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastNormalRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            return GetLastNormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID,SignalIds);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastNormalRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorBasicRecord>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastNormalRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastNormalRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorBasicRecord>(CorpID,MonitorPointIds);
        }

        // <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public Model.MonitorBasicRecord GetLastAbnormalRecord(long CorpID, long MonitorPointID, long SignalID) 
        {
            return GetLastAbnormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastAbnormalRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            return GetLastAbnormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID,SignalIds);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastAbnormalRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastAbnormalRecord<Model.MonitorBasicRecord>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastAbnormalRecord(long CorpID, long MonitorPointID)
        {
            return GetLastAbnormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.MonitorBasicRecord> GetLastAbnormalRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastAbnormalRecord<Model.MonitorBasicRecord>(CorpID, MonitorPointIds);
        }


        #endregion

        #region 实时记录

        /// <summary>
        /// 设置最近一条实时记录
        /// </summary>
        public void SetLastRealRecord(Model.MonitorRealRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条实时记录
        /// </summary>
        public void SetLastRealRecord(IEnumerable<Model.MonitorRealRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条实时记录
        /// </summary>
        public Model.MonitorRealRecordPure GetLastRealRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorRealRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        /// 获取最后一条实时记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRealRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            return GetLastRecord<Model.MonitorRealRecordPure>(CorpID, MonitorPointID, SignalIds);
        }

        /// <summary>
        /// 获取最后一条实时记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRealRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorRealRecordPure>(CorpID,dict);
        }

        /// <summary>
        /// 获取最后一条实时记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRealRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorRealRecordPure>(CorpID,MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条实时记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRealRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorRealRecordPure>(CorpID,MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条实时正常记录
        /// </summary>
        public Model.MonitorRealRecordPure GetLastNormalRealRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorRealRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        /// 获取最后一条实时正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRealRecord(long CorpID, Dictionary<long,long> dict) 
        {
            return GetLastNormalRecord<Model.MonitorRealRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条实时正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRealRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorRealRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条实时正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRealRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorRealRecordPure>(CorpID, MonitorPointIds);
        }


        #endregion

        #region 时记录

        /// <summary>
        /// 设置最近一条时记录
        /// </summary>
        public void SetLastHourRecord(Model.MonitorHourRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条时记录
        /// </summary>
        public void SetLastHourRecord(IEnumerable<Model.MonitorHourRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条时记录
        /// </summary>
        public Model.MonitorHourRecordPure GetLastHourRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条时记录
        /// </summary>
        public List<Model.MonitorHourRecordPure> GetLastHourRecord(long CorpID, long MonitorPointID,IEnumerable<long> SignalIds)
        {
            return GetLastRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointID,SignalIds);
        }

        /// <summary>
        ///获取最后一条时记录
        /// </summary>
        public List<Model.MonitorHourRecordPure> GetLastHourRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorHourRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条时记录
        /// </summary> 
        public List<Model.MonitorHourRecordPure> GetLastHourRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条时记录
        /// </summary>
        public List<Model.MonitorHourRecordPure> GetLastHourRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常时记录
        /// </summary>
        public Model.MonitorHourRecordPure GetLastNormalHourRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条正常时记录
        /// </summary>
        public List<Model.MonitorHourRecordPure> GetLastNormalHourRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorHourRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常时记录
        /// </summary> 
        public List<Model.MonitorHourRecordPure> GetLastNormalHourRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常时记录
        /// </summary>
        public List<Model.MonitorHourRecordPure> GetLastNormalHourRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorHourRecordPure>(CorpID, MonitorPointIds);
        }

        #endregion

        #region 日记录

        /// <summary>
        /// 设置最近一条日记录
        /// </summary>
        public void SetLastDayRecord(Model.MonitorDayRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条日记录
        /// </summary>
        public void SetLastDayRecord(IEnumerable<Model.MonitorDayRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条日记录
        /// </summary>
        public Model.MonitorDayRecordPure GetLastDayRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条日记录
        /// </summary>
        public List<Model.MonitorDayRecordPure> GetLastDayRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds) 
        {
            return GetLastRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointID, SignalIds);
        }

        /// <summary>
        ///获取最后一条日记录
        /// </summary>
        public List<Model.MonitorDayRecordPure> GetLastDayRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorDayRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条日记录
        /// </summary> 
        public List<Model.MonitorDayRecordPure> GetLastDayRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条日记录
        /// </summary>
        public List<Model.MonitorDayRecordPure> GetLastDayRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常日记录
        /// </summary>
        public Model.MonitorDayRecordPure GetLastNormalDayRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条正常日记录
        /// </summary>
        public List<Model.MonitorDayRecordPure> GetLastNormalDayRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorDayRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常日记录
        /// </summary> 
        public List<Model.MonitorDayRecordPure> GetLastNormalDayRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常日记录
        /// </summary>
        public List<Model.MonitorDayRecordPure> GetLastNormalDayRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorDayRecordPure>(CorpID, MonitorPointIds);
        }

        #endregion

        #region 周记录

        /// <summary>
        /// 设置最近一条周记录
        /// </summary>
        public void SetLastWeekRecord(Model.MonitorWeekRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条周记录
        /// </summary>
        public void SetLastWeekRecord(IEnumerable<Model.MonitorWeekRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条周记录
        /// </summary>
        public Model.MonitorWeekRecordPure GetLastWeekRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条周记录
        /// </summary>
        public List<Model.MonitorWeekRecordPure> GetLastWeekRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            return GetLastRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointID, SignalIds);
        }

        /// <summary>
        ///获取最后一条周记录
        /// </summary>
        public List<Model.MonitorWeekRecordPure> GetLastWeekRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorWeekRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条周记录
        /// </summary> 
        public List<Model.MonitorWeekRecordPure> GetLastWeekRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条周记录
        /// </summary>
        public List<Model.MonitorWeekRecordPure> GetLastWeekRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常周记录
        /// </summary>
        public Model.MonitorWeekRecordPure GetLastNormalWeekRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条正常周记录
        /// </summary>
        public List<Model.MonitorWeekRecordPure> GetLastNormalWeekRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorWeekRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常周记录
        /// </summary> 
        public List<Model.MonitorWeekRecordPure> GetLastNormalWeekRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常周记录
        /// </summary>
        public List<Model.MonitorWeekRecordPure> GetLastNormalWeekRecord(long CorpID, IEnumerable<long> MonitorPointIds) 
        {
            return GetLastNormalRecord<Model.MonitorWeekRecordPure>(CorpID, MonitorPointIds);
        }

        #endregion

        #region 月记录

        /// <summary>
        /// 设置最近一条月记录
        /// </summary>
        public void SetLastMonthRecord(Model.MonitorMonthRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条月记录
        /// </summary>
        public void SetLastMonthRecord(IEnumerable<Model.MonitorMonthRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条月记录
        /// </summary>
        public Model.MonitorMonthRecordPure GetLastMonthRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条月记录
        /// </summary>
        public List<Model.MonitorMonthRecordPure> GetLastMonthRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            return GetLastRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointID, SignalIds);
        }

        /// <summary>
        ///获取最后一条月记录
        /// </summary>
        public List<Model.MonitorMonthRecordPure> GetLastMonthRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorMonthRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条月记录
        /// </summary> 
        public List<Model.MonitorMonthRecordPure> GetLastMonthRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条月记录
        /// </summary>
        public List<Model.MonitorMonthRecordPure> GetLastMonthRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常月记录
        /// </summary>
        public Model.MonitorMonthRecordPure GetLastNormalMonthRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条正常月记录
        /// </summary>
        public List<Model.MonitorMonthRecordPure> GetLastNormalMonthRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorMonthRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常月记录
        /// </summary> 
        public List<Model.MonitorMonthRecordPure> GetLastNormalMonthRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常月记录 
        /// </summary>
        public List<Model.MonitorMonthRecordPure> GetLastNormalMonthRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorMonthRecordPure>(CorpID, MonitorPointIds);
        }
        #endregion

        #region 年记录

        /// <summary>
        /// 设置最近一条年记录
        /// </summary>
        public void SetLastYearRecord(Model.MonitorYearRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最近一条年记录
        /// </summary>
        public void SetLastYearRecord(IEnumerable<Model.MonitorYearRecordPure> list)
        {
            SetLastRecord(list);
        }

        /// <summary>
        /// 获取最后一条年记录
        /// </summary>
        public Model.MonitorYearRecordPure GetLastYearRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条年记录
        /// </summary>
        public List<Model.MonitorYearRecordPure> GetLastYearRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds) 
        {
            return GetLastRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointID, SignalIds);
        }


        /// <summary>
        ///获取最后一条年记录
        /// </summary>
        public List<Model.MonitorYearRecordPure> GetLastYearRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastRecord<Model.MonitorYearRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条年记录
        /// </summary> 
        public List<Model.MonitorYearRecordPure> GetLastYearRecord(long CorpID, long MonitorPointID)
        {
            return GetLastRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条年记录
        /// </summary>
        public List<Model.MonitorYearRecordPure> GetLastYearRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointIds);
        }

        /// <summary>
        /// 获取最后一条正常年记录
        /// </summary>
        public Model.MonitorYearRecordPure GetLastNormalYearRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            return GetLastNormalRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointID, SignalID);
        }

        /// <summary>
        ///获取最后一条正常年记录
        /// </summary>
        public List<Model.MonitorYearRecordPure> GetLastNormalYearRecord(long CorpID, Dictionary<long, long> dict)
        {
            return GetLastNormalRecord<Model.MonitorYearRecordPure>(CorpID, dict);
        }

        /// <summary>
        /// 获取最后一条正常年记录
        /// </summary> 
        public List<Model.MonitorYearRecordPure> GetLastNormalYearRecord(long CorpID, long MonitorPointID)
        {
            return GetLastNormalRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointID);
        }

        /// <summary>
        /// 获取最后一条正常年记录
        /// </summary>
        public List<Model.MonitorYearRecordPure> GetLastNormalYearRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            return GetLastNormalRecord<Model.MonitorYearRecordPure>(CorpID, MonitorPointIds);
        }
        #endregion

        #region 最后一条记录

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastRecord<T>(T t) where T : Model.MonitorBasicRecord
        {
            if (t == null)
                return;
            var redisKey = CreateRedisKey(t.CorpID, t.MonitorPointID, t.SignalID);
            _redisClient.HashSetJosn(redisKey, _lastRecord, t);

            if (t.DataStatus != null && (t.DataStatus.Contains(MonitorRecord.Status_DataFormatError) || t.DataStatus.Contains(MonitorRecord.Status_ConvertFailed) || t.DataStatus.Contains(MonitorRecord.Status_FilterFailed)))
            {
                _redisClient.HashSetJosn(redisKey, _lastAbnormalRecord, t);
            }
            else
            {
                _redisClient.HashSetJosn(redisKey, _lastNormalRecord, t);
            }
        }

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastRecord<T>(IEnumerable<T> list) where T : Model.MonitorBasicRecord
        {
            if (list == null || list.Count() < 1)
                return;
            foreach (var item in list)
            {
                SetLastRecord(item);
            }
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public T GetLastRecord<T>(long CorpID, long MonitorPointID, long SignalID) where T : Model.MonitorBasicRecord
        {
            var redisKey = CreateRedisKey(CorpID, MonitorPointID, SignalID);
            return _redisClient.HashGetJson<T>(redisKey, _lastRecord);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds) where T : Model.MonitorBasicRecord
        {
            if (SignalIds == null || SignalIds.Count() < 1)
                return default;
            return SignalIds.Select(x => GetLastRecord<T>(CorpID, MonitorPointID, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, Dictionary<long, long> dict) where T : Model.MonitorBasicRecord
        {
            if (dict == null || dict.Count < 1)
                return default;
            return dict.Select(x => GetLastRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, long MonitorPointID) where T : Model.MonitorBasicRecord
        {
            var key = GetRedisKeyPrefix(CorpID, MonitorPointID);
            var allKeys = _redisClient.AllKeyStartWidth(key);
            if (allKeys == null || allKeys.Count < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var redisKey in allKeys)
            {
                var vm = _redisClient.HashGetJson<T>(redisKey, _lastRecord);
                if (vm != null)
                {
                    vm_list.Add(vm);
                }
            }
            return vm_list;
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, IEnumerable<long> MonitorPointIds) where T : Model.MonitorBasicRecord
        {
            if (MonitorPointIds == null || MonitorPointIds.Count() < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var MonitorPointID in MonitorPointIds)
            {
                var vm = GetLastRecord<T>(CorpID, MonitorPointID);
                if (vm != null && vm.Count > 0)
                {
                    vm_list.AddRange(vm);
                }
            }
            return vm_list;
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public T GetLastNormalRecord<T>(long CorpID, long MonitorPointID, long SignalID) where T : Model.MonitorBasicRecord
        {
            var redisKey = CreateRedisKey(CorpID, MonitorPointID, SignalID);
            return _redisClient.HashGetJson<T>(redisKey, _lastNormalRecord);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, long MonitorPointID,IEnumerable<long> SignalIds) where T : Model.MonitorBasicRecord
        {
            if (SignalIds == null || SignalIds.Count() < 1)
                return default;
            return SignalIds.Select(x => GetLastNormalRecord<T>(CorpID, MonitorPointID, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, Dictionary<long, long> dict) where T : Model.MonitorBasicRecord
        {
            if (dict == null || dict.Count < 1)
                return default;
            return dict.Select(x => GetLastNormalRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, long MonitorPointID) where T : Model.MonitorBasicRecord
        {
            var key = GetRedisKeyPrefix(CorpID, MonitorPointID);
            var allKeys = _redisClient.AllKeyStartWidth(key);
            if (allKeys == null || allKeys.Count < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var redisKey in allKeys)
            {
                var vm = _redisClient.HashGetJson<T>(redisKey, _lastNormalRecord);
                if (vm != null)
                {
                    vm_list.Add(vm);
                }
            }
            return vm_list;
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, IEnumerable<long> MonitorPointIds) where T : Model.MonitorBasicRecord
        {
            if (MonitorPointIds == null || MonitorPointIds.Count() < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var MonitorPointID in MonitorPointIds)
            {
                var vm = GetLastNormalRecord<T>(CorpID, MonitorPointID);
                if (vm != null && vm.Count > 0)
                {
                    vm_list.AddRange(vm);
                }
            }
            return vm_list;
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public T GetLastAbnormalRecord<T>(long CorpID, long MonitorPointID, long SignalID) where T : Model.MonitorBasicRecord
        {
            var redisKey = CreateRedisKey(CorpID, MonitorPointID, SignalID);
            return _redisClient.HashGetJson<T>(redisKey, _lastAbnormalRecord);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds) where T : Model.MonitorBasicRecord
        {
            if (SignalIds == null || SignalIds.Count() < 1)
                return default;
            return SignalIds.Select(x => GetLastAbnormalRecord<T>(CorpID, MonitorPointID, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, Dictionary<long, long> dict) where T : Model.MonitorBasicRecord
        {
            if (dict == null || dict.Count < 1)
                return default;
            return dict.Select(x => GetLastAbnormalRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, long MonitorPointID) where T : Model.MonitorBasicRecord
        {
            var key = GetRedisKeyPrefix(CorpID, MonitorPointID);
            var allKeys = _redisClient.AllKeyStartWidth(key);
            if (allKeys == null || allKeys.Count < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var redisKey in allKeys)
            {
                var vm = _redisClient.HashGetJson<T>(redisKey, _lastAbnormalRecord);
                if (vm != null)
                {
                    vm_list.Add(vm);
                }
            }
            return vm_list;
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, IEnumerable<long> MonitorPointIds) where T : Model.MonitorBasicRecord
        {
            if (MonitorPointIds == null || MonitorPointIds.Count() < 1)
                return default;
            var vm_list = new List<T>();
            foreach (var MonitorPointID in MonitorPointIds)
            {
                var vm = GetLastAbnormalRecord<T>(CorpID, MonitorPointID);
                if (vm != null && vm.Count > 0)
                {
                    vm_list.AddRange(vm);
                }
            }
            return vm_list;
        }


        #endregion

    }
}